/*

* 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 <AknsUtils.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()

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

//

void NcsUtility::CompleteRelativePathL( 

        const TDesC& aRelativePath, TPtr& aAbsolutePath )

    {

    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()

//

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

//

HBufC* NcsUtility::GenerateFromLineToMessageBodyL( 

        const RPointerArray<CNcsEmailAddressObject>& aFromArray )

    {

    FUNC_LOG;

    HBufC* buf = DoGenerateAddressLineToMessageBodyL( 

            R_NCS_ENGINE_EMAIL_FROM, aFromArray );

    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()

//

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

//

CNcsEmailAddressObject* NcsUtility::CreateNcsAddressL( 

        const CFSMailAddress& aFsAddress )

    {

    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

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

//

CFSMailAddress* NcsUtility::CreateFsAddressL( 

        const CNcsEmailAddressObject& aNcsAddress )

    {

    FUNC_LOG;

    CFSMailAddress* address = CFSMailAddress::NewL();

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

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

    return address;

    }

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

// NcsUtility::FormatSubjectLineL()

//

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

//

HBufC* NcsUtility::FormatSubjectLineL( 

        const TDesC& aNewSubjectLine, const TDesC& aPrefix )

    {

    FUNC_LOG;

        HBufC* formattedSubjectLine = aNewSubjectLine.AllocLC();

        HBufC* prefix = aPrefix.AllocLC();

        TPtr formattedSubjectLinePtr = formattedSubjectLine->Des();

        TPtr prefixPtr = prefix->Des();

        prefixPtr.Trim();

        HBufC* fwdPrefix = StringLoader::LoadLC( R_NCS_ENGINE_EMAIL_FORWARD_PREFIX );

        TPtr fwdPrt = fwdPrefix->Des();

        fwdPrt.Trim();

            {

            }

        HBufC* finalSubject = HBufC::NewL( formattedSubjectLinePtr.Length() + prefixPtr.Length() + KSpace().Length()  );

        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( fwdPrefix );

        CleanupStack::PopAndDestroy( prefix );

        CleanupStack::PopAndDestroy( formattedSubjectLine );

        return finalSubject;

    }

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

// NcsUtility::ConvertAddressArrayL()

//

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

//

void NcsUtility::ConvertAddressArrayL( 

        const RPointerArray<CFSMailAddress>& aSrc, 

        RPointerArray<CNcsEmailAddressObject>& aDst )

    {

    FUNC_LOG;

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

        {

        CNcsEmailAddressObject* ncsRecipient = 

            NcsUtility::CreateNcsAddressL( *aSrc[i] );

        CleanupStack::PushL( ncsRecipient );

        aDst.AppendL( ncsRecipient );

        CleanupStack::Pop( ncsRecipient );

        }

    }

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

// NcsUtility::ConvertAddressArrayL()

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

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

//

void NcsUtility::ConvertAddressArrayL( 

        const RPointerArray<CNcsEmailAddressObject>& aSrc, 

        RPointerArray<CFSMailAddress>& aDst )

    {

    FUNC_LOG;

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

        {

        CFSMailAddress* fsRecipient = 

            NcsUtility::CreateFsAddressL( *aSrc[i] );

        CleanupStack::PushL( fsRecipient );

        aDst.AppendL( fsRecipient );

        CleanupStack::Pop( fsRecipient );

        }

    }

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

// NcsUtility::LoadScalableIconL()

//

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

//

void NcsUtility::LoadScalableIconL( 

        const TDesC& aMifRelativeFileName, TInt aImgId, 

        TInt aMaskId, CEikImage*& aIcon, 

        CFbsBitmap*& aImage, CFbsBitmap*& aMask )

    {

    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

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

//

TBool NcsUtility::IsEqualAddressArray( 

        const RPointerArray<CFSMailAddress>& aAddresses1,

        const RPointerArray<CFSMailAddress>& aAddresses2 )

    {

    FUNC_LOG;

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

        {

        return EFalse;

        }

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

        {

        if ( aAddresses1[i]->GetEmailAddress().Compare( 

                aAddresses2[i]->GetEmailAddress() ) != 0 )

            {

            return EFalse;

            }

        if ( aAddresses1[i]->GetDisplayName().Compare( 

                aAddresses2[i]->GetDisplayName() ) != 0 )

            {

            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;