/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: utility class definition

*

*/

// INCLUDE FILES

#include "emailtrace.h"

#include <StringLoader.h>

#include <AknUtils.h>

#include <AknsSkinInstance.h>

#include <aknbutton.h>

#include <eikedwin.h>

#include <FreestyleEmailUi.rsg>

#include <RPbkViewResourceFile.h>

#include <CPbkContactEngine.h>

#include <CPbkMultipleEntryFetchDlg.h>

#include <CPbkContactItem.h>

#include <AknIconUtils.h>

#include <eikimage.h>

#include <fbs.h>

#include <flogger.h>

#include <aknenv.h>	// CAknEnv

#include "CFSMailBox.h"

#include "CFSMailClient.h"

#include "CFSMailAddress.h"

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknLayoutFont.h>

#include "ncsutility.h"

#include "ncsemailaddressobject.h"

#include "ncsconstants.h"

#include "FSDelayedLoader.h"

#include "FreestyleEmailUiUtilities.h"

#include "FreestyleEmailUiLayoutData.h"

// CONSTANTS

const TInt KFSUtilityMinColorValue = 0;

const TInt KFSUtilityMaxColorValue = 255;

const TInt KFSUtilityThresholdColorValue = 200;

const TInt KFSUtilityThresholdColorMiddleValue = 127;

// ========================= MEMBER FUNCTIONS ==================================

// -----------------------------------------------------------------------------

// NcsUtility::CompleteRelativePathL()

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

	// + 2 is for drive letter and ":"

	if( aAbsolutePath.MaxLength() < aRelativePath.Length() + 2 )

		{

		User::Leave( KErrArgument );

		}

	TFileName path;

  	path.Copy( aRelativePath );

	TInt err = CompleteWithAppPath( path );

	User::LeaveIfError( err );

	aAbsolutePath.Copy( path );

	}

// -----------------------------------------------------------------------------

// NcsUtility::GenerateFromLineToMessageBodyL()

//

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

	return buf;

	}

// -----------------------------------------------------------------------------

// NcsUtility::GenerateSentLineToMessageBodyL()

//

// -----------------------------------------------------------------------------

//

HBufC* NcsUtility::GenerateSentLineToMessageBodyL( CFSMailMessage& aMessage )

	{

    FUNC_LOG;

	HBufC* dateText = TFsEmailUiUtility::DateTextFromMsgLC( &aMessage );

	HBufC* timeText = TFsEmailUiUtility::TimeTextFromMsgLC( &aMessage );

	HBufC* sent = StringLoader::LoadLC( R_NCS_ENGINE_EMAIL_SENT );

	HBufC* buf = HBufC::NewL( sent->Length() +

                              KSpace().Length() +

	                          dateText->Length() +

	                          KSentLineDateAndTimeSeparatorText().Length() +

	                          timeText->Length() );

	TPtr ptr = buf->Des();

	ptr.Append( *sent );

	ptr.Append( KSpace );

	ptr.Append( *dateText );

	ptr.Append( KSentLineDateAndTimeSeparatorText );

	ptr.Append( *timeText );

	CleanupStack::PopAndDestroy( sent );

	CleanupStack::PopAndDestroy( timeText );

	CleanupStack::PopAndDestroy( dateText );

	return buf;

	}

// -----------------------------------------------------------------------------

// NcsUtility::GenerateAddressLineToMessageBodyL()

//

// -----------------------------------------------------------------------------

//

HBufC* NcsUtility::GenerateAddressLineToMessageBodyL(

	RPointerArray<CNcsEmailAddressObject>& aToArray, TRecipientType aType )

	{

    FUNC_LOG;

	// figure out the recipient type dependent text

    TInt labelResource = R_NCS_ENGINE_EMAIL_TO;

    if ( aType == ERecipientTypeCc )

        {

        labelResource = R_NCS_ENGINE_EMAIL_CC;

        }

    HBufC* buf = DoGenerateAddressLineToMessageBodyL( labelResource, aToArray );

    return buf;

	}

// -----------------------------------------------------------------------------

// NcsUtility::DoGenerateAddressLineToMessageBodyL()

//

// -----------------------------------------------------------------------------

//

HBufC* NcsUtility::DoGenerateAddressLineToMessageBodyL( TInt aLabelResourceId,

        const RPointerArray<CNcsEmailAddressObject>& aAddressArray )

    {

    FUNC_LOG;

    // load label string (e.g. "From:", "To:", "Cc:")

    HBufC* label = StringLoader::LoadLC( aLabelResourceId );

    // calculate how large buffer do we need for the whole line

    TInt bufLength = label->Length();

    TInt count = aAddressArray.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        CNcsEmailAddressObject* obj = aAddressArray[i];

        const TDesC& dispName = obj->DisplayName();

        // use display name if it is available, otherwise email address

        if ( dispName.Length() > 0 )

            {

            bufLength += dispName.Length();

            }

        else

            {

            bufLength += obj->EmailAddress().Length();

            }

        if ( i < ( count - 1 ) )

            {

            bufLength += KEmailAddressSeparator().Length();

            bufLength += KSpace().Length();

            }

        }

    // allocate buffer to contain the whole text

    HBufC* buf = HBufC::NewL( bufLength );

    TPtr ptr = buf->Des();

    // add label

    ptr.Append( *label );

    CleanupStack::PopAndDestroy( label );

    // append each address into our text buffer

    for ( TInt i = 0; i < count; i++ )

        {

        CNcsEmailAddressObject* obj = aAddressArray[i];

        const TDesC& dispName = obj->DisplayName();

        // use display name if it is available, otherwise email address

        if ( dispName.Length() > 0 )

            {

            ptr.Append( dispName );

            }

        else

            {

            ptr.Append( obj->EmailAddress() );

            }

        if ( i < ( count - 1 ) )

            {

            ptr.Append( KEmailAddressSeparator );

            ptr.Append( KSpace );

            }

        }

    return buf;

    }

// -----------------------------------------------------------------------------

// NcsUtility::GenerateSubjectLineToMessageBodyL()

//

// -----------------------------------------------------------------------------

//

HBufC* NcsUtility::GenerateSubjectLineToMessageBodyL( const TDesC& aSubject )

	{

    FUNC_LOG;

	// load "Subject:" string

	HBufC* subjectLabel = StringLoader::LoadLC( R_NCS_ENGINE_EMAIL_SUBJECT );

	// allocate buffer for the text

	HBufC* buf = HBufC::NewL( subjectLabel->Length() + aSubject.Length() );

    TPtr ptr = buf->Des();

    ptr.Append( *subjectLabel );

    ptr.Append( aSubject );

    CleanupStack::PopAndDestroy( subjectLabel );

	return buf;

	}

// -----------------------------------------------------------------------------

// NcsUtility::CreateNcsAddressL()

//

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

	CNcsEmailAddressObject* address = CNcsEmailAddressObject::NewL( ETrue );

	CleanupStack::PushL( address );

	// temporary ugly code because email API can return references to null

	TDesC& a = aFsAddress.GetEmailAddress();

	if ( &a )

		{

		address->SetEmailAddressL( a );

		}

	TDesC& name = aFsAddress.GetDisplayName();

	if ( &name )

		{

		address->SetDisplayNameL( name );

		}

	CleanupStack::Pop( address );

	return address;

	}

// -----------------------------------------------------------------------------

// NcsUtility::CreateFsAddressL()

// Caller takes the ownership of the returned address object

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

	CFSMailAddress* address = CFSMailAddress::NewL();

	address->SetEmailAddress( aNcsAddress.EmailAddress() );

	address->SetDisplayName( aNcsAddress.DisplayName() );

	return address;

	}

// -----------------------------------------------------------------------------

// NcsUtility::FormatSubjectLineL()

//

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

	HBufC* formattedSubjectLine = aNewSubjectLine.AllocLC();

	HBufC* prefix = aPrefix.AllocLC();

	TPtr formattedSubjectLinePtr = formattedSubjectLine->Des();

	TPtr prefixPtr = prefix->Des();

	prefixPtr.Trim();

	TInt subjectLineLength = formattedSubjectLinePtr.Length();

	TInt index = 0;

	TInt length = subjectLineLength;

	TInt prefixLength = prefixPtr.Length();

	do

		{

		formattedSubjectLinePtr = formattedSubjectLinePtr.RightTPtr( length );

		index = formattedSubjectLinePtr.FindC( prefixPtr );

		length = formattedSubjectLinePtr.Length() - index - prefixLength;

		}

	while( index != KErrNotFound );

	formattedSubjectLinePtr.Trim();

	TPtr ptr = finalSubject->Des();

	if ( AknLayoutUtils::LayoutMirrored() )

		{

		ptr.Append( formattedSubjectLinePtr );

		ptr.Append( KSpace );

		ptr.Append( prefixPtr );		

		}

	else

		{

		ptr.Append( prefixPtr );

		ptr.Append( KSpace );

		ptr.Append( formattedSubjectLinePtr );

		}

	CleanupStack::PopAndDestroy( prefix );

	CleanupStack::PopAndDestroy( formattedSubjectLine );

	return finalSubject;

	}

// -----------------------------------------------------------------------------

// NcsUtility::ConvertAddressArrayL()

//

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

 	for ( TInt i=0; i<aSrc.Count(); i++ )

 		{

		CleanupStack::PushL( ncsRecipient );

		aDst.AppendL( ncsRecipient );

		CleanupStack::Pop( ncsRecipient );

 		}

	}

// -----------------------------------------------------------------------------

// NcsUtility::ConvertAddressArrayL()

// Caller takes the ownership of address objects pointoed in the array aDst.

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

 	for ( TInt i=0; i<aSrc.Count(); i++ )

 		{

		CleanupStack::PushL( fsRecipient );

		aDst.AppendL( fsRecipient );

		CleanupStack::Pop( fsRecipient );

 		}

	}

// -----------------------------------------------------------------------------

// NcsUtility::LoadScalableIconL()

//

// -----------------------------------------------------------------------------

//

    {

    FUNC_LOG;

	HBufC* buf = HBufC::NewLC( KMaxFileName );

	TPtr ptr = buf->Des();

	NcsUtility::CompleteRelativePathL( aMifRelativeFileName, ptr );

    AknIconUtils::CreateIconL( aImage,

                               aMask,

                               ptr,

	                           aImgId,

	                           aMaskId );

    TSize size;

    AknIconUtils::GetContentDimensions( aImage, size );

    AknIconUtils::SetSize( aImage, size );

    aIcon = new ( ELeave ) CEikImage;

    aIcon->SetNewBitmaps( aImage, aMask );

    aIcon->SetPictureOwnedExternally( ETrue );

	CleanupStack::PopAndDestroy( buf );

    }

// -----------------------------------------------------------------------------

// NcsUtility::DebugLog

// -----------------------------------------------------------------------------

//

void NcsUtility::DebugLog( TRefByValue<const TDesC> aFmt, ... )

    {

    FUNC_LOG;

    _LIT( KDebugDir, "FreestyleEmailUi" );

    _LIT( KDebugLog, "log.txt" );

    VA_LIST args;

    VA_START( args, aFmt );

    RFileLogger::WriteFormat( KDebugDir,

                              KDebugLog,

                              EFileLoggingModeAppend,

                              aFmt,

                              args );

    VA_END( args );

    }

// -----------------------------------------------------------------------------

// NcsUtility::IsEqualAddressArray

// -----------------------------------------------------------------------------

//

	{

    FUNC_LOG;

	if ( aAddresses1.Count() != aAddresses2.Count() )

		{

		return EFalse;

		}

    for ( TInt i=0; i<aAddresses1.Count(); i++ )

    	{

    		{

    		return EFalse;

    		}

    		{

    		return EFalse;

    		}

    	}

    return ETrue;

	}

// -----------------------------------------------------------------------------

// NcsUtility::Measures

// -----------------------------------------------------------------------------

//

TNcsMeasures NcsUtility::Measures()

	{

    FUNC_LOG;

	TNcsMeasures ms;

	TAknUiZoom zoomLevel = EAknUiZoomNormal;

	CAknEnv::Static()->GetCurrentGlobalUiZoom( zoomLevel );

	switch ( zoomLevel )

		{

		case EAknUiZoomNormal: case EAknUiZoomAutomatic:

			{

			ms.iAifHeight = KAifHeight;

			ms.iAifLabelMarginVertical = KAifLabelMarginVertical;

			ms.iAifEditorMarginVertical = KAifEditorMarginVertical;

			ms.iAifEditorHeight = KAifEditorHeight;

			ms.iSubjectExtraHeightBottom = KSubjectExtraHeightBottom;

			ms.iAttachmentExtraHeightBottom = KAttachmentExtraHeightBottom;

			ms.iIconMarginPriorityVertical = KIconMarginPriorityVertical;

			ms.iIconMarginFollowUpVertical = KIconMarginFollowUpVertical;

            ms.iIconMarginAttachmentVertical = KIconMarginAttachmentVertical;

			ms.iLabelFontHeightPx = KLabelFontHeightPx;

			ms.iEditorFontHeightPx = KEditorFontHeightPx;

			}

            break;

		case EAknUiZoomSmall: case EAknUiZoomVerySmall:

			{

			ms.iAifHeight = KAifHeightSmall;

			ms.iAifLabelMarginVertical = KAifLabelMarginVerticalSmall;

			ms.iAifEditorMarginVertical = KAifEditorMarginVerticalSmall;

			ms.iAifEditorHeight = KAifEditorHeightSmall;

			ms.iSubjectExtraHeightBottom = KSubjectExtraHeightBottomSmall;

			ms.iIconMarginPriorityVertical = KIconMarginPriorityVerticalSmall;

			ms.iIconMarginFollowUpVertical = KIconMarginFollowUpVerticalSmall;