FCL/sf/app/commonemail: comparison emailuis/emailui/src/FreestyleEmailUiHtmlViewerView.cpp

equal deleted inserted replaced

-:efd4f1afd43e
+:d620048b4810
 #include "FreestyleEmailUiMailViewerConstants.h"
 #include "FSDelayedLoader.h"
 #include "FreestyleMessageHeaderURL.h"
 #include "FreestyleEmailUiAknStatusIndicator.h"
-#include <akntoolbar.h>
+#include <eiksoftkeyimage.h>
-CFsEmailUiHtmlViewerView* CFsEmailUiHtmlViewerView::NewL(
+CFsEmailUiHtmlViewerView* CFsEmailUiHtmlViewerView::NewL(
 CAlfEnv& aEnv,
 CFreestyleEmailUiAppUi& aAppUi,
 CAlfControlGroup& aControlGroup )
 {
 FUNC_LOG;
 CFsEmailUiHtmlViewerView* self = new ( ELeave ) CFsEmailUiHtmlViewerView( aEnv, aAppUi, aControlGroup );
 CleanupStack::PushL( self );
 CleanupStack::Pop( self );
 return self;
 }
 CFsEmailUiHtmlViewerView::CFsEmailUiHtmlViewerView( CAlfEnv& aEnv,
 CFreestyleEmailUiAppUi& aAppUi,
 CAlfControlGroup& aControlGroup )
 : CFsEmailUiViewBase( aControlGroup, aAppUi ),
 iEnv( aEnv )
 {
 FUNC_LOG;
 if ( iAppUi.DownloadInfoMediator() && iMessage )
 {
 iAppUi.DownloadInfoMediator()->StopObserving( this, iMessage->GetMessageId() );
 }
-// <cmail>
 if ( iContainer )
 {
 iContainer->PrepareForExit();
 }
 delete iNewMailTempAddress;
-// </cmail>
 if ( iContainer )
 {
 iContainer->CancelFetch();
 }
 delete iContainer;
 delete iOpenMessages;
 iOpenMessages = NULL;
 delete iEmbeddedMessages;
 iEmbeddedMessages = NULL;
 iMessage = NULL;
 delete iMailBox;
 iMailBox = NULL;
 delete iAsyncCallback;
 }
 void CFsEmailUiHtmlViewerView::ConstructL()
 {
 FUNC_LOG;
-BaseConstructL( R_FSEMAILUI_HTML_VIEW );
+BaseConstructL( R_FSEMAILUI_HTML_VIEW_FULLSCREEN );
 iAsyncCallback = new (ELeave) CAsyncCallBack( CActive::EPriorityLow );
 iOpenMessages = new (ELeave) CStack<CFSMailMessage, ETrue>();
 iEmbeddedMessages = new (ELeave) CStack<CFSMailMessage, EFalse>();
 iNextOrPrevMessageSelected = EFalse;
 iForwardingMessage = EFalse;
 iMessageIsDeleted = EFalse;
 }
 // -----------------------------------------------------------------------------
 }
 CSchemeHandler* handler = CSchemeHandler::NewL( *url );
 CleanupStack::PushL( handler );
 handler->HandleUrlStandaloneL();
 CleanupStack::PopAndDestroy( handler );
 CleanupStack::PopAndDestroy( url );
 }
 break;
 case TBrCtlDefs::EElementNone:
 default:
 break;
 {
 TAttachmentListActivationData params;
 params.iMailBoxId = iMessage->GetMailBoxId();
 params.iFolderId = iMessage->GetFolderId();
 params.iMessageId = iMessage->GetMessageId();
 // use package buffer to pass the params
 TPckgBuf<TAttachmentListActivationData> buf( params );
 TUid emptyCustomMessageId = { 0 };
 iAppUi.EnterFsEmailViewL( AttachmentMngrViewId, emptyCustomMessageId, buf );
 }
 }
 case EFsEmailUiCmdCompose:
 {
 if ( iMessage )
 {
 if ( iActivationData.iEmbeddedMessageMode )
 {
 iCreateNewMsgFromEmbeddedMsg = ETrue;
 }
 HBufC* mailAddress=iMessage->GetSender()->GetEmailAddress().AllocLC();
 delete iNewMailTempAddress;
 iNewMailTempAddress = NULL;
 iNewMailTempAddress = CFSMailAddress::NewL();
 iNewMailTempAddress->SetEmailAddress( *mailAddress );
 */
 }
 break;
 }
 }
 TIMESTAMP( "Html viewer selected operation done" );
 }
 // ---------------------------------------------------------------------------
 // Changes the MSK command depending on the focused element.
 // ---------------------------------------------------------------------------
 {
 FUNC_LOG;
 TBool msgBodyStructurePresent ( EFalse );
 TBool msgBodyContentPresent ( EFalse );
 if( aCustomMessageId != KHtmlViewerReturnToPrevious)
 {
 ViewEntered( aPrevViewId );
 }
 if ( iMrObserverToInform &&
 aCustomMessageId == KStartViewerReturnToPreviousMsg )
 {
 // If returning from view launched by MRUI, complete the ongoing
 // async process.
 // Exception is the move message operation as it is not done through
 pckgData.Copy( aCustomMessage );
 iActivationData = pckgData();
 }
 CleanupClosePushL( iActivationData.iFile );
 if ( !iMessage && iContainer )
 {
 iContainer->ResetContent();
 iAppUi.RemoveFromStack( iContainer );
 iContainer->CancelFetch();
 iContainer->ClearCacheAndLoadEmptyContent();
 }
 if ( !iContainer )
 {
 iContainer = CFsEmailUiHtmlViewerContainer::NewL( iAppUi, *this );
 }
 // Check whether this activation is actually for a meeting request
 TBool openedInMrViewer( EFalse );
 if ( THtmlViewerActivationData::EMailMessage == iActivationData.iActivationDataType )
 {
 openedInMrViewer = IsOpenedInMRViewerL();
 }
 if ( openedInMrViewer )
 {
 // The previous contents are cleared (otherwise they are shown just
 // before the meeting request viewer kicks in, especially annoying
 // when navigating between prev/next meeting requests by using navi
 // decorator array buttons.
 iContainer->ClearCacheAndLoadEmptyContent();
 ClearMailViewer();
 }
 ShowContainerL();
 switch ( iActivationData.iActivationDataType )
 {
 case THtmlViewerActivationData::EMailMessage:
 {
 if ( iMessage && iAppUi.DownloadInfoMediator() )
 {
 iAppUi.DownloadInfoMediator()->StopObserving( this, iMessage->GetMessageId() );
 }
 //clean message stack which owns object iMessage
 EraseMessageStack();
 iMessage = NULL;
 iMessage = iAppUi.GetMailClient()->GetMessageByUidL(
 iActivationData.iMailBoxId,
 iActivationData.iFolderId,
 iActivationData.iMessageId,
 EFSMsgDataEnvelope  );
-UpdateToolbarL();
 if ( iMessage && iAppUi.DownloadInfoMediator() )
 {
 iAppUi.DownloadInfoMediator()->AddObserver( this, iMessage->GetMessageId() );
 }
 delete iAttachmentsListModel;
 iAttachmentsListModel = NULL;
 if ( iMessage )
 {
 {
 //take ownership of iMessage
 PushMessageL( iMessage, EFalse );
 }
 if ( openedInMrViewer )
 {
+iContainer->DisplayStatusIndicatorL();
+iAppUi.GetMailClient()->PrepareMrDescriptionL( iActivationData.iMailBoxId,
+iActivationData.iMessageId );
 // Setting MSK empty. This blocks unwanted MSK keypresses before MrViewer is initialized.
 ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
 iMrUiActive = ETrue;
 iAppUi.MrViewerInstanceL()->ExecuteViewL( *iMessage, *this );
 }
 else
 {
 // Attachment list model is not created when opening mrViewer, so attachment options menu is
 // not working with MR messages
 iAttachmentsListModel = CFSEmailUiAttachmentsListModel::NewL( iAppUi, *this );
 TPartData msgPartData( iActivationData.iMailBoxId, iActivationData.iFolderId, iActivationData.iMessageId );
 iAttachmentsListModel->UpdateListL( msgPartData );
 CheckMessageBodyL( *iMessage, msgBodyStructurePresent, msgBodyContentPresent );
 LoadContentFromMailMessageL( iMessage, ETrue );
 }
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 if ( aCustomMessageId != KStartViewerReturnToPreviousMsg && iMessage )
 {
 delete iMailBox; iMailBox = NULL;
 iMailBox = iAppUi.GetMailClient()->GetMailBoxByUidL( iMessage->GetMailBoxId() );
 // Change active mailbox if necessary
 if ( !iMessage->GetMailBoxId().IsNullId() )
 {
 iAppUi.SetActiveMailboxL( iMessage->GetMailBoxId(), EFalse );
 }
 {
 if ( aCustomMessageId != KStartViewerReturnFromEmbeddedMsg && !iCreateNewMsgFromEmbeddedMsg )
 {
 PushMessageL(iActivationData.iEmbeddedMessage, ETrue);
 }
 iMessage = iOpenMessages->Head();
 iCreateNewMsgFromEmbeddedMsg = EFalse;
 delete iAttachmentsListModel;
 iAttachmentsListModel = NULL;
 iAttachmentsListModel = CFSEmailUiAttachmentsListModel::NewL( iAppUi, *this );
 if ( iOpenMessages->Head()== iOpenMessages->Last() )
 {
 TPartData msgPartData( iActivationData.iMailBoxId, iActivationData.iFolderId, iActivationData.iMessageId);
 iAttachmentsListModel->UpdateListL( msgPartData );
 }
 else{
 iAttachmentsListModel->UpdateListL( iOpenMessages->Head() );
 }
 CheckMessageBodyL( *iOpenMessages->Head(), msgBodyStructurePresent, msgBodyContentPresent );
 LoadContentFromMailMessageL( iOpenMessages->Head(), ETrue );
-// update tool bar as some action menu boton should not appear in embbeded messages.
-UpdateToolbarL();
 }
 break;
 case THtmlViewerActivationData::EFile:
 {
 LoadContentFromFileL( iActivationData.iFile );
 {
 LoadContentFromUrlL( iActivationData.iUrl );
 }
 break;
 }
 CleanupStack::PopAndDestroy( &iActivationData.iFile );
 SetMskL();
 if(iMessage)
 {
 CFSMailAddress* address = iMessage->GetSender();
 if ( address )
 {
 HBufC* displayName = address->GetDisplayName().AllocLC();
 if ( displayName->Length() )
 {
 iAppUi.SetTitlePaneTextL( *displayName );
 }
 else
 CleanupStack::PopAndDestroy(emailAddress);
 }
 CleanupStack::PopAndDestroy( displayName );
 }
 }
 if ( !openedInMrViewer && iMessage)
 {
 CFSMailMessagePart* htmlBodyPart = iMessage->HtmlBodyPartL();
 TFetchedType type;
 if ( htmlBodyPart )
 {
 iContainer->DisplayStatusIndicatorL();
 StartWaitedFetchingL(EMessageStructure);
 iFetchingAlready = ETrue;
 }
 else
 {
 if ( msgBodyStructurePresent && !msgBodyContentPresent )
 {
 iAsyncProcessComplete = EFalse;
 iFetchingAlready = EFalse;
 }
 }
 }
 iNextOrPrevMessageSelected = EFalse;
 iForwardingMessage = EFalse;
 //update rect only if it has changed from previous time.
 if ( iContainer->Rect() != ContainerRect()  )
 {
 iContainer->SetRect( ContainerRect() );
 }
 TIMESTAMP( "Html viewer opened" );
-}
-// -----------------------------------------------------------------------------
-// CFsEmailUiHtmlViewerView::OfferToolbarEventL
-// -----------------------------------------------------------------------------
-void CFsEmailUiHtmlViewerView::OfferToolbarEventL( TInt aCommand )
-{
-FUNC_LOG;
-switch (aCommand)
-{
-case EFsEmailUiTbCmdReply:
-{
-HandleCommandL(EFsEmailUiCmdActionsReply);
-break;
-}
-case EFsEmailUiTbCmdForward:
-{
-HandleCommandL(EFsEmailUiCmdActionsForward);
-break;
-}
-case EFsEmailUiTbCmdDelete:
-{
-iAsyncCallback->Cancel();
-iAsyncCallback->Set( TCallBack( DeleteMail, this ) );
-iAsyncCallback->SetPriority( CActive::EPriorityHigh );
-iAsyncCallback->CallBack();
-break;
-}
-case EFsEmailUiTbCmdReplyAll:
-{
-HandleCommandL(EFsEmailUiCmdActionsReplyAll);
-break;
-}
-default:
-break;
-}
-}
-// -----------------------------------------------------------------------------
-// CFsEmailUiHtmlViewerView::ToolbarResourceId
-// -----------------------------------------------------------------------------
-TInt CFsEmailUiHtmlViewerView::ToolbarResourceId() const
-{
-TInt resourceId( R_FREESTYLE_EMAIL_UI_TOOLBAR_HTML_MESSAGE_VIEWER_NO_REPLY_ALL );
-if (iMessage)
-{
-if (!iActivationData.iEmbeddedMessageMode &&
-TFsEmailUiUtility::CountRecipientsSmart( iAppUi, iMessage ) > 1)
-{
-resourceId = R_FREESTYLE_EMAIL_UI_TOOLBAR_HTML_MESSAGE_VIEWER;
-}
-}
-return resourceId;
-}
-// -----------------------------------------------------------------------------
-// CFsEmailUiHtmlViewerView::GetInitiallyDimmedItemsL
-// -----------------------------------------------------------------------------
-void CFsEmailUiHtmlViewerView::GetInitiallyDimmedItemsL( const TInt aResourceId,
-RArray<TInt>& aDimmedItems ) const
-{
-if ( R_FREESTYLE_EMAIL_UI_TOOLBAR_HTML_MESSAGE_VIEWER == aResourceId ||
-R_FREESTYLE_EMAIL_UI_TOOLBAR_HTML_MESSAGE_VIEWER_NO_REPLY_ALL == aResourceId )
-{
-if ( iActivationData.iEmbeddedMessageMode )
-{
-aDimmedItems.AppendL(EFsEmailUiTbCmdActions);
-aDimmedItems.AppendL(EFsEmailUiTbCmdDelete);
-aDimmedItems.AppendL(EFsEmailUiTbCmdReply);
-aDimmedItems.AppendL(EFsEmailUiTbCmdForward);
-aDimmedItems.AppendL(EFsEmailUiTbCmdReplyAll);
-}
-}
 }
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::ChildDoDeactivate()
 // Deactivate the HTML view
 {
 // if app ui is exiting, a call to this function causes a KERN-EXEC 3 crash in iBrCtlInterface->ClearCache();
 iContainer->ClearCacheAndLoadEmptyContent();
 }
 }
-Toolbar()->SetToolbarObserver( this );
 iMessage = NULL;
 }
 void CFsEmailUiHtmlViewerView::DoExitL()
 {
 FUNC_LOG;
 delete iMessage;
 iMessage = NULL;
 CancelFetchings();
 if ( iFlagSelectionHandler )
 {
 iFlagSelectionHandler->Cancel();
 delete iFlagSelectionHandler;
 iFlagSelectionHandler = NULL;
 // Overriden from base class
 // -----------------------------------------------------------------------------
 void CFsEmailUiHtmlViewerView::NavigateBackL()
 {
 FUNC_LOG;
 // clean up current message
 if ( iMessage && iAppUi.DownloadInfoMediator() )
 {
 iAppUi.DownloadInfoMediator()->StopObserving( this, iMessage->GetMessageId() );
 }
 if( iContainer )
 if( tmp )
 {
 delete tmp;
 tmp = NULL;
 }
 if ( iFlagSelectionHandler )
 {
 iFlagSelectionHandler->Cancel();
 delete iFlagSelectionHandler;
 iFlagSelectionHandler = NULL;
 }
 // Return to previous message in the stack if there is still some left
 if ( !iOpenMessages->IsEmpty() )
 {
 THtmlViewerActivationData htmlData;
 if ( iOpenMessages->Head()!= iOpenMessages->Last() )
 {
 htmlData.iActivationDataType = THtmlViewerActivationData::EmbeddedEmailMessage;
 htmlData.iEmbeddedMessageMode = ETrue;
 }
 else
 {
 htmlData.iActivationDataType = THtmlViewerActivationData::EMailMessage;
 htmlData.iMailBoxId = iOpenMessages->Head()->GetMailBoxId();
 htmlData.iFolderId  = iOpenMessages->Head()->GetFolderId();
 htmlData.iMessageId = iOpenMessages->Head()->GetMessageId();
 }
 TPckgBuf<THtmlViewerActivationData> pckgData( htmlData );
 iAppUi.EnterFsEmailViewL( HtmlViewerId, KStartViewerReturnFromEmbeddedMsg, pckgData );
 }
 // In usual case we use the base view implementation
 else
 {
 iMessage = NULL;
 {
 HideContainer();
 iContainer->ResetContent();
 }
 }
+}
+// ---------------------------------------------------------------------------
+// Wrapper for implementation in view base class
+// ---------------------------------------------------------------------------
+//
+void CFsEmailUiHtmlViewerView::ChangeMskCommandL( TInt /*aLabelResourceId*/ )
+{
+CEikButtonGroupContainer* cba( Cba() );
+if ( cba )
+			{
+cba->SetCommandSetL( R_FREESTYLE_EMAUIL_UI_SK_OPTIONS_BACK_FULLSCREEN );
+CEikCba* eikCba( static_cast< CEikCba* >( cba->ButtonGroup() ) );
+TFileName filename;
+			TFsEmailUiUtility::GetFullIconFileNameL( filename );
+		  if (iActivationData.iEmbeddedMessageMode)
+		  	{
+	      eikCba->UpdateMSKIconL( KAknsIIDQsnIconColors,  filename,
+	          EMbmFreestyleemailuiQgn_graf_cmail_blank,
+	          EMbmFreestyleemailuiQgn_graf_cmail_blank_mask, ETrue );
+		  	}
+		  else
+		    {
+	      eikCba->UpdateMSKIconL( KAknsIIDQsnIconColors,  filename,
+	          EMbmFreestyleemailuiQgn_prop_cmail_action_delete,
+	          EMbmFreestyleemailuiQgn_prop_cmail_action_delete_mask, ETrue );
+	      }
+}
+}
+// ---------------------------------------------------------------------------
+// Sets status bar layout
+// ---------------------------------------------------------------------------
+//
+TBool CFsEmailUiHtmlViewerView::IsStatusPaneVisible() const
+{
+return EFalse;
 }
 // ---------------------------------------------------------------------------
 // Sets status bar layout
 // ---------------------------------------------------------------------------
 //
 void CFsEmailUiHtmlViewerView::SetStatusBarLayout()
 {
-TInt res = R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT;
+if( StatusPane()->CurrentLayoutResId() != R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT )
-if( Layout_Meta_Data::IsLandscapeOrientation() )
+{
-{
+TRAP_IGNORE( StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT ) );
-// landscape must use different layout
+}
-		res = R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT;
-}
-if( StatusPane()->CurrentLayoutResId() != res )
-{
-TRAP_IGNORE(
-StatusPane()->SwitchLayoutL( res ));
-}
 }
 void CFsEmailUiHtmlViewerView::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )
 {
 FUNC_LOG;
 if ( aResourceId == R_FSEMAILUI_HTMLVIEWER_MENUPANE )
 {
 // Pinch zoom only
 aMenuPane->SetItemDimmed( EFsEmailUiCmdZoomLevel, ETrue );
 if ( FeatureManager::FeatureSupported( KFeatureIdFfCmailIntegration ) )
 {
 // remove help support in pf5250
 aMenuPane->SetItemDimmed( EFsEmailUiCmdHelp, ETrue);
 }
-TBool toolbarExists = EFalse;
+const TBool toolbarExists( EFalse );
-if( iAppUi.CurrentFixedToolbar() )
-{
-toolbarExists = iAppUi.CurrentFixedToolbar()->IsVisible();
-}
 // Some commands are blocked when viewing embedded message object
 // or separate HTML file.
 const TBool blockCmds( !iMessage || iActivationData.iEmbeddedMessageMode || toolbarExists );
 const TBool blockReplyALLCmd( toolbarExists || !iMessage || iActivationData.iEmbeddedMessageMode ||
 TFsEmailUiUtility::CountRecipientsSmart( iAppUi, iMessage ) < 2 );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsReply, blockCmds );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsReplyAll, blockReplyALLCmd );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsForward, blockCmds );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsDelete, blockCmds );
 if( iActivationData.iEmbeddedMessageMode )
 {
 aMenuPane->SetItemDimmed( EFsEmailUiCmdMarkAsRead, ETrue );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdMarkAsUnread, ETrue );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsMoveMessage, ETrue );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsFlag, ETrue );
 }
 TBool hideNext = !ShowNextMessageMenuInOptions();
 TBool blockNextCmd = !iMessage || iActivationData.iEmbeddedMessageMode || hideNext;
 TInt menuPos;
 if( aMenuPane->MenuItemExists( EFsEmailUiCmdNextMessage, menuPos ) )
 {
 TBool blockPrevCmd = !iMessage || iActivationData.iEmbeddedMessageMode || hidePrev;
 if( aMenuPane->MenuItemExists( EFsEmailUiCmdPreviousMessage, menuPos ) )
 {
 aMenuPane->SetItemDimmed( EFsEmailUiCmdPreviousMessage, blockPrevCmd );
 }
 CFSMailFolder* currentFolder = NULL;
 if ( iMessage )
 {
 TRAP_IGNORE( currentFolder =
 iAppUi.GetMailClient()->GetFolderByUidL(
 iMessage->GetMailBoxId(),
 iMessage->GetFolderId() ) );
 }
 if ( currentFolder &&
 currentFolder->GetFolderType() != EFSOutbox )
 {
 // Mark as read/unread options
 TBool messageIsRead( iMessage->IsFlagSet( EFSMsgFlag_Read ) );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdMarkAsRead, messageIsRead );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdMarkAsUnread, !messageIsRead );
 // Move to another folder option
 aMenuPane->SetItemDimmed(
 EFsEmailUiCmdActionsMoveMessage,
 !iAppUi.GetActiveMailbox()->HasCapability( EFSMBoxCapaMoveToFolder ) );
 // Follow-up flag option
 aMenuPane->SetItemDimmed(
 EFsEmailUiCmdActionsFlag,
 !( iMailBox && TFsEmailUiUtility::IsFollowUpSupported( *iMailBox ) ) );
 }
 else
 {
 DynInitZoomMenuL( aMenuPane );
 }
 iAppUi.ShortcutBinding().AppendShortcutHintsL( *aMenuPane,
 CFSEmailUiShortcutBinding::EContextHtmlViewer );
 }
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::HandleMrCommandL
 // Handle accept/decline/tentative/remove commands given for meeting request
 // message directly from list UI.
 // -----------------------------------------------------------------------------
 TFSMailMsgId aMailboxId,
 TFSMailMsgId aFolderId,
 TFSMailMsgId aMessageId )
 {
 FUNC_LOG;
 ///any init required?
 UpdateMessagePtrL( aMailboxId, aFolderId, aMessageId );
 if ( aCommandId == EFsEmailUiCmdCalRemoveFromCalendar && iMessage )
 {
 iAppUi.MrViewerInstanceL()->RemoveMeetingRequestFromCalendarL(
 }
 void CFsEmailUiHtmlViewerView::HandleStatusPaneSizeChange()
 {
 CFsEmailUiViewBase::HandleStatusPaneSizeChange();
 	HandleViewRectChange();
 }
 void CFsEmailUiHtmlViewerView::HandleViewRectChange()
 {
 CFsEmailUiViewBase::HandleViewRectChange();
 if ( iContainer )
 {
 iContainer->SetRect( ContainerRect() );
 }
 }
 void CFsEmailUiHtmlViewerView::HandleDynamicVariantSwitchL( CFsEmailUiViewBase::TDynamicSwitchType aType )
 {
 FUNC_LOG;
 if ( aType == EScreenLayoutChanged )
 {
 SetStatusBarLayout();
 }
 if ( iContainer )
 {
 iContainer->SetRect( ContainerRect() );
 iContainer->HandleResourceChange( aType );
 }
 }
-TRect  CFsEmailUiHtmlViewerView::ContainerRect() const
+TRect CFsEmailUiHtmlViewerView::ContainerRect() const
 {
-TRect rect = ClientRect();
+TRect rect( ClientRect() );
+return rect;
-CAknToolbar* toolbar = iAppUi.CurrentFixedToolbar();
-if( toolbar && toolbar->IsVisible() && Layout_Meta_Data::IsLandscapeOrientation() )
-{
-TPoint pos = toolbar->PositionRelativeToScreen();
-// In some LS status pane layouts the toolbar will be shown on top of the client area
-if( pos.iX > 0 )
-{
-rect.iBr.iX = pos.iX;
-}
-}
-return rect;
 }
 void CFsEmailUiHtmlViewerView::LoadContentFromFileL( const TDesC& aFileName )
 {
 FUNC_LOG;
 return;
 }
 TInt reallyDelete( ETrue );
 if ( iAppUi.GetCRHandler()->WarnBeforeDelete() &&
 !aSilentDelete )
 {
 reallyDelete = TFsEmailUiUtility::ShowConfirmationQueryL(
 R_FREESTYLE_EMAIL_UI_DELETE_MESSAGE_CONFIRMATION );
 }
 if ( iContainer )
 {
 HideContainer();
 iContainer->ResetContent();
 }
 RArray<TFSMailMsgId> msgIds;
 CleanupClosePushL( msgIds );
 msgIds.Append( currentMsgId );
 TFSMailMsgId mailBox = iMessage->GetMailBoxId();
 TFSMailMsgId folderId = iMessage->GetFolderId();
 //Get the id and check if there is a previous message available
 TFSMailMsgId prevMsgId;
 TFSMailMsgId prevMsgFolderId;
 //Get the previous message if it exists
 TBool available = iAppUi.IsPreviousMsgAvailable( currentMsgId,
 prevMsgId,
 prevMsgFolderId );
 //Delete the message
 iLastDeletedMessageID = iMessage->GetMessageId();
 iAppUi.GetMailClient()->DeleteMessagesByUidL( mailBox, folderId, msgIds );
 CleanupStack::PopAndDestroy( &msgIds );
 // Notify appui of deleted mail item
 SendEventToAppUiL( TFSEventMailDeletedFromViewer );
 if ( iAppUi.CurrentActiveView()->Id() == HtmlViewerId )
 {
 //Open the previous message or navigate back to list viewer
 if ( available )
 {
 				iMessageIsDeleted = ETrue;
 TRAPD( err, iAppUi.MoveToPreviousMsgAfterDeleteL( prevMsgId ) );
 iMessageIsDeleted = EFalse;
 User::LeaveIfError( err );
 }
 else
 {
 ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
 NavigateBackL();
 }
 {
 FUNC_LOG;
 if ( /*iFirstStartCompleted &&*/ iMessage && aMailbox.Id() == iAppUi.GetActiveMailboxId().Id() &&
 (aEvent == TFSEventMailDeleted || aEvent == TFSEventMailDeletedFromViewer) && aParam1 ) // Safety, in list events that only concern active mailbox are handled
 {
 TFSMailMsgId curMsgId = iMessage->GetMessageId();
 RArray<TFSMailMsgId>* removedEntries = static_cast<RArray<TFSMailMsgId>*>( aParam1 );
 TBool cont = ETrue;
 for ( TInt i = 0 ; i < removedEntries->Count() && cont; i++ )
 {
 if ( ( curMsgId == ( *removedEntries )[i] ) &&
 (iDeletedMessageFromMrui != curMsgId) )
 {
 cont = EFalse;
 ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
 if( aEvent == TFSEventMailDeleted  && !iMessageIsDeleted )
 {   //Delete event came from server; close the viewer.
 	HandleCommandL( EAknSoftkeyBack );
 	// The message we are viewing was deleted => stop here
 	return;
 }
 }
 }
 }
 if ( iContainer && iMessage && aMailbox.Id() == iAppUi.GetActiveMailboxId().Id() )
 {
 if ( aEvent == TFSEventNewMail ||
 aEvent == TFSEventMailDeleted ||
 aEvent == TFSEventMailChanged )
 {
 iContainer->MailListModelUpdatedL();
 }
 // DSW fix for FAMZ-82YJQ2
 // Dismiss the download status dialog after sync has been finished or cancelled
 if ( aEvent == TFSEventMailboxSyncStateChanged )
 {
 TSSMailSyncState* newSyncState = static_cast<TSSMailSyncState*>( aParam1 );
 if ( newSyncState && ( *newSyncState == FinishedSuccessfully ||
 *newSyncState == SyncCancelled ||
 *newSyncState == Idle ||
 *newSyncState == SyncError ))
 {
 iContainer->HideDownloadStatus();
 }
 }
 }
 }
 void CFsEmailUiHtmlViewerView::DynInitZoomMenuL( CEikMenuPane* aMenuPane )
 {
 FUNC_LOG;
 /* -- Pinch zoom only --
 TInt zoomLevelIdx = iContainer->ZoomLevelL();
 // Set the radio button state to match current zoom level
 if ( zoomLevelIdx >= 0 && zoomLevelIdx < iContainer->MaxZoomLevel() )
 }
 case EFsEmailUiCmdActionsCopyWWWAddressToClipboard:
 {
 CopyCurrentToClipBoardL( aUrl );
 break;
 }
 }
 }
 void CFsEmailUiHtmlViewerView::SaveEmailAsContactL(
 const TDesC& aEmailAddress )
 {
 // this method assumes that remote lookup is available with current plugin.
 HBufC* textData = aEmailAddress.AllocLC();
 CFSMailBox* mailBox = iAppUi.GetMailClient()->GetMailBoxByUidL( iMessage->GetMailBoxId() );
 CleanupStack::PushL( mailBox );
-//UI options Delete and Actions dimmed in Remote Lookup.
-const TInt resourceId(ToolbarResourceId());
-RArray<TInt> dimmedItems;
-CleanupClosePushL(dimmedItems);
-GetInitiallyDimmedItemsL(resourceId, dimmedItems); // get the currently dimmed buttons
-SetToolbarItemDimmed( EFsEmailUiTbCmdActions, ETrue);
-SetToolbarItemDimmed( EFsEmailUiTbCmdDelete, ETrue);
-HideToolbar();
 CFsDelayedLoader::InstanceL()->GetContactHandlerL()->LaunchRemoteLookupWithQueryL( *mailBox, *textData );
-ShowToolbar();
-SetToolbarItemDimmed( EFsEmailUiTbCmdActions, EFalse);
-SetToolbarItemDimmed( EFsEmailUiTbCmdDelete, EFalse);
-for (TInt i = 0; i < dimmedItems.Count(); i++) // restore the buttons
-{
-SetToolbarItemDimmed(dimmedItems[i], ETrue);
-}
-CleanupStack::PopAndDestroy(); // dimmedItems.Close()
 CleanupStack::PopAndDestroy( mailBox );
 CleanupStack::PopAndDestroy( textData );
 }
 // -----------------------------------------------------------------------------
 TBool downloadRequired = iAttachmentsListModel->SaveAttachmentL( aAttachment, fileName, savedCount );
 if ( downloadRequired && iContainer && !iContainer->AttachmentDownloadStatusVisible() )
 {
 iContainer->ShowAttachmentDownloadStatusL( TFSProgress::EFSStatus_Status, aAttachment );
 }
 if ( savedCount )
 {
 TFsEmailUiUtility::ShowFilesSavedToFolderNoteL( savedCount );
 }
 }
 }
 void CFsEmailUiHtmlViewerView::SaveAllAttachmentsL()
 return iActivationData.iEmbeddedMessageMode;
 }
 TBool CFsEmailUiHtmlViewerView::IsEmbeddedMsgSavingAllowed()
 {
 return iMailBox->HasCapability(
 EFSMboxCapaSupportsSavingOfEmbeddedMessages );
 }
 void CFsEmailUiHtmlViewerView::UpdateDownloadIndicatorL(
 const TPartData& aPart,
 const TFSProgress& aEvent )
 {
 FUNC_LOG;
 if ( !iMessage || !iContainer || ( aEvent.iError != KErrNone ) )
 return;
 TAttachmentData* attachment = NULL;
 const RArray<TAttachmentData>& attachments = iAttachmentsListModel->GetModel();
 for ( TInt i=0; i < attachments.Count(); i++ )
 {
 if ( attachments[i].partData == aPart )
 {
 attachment = CONST_CAST( TAttachmentData*, &iAttachmentsListModel->GetModel()[i] );
 break;
 }
 }
 if ( attachment )
 {
 switch ( aEvent.iProgressStatus )
 {
 case TFSProgress::EFSStatus_Status:
 {
 attachment->downloadProgress = KNone;
 }
 }
 break;
 case TFSProgress::EFSStatus_RequestComplete:
 {
 attachment->downloadProgress = KComplete;
 }
 break;
 default:
 break;
 }
 iContainer->ShowAttachmentDownloadStatusL( aEvent.iProgressStatus, *attachment );
 }
 }
 void CFsEmailUiHtmlViewerView::RequestResponseL( const TFSProgress& aEvent, const TPartData& aPart )
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::PushMessageL
 // Message stack handling. Ownership of message is transferred when succesful.
 // -----------------------------------------------------------------------------
 //
 void CFsEmailUiHtmlViewerView::PushMessageL( CFSMailMessage* aMessage, TBool aIsEmbedded )
 {
 if ( !iOpenMessages || !iEmbeddedMessages )
 {
 User::Leave( KErrNotReady );
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::PopMessage
 // Message stack handling. Ownership of message is returned.
 // -----------------------------------------------------------------------------
 //
 CFSMailMessage* CFsEmailUiHtmlViewerView::PopMessage()
 {
 ASSERT( iOpenMessages && iEmbeddedMessages );
 ASSERT( iOpenMessages->Count() == iEmbeddedMessages->Count() );
 CFSMailMessage* msg = NULL;
 if ( !iOpenMessages->IsEmpty() )
 {
 msg = iOpenMessages->Pop();
 }
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::EraseMessageStack
 // Message stack handling. All messages in stack are deallocated
 // -----------------------------------------------------------------------------
 //
 void CFsEmailUiHtmlViewerView::EraseMessageStack()
 {
 ASSERT( iOpenMessages && iEmbeddedMessages );
 ASSERT( iOpenMessages->Count() == iEmbeddedMessages->Count() );
 // Send flags, local and server
 iMessage->ResetFlag( EFSMsgFlag_Read );
 }
 iMessage->SaveMessageL(); // Save read status
 SendEventToAppUiL( TFSEventMailChanged );
 }
 }
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::ShowNextMessageMenuInOptions
 TBool CFsEmailUiHtmlViewerView::ShowNextMessageMenuInOptions() const
 {
 FUNC_LOG;
 TBool available = EFalse;
 // Next/previous message options are inavailable in the embedded mode
 if ( iMessage && !iActivationData.iEmbeddedMessageMode )
 {
 TFSMailMsgId currentMsgId = iMessage->GetMessageId();
 TFSMailMsgId nextMsgId;
 TFSMailMsgId nextMsgFolderId;
 available = iAppUi.IsNextMsgAvailable( currentMsgId, nextMsgId, nextMsgFolderId );
 }
 // Stop timer and cancel fetchings before showing next message
 //iFetchingAnimationTimer->Stop();
 CancelFetchings();
 // Change empty msk when moving to next
 ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
 iAppUi.MoveToNextMsgL( currentMsgId, nextMsgId );
 // Next message is displayed in this view through doactivate, because view is re-activate by mail list
 {
 TFSMailMsgId currentMsgId = iMessage->GetMessageId();
 TFSMailMsgId prevMsgId;
 TFSMailMsgId prevMsgFolderId;
 if ( iAppUi.IsPreviousMsgAvailable( currentMsgId, prevMsgId, prevMsgFolderId ) )
 {
 if (iContainer)
 {
 iContainer->PrepareForMessageNavigation();
 }
 // Stop timer and cancel fetchings before showing prev message
 CancelFetchings();
 // Change empty msk when moving to previous
 ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
 iAppUi.MoveToPreviousMsgL( currentMsgId, prevMsgId );
 // Previous message is displayed in this view through doactivate, because view is re-activate by mail list
 // for MFSMailRequestObserver callback
 // -----------------------------------------------------------------------------
 void CFsEmailUiHtmlViewerView::RequestResponseL( TFSProgress aEvent, TInt aRequestId )
 {
 FUNC_LOG;
 TBool reloadContent ( EFalse );
 if ( aRequestId == iCurrentPlainTextBodyFetchRequestId && iFetchingPlainTextMessageBody )
 {
 if ( aEvent.iError != KErrNone ||
 aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestCancelled )
 {
 TFSMailMsgId folderId = iMessage->GetFolderId();
 TFSMailMsgId messageId = iMessage->GetMessageId();
 UpdateMessagePtrL( mailboxId, folderId, messageId );
 reloadContent = ETrue;
 }
 }
 }
 else if ( aRequestId == iCurrentHtmlBodyFetchRequestId && iFetchingHtmlMessageBody )
 {
 iFetchingHtmlMessageBody = EFalse;
 }
 else if ( aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete )
 {
 iAsyncProcessComplete = ETrue;
 iFetchingHtmlMessageBody = EFalse;
 reloadContent = ETrue;
 }
 }
 else if ( aRequestId == iCurrentStructureFetchRequestId && iFetchingMessageStructure )
 {
 if ( aEvent.iError != KErrNone ||
 {
 iContainer->HideDownloadStatus();
 }
 if ( reloadContent )
 {
 if (  iContainer )
 {
 iContainer->ResetContent();
 if( iMessage )
 {
 LoadContentFromMailMessageL( iMessage , EFalse);
 SetMskL();
 }
 }
 }
 if(iAsyncProcessComplete && iWaitDialog && iDialogNotDismissed)
 {
 iWaitDialog->ProcessFinishedL(); // deletes the dialog
 }
 if ( iAppUi.DownloadInfoMediator() && messageChanged )
 {
 iAppUi.DownloadInfoMediator()->AddObserver( this, iMessage->GetMessageId() );
 }
 }
-UpdateToolbarL();
 }
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::CancelFetchings
 // -----------------------------------------------------------------------------
 {
 TRAP_IGNORE( iAppUi.GetMailClient()->CancelL( iCurrentStructureFetchRequestId ) );
 iFetchingMessageStructure = EFalse;
 }
 iAsyncProcessComplete = ETrue;
 //also cancel embedded images download in DownloadInfoMediator
 if ( iMailBox )
 {
 TRAP_IGNORE( iAppUi.DownloadInfoMediator()->CancelAllDownloadsL( iMailBox->GetId() ) );
 }
 //<cmail>
 if(iWaitDialog && iDialogNotDismissed)
 TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); // deletes the dialog
 //</cmail>
 /*iWaitDialog = new(ELeave)CAknWaitDialog(
 (REINTERPRET_CAST(CEikDialog**,&iWaitDialog)), ETrue);
 iWaitDialog->SetCallback(this);
 iDialogNotDismissed = ETrue;
 iWaitDialog->ExecuteLD(R_FSE_FETCHING_WAIT_DIALOG);
 */
 if( iMessage )
 {
 StartFetchingMessagePartL( *iMessage, iStartAsyncFetchType );
 }
 //  iFetchingAlready = ETrue;
 break;
 }
 return ret;
 }
 void CFsEmailUiHtmlViewerView::ProcessAsyncCommandL( TESMRIcalViewerOperationType aCommandId,
 const CFSMailMessage& aMessage,
 MESMRIcalViewerObserver* aObserver )
 {
 FUNC_LOG;
 // iAppUi.EnterFsEmailViewL( DownloadManagerViewId );
 //}
 }
 break;
 case EESMRCmdMailComposeMessage:
 {
 iAppUi.CreateNewMailL();
 iOpResult.iResultCode = KErrNone;
 }
 break;
 case EESMRCmdMailReply:
 // Show message in standard mail viewer in case launchin MRUI fails for any
 // other reason than viewer being cancelled by calling CancelPendingMrCommand().
 if ( aResult.iOpType == EESMRViewLaunch )
 {
 iMrUiActive = EFalse;
 // load mr content to viewer so we don't end up with empty view
 if (  iContainer )
 {
 iContainer->ResetContent();
 }
 if( iMessage )
 {
 TRAP_IGNORE( LoadContentFromMailMessageL( iMessage ) );
 TRAP_IGNORE( SetMskL() );
 }
 }
 }
 iAppUi.MrViewerInstanceL()->CancelOperation();
 }
 iMrUiActive = EFalse;
 iMrObserverToInform = NULL;
 }
 // -----------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::ClearMailViewer
 // -----------------------------------------------------------------------------
 void CFsEmailUiHtmlViewerView::ClearMailViewer()
 {
 iOpenMessages = NULL;
 delete iEmbeddedMessages;
 iEmbeddedMessages = NULL;
 iMessage = NULL;
 CancelFetchings();
 delete iMailBox;
 iMailBox = NULL;
 }
 void CFsEmailUiHtmlViewerView::ReloadPageL(  )
 {
 FUNC_LOG;
 if( iContainer )
 {
 iContainer->ReloadPageL();
 TBool CFsEmailUiHtmlViewerView::GetAsyncFetchStatus()
 {
 return ( iFetchingHtmlMessageBody || iFetchingMessageStructure || iFetchingPlainTextMessageBody );
 }
 // ---------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::UpdateEmailHeaderIndicatorsL
 // ---------------------------------------------------------------------------
 //
 void CFsEmailUiHtmlViewerView::UpdateEmailHeaderIndicators()
 //
 TBool CFsEmailUiHtmlViewerView::IsOpenedInMRViewerL()
 {
 FUNC_LOG;
 TBool retVal( EFalse );
 CFSMailMessage* msg = iAppUi.GetMailClient()->GetMessageByUidL(
 iActivationData.iMailBoxId, iActivationData.iFolderId,
 iActivationData.iMessageId, EFSMsgDataEnvelope );
 if ( msg )
 {
 CleanupStack::PushL( msg );
 if ( msg->IsFlagSet( EFSMsgFlag_CalendarMsg ) &&
 iAppUi.MrViewerInstanceL() )
 {
 TESMRMeetingRequestMethod mrMethod( EESMRMeetingRequestMethodUnknown );
 mrMethod = iAppUi.MrViewerInstanceL()->ResolveMeetingRequestMethodL( *msg );
 // Opened in MR viewer if request/cancellation or unknown MR
 retVal =
 mrMethod == EESMRMeetingRequestMethodRequest ||
 mrMethod == EESMRMeetingRequestMethodCancellation ||
 mrMethod == EESMRMeetingRequestMethodUnknown;
 }
 CleanupStack::PopAndDestroy( msg );
 // CFsEmailUiHtmlViewerView::CopyToClipBoardL
 // -----------------------------------------------------------------------------
 void CFsEmailUiHtmlViewerView::CopyCurrentToClipBoardL( const TDesC& aArgument ) const
 {
 FUNC_LOG;
 // Making sure that we are copying something to the clipboard
 if ( aArgument.Length() > 0 )
 {
 HBufC* clipBoardText = aArgument.AllocLC();
 CClipboard* cb = CClipboard::NewForWritingLC( CCoeEnv::Static()->FsSession() );
 cb->StreamDictionary().At( KClipboardUidTypePlainText );
 plainText->InsertL( 0 , *clipBoardText );
 plainText->CopyToStoreL( cb->Store(), cb->StreamDictionary(), 0, plainText->DocumentLength() );
 CleanupStack::PopAndDestroy( plainText );
 cb->CommitL();
 CleanupStack::PopAndDestroy( cb );
 CleanupStack::PopAndDestroy( clipBoardText );
 }
 }
 // --------------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::OpenLinkInBrowserL
 // --------------------------------------------------------------------------------
 void CFsEmailUiHtmlViewerView::OpenLinkInBrowserL( const TDesC& aUrl ) const
 {
 FUNC_LOG;
 // Create session
 RApaLsSession session;
 User::LeaveIfError( session.Connect() );
 CleanupClosePushL( session );
 // Gets the default application UID for for the given MIME type
 TUid uid;
 TDataType dataType( _L8( "text/html" ) );
 session.AppForDataType( dataType, uid );
 // Runs the default application using the dataType
 TThreadId threadId;
 User::LeaveIfError( session.StartDocument( aUrl , dataType, threadId ) );
 CleanupStack::PopAndDestroy(); // session
 }
 // --------------------------------------------------------------------------------
 // CFsEmailUiHtmlViewerView::SaveWebAddressToFavouritesL
 // --------------------------------------------------------------------------------
 void CFsEmailUiHtmlViewerView::SaveWebAddressToFavouritesL( const TDesC& aUrl ) const
 {
 FUNC_LOG;
 HBufC* url = aUrl.AllocLC();
 RFavouritesSession fSession;
 User::LeaveIfError( fSession.Connect() );
 CleanupClosePushL( fSession );
 RFavouritesDb favourites;
 CleanupStack::PopAndDestroy( favouritesItem );
 CleanupStack::PopAndDestroy( &favourites );
 CleanupStack::PopAndDestroy( &fSession );
 CleanupStack::PopAndDestroy( url );
 if ( error == KErrNone )
 {
 TFsEmailUiUtility::ShowInfoNoteL(
 R_FREESTYLE_EMAIL_UI_VIEWER_BOOKMARK_ADDED, ETrue );
 }
 R_FREESTYLE_EMAIL_ERROR_GENERAL_UNABLE_TO_COMPLETE, ETrue );
 }
 }
 /*
 * Delaying the fetch for MfE till the user scrolls to the bottom of
 * the message.
 */
 void CFsEmailUiHtmlViewerView::StartFetchingMessageL()
 {
 	if( iMessage )
 	    {
 }
 else
 {
 type = EMessagePlainTextBodyPart;
 }
 if ( !MessagePartFullyFetchedL( type ))
 {
 iAsyncProcessComplete = EFalse;
 iStartAsyncFetchType = type;
 //check to make sure we don't kick off fetch twice for the cases where bodypart
 //not found(OZ)
 if(iMessage && !GetAsyncFetchStatus())
 {
 StartFetchingMessagePartL( *iMessage, type );
 }
 CFSMailMessagePart* bodyPart = iMessage->HtmlBodyPartL();
 if ( !bodyPart )
 {
 bodyPart = iMessage->PlainTextBodyPartL();
 }
 if ( bodyPart )
 {
 aMessageBodyStructurePresent = ETrue;
 CleanupStack::PushL( bodyPart );
 if ( bodyPart->FetchedContentSize() == 0 && bodyPart->ContentSize() != 0 )
 {
 aMessageBodyContentPresent = EFalse;
 }
 else
 {
 aMessageBodyContentPresent = ETrue;
 }
 CleanupStack::PopAndDestroy( bodyPart );
 }
 else
 {
 aMessageBodyStructurePresent = EFalse;
 FUNC_LOG;
 TInt err( KErrNone );
 return err;
 }
-CFlagSelectionNoteHandler::CFlagSelectionNoteHandler(  CFsEmailUiHtmlViewerView& aViewerVisualiser )
+CFlagSelectionNoteHandler::CFlagSelectionNoteHandler( CFsEmailUiHtmlViewerView& aViewerVisualiser )
 : CActive ( EPriorityHigh ),
 iViewerView( aViewerVisualiser )
 {
 FUNC_LOG;
 CActiveScheduler::Add( this );

branch	RCL_3
changeset 60	d620048b4810
parent 52	efd4f1afd43e
child 61	dcf0eedfc1a3