/*

* Copyright (c) 2005-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:  

*       Defines implementation of CUniBaseHeader class methods.

*

*/

// INCLUDE FILES

#include "UniBaseHeader.h"

#include <eikrted.h>

#include <txtrich.h>                // CRichText

#include <mtclbase.h>

#include <centralrepository.h>    // link against centralrepository.lib

#include <messaginginternalcrkeys.h> // for Central Repository keys

#include <mmsgenutils.h>

#include <messagingvariant.hrh>

#include <MsgExpandableControl.h>

#include <MsgAddressControl.h>

#include <uniaddresshandler.h>

#include <uniobjectlist.h>

// ==========================================================

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// CUniBaseHeader::CUniBaseHeader

//

// Constructor.

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

//

EXPORT_C CUniBaseHeader::CUniBaseHeader( CBaseMtm& aMtm,

                                         CMsgEditorView& aView,

                                         RFs& aFs ) : 

    iMtm( aMtm ),

    iView( aView ),

    iFs( aFs )

    {

    iHeaders[EHeaderAddressFrom].iControlType = EMsgComponentIdFrom;

    iHeaders[EHeaderAddressTo].iControlType = EMsgComponentIdTo;

    iHeaders[EHeaderAddressCc].iControlType = EMsgComponentIdCc;

    iHeaders[EHeaderAddressBcc].iControlType = EMsgComponentIdBcc;

    iHeaders[EHeaderSubject].iControlType = EMsgComponentIdSubject;

    iHeaders[EHeaderAttachment].iControlType = EMsgComponentIdAttachment;

    iHeaders[EHeaderAddressTo].iRecipientTypeValue = EMsvRecipientTo;

    iHeaders[EHeaderAddressCc].iRecipientTypeValue = EMsvRecipientCc;

    iHeaders[EHeaderAddressBcc].iRecipientTypeValue = EMsvRecipientBcc;

    }

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

// CUniBaseHeader::~CUniBaseHeader

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

//

EXPORT_C CUniBaseHeader::~CUniBaseHeader()

    {

    for (TInt i = EHeaderAddressFrom; i <= EHeaderAttachment; i++ )

        {

        if ( iHeaders[i].iOwned )

            {

            delete iHeaders[i].iControl;

            }

        delete iHeaders[i].iAddressHandler;

        }

    }

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

// CUniBaseHeader::AddToViewL

//

// Assumes that slide is automatically correct. Caller's responsibility

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

// 

EXPORT_C void CUniBaseHeader::AddToViewL()

    {    

    DoAddToViewL( EFalse ); // do not read data

    }

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

// CUniBaseHeader::DoAddToViewL

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

// 

EXPORT_C void CUniBaseHeader::DoAddToViewL( TBool aReadContent )

    {

    TInt flag = EUniFeatureFrom;

    // Headers must be in right order. Remove additional first

    RemoveFromViewL( EUniFeatureCc | EUniFeatureBcc | EUniFeatureSubject | EUniFeatureAttachment );

    for ( TInt i = EHeaderAddressFrom; i <= EHeaderAttachment; i++ )

        {

        if ( i == EHeaderAddressTo )

            {

            flag = EUniFeatureTo;

            }

        else if ( i == EHeaderAddressCc )

            {

            flag = EUniFeatureCc;

            }

        else  if ( i == EHeaderAddressBcc )

            {

            flag = EUniFeatureBcc;

            }

        else  if ( i == EHeaderSubject )

            {

            flag = EUniFeatureSubject;

            }

        else if ( i == EHeaderAttachment )

            {

            flag = EUniFeatureAttachment;

            }

        if ( iHeaders[i].iControl &&  

             !iView.ControlById( iHeaders[i].iControlType ) )

            {

            iView.AddControlL( iHeaders[i].iControl,

                               iHeaders[i].iControlType,

                               EMsgAppendControl,

                               EMsgHeader );

            iHeaders[i].iOwned = EFalse;

            }

        else if ( iAddDelayed & EUniFeatureFrom &&  

                  i == EHeaderAddressFrom )

            {

            InsertFromL( aReadContent );          // read from MTM

            iAddDelayed &= ( ~EUniFeatureFrom );

            }

        else if ( iAddDelayed & EUniFeatureSubject &&  

                  i == EHeaderSubject )

            {

            InsertSubjectL( aReadContent );

            iAddDelayed &= ( ~EUniFeatureSubject );

            }

        else if ( iAddDelayed & EUniFeatureAttachment &&

                  i == EHeaderAttachment )

            {

            InsertAttachmentL( aReadContent );

            iAddDelayed &= ( ~EUniFeatureAttachment );

            }

        else if ( iAddDelayed & flag &&  

                  ( i == EHeaderAddressTo ||  

                    i == EHeaderAddressCc ||  

                    i == EHeaderAddressBcc ) )

            {

            InsertRecipientL( iHeaders[i],

                              static_cast<THeaderFields> ( i ),

                              aReadContent);          // read from MTM

            iAddDelayed &= ( ~flag );

            }

        }

    iAddDelayed = 0;

    }

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

// CUniBaseHeader::InsertFromL

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

// 

EXPORT_C void CUniBaseHeader::InsertFromL( TBool /*aReadContent*/) // read from MTM

    {

    }

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

// CUniBaseHeader::RemoveFromViewL

//

// Assumes that slide is automatically correct. Caller's responsibility

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

// 

EXPORT_C void CUniBaseHeader::RemoveFromViewL( TInt aFlags )

    {

    for ( TInt i = EHeaderAddressFrom; i <= EHeaderAttachment; i++ )

        {      

        TInt flag( EUniFeatureTo );

        if ( i == EHeaderAddressFrom )

            {

            flag = EUniFeatureFrom; 

            }

        else if ( i == EHeaderAddressCc )

            {

            flag = EUniFeatureCc; 

            }

        else if ( i == EHeaderAddressBcc )

            {

            flag = EUniFeatureBcc; 

            }

        else if ( i == EHeaderSubject )

            {

            flag = EUniFeatureSubject; 

            }

        else if ( i == EHeaderAttachment )

            {

            flag = EUniFeatureAttachment;

            }

        if ( aFlags & flag &&  

             iHeaders[i].iControl )

            {   

            if ( iView.RemoveControlL( iHeaders[i].iControlType ) )

                {

                iHeaders[i].iOwned = ETrue;

                }

            // else - not removed

            }

        }        

    }

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

// MtmAddressTypes

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

//

EXPORT_C TInt CUniBaseHeader::MtmAddressTypes()

    {

    TInt ret(0);

    const CMsvRecipientList& addresses = iMtm.AddresseeList();

    TInt addrCnt = addresses.Count();        

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

        {          

        if ( addresses.Type(i) == EMsvRecipientTo )

            {

            ret |= EUniFeatureTo;

            }

        else if ( addresses.Type(i) == EMsvRecipientCc )

            {

            ret |= EUniFeatureCc;

            }

        else if ( addresses.Type(i) == EMsvRecipientBcc )

            {

            ret |= EUniFeatureBcc;

            }

        }

    return ret;

    }

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

// CUniBaseHeader::FocusedAddressField

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

//

EXPORT_C TInt CUniBaseHeader::FocusedAddressField( CMsgBaseControl* aFocusedControl )

    {

    TInt ret = KErrNotFound;

    for ( TInt i = EHeaderAddressFrom; i <= EHeaderAttachment ; i++ )

        {    

        if ( iHeaders[i].iControl == aFocusedControl )

            {

            return iHeaders[i].iControlType;

            }

        }

    return ret;

    }

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

// CUniBaseHeader::AddHeadersVariation

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

//

EXPORT_C void CUniBaseHeader::AddHeadersVariationL( TBool aIsUpload )

    {

    TInt featureBitmask = 0;

    CRepository* repository = CRepository::NewL( KCRUidMuiuVariation );

    repository->Get( KMuiuMmsFeatures, featureBitmask );

    delete repository;

    // bit 0x2

    if ( featureBitmask & KMmsFeatureIdEditorSubjectField )

        { // Subject is supported

        iAddHeadersVariation |= EUniFeatureSubject;

        if( featureBitmask & KMmsFeatureIdEditorSubjectConfigurable )

            { // It is also configurable

            iAddHeadersVariation |= EUniFeatureSubjectConfigurable;

            }

        }

    // bit 0x400

    // do not show for upload messages

    if ( featureBitmask & KMmsFeatureIdEditorCcField && 

         !aIsUpload )

        {

        iAddHeadersVariation |= EUniFeatureCc;

        }

    // bit 0x800

    // do not show for upload messages

    if ( featureBitmask & KMmsFeatureIdEditorBccField &&  

         !aIsUpload )

        {

        iAddHeadersVariation |= EUniFeatureBcc;

        }        

    }

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

// CUniBaseHeader::AddHeadersConfig

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

//

EXPORT_C TInt CUniBaseHeader::AddHeadersConfigL()

    {

    TInt featureBitmask = 0;

    TInt ret = 0;

    CRepository* repository = CRepository::NewL( KCRUidMmsui );

    repository->Get( KMmsuiAdditionalHeaders, featureBitmask );

    delete repository;

    // set bit to null if variation is OFF

    if ( featureBitmask & KMmsuiHeaderSubject &&  

         iAddHeadersVariation & EUniFeatureSubjectConfigurable )

        {

        ret |= EUniFeatureSubject;

        }

    if ( featureBitmask & KMmsuiHeaderCC &&  

         iAddHeadersVariation & EUniFeatureCc )

        {

        ret |= EUniFeatureCc;

        }

    if ( featureBitmask & KMmsuiHeaderBCC &&  

         iAddHeadersVariation & EUniFeatureBcc )

        {

        ret |= EUniFeatureBcc;

        }

    iAddHeadersConfig = ret;

    return ret;

    }

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

// CUniBaseHeader::SaveAddHeadersConfigL

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

//

EXPORT_C void CUniBaseHeader::SaveAddHeadersConfigL(TInt aFlags)

    {

    TInt featureBitmask = 0;    

    CRepository* repository = CRepository::NewL( KCRUidMmsui  );

    // Do not set bit if variation is OFF

    if ( aFlags & EUniFeatureSubject &&  

         iAddHeadersVariation & EUniFeatureSubjectConfigurable )

        {

        featureBitmask |= KMmsuiHeaderSubject;

        }

    if ( aFlags & EUniFeatureCc &&  

         iAddHeadersVariation & EUniFeatureCc )

        {

        featureBitmask |= KMmsuiHeaderCC;

        }

    if ( aFlags & EUniFeatureBcc &&  

         iAddHeadersVariation & EUniFeatureBcc )

        {

        featureBitmask |= KMmsuiHeaderBCC;

        }

    // Don't save anything, which is variated off

    repository->Set( KMmsuiAdditionalHeaders, featureBitmask );

    delete repository;

    }

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

// CUniBaseHeader::HasRecipients

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

//

EXPORT_C TBool CUniBaseHeader::HasRecipients( )

    {

    TBool result( EFalse );

    for ( TInt i = EHeaderAddressTo; i <= EHeaderAddressBcc ; i++ )

        {    

        if ( iHeaders[i].iControl )

            {

            CMsgRecipientArray* recipients = NULL;

            TRAP_IGNORE( recipients = 

                            static_cast<CMsgAddressControl*>( iHeaders[i].iControl )->GetRecipientsL() );

            if ( recipients &&  

                 recipients->Count() > 0 )

                {

                result = ETrue;

                break;

                }

            }

        }

    return result;

    }

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

// CUniBaseHeader::IsAddressControl

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

//

EXPORT_C TBool CUniBaseHeader::IsAddressControl (TInt aId )

    {

    TBool result( EFalse );

    for ( TInt i = EHeaderAddressTo; i <= EHeaderAddressBcc ; i++ )

        {    

        if ( iHeaders[i].iControl &&  

             iHeaders[i].iControlType == aId )

            {

            result = ETrue;

            break;

            }

        }

    return result;

    }

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

// CUniBaseHeader::HandleResourceChange

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

//

EXPORT_C void CUniBaseHeader::HandleResourceChange( TInt aType )

    {

    for ( TInt i = EHeaderAddressFrom; i <= EHeaderAttachment ; i++ )

        {    

        if ( iHeaders[i].iControl &&  

             iHeaders[i].iOwned )

            {

            iHeaders[i].iControl->HandleResourceChange( aType );

            }

        }

    }

//  End of File