/*

* 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:  

*       Provides Uni MTM UI methods.

*

*/

// INCLUDE FILES

#include <apgcli.h>

#include <msvuids.h>

#include <mtmuidef.hrh>

#include <mtmdef.h>

#include <UniMtms.rsg>

#include <msvstore.h>

#include <mmsvattachmentmanager.h>

#include <e32keys.h>

#include <coemain.h>

#include <eikenv.h>

#include <eikdef.h>

#include <eikmfne.h>

#include <eikedwin.h>

#include <eikcapc.h>

#include <gulicon.h>

#include <ErrorUI.h> //CErrorUI

#include <aknPopup.h>

#include <aknlists.h>

#include <aknconsts.h>

#include <akncontext.h>

#include <akntabgrp.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

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

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

#include <messagingvariant.hrh>     // additional headers variation flags. 

									// Currently MMS variation, no variataion for unieditor available.

#include <StringLoader.h>

#include <Muiumsginfo.h>

#include <MuiuMsvUiServiceUtilities.h>

#include <MuiuOperationWait.h>

#include <muiumsguploadparam.h>

#include <MtmExtendedCapabilities.hrh>

#include <mmsgenutils.h>

#include <unimsventry.h>

#include "UniMtmUi.h"

#include "UniMtmPanic.h"

#include "UniMtmConst.h"

#include "UniClientMtm.h"

#include "UniEditorUids.hrh"

// EXTERNAL FUNCTION PROTOTYPES  

extern void Panic( TUniMtmPanic aPanic );

// CONSTANTS

_LIT( KCharLeftAddressIterator, "<" );

_LIT( KCharRightAddressIterator, ">" );

_LIT( KMmsCharCommaAndSpace, ", " );

const TInt KMessageSize = 20;

const TInt KZero = 0; //constant for memory check

const TInt KMmsAdditionalCharsStringLength = 6;

const TUint KMmsLRMarker = 0x200E;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================

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

// NewUniMtmUiL

// Factory function

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

//

EXPORT_C CBaseMtmUi* NewUniMtmUiL( CBaseMtm& aMtm, CRegisteredMtmDll& aRegisteredDll )

    {

    return CUniMtmUi::NewL( aMtm, aRegisteredDll );

    }

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

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

// CUniMtmUi::CUniMtmUi

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUniMtmUi::CUniMtmUi( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll )

    :   CBaseMtmUi( aBaseMtm, aRegisteredMtmDll )

    {

    }

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

// CUniMtmUi::ConstructL

// Symbian OS default constructor can leave.

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

//

void CUniMtmUi::ConstructL()

    {

    CBaseMtmUi::ConstructL();

    }

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

// CUniMtmUi::NewL

// Two-phased constructor.

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

// 

CUniMtmUi* CUniMtmUi::NewL( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll )

    {

    CUniMtmUi* self = new ( ELeave ) CUniMtmUi( aBaseMtm, aRegisteredMtmDll );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUniMtmUi::~CUniMtmUi

// Destructor

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

//

CUniMtmUi::~CUniMtmUi()

    {

    }

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

// CUniMtmUi::QueryCapability

// Capability check for UI mtm specific functionality. These should

// be minimal, as the default capability checking places are UI data MTM

// (UI) and client MTM (engine).

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

TInt CUniMtmUi::QueryCapability( TUid aCapability, TInt& aResponse )

    {

    return CBaseMtmUi::QueryCapability( aCapability, aResponse );

    }

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

// CUniMtmUi::CreateL

// Launches Uni editor for creating a new message.

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

//

CMsvOperation* CUniMtmUi::CreateL( const TMsvEntry& aEntry, 

                                  CMsvEntry& aParent, 

                                  TRequestStatus& aStatus )

    {

    __ASSERT_DEBUG( aEntry.iMtm == Type(), Panic( EUniWrongMtm ) );

    __ASSERT_DEBUG( aEntry.iType == KUidMsvMessageEntry, Panic( EUniNotAMessage ) );

    if( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL(

    	Session(),

        KZero ) )

        {

        User::Leave( KErrDiskFull );

        }

    return LaunchEditorApplicationL( aStatus, aParent.Session(), ECreateNewMessage );

    }

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

// CUniMtmUi::DeleteServiceL

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

//

CMsvOperation* CUniMtmUi::DeleteServiceL( const TMsvEntry& /*aService*/, 

                                         TRequestStatus& /*aStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::DeleteFromL

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

//

CMsvOperation* CUniMtmUi::DeleteFromL( const CMsvEntrySelection& /*aSelection*/, 

                                      TRequestStatus& /*aStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::CopyToL

// Copy local outbox entry to remote server = called when sending the entry from MCE outbox

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

//

CMsvOperation* CUniMtmUi::CopyToL( const CMsvEntrySelection& aSelection, 

                                  TRequestStatus& aStatus )

    {

    return CopyMoveToL( aSelection, aStatus, ETrue );

    }

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

// CUniMtmUi::MoveToL

// Move local outbox entry to remote server.

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

//

CMsvOperation* CUniMtmUi::MoveToL( const CMsvEntrySelection& aSelection, 

                                  TRequestStatus& aStatus )

    {

    return CopyMoveToL( aSelection, aStatus, EFalse );

    }

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

// CUniMtmUi::CopyMoveToL

// Performs either CopyToL or MoveToL operation.

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

//

CMsvOperation* CUniMtmUi::CopyMoveToL( const CMsvEntrySelection& aSelection, 

                                      TRequestStatus& aStatus, TBool aCopyOnly )

    {

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EUniWrongMtm ) );

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iType==KUidMsvServiceEntry, Panic( EUniNotAService ) );

    // --- Carry out the operation ---

    TMsvEntry service ( BaseMtm().Entry().Entry() );

    //    Get CMsvEntry of parent of messages to be sent

    CMsvEntry* parentEntry = Session().GetEntryL( aSelection[0] );    

    CleanupStack::PushL( parentEntry );

    parentEntry->SetEntryL( parentEntry->Entry().Parent() );

    // Do the copy/move

    CMsvOperation* op = aCopyOnly ?

        parentEntry->CopyL( aSelection, service.Id(), aStatus ) :

        parentEntry->MoveL( aSelection, service.Id(), aStatus );

    CleanupStack::PopAndDestroy( parentEntry ); 

    return op;

    }

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

// CUniMtmUi::CopyFromL

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

//

CMsvOperation* CUniMtmUi::CopyFromL(const CMsvEntrySelection& /*aSelection*/, 

                                    TMsvId /*aTargetId*/, 

                                    TRequestStatus& /*aStatus*/)

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::MoveFromL

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

//

CMsvOperation* CUniMtmUi::MoveFromL(const CMsvEntrySelection& /*aSelection*/, 

                                    TMsvId /*aTargetId*/, 

                                    TRequestStatus& /*aStatus*/)

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::OpenL

// Handles request to open existing message server entry (message/service)

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

//

CMsvOperation* CUniMtmUi::OpenL( TRequestStatus& aStatus )

    {

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EUniWrongMtm ) );

    const TMsvEntry& entry = BaseMtm().Entry().Entry();

    __ASSERT_DEBUG( !entry.ReadOnly(), Panic( EUniWrongParameters ));

    return EditL( aStatus );    

    }

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

// CUniMtmUi::OpenL

// Opens the first entry in a selection

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

//

CMsvOperation* CUniMtmUi::OpenL( TRequestStatus& aStatus, 

                                const CMsvEntrySelection& aSelection )

    {

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EUniWrongMtm ) );

    BaseMtm().SwitchCurrentEntryL( aSelection[0] );

    return OpenL( aStatus );

    }

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

// CUniMtmUi::CloseL

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

//

CMsvOperation* CUniMtmUi::CloseL( TRequestStatus& /*aStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::CloseL

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

//

CMsvOperation* CUniMtmUi::CloseL( TRequestStatus& /*aStatus*/, 

                                 const CMsvEntrySelection& /*aSelection*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::EditL

// Opens a message (editor) for editing.

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

//

CMsvOperation* CUniMtmUi::EditL( TRequestStatus& aStatus )

    {

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EUniWrongMtm ) );

    CMsvOperation* msvoperation = NULL;

    switch ( iBaseMtm.Entry().Entry().iType.iUid )

        {

        case KUidMsvMessageEntryValue:

            {

            if ( iBaseMtm.Entry().Entry().Connected() )

                {

                User::Leave( KErrLocked ); 

                }

            msvoperation = LaunchEditorApplicationL( aStatus, iBaseMtm.Entry().Session() );

            }

            break;

        case KUidMsvServiceEntryValue:

        case KUidMsvAttachmentEntryValue:   // flow through

        case KUidMsvFolderEntryValue:       // flow through

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return msvoperation;

    }

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

// CUniMtmUi::EditL

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

//

CMsvOperation* CUniMtmUi::EditL( TRequestStatus& aStatus, 

                                const CMsvEntrySelection& aSelection )

    {

    BaseMtm().SwitchCurrentEntryL( aSelection[0] );

    return EditL( aStatus );

    }

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

// CUniMtmUi::ViewL

// Opens the message for reading in Viewer.

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

//

CMsvOperation* CUniMtmUi::ViewL( TRequestStatus& /*aStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::ViewL

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

//

CMsvOperation* CUniMtmUi::ViewL( TRequestStatus& /*aStatus*/, 

                                const CMsvEntrySelection& /*aSelection*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::LaunchEditorApplicationL()

// Does the actual opening.

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

//

CMsvOperation* CUniMtmUi::LaunchEditorApplicationL( TRequestStatus& aStatus, 

                                                   CMsvSession& aSession, 

                                                   TEditorType aEditorType )

    {

    TEditorParameters temp;    

    if ( iBaseMtm.HasContext() )

        {

        temp.iId = iBaseMtm.Entry().EntryId();

        }

    switch( aEditorType )

        {

        case EReadOnly:

        case ESpecialEditor:

            User::Leave( KErrNotSupported );

            break;                             

        case ECreateNewMessage:

            temp.iFlags|=EMsgCreateNewMessage ;

            temp.iId=KMsvDraftEntryIdValue;

            break;

        case EEditExisting:  //fall through

        default:

            break;

        };

    temp.iFlags &= ~( EMtmUiFlagEditorPreferEmbedded|EMtmUiFlagEditorNoWaitForExit );

    temp.iFlags |= ( Preferences() & EMtmUiFlagEditorPreferEmbedded?EMsgLaunchEditorEmbedded:EMsgLaunchEditorStandAlone );

    TPckgC<TEditorParameters> paramPack( temp );

    return MsgEditorLauncher::LaunchEditorApplicationL(

        aSession,

        Type(),

        aStatus,

        temp,

        KNullDesC(),

        paramPack );

    }

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

// CUniMtmUi::ForwardL

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

//

CMsvOperation* CUniMtmUi::ForwardL( TMsvId /*aDestination*/,

                                   TMsvPartList /*aPartList*/, 

                                   TRequestStatus& /*aCompletionStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::ReplyL

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

//

CMsvOperation* CUniMtmUi::ReplyL( TMsvId /*aDestination*/, 

                                 TMsvPartList /*aPartList*/, 

                                 TRequestStatus& /*aCompletionStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::CancelL

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

//

CMsvOperation* CUniMtmUi::CancelL( TRequestStatus& /*aStatus*/, 

                                  const CMsvEntrySelection& /*aSelection*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniMtmUi::InvokeSyncFunctionL

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

//

void CUniMtmUi::InvokeSyncFunctionL( TInt aFunctionId, 

                                    const CMsvEntrySelection& aSelection, 

                                    TDes8& aParameter )

    {

    CBaseMtmUi::InvokeSyncFunctionL( aFunctionId, aSelection, aParameter );

    }

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

// CUniMtmUi::InvokeAsyncFunctionL

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

//

CMsvOperation* CUniMtmUi::InvokeAsyncFunctionL( TInt aFunctionId, 

                                               const CMsvEntrySelection& aSelection, 

                                               TRequestStatus& aCompletionStatus, 

                                               TDes8& aParameter )

    {

    CMsvOperation* msvoperation = NULL;

    switch ( aFunctionId )

        {

    case KMtmUiFunctionMessageInfo:

        msvoperation = OpenMessageInfoL( aCompletionStatus, aParameter );

        break;

    default:

        msvoperation = CBaseMtmUi::InvokeAsyncFunctionL( aFunctionId, 

            aSelection, 

            aCompletionStatus, 

            aParameter);

        break;

        }

    return msvoperation;

    }

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

// CUniMtmUi::DisplayProgressSummary

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