1 /*

     2 * Copyright (c) 2007 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 : FreestyleEmailUi  list implementation

    15 *

    16 */

    17 

    18 

    19 

    20 // SYSTEM INCLUDES

    21 #include "emailtrace.h"

    22 #include <AknUtils.h>

    23 #include <freestyleemailui.mbg>

    24 #include <FreestyleEmailUi.rsg>

    25 #include <StringLoader.h>

    26 #include <AknBidiTextUtils.h>

    27 

    28 #ifndef FF_CMAIL_INTEGRATION

    29 #include <txtclipboard.h>

    30 #endif // FF_CMAIL_INTEGRATION

    31 

    32 //<cmail>

    33 #include "fstextviewer.h"

    34 #include "fsrichtext.h"

    35 ///</cmail>

    36 #include <aknlistquerydialog.h>

    37 //<cmail>

    38 #include "fssmileydictionary.h"

    39 ///</cmail>

    40 #include <commonphoneparser.h>

    41 #include <browserlauncher.h>

    42 //<cmail>

    43 #include "cfsmailmessagepart.h"

    44 #include "cfsmailclient.h"

    45 //</cmail>

    46 #include <apgcli.h>

    47 //<cmail>

    48 #include "cfsmailcommon.h"

    49 //</cmail>

    50 #include <featmgr.h>

    51 //</cmail>

    52 

    53 #include <txtfrmat.h>

    54 #include <aknlists.h> // CAknSinglePopupMenuStyleListBox

    55 #include <baclipb.h> // for clipboard copy

    56 //<cmail>

    57 #include "fstextviewerkeys.h"

    58 #include "fstextviewerwatermark.h"

    59 #include <alf/alfstatic.h>

    60 #include <alf/alfroster.h>

    61 #include <alf/alfevent.h>

    62 #include <alf/alfcontrolgroup.h>

    63 // </cmail>

    64 //<cmail>

    65 #include "AknWaitDialog.h"

    66 //</cmail>

    67 #include <finditemengine.h>

    68 #include <AknGlobalListQuery.h>

    69 #include <AknGlobalNote.h>

    70 

    71 // Meeting request

    72 #include <MeetingRequestUids.hrh>

    73 //<cmail>

    74 #include "cesmricalviewer.h"

    75 //</cmail>

    76 

    77 // for intranet application opening

    78 #include <AiwServiceHandler.h>

    79 #include <AiwMenu.h>

    80 

    81 // for opening normal browser

    82 #include <browseroverriddensettings.h>

    83 #include <browserlauncher.h>

    84 

    85 // for bookmarks

    86 #include <favouriteslimits.h>   // KBrowserBookmarks

    87 #include <favouritesdb.h>

    88 

    89 // for fonts

    90 #include <AknFontAccess.h>

    91 #include <AknLayoutFont.h>

    92 

    93 // for action menu

    94 #include <CPbkContactEngine.h>

    95 #include <CPbkContactItem.h>

    96 #include <CPbkContactEditorDlg.h>

    97 #include <RPbkViewResourceFile.h>

    98 #include <CPbkDataSaveAppUi.h>

    99 #include <PbkDataSaveAppUi.hrh>

   100 #include <CPbkFieldsInfo.h>

   101 

   102 // <cmail>

   103 #include "cfsccontactactionmenu.h"

   104 #include "mfsccontactactionmenumodel.h"

   105 #include "cfsccontactactionservice.h"

   106 #include "cfsccontactactionmenuitem.h"

   107 #include "fsccontactactionmenuuids.hrh"

   108 #include "fsccontactactionmenudefines.h"

   109 // </cmail>

   110 

   111 // <cmail>

   112 #include "cfsccontactactionservice.h"

   113 #include <csxhelp/cmail.hlp.hrh>

   114 // </cmail>

   115 #include <aknnotewrappers.h>

   116 

   117 #include <schemehandler.h> // CSchemeHandler

   118 

   119 // <cmail>

   120 #include "FreestyleEmailUiConstants.h"

   121 //</cmail>

   122 // INTERNAL INCLUDES

   123 #include "FreestyleEmailUiAppui.h"

   124 #include "FreestyleEmailUiMailViewerControl.h"

   125 #include "FreestyleEmailUiMailListVisualiser.h"

   126 #include "FreestyleEmailUiFileSystemInfo.h"

   127 #include "FreestyleEmailUi.hrh"

   128 #include "freestyleemailcenrephandler.h"

   129 #include "FreestyleEmailUiLayoutHandler.h"

   130 #include "FreestyleEmailUiTextureManager.h"

   131 #include "FreestyleEmailUiMsgDetailsVisualiser.h"

   132 #include "FreestyleEmailUiFolderListVisualiser.h"

   133 #include "FreestyleEmailUiAttachmentsListVisualiser.h"

   134 #include "FreestyleEmailUiShortcutBinding.h"

   135 #include "FreestyleEmailUiContactHandler.h"

   136 #include "FreestyleEmailUiUtilities.h"

   137 #include "FreestyleEmailUiStatusIndicator.h"

   138 #include "FSEmail.pan"

   139 #include "FSDelayedLoader.h"

   140 

   141 #include "FreestyleEmailUiMailViewerVisualiser.h"

   142 #include "FreestyleEmailUiMailViewerRichText.h"

   143 #include "FreestyleEmailUiMailViewerConstants.h"

   144 

   145 #include <aknnavi.h>

   146 #include <aknnavide.h>

   147 #include <akntoolbar.h>

   148 // -----------------------------------------------------------------------------

   149 // CFSEmailUiMailViewerVisualiser::NewL

   150 // -----------------------------------------------------------------------------

   151 CFSEmailUiMailViewerVisualiser* CFSEmailUiMailViewerVisualiser::NewL( CAlfEnv& aEnv, CFreestyleEmailUiAppUi& aAppUi, CAlfControlGroup& aMailViewerControlGroup )

   152     {

   153     FUNC_LOG;

   154     CFSEmailUiMailViewerVisualiser* self = CFSEmailUiMailViewerVisualiser::NewLC( aEnv, aAppUi, aMailViewerControlGroup );

   155     CleanupStack::Pop(self);

   156     return self;

   157     }

   158 

   159 // -----------------------------------------------------------------------------

   160 // CFSEmailUiMailViewerVisualiser::NewLC

   161 // -----------------------------------------------------------------------------

   162 CFSEmailUiMailViewerVisualiser* CFSEmailUiMailViewerVisualiser::NewLC( CAlfEnv& aEnv, CFreestyleEmailUiAppUi& aAppUi, CAlfControlGroup& aMailViewerControlGroup )

   163     {

   164     FUNC_LOG;

   165     CFSEmailUiMailViewerVisualiser* self = new (ELeave) CFSEmailUiMailViewerVisualiser( aEnv, aAppUi, aMailViewerControlGroup );

   166     CleanupStack::PushL( self );

   167     self->ConstructL();

   168     return self;

   169     }

   170 

   171 // -----------------------------------------------------------------------------

   172 // CFSEmailUiMailViewerVisualiser::ConstructL

   173 // -----------------------------------------------------------------------------

   174 void CFSEmailUiMailViewerVisualiser::ConstructL()

   175     {

   176     FUNC_LOG;

   177     BaseConstructL( R_FSEMAILUI_MAIL_VIEWER_VIEW );

   178     iMessage = NULL;

   179     iNextOrPevMessageSelected = EFalse;

   180     iFirstStartCompleted = EFalse;

   181     }

   182 

   183 // -----------------------------------------------------------------------------

   184 // CFSEmailUiMailViewerVisualiser::DoFirstStartL()

   185 // Purpose of this function is to do first start only when viewer is

   186 // really needed to be shown. Implemented to make app start up faster.

   187 // -----------------------------------------------------------------------------

   188 void CFSEmailUiMailViewerVisualiser::DoFirstStartL()

   189     {

   190     FUNC_LOG;

   191     iOpenMessages = new (ELeave) CStack<CFSMailMessage, ETrue>();

   192     iEmbeddedMessages = new (ELeave) CStack<CFSMailMessage, EFalse>();

   193     iSmDictionary = CFsSmileyDictionary::NewL();

   194     iIBServiceHandler = CAiwServiceHandler::NewL();

   195     iIBServiceHandler->AttachMenuL( R_FSEMAILUI_MAILVIEWER_SUBMENU_ACTIONS, R_INTRANET_AIW_INTEREST_MENU );

   196     iIBServiceHandler->AttachL( R_INTRANET_AIW_INTEREST_BASE );

   197 

   198     // Initialize browser laucher api

   199     iFetchingAnimationTimer = CFSEmailUiGenericTimer::NewL( this );

   200     iAsyncCallback = new (ELeave) CAsyncCallBack( CActive::EPriorityLow );

   201     iDownloadProgressControlGroup = &iEnv.NewControlGroupL( KDownloadIndicatorControlGroup );

   202     iDownloadProgressIndicator = CFSEmailUiStatusIndicator::NewL( iEnv, *iDownloadProgressControlGroup,

   203                                                                   &iAppUi );

   204 

   205     iViewerRichText = CFSEmailUiMailViewerRichText::NewL( iAppUi );

   206 

   207     //here is set menu for msk

   208     MenuBar()->SetContextMenuTitleResourceId( R_FSEMAILUI_MAILVIEWER_MSK_MENUBAR );

   209 

   210     iFirstStartCompleted = ETrue;

   211     }

   212 

   213 // -----------------------------------------------------------------------------

   214 // CFSEmailUiMailViewerVisualiser::CFSEmailUiMailViewerVisualiser

   215 // -----------------------------------------------------------------------------

   216 CFSEmailUiMailViewerVisualiser::CFSEmailUiMailViewerVisualiser( CAlfEnv& aEnv,

   217     CFreestyleEmailUiAppUi& aAppUi, CAlfControlGroup& aMailViewerControlGroup )

   218     : CFsEmailUiViewBase( aMailViewerControlGroup, aAppUi ),

   219     iMoveToFolderOngoing( EFalse ),

   220     iFetchingMessageStructure( EFalse ),

   221     iFetchingPlainTextMessageBody( EFalse ),

   222     iFetchingHtmlMessageBody( EFalse ),

   223     iAsyncProcessComplete( ETrue ),

   224     iEnv( aEnv )

   225     {

   226     FUNC_LOG;

   227     }

   228 

   229 // -----------------------------------------------------------------------------

   230 // CFSEmailUiMailViewerVisualiser::~CFSEmailUiMailViewerVisualiser

   231 // -----------------------------------------------------------------------------

   232 CFSEmailUiMailViewerVisualiser::~CFSEmailUiMailViewerVisualiser()

   233     {

   234     FUNC_LOG;

   235         //<cmail> notewrapper is replaced by iWaitDialog

   236     //delete iAsyncWaitNote;

   237         //</cmail>

   238     if( iIBServiceHandler )

   239         {

   240         iIBServiceHandler->Reset();

   241         delete iIBServiceHandler;

   242         }

   243 

   244     if ( iAsyncCallback )

   245         {

   246         iAsyncCallback->Cancel();

   247         delete iAsyncCallback;

   248         }

   249 

   250     iDownloadProgressControlGroup = NULL; // owned by AlfEnv

   251     }

   252 

   253 void CFSEmailUiMailViewerVisualiser::PrepareForExit()

   254     {

   255     FUNC_LOG;

   256     delete iSmDictionary;

   257     iSmDictionary = NULL;

   258     delete iNewMailTempAddress;

   259     iNewMailTempAddress = NULL;

   260 

   261     // Text viewer control need to be removed control group and deleted here,

   262     // because akn physics (used by text viewer control) object's destructor

   263     // ends up calling CoeEnv->AppUi, so AppUi must be alive when deleting

   264     // text viewer control

   265     if ( iTextViewerControl )

   266         {

   267         ControlGroup().Remove( iTextViewerControl );

   268         }

   269 

   270     delete iTextViewer;

   271     iTextViewer = NULL;

   272 

   273     delete iTextViewerControl;

   274     iTextViewerControl = NULL;

   275 

   276     delete iViewerRichText;

   277     iViewerRichText = NULL;

   278 

   279     if ( iFlagSelectionHanler )

   280         {

   281         iFlagSelectionHanler->Cancel();

   282         delete iFlagSelectionHanler;

   283         iFlagSelectionHanler = NULL;

   284         }

   285     if ( iFetchingAnimationTimer )

   286         {

   287         iFetchingAnimationTimer->Stop();

   288         delete iFetchingAnimationTimer;

   289         iFetchingAnimationTimer = NULL;

   290         }

   291     if ( iAppUi.DownloadInfoMediator() && iMessage )

   292         {

   293         iAppUi.DownloadInfoMediator()->StopObserving( this, iMessage->GetMessageId() );

   294         }

   295 

   296     delete iOpenMessages;

   297     iOpenMessages = NULL;

   298     delete iEmbeddedMessages;

   299     iEmbeddedMessages = NULL;

   300     iMessage = NULL;

   301 

   302     delete iMailBox;

   303     iMailBox = NULL;

   304     }

   305 

   306 // -----------------------------------------------------------------------------

   307 // CFSEmailUiMailViewerVisualiser::HandleForegroundEventL

   308 // -----------------------------------------------------------------------------

   309 void CFSEmailUiMailViewerVisualiser::HandleForegroundEventL()

   310     {

   311     FUNC_LOG;

   312     if ( iFirstStartCompleted ) //Safety

   313         {

   314         // Resize the download indicator after returning from the screensaver

   315         iDownloadProgressIndicator->HandleForegroundEventL();

   316         }

   317     }

   318 

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

   320 // CFSEmailUiMailViewerVisualiser::RequestResponseL

   321 // for MFSEmailDownloadInformationObserver callback

   322 // -----------------------------------------------------------------------------

   323 void CFSEmailUiMailViewerVisualiser::RequestResponseL( const TFSProgress& aEvent, const TPartData& /*aPart*/ )

   324     {

   325     FUNC_LOG;

   326     if ( iFirstStartCompleted && iAppUi.CurrentActiveView() == this )

   327         {

   328         UpdateDownloadIndicatorL( aEvent.iProgressStatus );

   329 

   330         // <cmail> Action menu is dismissed if it's opened on an attachment

   331         // and the download has completed (to prevent canceling after completion).

   332         SViewerHeadingHotSpotData currentHeaderHotSpotData;

   333         CFindItemEngine::SFoundItem currentBodyHotSpotData;

   334 

   335         THotspotType hotspotType = iViewerRichText->FindCurrentHotSpotL(

   336             currentHeaderHotSpotData, currentBodyHotSpotData );

   337 

   338         if( aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete &&

   339             hotspotType == EHeaderHotspot &&

   340             (currentHeaderHotSpotData.iType == ETypeAttachment ||

   341             currentHeaderHotSpotData.iType == ETypeAttachments) )

   342             {

   343             CFSEmailUiActionMenu::Dismiss( ETrue );

   344 

   345             // close actions menu if open

   346             CEikMenuBar* menu = MenuBar();

   347 

   348             if( menu->IsDisplayed() )

   349                 {

   350                 menu->MenuPane()->CloseCascadeMenu();

   351                 }

   352             }

   353         // </cmail>

   354         }

   355     }

   356 

   357 // -----------------------------------------------------------------------------

   358 // CFSEmailUiMailViewerVisualiser::RequestResponseL

   359 // for MFSMailRequestObserver callback

   360 // -----------------------------------------------------------------------------

   361 void CFSEmailUiMailViewerVisualiser::RequestResponseL( TFSProgress aEvent, TInt aRequestId )

   362     {

   363     FUNC_LOG;

   364     if ( iFirstStartCompleted ) // Safety

   365         {

   366         if ( aRequestId == iCurrentPlainTextBodyFetchRequestId && iFetchingPlainTextMessageBody )

   367             {

   368             if ( aEvent.iError != KErrNone ||

   369                  aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestCancelled )

   370                 {

   371                 iAsyncProcessComplete = ETrue;

   372                 iFetchingPlainTextMessageBody = EFalse;

   373                 iFetchingAnimationTimer->Stop();

   374 

   375                 // Clear the "fetching body" text from the end of the message

   376                 iViewerRichText->SetEmptyStatusLayoutTextL();

   377                 }

   378             else if ( aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete )

   379                 {

   380                 iAsyncProcessComplete = ETrue;

   381                 iFetchingPlainTextMessageBody = EFalse;

   382                 iFetchingAnimationTimer->Stop();

   383 

   384                 // get message again, there might be new information (in case of POP protocol)

   385                 TFSMailMsgId mailboxId = iMessage->GetMailBoxId();

   386                 TFSMailMsgId folderId = iMessage->GetFolderId();

   387                 TFSMailMsgId messageId = iMessage->GetMessageId();

   388                 UpdateMessagePtrL( mailboxId, folderId, messageId );

   389 

   390                 // Refresh viewer to show newly fetched content.

   391                 // Prevent screen flickering by stopping automatic screen refresh during the update

   392                 iEnv.SetRefreshMode( EAlfRefreshModeManual );

   393                 // Make sure we don't leave and forget the refresh mode as manual.

   394                 TRAP_IGNORE(

   395                     // Try to preserve the scroll position on the same line.

   396                     iAppUi.Display().Roster().Hide( ControlGroup() );

   397                     TInt firstLine = iTextViewer->GetFirstDisplayedLine();

   398                     RefreshL();

   399                     iTextViewer->FocusLineL( firstLine, ETrue );

   400                     iAppUi.Display().Roster().ShowL( ControlGroup() );

   401                     );

   402                 iEnv.SetRefreshMode( EAlfRefreshModeAutomatic );

   403                 }

   404             }

   405 

   406         else if ( aRequestId == iCurrentHtmlBodyFetchRequestId && iFetchingHtmlMessageBody )

   407             {

   408             if ( aEvent.iError != KErrNone ||

   409                  aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestCancelled )

   410                 {

   411                 iAsyncProcessComplete = ETrue;

   412                 iFetchingHtmlMessageBody = EFalse;

   413                 }

   414             else if ( aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete )

   415                 {

   416                 iAsyncProcessComplete = ETrue;

   417                 iFetchingHtmlMessageBody = EFalse;

   418                 LaunchHtmlViewerL();

   419                 }

   420             }

   421         else if ( aRequestId == iCurrentStructureFetchRequestId && iFetchingMessageStructure )

   422             {

   423             if ( aEvent.iError != KErrNone ||

   424                  aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestCancelled )

   425                 {

   426                 iAsyncProcessComplete = ETrue;

   427                 iFetchingMessageStructure = EFalse;

   428                 }

   429             else if ( aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete )

   430                 {

   431                 iAsyncProcessComplete = ETrue;

   432                 iFetchingMessageStructure = EFalse;

   433 

   434                 // get message again, there might be new information

   435                 TFSMailMsgId mailboxId = iMessage->GetMailBoxId();

   436                 TFSMailMsgId folderId = iMessage->GetFolderId();

   437                 TFSMailMsgId messageId = iMessage->GetMessageId();

   438 

   439                 UpdateMessagePtrL( mailboxId, folderId, messageId );

   440                 if ( iMessage )

   441                     {

   442                     // Stop automatic screen refresh temporarily to prevent flickering

   443                     iEnv.SetRefreshMode( EAlfRefreshModeManual );

   444                     // we must not leave before the update mode has been restored

   445                     TRAP_IGNORE(

   446                         iAppUi.Display().Roster().Hide( ControlGroup() );

   447                         RefreshL( ETrue );

   448                         iAppUi.Display().Roster().ShowL( ControlGroup() );

   449                         );

   450                     iEnv.SetRefreshMode( EAlfRefreshModeAutomatic );

   451                     }

   452                 }

   453             }

   454         }

   455     //<cmail>

   456     if(iAsyncProcessComplete && iWaitDialog && iDialogNotDismissed)

   457         iWaitDialog->ProcessFinishedL(); // deletes the dialog

   458     //</cmail>

   459     }

   460 

   461 

   462 // -----------------------------------------------------------------------------

   463 // CFSEmailUiMailViewerVisualiser::FolderSelectedL

   464 // -----------------------------------------------------------------------------

   465 void CFSEmailUiMailViewerVisualiser::FolderSelectedL(

   466     TFSMailMsgId aSelectedFolderId, TFSEmailUiCtrlBarResponse aResponse )

   467     {

   468     FUNC_LOG;

   469 

   470     if ( iMoveToFolderOngoing )

   471         {

   472         iMoveToFolderOngoing = EFalse;

   473         if ( !iMovingMeetingRequest )

   474             {

   475             switch ( aResponse )

   476                 {

   477                 case EFSEmailUiCtrlBarResponseSelect:

   478                     {

   479                     iMoveDestinationFolder = aSelectedFolderId;

   480                     iAsyncCallback->Cancel(); // cancel any outstanding callback just to be safe

   481                     iAsyncCallback->Set( TCallBack( MoveToFolderAndExitL, this ) );

   482                     iAsyncCallback->CallBack();

   483                     }

   484                     break;

   485                 case EFSEmailUiCtrlBarResponseCancel:

   486                 default:

   487                     break;

   488                 }

   489             }

   490         else

   491             {

   492             iMovingMeetingRequest = EFalse;

   493             switch ( aResponse )

   494                 {

   495                 case EFSEmailUiCtrlBarResponseCancel:

   496                     iOpResult.iResultCode = KErrCancel;

   497                     break;

   498                 case EFSEmailUiCtrlBarResponseSelect:

   499                     {

   500                     // Do moving here, do not exit, because mrui exists itself.

   501                     iOpResult.iResultCode = KErrNone;

   502                     iMoveDestinationFolder = aSelectedFolderId;

   503                     RArray<TFSMailMsgId> messageIds;

   504                     CleanupClosePushL( messageIds );

   505                     messageIds.Append( iMessage->GetMessageId() );

   506                     // Trap is needed because protocol might return KErrNotSupported

   507                     // if move away from current folder is not supprted

   508                     TRAPD(errMove, iAppUi.GetActiveMailbox()->MoveMessagesL( messageIds,

   509                                                       iMessage->GetFolderId(), iMoveDestinationFolder ));

   510                     if ( errMove != KErrNotSupported )

   511                         {

   512                         if ( errMove == KErrNone )

   513                             {

   514                             TFsEmailUiUtility::DisplayMsgsMovedNoteL( 1, iMoveDestinationFolder, ETrue );

   515                             }

   516                         else

   517                             {

   518                             User::Leave( errMove );

   519                             }

   520                         }

   521                     CleanupStack::PopAndDestroy( &messageIds );

   522                     }

   523                     break;

   524                 default:

   525                     break;

   526                 }

   527             }

   528         }

   529 

   530     }

   531 

   532 // ---------------------------------------------------------------------------

   533 // From MFSEmailUiContactHandlerObserver

   534 // The ownership of the CLS items in the contacts array is transferred to the

   535 // observer, and they must be deleted by the observer.

   536 // ---------------------------------------------------------------------------

   537 //

   538 void CFSEmailUiMailViewerVisualiser::OperationCompleteL(

   539     TContactHandlerCmd /*aCmd*/, const RPointerArray<CFSEmailUiClsItem>& /*aContacts*/ )

   540     {

   541     FUNC_LOG;

   542     }

   543 

   544 // ---------------------------------------------------------------------------

   545 // From MFSEmailUiContactHandlerObserver

   546 // Handles error in contatct handler operation.

   547 // ---------------------------------------------------------------------------

   548 //

   549 void CFSEmailUiMailViewerVisualiser::OperationErrorL(

   550     TContactHandlerCmd /*aCmd*/, TInt /*aError*/ )

   551     {

   552     FUNC_LOG;

   553     }

   554 

   555 // -----------------------------------------------------------------------------

   556 // CFSEmailUiMailViewerVisualiser::MoveToFolderAndExitL

   557 // -----------------------------------------------------------------------------

   558 TInt CFSEmailUiMailViewerVisualiser::MoveToFolderAndExitL( TAny* aMailViewerVisualiser )

   559     {

   560     FUNC_LOG;

   561     CFSEmailUiMailViewerVisualiser* self =

   562         static_cast<CFSEmailUiMailViewerVisualiser*>(aMailViewerVisualiser);

   563 

   564     RArray<TFSMailMsgId> messageIds;

   565     CleanupClosePushL( messageIds );

   566     messageIds.Append( self->iMessage->GetMessageId() );

   567 

   568     // Trap is needed because protocol might return KErrNotSupported

   569     // if move away from current folder is not supprted

   570     TRAPD(errMove, self->iAppUi.GetActiveMailbox()->MoveMessagesL( messageIds,

   571                                                      self->iMessage->GetFolderId(),

   572                                                      self->iMoveDestinationFolder ) );

   573     if ( errMove != KErrNotSupported )

   574         {

   575         if ( errMove == KErrNone )

   576             {

   577             // move successfull, display note

   578             TFsEmailUiUtility::DisplayMsgsMovedNoteL( 1, self->iMoveDestinationFolder, ETrue );

   579             }

   580         else

   581             {

   582             // Leave with any other err code than KErrNone or KErrNotSupported.

   583             User::Leave( errMove );

   584             }

   585         }

   586     CleanupStack::PopAndDestroy( &messageIds );

   587 

   588     // return to previous view

   589     self->HandleCommandL( EAknSoftkeyBack );

   590 

   591     return KErrNone;

   592     }

   593 

   594 // -----------------------------------------------------------------------------

   595 // CFSEmailUiMailViewerVisualiser::OpenFolderListForMessageMovingL

   596 // -----------------------------------------------------------------------------

   597 TBool CFSEmailUiMailViewerVisualiser::OpenFolderListForMessageMovingL()

   598     {

   599     FUNC_LOG;

   600     TBool ret = EFalse;

   601     // Ignore if mailbox doesn't support moving or we are viewing embedded message

   602     if ( iAppUi.GetActiveMailbox()->HasCapability( EFSMBoxCapaMoveToFolder ) &&

   603             !iEmbeddedMessageMode )

   604         {

   605         // Activate folder selection view and handle moving after callback gets destination

   606         iMoveToFolderOngoing = ETrue;

   607         TFolderListActivationData folderListData;

   608         folderListData.iCallback = this;

   609         CFSMailFolder* folder = iAppUi.GetMailClient()->GetFolderByUidL( iMessage->GetMailBoxId(), iMessage->GetFolderId() );

   610         folderListData.iSourceFolderType = TFSFolderType( folder->GetFolderType() );

   611         delete folder;

   612         const TPckgBuf<TFolderListActivationData> pkgOut( folderListData );

   613         iAppUi.EnterFsEmailViewL( FolderListId, KFolderListMoveMessage, pkgOut );

   614         ret = ETrue;

   615         }

   616     return ret;

   617     }

   618 

   619 

   620 // -----------------------------------------------------------------------------

   621 // CFSEmailUiMailViewerVisualiser::ViewerControl

   622 // -----------------------------------------------------------------------------

   623 CAlfControl* CFSEmailUiMailViewerVisualiser::ViewerControl()

   624     {

   625     FUNC_LOG;

   626     return iTextViewerControl;

   627     }

   628 

   629 // -----------------------------------------------------------------------------

   630 // CFSEmailUiMailViewerVisualiser::Id

   631 // -----------------------------------------------------------------------------

   632 TUid CFSEmailUiMailViewerVisualiser::Id() const

   633     {

   634     FUNC_LOG;

   635     return MailViewerId;

   636     }

   637 

   638 // -----------------------------------------------------------------------------

   639 // CFSEmailUiMailViewerVisualiser::ChildDoActivateL

   640 // -----------------------------------------------------------------------------

   641 // <cmail> Toolbar

   642 /*void CFSEmailUiMailViewerVisualiser::DoActivateL(

   643     const TVwsViewId& aPrevViewId,

   644     TUid aCustomMessageId,

   645     const TDesC8& aCustomMessage )*/

   646 // </cmail> Toolbar

   647 void CFSEmailUiMailViewerVisualiser::ChildDoActivateL(

   648     const TVwsViewId& aPrevViewId,

   649     TUid aCustomMessageId,

   650     const TDesC8& aCustomMessage )

   651     {

   652     FUNC_LOG;

   653 

   654     // Read the activation parameters

   655     TMsgViewerActivationData activationData;

   656     if ( &aCustomMessage && aCustomMessage.Length() )

   657         {

   658         TPckgBuf<TMsgViewerActivationData> pkgBuf;

   659         pkgBuf.Copy( aCustomMessage );

   660         activationData = pkgBuf();

   661         }

   662 

   663     // Take ownership of the passed message pointer. No pointer should be passed

   664     // in other than embedded message cases.

   665     // No leaving functions may be called before this step.

   666     if ( aCustomMessageId != KStartViewerWithEmbeddedMsgPtr && activationData.iEmbeddedMessage )

   667         {

   668         delete activationData.iEmbeddedMessage;

   669         activationData.iEmbeddedMessage = NULL;

   670         __ASSERT_DEBUG( EFalse, Panic(EFSEmailUiUnexpectedValue) );

   671         }

   672 

   673     CleanupStack::PushL( activationData.iEmbeddedMessage );

   674 

   675     if ( !iFirstStartCompleted )

   676         {

   677         DoFirstStartL();

   678         }

   679     if ( aCustomMessageId == KStartViewerWithEmbeddedMsgPtr )

   680         {

   681         PushMessageL( activationData.iEmbeddedMessage, ETrue );

   682         }

   683     CleanupStack::Pop( activationData.iEmbeddedMessage ); // ownership transferred

   684 

   685     // Clear MSK to prevent unintentional presses before viewer is fully constructed

   686     ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );

   687 

   688     // If returning from view launched by MRUI, just complete the ongoing async process.

   689     // This will cause MRUI to be reopened and no other activation actions are needed.

   690     if ( iMrObserverToInform && aCustomMessageId == KStartViewerReturnToPreviousMsg )

   691         {

   692         CompletePendingMrCommand();

   693         }

   694     // Otherwise go on with the standard view activation

   695     else

   696         {

   697         // Cancel any pending asynchronous MR operation. There may be one at least if we

   698         // have navigated from MRUI to Donwload manager and from there to another message

   699         // or if external view activation happens while MRUI is open.

   700         CancelPendingMrCommandL();

   701 

   702         // Get message object unless returning to previously shown message.

   703         // In KStartViewerReturnToPreviousMsg the UI assumes that iMessage is alive.

   704         if ( aCustomMessageId == KStartViewerWithMsgId )

   705             {

   706             // Inform base view if view has been forward navigated to get correct back

   707             // navigation functionality in case of external activation.

   708             ViewEntered( aPrevViewId );

   709             UpdateMessagePtrL( activationData.iMailBoxId, activationData.iFolderId, activationData.iMessageId );

   710             }

   711         else if ( aCustomMessageId == KStartViewerWithEmbeddedMsgPtr ||

   712                   aCustomMessageId == KStartViewerReturnFromEmbeddedMsg )

   713             {

   714             if ( !iOpenMessages || iOpenMessages->IsEmpty() )

   715                 {

   716                 User::Leave( KErrNotFound );

   717                 }

   718             UpdateMessagePtr( iOpenMessages->Head() );

   719             }

   720 

   721         // Regardless of the activation mode, we should now have a valid message pointer.

   722         // Otherwise we cannot go on.

   723         User::LeaveIfNull( iMessage );

   724 

   725         iEmbeddedMessageMode = (iEmbeddedMessages->Head() != NULL);

   726 

   727         // Update mailbox unless returning to previously open message

   728         if ( aCustomMessageId != KStartViewerReturnToPreviousMsg )

   729             {

   730             delete iMailBox; iMailBox = NULL;

   731             iMailBox = iAppUi.GetMailClient()->GetMailBoxByUidL( iMessage->GetMailBoxId() );

   732 

   733             // Change active mailbox if necessary

   734             if ( !iMessage->GetMailBoxId().IsNullId() )

   735                 {

   736                 iAppUi.SetActiveMailboxL( iMessage->GetMailBoxId(), EFalse );

   737                 }

   738             }

   739 

   740         // Check if MSG should be shown in the Meeting Request viewer

   741         TBool msgSentToMrUi( EFalse );

   742         if ( iMessage->IsFlagSet( EFSMsgFlag_CalendarMsg ) &&

   743              iAppUi.MrViewerInstanceL() &&

   744              !iEmbeddedMessageMode )

   745             {

   746             // Resolve meeting requst method

   747             TESMRMeetingRequestMethod mrMethod( EESMRMeetingRequestMethodUnknown );

   748             mrMethod = iAppUi.MrViewerInstanceL()->ResolveMeetingRequestMethodL( *iMessage );

   749             if ( mrMethod == EESMRMeetingRequestMethodRequest ||      // Request is shown in mrui

   750                  mrMethod == EESMRMeetingRequestMethodCancellation || // Cancellation is shown in mrui

   751                  mrMethod == EESMRMeetingRequestMethodUnknown )       // Unknown MR needs to be to resolved in MRUI (Usually IMAP)

   752                 {

   753                 // Setting MSK empty. This blocks unwanted MSK keypresses before MrViewer is initialized.

   754                 ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );

   755 

   756                 msgSentToMrUi = ETrue;

   757                 ClearMailViewer(); // clear prev message to avoid it becoming visible before MRUI opens

   758                 iMrUiActive = ETrue;

   759                 // Same navi pane shown in MR viewer

   760                 UpdateNaviPaneL( ETrue );

   761                 SetMailboxNameToStatusPaneL();

   762                 iAppUi.MrViewerInstanceL()->ExecuteViewL( *iMessage, *this );

   763                 }

   764             }

   765 

   766         // MSG is not sent to MRUI, display in internal mail viewer

   767         // Message is either normal email message or response to meeting request

   768         if ( !msgSentToMrUi )

   769             {

   770             iMrUiActive = EFalse;

   771 

   772             // Update the viewer if new message has been opened or layout has changed while we were in some other view

   773             TBool changeMsg = (aCustomMessageId != KStartViewerReturnToPreviousMsg);

   774             if ( changeMsg || iLayoutChangedWhileNotActive )

   775                 {

   776                 RefreshL( changeMsg );

   777                 }

   778             else // update MSK anyway as the attachment status may have changed

   779                 {

   780                 iShowMskDownloadOption = ShowMskDownloadOptionL();

   781                 SetMskL();

   782                 }

   783 

   784             SetMailboxNameToStatusPaneL();

   785 

   786             // Update navipane content

   787             UpdateNaviPaneL();

   788             }

   789 

   790         // Set email indicator off.. user has checked the new emails

   791         TFsEmailUiUtility::ToggleEmailIconL( EFalse, activationData.iMailBoxId );

   792         }

   793 

   794     iNextOrPevMessageSelected = EFalse;

   795     }

   796 

   797 // -----------------------------------------------------------------------------

   798 // CFSEmailUiMailViewerVisualiser::OfferToolbarEventL

   799 // -----------------------------------------------------------------------------

   800 void CFSEmailUiMailViewerVisualiser::OfferToolbarEventL( TInt aCommand )

   801     {

   802     FUNC_LOG;

   803     switch (aCommand)

   804         {

   805         case EFsEmailUiTbCmdReply:

   806             {

   807             HandleCommandL(EFsEmailUiCmdActionsReply);

   808             break;

   809             }

   810 

   811         case EFsEmailUiTbCmdForward:

   812             {

   813             HandleCommandL(EFsEmailUiCmdActionsForward);

   814             break;

   815             }

   816         case EFsEmailUiTbCmdDelete:

   817             {

   818             HandleCommandL(EFsEmailUiCmdActionsDelete);

   819             break;

   820             }

   821         case EFsEmailUiTbCmdReplyAll:

   822             {

   823             HandleCommandL(EFsEmailUiCmdActionsReplyAll);

   824             break;

   825             }

   826         default:

   827             break;

   828         }

   829     }

   830 

   831 // -----------------------------------------------------------------------------

   832 // CFSEmailUiMailViewerVisualiser::ToolbarResourceId

   833 // -----------------------------------------------------------------------------

   834 TInt CFSEmailUiMailViewerVisualiser::ToolbarResourceId() const

   835     {

   836     return R_FREESTYLE_EMAIL_UI_TOOLBAR_MESSAGE_VIEWER;

   837     }

   838 

   839 // -----------------------------------------------------------------------------

   840 // CFSEmailUiMailViewerVisualiser::ChildDoDeactivate

   841 // -----------------------------------------------------------------------------

   842 void CFSEmailUiMailViewerVisualiser::ChildDoDeactivate()

   843     {

   844     FUNC_LOG;

   845     CancelFetchings();

   846     if ( iFetchingAnimationTimer )

   847         {

   848         iFetchingAnimationTimer->Stop();

   849         }

   850     if ( iDownloadProgressIndicator )

   851         {

   852         iDownloadProgressIndicator->HideIndicator();

   853         }

   854 

   855     // Hide this view's navipane

   856     HideNaviPane();

   857 

   858     // set view itself as toolbar observer again (e.g. MRGUI could have been changed it)

   859     Toolbar()->SetToolbarObserver( this );

   860     }

   861 

   862 // -----------------------------------------------------------------------------

   863 // CFSEmailUiMailViewerVisualiser::HideNaviPane

   864 // -----------------------------------------------------------------------------

   865 void CFSEmailUiMailViewerVisualiser::HideNaviPane()

   866     {

   867     FUNC_LOG;

   868     CAknNavigationControlContainer* naviPaneContainer = NULL;

   869     TRAP_IGNORE( naviPaneContainer = static_cast<CAknNavigationControlContainer*>( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) ) );

   870     TRAP_IGNORE( naviPaneContainer->PushDefaultL() );

   871 

   872     CCustomStatuspaneIndicators* indicators = iAppUi.GetStatusPaneIndicatorContainer();

   873     if ( indicators)

   874         {

   875         indicators->HideStatusPaneIndicators();

   876         }

   877     }

   878 

   879 // -----------------------------------------------------------------------------

   880 // CFSEmailUiMailViewerVisualiser::ActivateControlGroup

   881 // Overriden to make any running download progress bar visible after

   882 // control group has been swithced

   883 // -----------------------------------------------------------------------------

   884 void CFSEmailUiMailViewerVisualiser::ActivateControlGroup( TInt aDelay /*= 0*/ )

   885     {

   886     CFsEmailUiViewBase::ActivateControlGroup( aDelay );

   887     TRAP_IGNORE( UpdateDownloadIndicatorL() );

   888     }

   889 

   890 // -----------------------------------------------------------------------------

   891 // CFSEmailUiMailViewerVisualiser::HandleMrCommandL

   892 // Handle accept/decline/tentative/remove commands given for meeting request

   893 // message directly from list UI.

   894 // -----------------------------------------------------------------------------

   895 void CFSEmailUiMailViewerVisualiser::HandleMrCommandL(

   896     TInt aCommandId,

   897     TFSMailMsgId aMailboxId,

   898     TFSMailMsgId aFolderId,

   899     TFSMailMsgId aMessageId )

   900     {

   901     FUNC_LOG;

   902 

   903     // All items should be run

   904     if ( !iFirstStartCompleted )

   905         {

   906         DoFirstStartL();

   907         }

   908 

   909     UpdateMessagePtrL( aMailboxId, aFolderId, aMessageId );

   910 

   911     if ( aCommandId == EFsEmailUiCmdCalRemoveFromCalendar )

   912         {

   913         iAppUi.MrViewerInstanceL()->RemoveMeetingRequestFromCalendarL(

   914             *iMessage, *this );

   915         }

   916     else

   917         {

   918         TESMRAttendeeStatus respondStatus;

   919         if ( aCommandId == EFsEmailUiCmdCalActionsAccept )

   920             {

   921             respondStatus = EESMRAttendeeStatusAccept;

   922             }

   923         else if ( aCommandId == EFsEmailUiCmdCalActionsTentative )

   924             {

   925             respondStatus = EESMRAttendeeStatusTentative;

   926             }

   927         else // ( aCommandId == EFsEmailUiCmdCalActionsDecline )

   928             {

   929             respondStatus = EESMRAttendeeStatusDecline;

   930             }

   931         iAppUi.MrViewerInstanceL()->ResponseToMeetingRequestL(

   932             respondStatus, *iMessage, *this );

   933         }

   934     }

   935 

   936 // -----------------------------------------------------------------------------

   937 // CFSEmailUiMailViewerVisualiser::HandleTextViewerEventL

   938 // From viewer observer for CFsTextViewer callbacks

   939 // -----------------------------------------------------------------------------

   940 void CFSEmailUiMailViewerVisualiser::HandleTextViewerEventL( TFsTextViewerEvent aEvent )

   941     {

   942     FUNC_LOG;

   943     if ( iFirstStartCompleted ) // Safety

   944         {

   945         if ( aEvent == EFsTextViewerHotspotClicked )

   946             {

   947             // Get currently focused hotspot data

   948             SViewerHeadingHotSpotData currentHeaderHotSpotData;

   949             CFindItemEngine::SFoundItem currentBodyHotSpotData;

   950             THotspotType hotspotType = iViewerRichText->FindCurrentHotSpotL(

   951                 currentHeaderHotSpotData, currentBodyHotSpotData );

   952 

   953             // Some header hotspots have some immediate action defined, so

   954             // in case of header hotspot, try to handle the action first

   955             TBool actionTaken( EFalse );

   956             if ( hotspotType == EHeaderHotspot )

   957                 {

   958                 actionTaken = HandleHeaderHotspotActionL( currentHeaderHotSpotData.iType );

   959                 }

   960 

   961             // If the current item is valid hotspot but it didn't have any

   962             // immediate action defined, launch item specific action menu

   963             if( ( hotspotType == EHeaderHotspot || hotspotType == EBodyHotspot ) &&

   964                 !actionTaken )

   965                 {

   966                 LaunchActionMenuL();

   967                 }

   968             }

   969         else if ( aEvent == EFsTextViewerHotspotLongTap )

   970             {

   971             LaunchActionMenuL();

   972             }

   973         else if ( aEvent == EFsTextViewerScrollDown )

   974             {

   975             // check if user has scroll to the bottom for start fetching rest of the message.

   976             // if whole message has already been fetched, no actions are needed

   977             StartFetchingRemaininBodyLinesIfAtBottomL();

   978 

   979             // Hide action menu icon if current hotspot does not have action menu.

   980             // Seems that this needs to be checked also here because "hotspot changed" events

   981             // are not received reliably when scrolling down.

   982             SetActionMenuIconVisbilityL();

   983             }

   984 

   985         else if ( aEvent == EFsTextViewerHotspotChanged )

   986             {

   987             // Hide action menu icon if current hotspot does not have action menu.

   988             SetActionMenuIconVisbilityL();

   989             }

   990         }

   991     }

   992 

   993 // -----------------------------------------------------------------------------

   994 // CFSEmailUiMailViewerVisualiser::HandleHeaderHotspotActionL

   995 // Handle appropriate command for the selected header hotspot, if the currently

   996 // focused item has some action specified. Returns ETrue, if current item has

   997 // some action defined (and the action is initiated), EFalse if not.

   998 // -----------------------------------------------------------------------------

   999 TBool CFSEmailUiMailViewerVisualiser::HandleHeaderHotspotActionL(

  1000         TViewerHeadingHotspotType aHotspotType )

  1001     {

  1002     TBool actionTaken( EFalse );

  1003 

  1004     switch( aHotspotType )

  1005         {

  1006         case ETypeToNMoreRecipients:

  1007         case ETypeCcNMoreRecipients:

  1008         case ETypeBccNMoreRecipients:

  1009             {

  1010             HandleCommandL( EFsEmailUiCmdViewAll );

  1011             actionTaken = ETrue;

  1012             }

  1013             break;

  1014         case ETypeAttachment:

  1015             {

  1016             HandleCommandL( EFsEmailUiCmdOpenAttachment );

  1017             actionTaken = ETrue;

  1018             }

  1019             break;

  1020         case ETypeAttachments:

  1021             {

  1022             HandleCommandL( EFsEmailUiCmdOpenAttachmentList );

  1023             actionTaken = ETrue;

  1024             }

  1025             break;

  1026         case ETypeHtml:

  1027             {

  1028             HandleCommandL( EFsEmailUiCmdActionsOpenHtmlViewer );

  1029             actionTaken = ETrue;

  1030             }

  1031             break;

  1032         }

  1033 

  1034     return actionTaken;

  1035     }

  1036 

  1037 // Helper funcitons to get viewed message ID and Folder id

  1038 TFSMailMsgId CFSEmailUiMailViewerVisualiser::ViewedMessageFolderId()

  1039     {

  1040     FUNC_LOG;

  1041     TFSMailMsgId ret;

  1042     if ( iMessage )

  1043         {

  1044         ret = iMessage->GetFolderId();

  1045         }

  1046     return ret;

  1047     }

  1048 

  1049 TFSMailMsgId CFSEmailUiMailViewerVisualiser::ViewedMessageId()

  1050     {

  1051     FUNC_LOG;

  1052     TFSMailMsgId ret;

  1053     if ( iMessage )

  1054         {

  1055         ret = iMessage->GetMessageId();

  1056         }

  1057     return ret;

  1058     }

  1059 

  1060 // -----------------------------------------------------------------------------

  1061 // CFSEmailUiMailViewerVisualiser::RefreshL

  1062 // -----------------------------------------------------------------------------

  1063 void CFSEmailUiMailViewerVisualiser::RefreshL( TBool aFirstRefresh /*= EFalse*/ )

  1064     {

  1065     FUNC_LOG;

  1066     if ( iFirstStartCompleted ) // Safety

  1067         {

  1068         // Show "Opening" wait note if the viewed message is a large one

  1069         //<cmail>

  1070         //TInt waitNoteId = KErrNotFound;

  1071         //</cmail>

  1072         if ( TFsEmailUiUtility::IsMessageBodyLargeL( iMessage ) )

  1073             {

  1074             //<cmail> using normal wait note instead of using global

  1075             //waitNoteId = TFsEmailUiUtility::ShowGlobalWaitNoteLC( R_FSE_WAIT_OPENING_TEXT );

  1076             iWaitDialogOpening = new(ELeave)CAknWaitDialog(

  1077                                 (REINTERPRET_CAST(CEikDialog**,&iWaitDialogOpening)));

  1078             HBufC* noteText = StringLoader::LoadLC( R_FSE_WAIT_OPENING_TEXT );

  1079             iWaitDialogOpening->SetTextL(*noteText);

  1080             //iWaitDialogOpening->DrawableWindow()->SetOrdinalPosition(0);

  1081             CleanupStack::PopAndDestroy(noteText);

  1082             iWaitDialogOpening->ExecuteLD(R_FSE_WAIT_DIALOG_NO_CANCEL);

  1083             //</cmail>

  1084             }

  1085 

  1086         // Do the update

  1087         UpdateMailViewerL();

  1088         AddBackgroundPicturesL();

  1089 

  1090         // scroll to Sent line after updating if requested

  1091         if ( aFirstRefresh )

  1092             {

  1093             iTextViewer->FocusLineL( iViewerRichText->SentTextLine(), ETrue );

  1094 

  1095             iAsyncCallback->Cancel(); // just in case

  1096             iAsyncCallback->Set( TCallBack( DoPostRefresh, this ) );

  1097             iAsyncCallback->CallBack();

  1098             }

  1099 

  1100         // Close the wait note if it was opened

  1101         if ( iWaitDialogOpening )//<cmail>

  1102             {

  1103             //<cmail>

  1104             //CleanupStack::PopAndDestroy( (TAny*)waitNoteId );

  1105             iWaitDialogOpening->ProcessFinishedL(); //it destroys the waitnote also

  1106             //</cmail>

  1107             }

  1108         }

  1109     }

  1110 

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

  1112 // CFSEmailUiMailViewerVisualiser::DoPostActivation

  1113 // Callback function for deferred activation actions

  1114 // -----------------------------------------------------------------------------

  1115 TInt CFSEmailUiMailViewerVisualiser::DoPostRefresh( TAny* aSelfPtr )

  1116     {

  1117     FUNC_LOG;

  1118     CFSEmailUiMailViewerVisualiser* self =

  1119         static_cast<CFSEmailUiMailViewerVisualiser*>( aSelfPtr );

  1120     TRAPD( err, self->PostRefreshL() );

  1121     return err;

  1122     }

  1123 

  1124 void CFSEmailUiMailViewerVisualiser::PostRefreshL()

  1125     {

  1126     FUNC_LOG;

  1127     // Focus attahcment line if available

  1128     TInt attachmentTextLine = iViewerRichText->AttachmentTextLine();

  1129     TInt viewHtmlTextLine = iViewerRichText->ViewHtmlTextLine();

  1130     if ( attachmentTextLine > 0 )

  1131         {

  1132         iTextViewer->FocusLineL( attachmentTextLine, EFalse );

  1133         iViewerRichText->SetHotspotByIndexL( iViewerRichText->AttachmentHotSpotIndex() );

  1134         }