1 /*

     2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  MsgEditorAppUi implementation

    15 *

    16 */

    17 

    18 

    19 

    20 // ========== INCLUDE FILES ================================

    21 

    22 #include <featmgr.h>                // for feature manager

    23 

    24 #include <eikenv.h>                 // Eikon Enviroment

    25 #include <txtrich.h>                // Rich Text

    26 #include <eikrted.h>                // CEikRichTextEditor

    27 #include <eikmenub.h>               // CEikMenuBar

    28 #include <eikspane.h>               // status panel

    29 

    30 #include <eikapp.h>                 // CEikApplication

    31 #include <eikserverapp.h>

    32 #include <bautils.h>                // NearestLanguageFile

    33 #include <eikdialg.h>               // CEikDialog

    34 #include <data_caging_path_literals.hrh>

    35 

    36 #include <msvapi.h>                 //

    37 #include <mtmuibas.h>               // MTM UI

    38 #include <mtmuidef.hrh>             // Preferences

    39 #include <mtmdef.h>                 // TMsvPartList

    40 

    41 #include <MuiuMsgEmbeddedEditorWatchingOperation.h>

    42 #include <MuiuMsgEditorLauncher.h>  // for TEditorParameters

    43 #include <MuiuMessageIterator.h>    // for CMessageIterator

    44 #include <MuiuOperationWait.h>      // for CMuiuOperationWait

    45 #include <muiu.mbg>

    46 

    47 #include <aknenv.h>

    48 #include <aknnavi.h>                // CAknNavigationControlContainer

    49 #include <aknnavide.h>              // CAknNavigationDecorator

    50 #include <akntabgrp.h>              // CAknTabGroup

    51 #include <akninputblock.h>          // CAknInputBlock

    52 #include <aknnotewrappers.h>

    53 #include <AknIndicatorContainer.h>

    54 #include <akncontext.h>             // For message store in MMC -indication

    55 #include <AknsUtils.h>

    56 #include <AknsConstants.h>

    57 #include <commonphoneparser.h>      // Common phone number validity checker

    58 #include <apgicnfl.h>               // apamasked bitmaps

    59 #include <ErrorUI.h>				// CErrorUI - to show global error notes

    60 #include <StringLoader.h>           // StringLoader

    61 #include <NpdApi.h>                 // Notepad API

    62 #include <avkon.hrh>

    63 #include <AknStatuspaneUtils.h>

    64 #include <AknSettingCache.h>

    65 #include <messaginginternalcrkeys.h>

    66 #include <MessagingSDKCRKeys.h>

    67 #include "MsgEditorAppUiExtension.h"

    68 

    69 #include <aknlayoutscalable_avkon.cdl.h>

    70 

    71 #include "MsgEditorShutter.h"

    72 

    73 #include "MsgEditorCommon.h"

    74 #include "MsgEditorAppUi.h"         // class header

    75 #include "MsgEditorView.h"          // View

    76 #include "MsgBodyControl.h"         // Body Control

    77 #include "MsgSendKeyAcceptingQuery.h"

    78 #include "MsgEditorAppUiPanic.h"    // Panics

    79 #include "MsgEditorFlags.h"         // EditorFlags

    80 #include "MsgAttachmentUtils.h"

    81 #include <MsgEditorAppUi.rsg>       // resource identifiers

    82 #include "MsgNaviPaneControl.h"

    83 

    84 #ifdef RD_MSG_FAST_PREV_NEXT

    85 #include <messaginginternalpskeys.h>

    86 #endif

    87 

    88 #include "MsgEditorLogging.h"

    89 

    90 // ========== EXTERNAL DATA STRUCTURES =====================

    91 

    92 // ========== EXTERNAL FUNCTION PROTOTYPES =================

    93 

    94 // ========== CONSTANTS ====================================

    95 

    96 const TInt KMsgDiskSpaceForDelete = ( 5 * 1024 ); // minimum disk space needed when deleting messages

    97 

    98 // ========== MACROS =======================================

    99 

   100 _LIT( KMsgEditorAppUiResourceFileName, "msgeditorappui.rsc" );

   101 _LIT( KMuiuBitmapFileName, "muiu.mbm" );

   102 _LIT( KMsgEditorAppUiFilterRe, "RE:" );

   103 _LIT( KMsgEditorAppUiFilterFw, "FW:" );

   104 _LIT( KMsgEditorAppUiFilterFwd, "FWD:" );

   105 

   106 // ========== LOCAL CONSTANTS AND MACROS ===================

   107 

   108 // ========== MODULE DATA STRUCTURES =======================

   109 

   110 // ========== LOCAL FUNCTION PROTOTYPES ====================

   111 

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

   113 

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

   115 

   116 // ---------------------------------------------------------

   117 // CMsgEditorAppUi::CMsgEditorAppUi

   118 //

   119 // Constructor.

   120 // ---------------------------------------------------------

   121 //

   122 EXPORT_C CMsgEditorAppUi::CMsgEditorAppUi() : 

   123     iExitMode( MApaEmbeddedDocObserver::EKeepChanges ),

   124     iCloseWithEndKey( ETrue )

   125     {

   126     }

   127 

   128 // ---------------------------------------------------------

   129 // CMsgEditorAppUi::ConstructL

   130 //

   131 // 2nd phase constructor.

   132 // ---------------------------------------------------------

   133 //

   134 EXPORT_C void CMsgEditorAppUi::ConstructL()

   135     {

   136     CMsgEditorBaseUi::ConstructL();

   137     

   138     iMsgNaviDirection = KErrNotFound; 

   139 

   140     // initialize feature manager to check supported features

   141     FeatureManager::InitializeLibL();

   142     iMmcFeatureSupported = FeatureManager::FeatureSupported( KFeatureIdMmc );

   143 

   144     TParse parse;

   145     parse.Set( KMsgEditorAppUiResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL );

   146     TFileName fileName( parse.FullName() );

   147 

   148     BaflUtils::NearestLanguageFile( iCoeEnv->FsSession(), fileName );

   149     iResourceFileOffset = iEikonEnv->AddResourceFileL( fileName );

   150 

   151     Document()->SetEditorModelObserver( this );

   152 

   153     iFileMan = CFileMan::NewL( iEikonEnv->FsSession() );

   154 

   155     // create msgeditor temp directory.

   156     TFileName temppath;

   157     MsgAttachmentUtils::GetMsgEditorTempPath( temppath );

   158 

   159     RFs& fs = iEikonEnv->FsSession();

   160     fs.MkDir( temppath );

   161 

   162     CEikStatusPane* sp = StatusPane();

   163     if ( iMmcFeatureSupported && 

   164         TInt( Document()->Session().CurrentDriveL() ) == EDriveE )

   165         {

   166         CAknContextPane* contextPane = static_cast<CAknContextPane*>

   167             ( sp->ControlL( TUid::Uid( EEikStatusPaneUidContext ) ) );

   168         TParse fileParse;

   169         fileParse.Set( KMuiuBitmapFileName, &KDC_APP_BITMAP_DIR, NULL );

   170         CFbsBitmap* bmp = NULL;

   171         CFbsBitmap* mask = NULL;

   172 #ifdef __SCALABLE_ICONS

   173         AknsUtils::CreateIconL(

   174             AknsUtils::SkinInstance(),

   175             KAknsIIDQgnMenuMceMmcCxt,

   176             bmp,

   177             mask,

   178             fileParse.FullName(),

   179             EMbmMuiuQgn_menu_mce_mmc,

   180             EMbmMuiuQgn_menu_mce_mmc_mask );

   181 #else

   182         AknsUtils::CreateIconL(

   183             AknsUtils::SkinInstance(),

   184             KAknsIIDQgnMenuMceMmcCxt,

   185             bmp,

   186             mask,

   187             fileParse.FullName(),

   188             EMbmMuiuQgn_menu_mce_mmc_cxt,

   189             EMbmMuiuQgn_menu_mce_mmc_cxt_mask );

   190 #endif  //__SCALABLE_ICONS

   191         contextPane->SetPicture( bmp, mask );

   192         }

   193     iOwnNaviPane = static_cast<CAknNavigationControlContainer*>

   194         ( sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );

   195     iCoeEnv->FsSession().ReserveDriveSpace(

   196         TInt( Document()->Session().CurrentDriveL() ),

   197         KMsgDiskSpaceForDelete );

   198   

   199     CMsgEditorDocument* doc = Document();

   200     iEditorShutter = CMsgEditorShutter::NewL(*doc);

   201   

   202     iMsgEditorAppUiExtension = new(ELeave) CMsgEditorAppUiExtension( this );

   203     CAknEnv* env = iAvkonEnv;

   204     CAknSettingCache& cache = env->SettingCache();

   205     cache.RegisterPluginL( &( iMsgEditorAppUiExtension->iSettingCachePlugin ) );    

   206     

   207     iStatusPaneRes = StatusPane()->CurrentLayoutResId();

   208     }

   209 

   210 // ---------------------------------------------------------

   211 // CMsgEditorAppUi::~CMsgEditorAppUi

   212 //

   213 // Destructor.

   214 // ---------------------------------------------------------

   215 //

   216 EXPORT_C CMsgEditorAppUi::~CMsgEditorAppUi()

   217     {

   218     delete iEditorShutter;

   219 

   220     Document()->SetEditorModelObserver( NULL );

   221 

   222     // remove resource file from CONE-maintained resource file list.

   223     if ( iResourceFileOffset )

   224         {

   225         iEikonEnv->DeleteResourceFile( iResourceFileOffset );

   226         }

   227 

   228     // call NotifyExit on completion of editing of an embedded document.

   229     if ( iDoorObserver )

   230         {

   231         MEBLOGGER_WRITEF( _L( "MEB: CMsgEditorAppUi: Closing with exit mode %d" ), iExitMode );

   232         iDoorObserver->NotifyExit( iExitMode );

   233         }

   234 

   235     delete iView;

   236     delete iLock;

   237     delete iNaviDecorator;

   238 

   239     delete iIterator;

   240 

   241     // delete files from our temp directory.

   242     if ( iFileMan )

   243         {

   244         TFileName temppath;

   245         MsgAttachmentUtils::GetMsgEditorTempPath( temppath );

   246 

   247         /*TInt err =*/ iFileMan->Delete( temppath /*, CFileMan::ERecurse*/ );

   248         //TInt err2 = iFileMan->RmDir(temppath); // remove directory

   249         }

   250 

   251     delete iFileMan;

   252 

   253     // Uninitialize FeatureManager and members

   254     FeatureManager::UnInitializeLib();

   255     if( iMsgEditorAppUiExtension )

   256         {

   257         CAknEnv* env = iAvkonEnv;

   258         CAknSettingCache& cache = env->SettingCache();

   259         cache.DeRegisterPlugin( &( iMsgEditorAppUiExtension->iSettingCachePlugin ) );

   260         delete iMsgEditorAppUiExtension;

   261         }    

   262     }

   263 

   264 // ---------------------------------------------------------

   265 // CMsgEditorAppUi::HandleKeyEventL

   266 //

   267 // Route key events to view.

   268 // ---------------------------------------------------------

   269 //

   270 EXPORT_C TKeyResponse CMsgEditorAppUi::HandleKeyEventL(

   271     const TKeyEvent& aKeyEvent, TEventCode aType )

   272     {

   273     if ( iView )

   274         {

   275         return iView->OfferKeyEventL( aKeyEvent, aType );

   276         }

   277     return EKeyWasNotConsumed;

   278     }

   279 

   280 // ---------------------------------------------------------

   281 // CMsgEditorAppUi::HandleWsEventL

   282 //

   283 //

   284 // ---------------------------------------------------------

   285 //

   286 EXPORT_C void CMsgEditorAppUi::HandleWsEventL( const TWsEvent& aEvent,CCoeControl* aDestination )

   287     {

   288     TInt type = aEvent.Type();

   289 

   290     if ( type == EEventKey )

   291         {

   292         TKeyEvent* key = aEvent.Key();

   293         if ( ( key->iModifiers & EModifierShift ) &&

   294             ( key->iCode == EKeyBackspace ) )

   295             {

   296             if ( iView )

   297                 {

   298                 CMsgBodyControl* body = 

   299                         static_cast<CMsgBodyControl*>( iView->ControlById( EMsgComponentIdBody ) );

   300 

   301                 if ( body && body->IsReadOnly() )

   302                     {

   303                     TRAP_IGNORE( SaveBodyL( body ) );

   304                     }

   305                 }

   306 

   307             key->iModifiers &= ~EModifierShift;

   308             key->iCode = EKeyDelete;

   309             }

   310         }

   311         

   312     if ( type != KAknUidValueEndKeyCloseEvent ||

   313          iCloseWithEndKey )

   314         {

   315         CAknAppUi::HandleWsEventL( aEvent, aDestination );

   316         }

   317     }

   318 

   319 // ---------------------------------------------------------

   320 // CMsgEditorAppUi::NextMessageL

   321 //

   322 // Set a specific exit code for opening next or previous message. Codes are

   323 // defined in MuiuMsgEmbeddedEditorWatchingOperation.h 

   324 // and handled by MCE after msg viewer has been closed.

   325 // ---------------------------------------------------------

   326 //

   327 EXPORT_C void CMsgEditorAppUi::NextMessageL( TBool aForward )

   328     {

   329     // Next is ETrue if layout is EAknLayoutIdABRW,

   330     // EFalse if EAknLayoutIdELAF or EAknLayoutIdAPAC

   331     if ( AknLayoutUtils::LayoutMirrored() )

   332         {

   333         aForward = !aForward;

   334         }

   335 

   336     iMsgNaviDirection = aForward;

   337 #ifdef RD_MSG_FAST_PREV_NEXT

   338     // Check if next/previous message can be fast opened by viewer

   339     __ASSERT_DEBUG( iIterator != NULL, Panic( ENullPointer1 ) );

   340     if ( aForward )

   341         {

   342         iIterator->SetNextMessage();

   343         }

   344     else

   345         {

   346         iIterator->SetPreviousMessage();

   347         }

   348 

   349     if ( CanFastOpenL( *iIterator) )

   350         {

   351         // Load next/previous message

   352         TRAPD( err, Document()->SetEntryL( iIterator->CurrentMessage().Id() ) );

   353         // If fast open fails, view is incompletely constructed

   354         // Drop back to mce

   355         if( err == KErrCancel )

   356             {

   357             /* It is a known-valid failure(quick lauch cancelled in viewers due to heterogenous messages)

   358              * In that case, reset the current entry to original and exit with correct code so that message

   359              * will be launched completely from MCE.

   360              */

   361             if ( iMsgNaviDirection )

   362                 {

   363                 iIterator->SetPreviousMessage();

   364                 }

   365             else

   366                 {

   367                 iIterator->SetNextMessage();

   368                 }

   369             Document()->SetEntryWithoutNotificationL( iIterator->CurrentMessage().Id() );

   370             iExitMode = iMsgNaviDirection ?

   371                 MApaEmbeddedDocObserver::TExitMode(

   372                     CMsgEmbeddedEditorWatchingOperation::EMsgExitNext) :

   373                 MApaEmbeddedDocObserver::TExitMode(

   374                     CMsgEmbeddedEditorWatchingOperation::EMsgExitPrevious);

   375             Exit( iExitMode );

   376             }

   377         else if ( err != KErrNone )

   378             {

   379             // Unknown error during quick launch.

   380             iCoeEnv->HandleError( err );

   381             iExitMode = MApaEmbeddedDocObserver::ENoChanges;

   382             Exit( EAknSoftkeyClose );

   383             }

   384         }

   385     else

   386 #endif // RD_MSG_FAST_PREV_NEXT

   387         {

   388         iExitMode = aForward ?

   389             MApaEmbeddedDocObserver::TExitMode(

   390                 CMsgEmbeddedEditorWatchingOperation::EMsgExitNext) :

   391             MApaEmbeddedDocObserver::TExitMode(

   392                 CMsgEmbeddedEditorWatchingOperation::EMsgExitPrevious);

   393         Exit( iExitMode );

   394         }

   395     iMsgNaviDirection = KErrNotFound;

   396     }

   397 

   398 // ---------------------------------------------------------

   399 // CMsgEditorAppUi::IsNextMessageAvailableL

   400 //

   401 // Check if next or previous msg is available.

   402 // ---------------------------------------------------------

   403 //

   404 EXPORT_C TBool CMsgEditorAppUi::IsNextMessageAvailableL( TBool aForward )

   405     {

   406     TBool ret = EFalse;

   407     

   408     if ( iEikonEnv->StartedAsServerApp() )

   409         {

   410         CMsgEditorDocument* doc = Document();

   411 

   412         if ( iIterator == NULL )

   413             {

   414             iIterator = CMessageIterator::NewL( doc->Session(), doc->Entry() );

   415             iIterator->SetMessageIteratorObserver( this );

   416             }

   417 

   418         // Next is ETrue if layout is EAknLayoutIdABRW,

   419         // EFalse if EAknLayoutIdELAF or EAknLayoutIdAPAC

   420         if ( AknLayoutUtils::LayoutMirrored() )

   421             {

   422             aForward = !aForward;

   423             }

   424 

   425         if ( aForward )

   426             {

   427             if ( iIterator->NextMessageExists() )

   428                 {

   429                 ret = ETrue;

   430                 }

   431             }

   432         else

   433             {

   434             if ( iIterator->PreviousMessageExists() )

   435                 {

   436                 ret = ETrue;

   437                 }

   438             }

   439         }

   440         

   441     return ret;

   442     }

   443 

   444 // ---------------------------------------------------------

   445 // CMsgEditorAppUi::MessageIndexInFolderL

   446 //

   447 // Returns index of current msg and also total number of msgs in folder.

   448 // ---------------------------------------------------------

   449 //

   450 EXPORT_C void CMsgEditorAppUi::MessageIndexInFolderL( TInt& aCurrentIndex, 

   451                                                       TInt& aMsgsInFolder )

   452     {

   453     if ( iEikonEnv->StartedAsServerApp() )

   454         {

   455         CMsgEditorDocument* doc = Document();

   456 

   457         if ( iIterator == NULL )

   458             {

   459             iIterator = CMessageIterator::NewL( doc->Session(), doc->Entry() );

   460             iIterator->SetMessageIteratorObserver( this );

   461             }

   462 

   463         aCurrentIndex = iIterator->CurrentMessageIndex();

   464         aMsgsInFolder = iIterator->MessagesInFolder();

   465         }

   466     else

   467         {

   468         aCurrentIndex = 0;

   469         aMsgsInFolder = 0;

   470         }

   471     }

   472 

   473 // ---------------------------------------------------------

   474 // CMsgEditorAppUi::MoveMessageEntryL

   475 //

   476 // Moves an entry to another location.

   477 // ---------------------------------------------------------

   478 //

   479 EXPORT_C TMsvId CMsgEditorAppUi::MoveMessageEntryL( TMsvId aTarget ) const

   480     {

   481     TMsvEntry msvEntry = Document()->Entry();

   482     TMsvId id = KMsvNullIndexEntryId;

   483 

   484     if ( msvEntry.Parent() != aTarget )

   485         {

   486         CAknInputBlock::NewLC();

   487 

   488         CMsvEntry* parentEntry = Document()->Session().GetEntryL( msvEntry.Parent() );

   489         CleanupStack::PushL( parentEntry );

   490 

   491         // -- Change sort parameters so that parentEntry->MoveL does not leave as the child is invisible.

   492         TMsvSelectionOrdering sort = parentEntry->SortType();

   493         sort.SetShowInvisibleEntries( ETrue );

   494         parentEntry->SetSortTypeL( sort );

   495 

   496         // Copy original from the parent to the new location.

   497         CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();

   498 

   499         CMsvOperation* op = parentEntry->MoveL(

   500             msvEntry.Id(), aTarget, wait->iStatus );

   501         CleanupStack::PushL( op );

   502         wait->Start(); // wait for asynch operation

   503 

   504         TMsvLocalOperationProgress prog = McliUtils::GetLocalProgressL( *op );

   505         User::LeaveIfError( prog.iError );

   506         id = prog.iId;

   507 

   508         CleanupStack::PopAndDestroy( 4 );  // op, wait, parentEntry, absorber

   509         }

   510 

   511     return id;

   512     }

   513 

   514 // ---------------------------------------------------------

   515 // CMsgEditorAppUi::DeleteAndExitL

   516 //

   517 // Deletes current entry and then exits.

   518 // ---------------------------------------------------------

   519 //

   520 EXPORT_C void CMsgEditorAppUi::DeleteAndExitL()

   521     {

   522     DeleteCurrentEntryL();

   523     Exit( EAknSoftkeyBack );

   524     }

   525 

   526 // ---------------------------------------------------------

   527 // CMsgEditorAppUi::DeleteCurrentEntryL

   528 //

   529 // Deletes current entry.

   530 // ---------------------------------------------------------

   531 //

   532 EXPORT_C void CMsgEditorAppUi::DeleteCurrentEntryL()

   533     {

   534     CMsgEditorDocument* doc = Document();

   535     UnlockEntry();

   536 

   537     TInt msgStoreDrive = TInt( doc->Session().CurrentDriveL() );

   538     iCoeEnv->FsSession().GetReserveAccess( msgStoreDrive );

   539 

   540     if ( doc->CurrentEntry().OwningService() == KMsvLocalServiceIndexEntryId )

   541         {

   542         const TMsvId id = doc->Entry().Id();

   543         //doc->CurrentEntry().SetEntryL( doc->Entry().Parent() );

   544         TRAPD( 

   545                 err, 

   546                 {

   547                 doc->CurrentEntry().SetEntryL( doc->Entry().Parent() ); 

   548                 doc->CurrentEntry().DeleteL( id ); 

   549                 }

   550             );

   551         if ( err != KErrNone )

   552             {

   553             doc->Session().RemoveEntry( id );

   554             }

   555         }

   556     else

   557         {

   558         CMsvEntrySelection* sel = new ( ELeave ) CMsvEntrySelection;

   559         CleanupStack::PushL( sel );

   560         TMsvId id = doc->Entry().Id();

   561         sel->AppendL( id );

   562         doc->Mtm().SwitchCurrentEntryL( doc->Entry().Parent() );

   563 

   564         CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();

   565 

   566         CMsvOperation* op = doc->MtmUi().DeleteFromL( *sel, wait->iStatus );

   567         CleanupStack::PushL( op );

   568 

   569         wait->Start();

   570 

   571         const TInt err = doc->MtmUi().DisplayProgressSummary( op->ProgressL() );

   572         CleanupStack::PopAndDestroy( 3, sel );  // sel, wait, op

   573         if ( err == KErrCancel )

   574             {

   575             doc->Mtm().SwitchCurrentEntryL( id );

   576             LockEntryL();

   577             return ;

   578             }

   579         User::LeaveIfError( err );

   580         }

   581 

   582     iCoeEnv->FsSession().ReleaseReserveAccess( msgStoreDrive );

   583     }

   584 

   585 // ---------------------------------------------------------

   586 // CMsgEditorAppUi::PrepareToExit

   587 //

   588 //

   589 // ---------------------------------------------------------

   590 //

   591 EXPORT_C void CMsgEditorAppUi::PrepareToExit()

   592     {

   593     CMsgEditorDocument* doc = Document();

   594 

   595     if ( doc->HasModel() )

   596         {

   597         if ( doc->Entry().InPreparation() )

   598             {

   599             doc->Session().RemoveEntry( doc->Entry().Id() );

   600             }

   601         }

   602 

   603     CEikAppUi::PrepareToExit();

   604     }

   605 

   606 // ---------------------------------------------------------

   607 // CMsgEditorAppUi::ReplyL

   608 //

   609 // Asynchronous Mtm reply command.

   610 // ---------------------------------------------------------

   611 //

   612 EXPORT_C void CMsgEditorAppUi::ReplyL(

   613     TMsvId aTarget, TBool aIncludeOriginal /*= ETrue*/ )

   614     {

   615     TMsvPartList parts =

   616         KMsvMessagePartDescription |

   617         KMsvMessagePartOriginator;

   618 

   619     if ( aIncludeOriginal )

   620         {

   621         parts |= KMsvMessagePartBody;

   622         }

   623 

   624     CBaseMtmUi& mtmUi = Document()->MtmUi();

   625 

   626     // to by-pass scanner warning about member variable being stored into

   627     // cleanup stack blocker is first stored into temporary variable. Storing

   628     // is allowed here as it is not owned.

   629     CAknInputBlock* blocker = CAknInputBlock::NewCancelHandlerLC( this );

   630     iInputBlocker = blocker;

   631 

   632     CMuiuOperationWait* wait =

   633         CMuiuOperationWait::NewLC( EActivePriorityWsEvents + 10 );

   634 

   635     mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );

   636     CMsvOperation* oper = mtmUi.ReplyL( aTarget, parts, wait->iStatus );

   637     CleanupStack::PushL( oper );

   638 

   639     wait->Start();

   640     

   641     CleanupStack::PopAndDestroy( 3, iInputBlocker );  // absorber, wait, oper

   642     iInputBlocker = NULL;

   643     }

   644 

   645 // ---------------------------------------------------------

   646 // CMsgEditorAppUi::ReplyToAllL

   647 //

   648 // Asynchronous Mtm reply all command.

   649 // ---------------------------------------------------------

   650 //

   651 EXPORT_C void CMsgEditorAppUi::ReplyToAllL(

   652     TMsvId aTarget, TBool aIncludeOriginal /*= ETrue*/ )

   653     {

   654     TMsvPartList parts =

   655         KMsvMessagePartDescription |

   656         KMsvMessagePartRecipient |

   657         KMsvMessagePartOriginator ;

   658 

   659     if ( aIncludeOriginal )

   660         {

   661         parts |= KMsvMessagePartBody;

   662         }

   663 

   664     CBaseMtmUi& mtmUi = Document()->MtmUi();

   665     

   666     // to by-pass scanner warning about member variable being stored into

   667     // cleanup stack blocker is first stored into temporary variable. Storing

   668     // is allowed here as it is not owned.

   669     CAknInputBlock* blocker = CAknInputBlock::NewCancelHandlerLC( this );

   670     iInputBlocker = blocker;

   671 

   672     CMuiuOperationWait* wait =

   673         CMuiuOperationWait::NewLC( EActivePriorityWsEvents + 10 );

   674 

   675     mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );

   676     CMsvOperation* oper = mtmUi.ReplyL( aTarget, parts, wait->iStatus );

   677     CleanupStack::PushL( oper );

   678 

   679     wait->Start();

   680     

   681     CleanupStack::PopAndDestroy( 3, iInputBlocker );  // absorber, wait, oper

   682     iInputBlocker = NULL;

   683     }

   684 

   685 // ---------------------------------------------------------

   686 // CMsgEditorAppUi::ForwardL

   687 //

   688 // Asynchronous Mtm forward command.

   689 // ---------------------------------------------------------

   690 //

   691 EXPORT_C void CMsgEditorAppUi::ForwardL( TMsvId aTarget )

   692     {

   693     TMsvPartList parts =

   694         KMsvMessagePartBody |

   695         KMsvMessagePartDescription |

   696         KMsvMessagePartAttachments;

   697 

   698     CBaseMtmUi& mtmUi = Document()->MtmUi();

   699     mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );

   700     

   701     // to by-pass scanner warning about member variable being stored into

   702     // cleanup stack blocker is first stored into temporary variable. Storing

   703     // is allowed here as it is not owned.

   704     CAknInputBlock* blocker = CAknInputBlock::NewCancelHandlerLC( this );

   705     iInputBlocker = blocker;

   706     

   707     CMuiuOperationWait* wait = CMuiuOperationWait::NewLC( EActivePriorityWsEvents + 10 );

   708     

   709     CMsvOperation* oper = mtmUi.ForwardL( aTarget, parts, wait->iStatus );

   710     CleanupStack::PushL( oper );

   711 

   712     wait->Start();

   713 

   714     CleanupStack::PopAndDestroy( 3, iInputBlocker );  // absorber, wait, oper

   715     iInputBlocker = NULL;

   716     }

   717 

   718 // ---------------------------------------------------------

   719 // CMsgEditorAppUi::InsertTemplate

   720 //

   721 //

   722 // ---------------------------------------------------------

   723 //

   724 EXPORT_C TInt CMsgEditorAppUi::InsertTemplateL( TInt aMaxChars /*= -1*/ )

   725     {

   726     __ASSERT_DEBUG( iView != NULL, Panic( ENullPointer1 ) );

   727 

   728     // get memo content from notepad to buffer.

   729     HBufC* title = iEikonEnv->AllocReadResourceLC( R_QTN_MAIL_POPUP_TEXT_SEL_TEMP );

   730 

   731     HBufC* buf = CNotepadApi::FetchTemplateL( title );

   732     CleanupStack::PushL( buf );

   733 

   734     TInt err = DoInsertTextL( buf, aMaxChars );

   735 

   736     CleanupStack::PopAndDestroy( 2, title ); // buf, title

   737     return err;

   738     }

   739 

   740 // ---------------------------------------------------------

   741 // CMsgEditorAppUi::InsertTextMemoL

   742 //

   743 //

   744 // ---------------------------------------------------------

   745 //

   746 EXPORT_C TInt CMsgEditorAppUi::InsertTextMemoL( TInt aMaxChars )

   747     {

   748     __ASSERT_DEBUG( iView != NULL, Panic( ENullPointer1 ) );

   749 

   750     // get memo content from notepad to buffer.

   751     HBufC* title = iEikonEnv->AllocReadResourceLC( R_QTN_NMAKE_FETCH_MEMO_PRMPT );

   752 

   753     HBufC* buf = CNotepadApi::FetchMemoL( title );

   754     CleanupStack::PushL( buf );

   755 

   756     TInt err = DoInsertTextL( buf, aMaxChars );

   757     

   758     CleanupStack::PopAndDestroy( 2, title ); // buf, title

   759     return err;

   760     }

   761 

   762 // ---------------------------------------------------------

   763 // CMsgEditorAppUi::DoInsertTextL

   764 //

   765 //

   766 // ---------------------------------------------------------

   767 //

   768 TInt CMsgEditorAppUi::DoInsertTextL( HBufC* aBuffer, TInt aMaxChars )

   769     {

   770     TInt err( KErrNone );

   771     if ( aBuffer )

   772         {

   773         TInt buflen = aBuffer->Length();

   774 

   775         if ( aMaxChars == -1 || buflen <= aMaxChars )

   776             {

   777             CMsgBodyControl* body = 

   778                     static_cast<CMsgBodyControl*>( iView->ControlById( EMsgComponentIdBody ) );

   779 

   780             if ( body )

   781                 {

   782                 CEikRichTextEditor& editor = body->Editor();

   783 

   784                 if ( body != iView->FocusedControl() )

   785                     {

   786                     editor.SetCursorPosL( editor.TextLength(), EFalse );

   787                     }

   788 

   789                 body->InsertTextL( *aBuffer );

   790 

   791                 iView->SetFocus( EMsgComponentIdBody );

   792 

   793                 Document()->SetChanged( ETrue );

   794                 }

   795             }

   796         else

   797             {

   798             err = KErrOverflow;

   799             }

   800         }

   801     else

   802         {

   803         err = KErrCancel;

   804         }

   805         

   806     return err;

   807     }

   808 

   809 // ---------------------------------------------------------

   810 // CMsgEditorAppUi::UpdateNaviPaneL

   811 //

   812 // Updates navi pane.

   813 // ---------------------------------------------------------

   814 //

   815 EXPORT_C void CMsgEditorAppUi::UpdateNaviPaneL(

   816     const CFbsBitmap* aBitmap     /*= NULL*/,

   817     const CFbsBitmap* aBitmapMask /*= NULL*/ )

   818     {

   819     UpdateNaviPaneL( EFalse, aBitmap, aBitmapMask );

   820     }

   821 

   822 // ---------------------------------------------------------

   823 // CMsgEditorAppUi::UpdateNaviPaneL

   824 //

   825 // Updates navi pane.

   826 // ---------------------------------------------------------

   827 //

   828 void CMsgEditorAppUi::UpdateNaviPaneL(

   829     TBool             aUpdateExisting,

   830     const CFbsBitmap* aBitmap     /*= NULL*/,

   831     const CFbsBitmap* aBitmapMask /*= NULL*/ )

   832     {

   833     if ( !iOwnNaviPane )

   834         {

   835         return;

   836         }

   837     TInt index = 0;

   838     TInt msgs = 0;

   839     HBufC* buf;

   840 

   841     MessageIndexInFolderL( index, msgs );

   842 

   843     TBool prevAvailable = IsNextMessageAvailableL( EFalse );

   844     TBool nextAvailable = IsNextMessageAvailableL( ETrue );

   845 

   846     CArrayFixFlat<TInt>* array = new( ELeave ) CArrayFixFlat<TInt>( 2 );

   847     CleanupStack::PushL( array );

   848 

   849     if ( msgs )

   850         {

   851         array->AppendL( index + 1 );

   852         array->AppendL( msgs );

   853         buf = StringLoader::LoadLC( R_QTN_STAT_MSG_NUMBER, *array, iCoeEnv );

   854         }

   855     else

   856         {

   857         // if no messages make empty message label.

   858         buf = HBufC::NewLC( 0 );

   859         prevAvailable = nextAvailable = 0;

   860         }

   861 

   862     if ( aUpdateExisting )

   863         {

   864         if ( iNaviDecorator )

   865             {

   866             CAknTabGroup* tabGroup =

   867                 static_cast<CAknTabGroup*>( iNaviDecorator->DecoratedControl() );

   868             tabGroup->ReplaceTabTextL( 0, *buf );

   869 

   870             iNaviDecorator->MakeScrollButtonVisible( ETrue );

   871             iNaviDecorator->SetScrollButtonDimmed(

   872                 CAknNavigationDecorator::ELeftButton,

   873                 !prevAvailable );

   874             iNaviDecorator->SetScrollButtonDimmed(

   875                 CAknNavigationDecorator::ERightButton,

   876                 !nextAvailable );

   877 

   878             iOwnNaviPane->PushL( *iNaviDecorator );

   879             }

   880         }

   881     else

   882         {

   883         delete iNaviDecorator;

   884         iNaviDecorator = NULL;

   885         iNaviDecorator = iOwnNaviPane->CreateTabGroupL();

   886         

   887         CAknTabGroup* tabGroup =

   888             static_cast<CAknTabGroup*>( iNaviDecorator->DecoratedControl() );

   889         tabGroup->AddTabL( 0, *buf );            

   890         tabGroup->SetActiveTabById( 0 );

   891         // does not leave with one tab.

   892         tabGroup->SetTabFixedWidthL( KTabWidthWithOneTab );

   893 

   894         iNaviDecorator->MakeScrollButtonVisible( ETrue );

   895         iNaviDecorator->SetScrollButtonDimmed(

   896             CAknNavigationDecorator::ELeftButton,

   897             !prevAvailable );

   898         iNaviDecorator->SetScrollButtonDimmed(

   899             CAknNavigationDecorator::ERightButton,

   900             !nextAvailable );

   901 

   902         iOwnNaviPane->PushL( *iNaviDecorator );

   903 

   904         if ( aBitmap && aBitmapMask )

   905             {

   906             // replace tab with new one containing text and bitmaps.

   907             // this must be done after PushL because this transfers

   908             // ownership of caller's bitmaps to tab group.

   909             tabGroup->ReplaceTabL( 0, *buf, aBitmap, aBitmapMask );

   910             }

   911         }

   912     CleanupStack::PopAndDestroy( 2, array ); // buf, array

   913     }

   914 

   915 // ---------------------------------------------------------

   916 // CMsgEditorAppUi::HandleIteratorEventL

   917 //

   918 //

   919 // ---------------------------------------------------------

   920 //

   921 EXPORT_C void CMsgEditorAppUi::HandleIteratorEventL(

   922     TMessageIteratorEvent aEvent )

   923     {

   924     if ( aEvent == EFolderCountChanged )

   925         {

   926         UpdateNaviPaneL( ETrue );

   927         }

   928     }

   929 

   930 // ---------------------------------------------------------

   931 // CMsgEditorAppUi::CallToSenderQueryL

   932 //

   933 //

   934 // ---------------------------------------------------------

   935 //

   936 EXPORT_C TBool CMsgEditorAppUi::CallToSenderQueryL(

   937     const TDesC& aNumber, const TDesC& aAlias )

   938     {

   939     CDesCArrayFlat* strings = new ( ELeave ) CDesCArrayFlat( 2 );

   940     CleanupStack::PushL( strings );

   941 

   942     strings->AppendL( aAlias );  // %0U

   943     strings->AppendL( aNumber ); // %1U

   944 

   945     HBufC* prompt = StringLoader::LoadLC(

   946         R_QTN_SMS_QUEST_CALL, *strings, iCoeEnv );

   947 

   948     CMsgSendKeyAcceptingQuery* dlg = CMsgSendKeyAcceptingQuery::NewL( *prompt );

   949     TInt ret = dlg->ExecuteLD( R_MEB_CALLBACK_QUERY );

   950 

   951     CleanupStack::PopAndDestroy( 2, strings ); // strings, prompt

   952 

   953     return ( ret != 0 ); // No = EFalse, others = ETrue.

   954     }

   955 

   956 // ---------------------------------------------------------

   957 // CMsgEditorAppUi::ProcessCommandParametersL

   958 //

   959 // Parses command line parameter and launch model accoring to them.

   960 // ---------------------------------------------------------

   961 //

   962 EXPORT_C TBool CMsgEditorAppUi::ProcessCommandParametersL(

   963     TApaCommand /*aCommand*/,

   964     TFileName& /*aDocumentName*/,

   965     const TDesC8& aTail )

   966     {

   967     CMsgEditorDocument& doc = *Document();

   968 

   969     if ( aTail.Length() > 0 )

   970         {

   971         // Get the parameters passed by the launching MTMUI.

   972         TPckgBuf<TEditorParameters> paramPack;

   973         const TInt paramSize = sizeof( TEditorParameters );

   974 

   975         __ASSERT_ALWAYS( aTail.Length() == paramSize, Panic( EInvalidArgument ) );

   976 

   977         paramPack.Copy( aTail );

   978         const TEditorParameters& params = paramPack();

   979         

   980         // to by-pass scanner warning about member variable being stored into

   981         // cleanup stack blocker is first stored into temporary variable. Storing

   982         // is allowed here as it is not owned.

   983         CAknInputBlock* blocker = CAknInputBlock::NewCancelHandlerLC( this );

   984         iInputBlocker = blocker;

   985 

   986         doc.LaunchParametersL( params );

   987         doc.EntryChangedL();  // notified after is unique (and unlocked).

   988         doc.PrepareToLaunchL( this );

   989 

   990         CleanupStack::PopAndDestroy( iInputBlocker );

   991         iInputBlocker = NULL;

   992         }

   993     else

   994         {

   995         // no parameters enable TestEditor launching...

   996         doc.PrepareToLaunchL( this );

   997         }

   998 

   999     return EFalse;

  1000     }

  1001 

  1002 // ---------------------------------------------------------

  1003 // CMsgEditorAppUi::MenuBar

  1004 //

  1005 // Returns application menubar.

  1006 // ---------------------------------------------------------

  1007 //

  1008 EXPORT_C CEikMenuBar* CMsgEditorAppUi::MenuBar() const

  1009     {

  1010     return iEikonEnv->AppUiFactory()->MenuBar();

  1011     }

  1012 

  1013 // ---------------------------------------------------------

  1014 // CMsgEditorAppUi::SetEmphasis

  1015 //

  1016 // From MEikMenuObserver (called when menu is opened).

  1017 // ---------------------------------------------------------

  1018 //

  1019 EXPORT_C void CMsgEditorAppUi::SetEmphasis(

  1020     CCoeControl* aMenuControl, TBool aEmphasis )

  1021     {

  1022     if ( iView )

  1023         {

  1024         UpdateStackedControlFlags(

  1025             iView,

  1026             aEmphasis ? ECoeStackFlagRefusesFocus : 0,

  1027             ECoeStackFlagRefusesFocus );

  1028         }

  1029 

  1030     UpdateStackedControlFlags(

  1031         aMenuControl,

  1032         aEmphasis ? 0 : ECoeStackFlagRefusesFocus,

  1033         ECoeStackFlagRefusesFocus );

  1034 

  1035     HandleStackChanged();

  1036     }

  1037 

  1038 // ---------------------------------------------------------

  1039 // CMsgEditorAppUi::HandleEntryChangeL

  1040 //

  1041 // Default error handling for all messaging editors and viewers.

  1042 // HandleEntryChangeL is called when the currently open message

  1043 // has been modified by some other messaging client. The default

  1044 // action is "do nothing", but editors can define their own event

  1045 // processing by overriding this function.

  1046 // ---------------------------------------------------------

  1047 //

  1048 EXPORT_C void CMsgEditorAppUi::HandleEntryChangeL()

  1049     {

  1050     // no action

  1051     }

  1052 

  1053 // ---------------------------------------------------------

  1054 // CMsgEditorAppUi::HandleEntryDeletedL

  1055 //

  1056 // Default error handling for all messaging editors and viewers.

  1057 // HandleEntryDeletedL is called when the currently open message

  1058 // has been deleted by some other messaging client.

  1059 // ---------------------------------------------------------

  1060 //

  1061 EXPORT_C void CMsgEditorAppUi::HandleEntryDeletedL()

  1062     {

  1063     // TODO: get error code from errorres.

  1064     ViewErrorL(-7005);

  1065 

  1066     // close the application (and possible chain of viewers, editors and mce etc.).

  1067     ProcessCommandL( EAknCmdExit );

  1068     //Exit();

  1069     }

  1070 

  1071 // ---------------------------------------------------------

  1072 // CMsgEditorAppUi::HandleEntryMovedL

  1073 //

  1074 // Default error handling for all messaging editors and viewers.

  1075 // HandleEntryMovedL is called when the currently open message

  1076 // has been moved to some other folder, by some other messaging

  1077 // client.

  1078 // ---------------------------------------------------------

  1079 //

  1080 EXPORT_C void CMsgEditorAppUi::HandleEntryMovedL(

  1081     TMsvId /*aOldParent*/, TMsvId /*aNewParent*/ )

  1082     {

  1083     // refresh model content.

  1084     Document()->SetEntryWithoutNotificationL( Document()->Entry().Id() );

  1085     }

  1086 

  1087 // ---------------------------------------------------------

  1088 // CMsgEditorAppUi::HandleMtmGroupDeinstalledL

  1089 //

  1090 // Default error handling for all messaging editors and viewers.

  1091 // HandleMtmGroupDeinstalledL is called when the MTM Group used

  1092 // by the currently open message has been removed from the device.

  1093 // ---------------------------------------------------------

  1094 //

  1095 EXPORT_C void CMsgEditorAppUi::HandleMtmGroupDeinstalledL()

  1096     {

  1097     // TODO: get error code from errorres.

  1098     ViewErrorL( -7006 );

  1099 

  1100     // close the application (and possible chain of viewers, editors and mce etc.).

  1101     ProcessCommandL( EAknCmdExit );

  1102     //Exit();

  1103     }

  1104 

  1105 // ---------------------------------------------------------

  1106 // CMsgEditorAppUi::HandleGeneralErrorL

  1107 //

  1108 // Default error handling for all messaging editors and viewers.

  1109 // HandleGeneralErrorL is called when some unknown error has

  1110 // happened. The aErrorCode parameter contains the error code.

  1111 // ---------------------------------------------------------

  1112 //

  1113 EXPORT_C void CMsgEditorAppUi::HandleGeneralErrorL( TInt /*aErrorCode*/ )

  1114     {

  1115     // TODO: show note?

  1116 

  1117     // close the application (and possible chain of viewers, editors and mce etc.).

  1118     ProcessCommandL( EAknCmdExit );

  1119     //Exit();

  1120     }

  1121 

  1122 // ---------------------------------------------------------

  1123 // CMsgEditorAppUi::HandleCloseSessionL

  1124 //

  1125 // Default error handling for all messaging editors and viewers.

  1126 // HandleCloseSessionL is called when the messaging server wants

  1127 // to close the session (e.g. because it's closing down and wants

  1128 // to get rid of all messaging clients).

  1129 // ---------------------------------------------------------

  1130 //

  1131 EXPORT_C void CMsgEditorAppUi::HandleCloseSessionL()

  1132     {

  1133     // save changes and close the application.

  1134     DoMsgSaveExitL();