MCL/sf/app/commonemail: comparison emailuis/emailui/src/FreestyleEmailUiMailListVisualiser.cpp

equal deleted inserted replaced

-:e1b6206813b4
+:f5907b1a1053
 #include "FreestyleEmailUiContactHandler.h"
 #include "FreestyleEmailUiLauncherGridVisualiser.h"
 #include "FreestyleEmailUiHtmlViewerView.h"
 #include "FSDelayedLoader.h"
 #include "FSEmail.pan"
+#include "fsemailstatuspaneindicatorhandler.h"
 // CONST VALUES
 const TInt KControlBarTransitionTime = 250;
 const TInt KMaxPreviewPaneLength = 60;
 const TInt KMsgUpdaterTimerDelay = 2500000; // Time to update list, 2,5sec
 {
 delete ptr;
 ptr = NULL;
 }
+// TDeleteTask
+// Task class for deleting mail
+// ---------------------------------------------------------------------------
+// Class definition
+// ---------------------------------------------------------------------------
+template <class T> struct TDeleteTask
+{
+public:
+typedef void ( T::*TDeleteMethod )( const RFsTreeItemIdList& aEntries );
+public:
+TDeleteTask(T& aObject, TDeleteMethod aMethod);
+~TDeleteTask();
+void ExecuteL();
+RFsTreeItemIdList& Entries();
+void Reset();
+private:
+T& iObject;
+TDeleteMethod iMethod;
+RFsTreeItemIdList iEntries;
+};
+// ---------------------------------------------------------------------------
+// TDeleteTask<T>::TDeleteTask
+// ---------------------------------------------------------------------------
+//
+template <class T> TDeleteTask<T>::TDeleteTask( T& aObject, TDeleteMethod aMethod )
+: iObject(aObject), iMethod(aMethod)
+{
+}
+// ---------------------------------------------------------------------------
+// TDeleteTask<T>::~TDeleteTask
+// ---------------------------------------------------------------------------
+//
+template <class T> TDeleteTask<T>::~TDeleteTask()
+{
+iEntries.Close();
+}
+// ---------------------------------------------------------------------------
+// TDeleteTask<T>::ExecuteL
+// ---------------------------------------------------------------------------
+//
+template <class T> void TDeleteTask<T>::ExecuteL()
+{
+(iObject.*iMethod)(iEntries);
+Reset();
+}
+// ---------------------------------------------------------------------------
+// TDeleteTask<T>::Entries
+// ---------------------------------------------------------------------------
+//
+template <class T> RFsTreeItemIdList& TDeleteTask<T>::Entries()
+{
+return iEntries;
+}
+// ---------------------------------------------------------------------------
+// TDeleteTask<T>::Reset
+// ---------------------------------------------------------------------------
+//
+template <class T> void TDeleteTask<T>::Reset()
+{
+iEntries.Reset();
+}
 // CMailListModelUpdater
 // ---------------------------------------------------------------------------
 // Constructor
 // ---------------------------------------------------------------------------
 	iFirstStartCompleted = EFalse;
 	iAsyncCallback = new (ELeave) CAsyncCallBack( CActive::EPriorityStandard );
 	iAsyncRedrawer = new (ELeave) CAsyncCallBack( CActive::EPriorityLow );
 	iLastFocus = EFalse;
+iDeleteTask = new (ELeave) TDeleteTask<CFSEmailUiMailListVisualiser> (*this, HandleDeleteTaskL);
+	iTouchFeedBack = MTouchFeedback::Instance();
 	}
 // CFSEmailUiMailListVisualiser::DoFirstStartL()
 // Purpose of this function is to do first start things only when list is
 // really needed to be shown. Implemented to make app startuo faster.
 // ---------------------------------------------------------------------------
 //
 CFSEmailUiMailListVisualiser::~CFSEmailUiMailListVisualiser()
 {
 FUNC_LOG;
+if (iExtension)
+{
+iAppUi.GetMailClient()->ReleaseExtension(iExtension);
+}
 SafeDelete(iMailListModelUpdater);
 SafeDelete(iMailFolder);
 delete iTouchManager;
 delete iStylusPopUpMenu;
 delete iMailList;
 delete iNewEmailText;
 	// Don't construct this anywhere else than in constructor.
 	// Don't delete anywhere else thatn here to avoid NULL checks.
 delete iModel;
+delete iDeleteTask;
 }
 void CFSEmailUiMailListVisualiser::PrepareForExit()
 {
 FUNC_LOG;
 }
 SafeDelete(iMailFolder);
 iTreeItemArray.Reset();
 	// Reset, not delete to avoid NULL checks.
 iModel->Reset();
+// Resources freed, new start required
+iFirstStartCompleted = EFalse;
 }
 // ---------------------------------------------------------------------------
 // Returns reference to mail list.
 // ---------------------------------------------------------------------------
 iMailList->SetFocusedItemL( iTreeItemArray[0].iListItemId );
 }
 }
 SetListAndCtrlBarFocusL();
 iAppUi.StartMonitoringL();
 TIMESTAMP( "Locally stored messages fetched for message list" );
 }
 // ---------------------------------------------------------------------------
 // @see CMailListModelUpdater::MObserver::UpdateCancelled
 // ---------------------------------------------------------------------------
 static_cast<CFSEmailUiMailListModelItem*>( iModel->Item(idx) );
 TFsTreeItemId nextNodeId = nextNode->CorrespondingListId();
 TInt nodeIdxUnderRoot = iMailList->ChildIndex( KFsTreeRootID, nextNodeId );
 InsertNodeItemL( idx-1, nodeIdxUnderRoot, aAllowRefresh );
 }
 moveViewPortPosition += iAppUi.LayoutHandler()->OneLineListItemHeight();
 }
 else
 {
 // Suitable parent node exists and was found
 parentNode = static_cast<CFSEmailUiMailListModelItem*>( iModel->Item(parentIdx) );
 // Insert the tree list item
 TPoint viewPortCenterPos = iMailTreeListVisualizer->ViewPosition();
 TPoint viewPortTopPos = iMailTreeListVisualizer->ViewPortTopPosition();
 TInt itemPos = iMailTreeListVisualizer->GetItemWorldPosition( idx );
 TBool refresh = viewPortTopPos.iY != 0 && itemPos < viewPortCenterPos.iY;
 if( refresh )
 	{
 		InsertListItemL( idx, parentId, childIdx, EFalse );
 		// viewPort update needed
 		moveViewPortPosition += iAppUi.LayoutHandler()->TwoLineListItemHeight(); // add mail item height
 	if ( !iFirstStartCompleted )
 	    {
 	    DoFirstStartL();
 	    }
+// set when editor was called so reset is needed i.e. here (Called by DoActivate)
+	iMailOpened = EFalse;
 // Make sure that pending popup is not displayd
 	if ( iAppUi.FolderList().IsPopupShown() )
 {
 iAppUi.FolderList().HidePopupL();
 // Set control bar and list layout size always in activation
 TRect clientRect = iAppUi.ClientRect();
 iScreenAnchorLayout->SetSize( clientRect.Size() );
 SetMailListLayoutAnchors();
-TInt listHeight = clientRect.Height() - iAppUi.LayoutHandler()->ControlBarHeight();
-iListLayout->SetSize( TSize( clientRect.Width(), listHeight ) ); // needs to be set separately to avoid layout problems in some special cases
 ScaleControlBarL();
 SetListAndCtrlBarFocusL();
 	// Update mail list settings and date formats, is done every time
 	// the user might have changed these in settings, so the list needs to refresh
 	UpdateMailListSettingsL();
 	UpdateMailListTimeDateSettings();
 	// Check for changed settings, in that case a complete list refresh is needed
 	TBool refreshNeeded(EFalse);
-	if ( iSkinChanged
+	if ( aCustomMessageId == KStartListWithFolderIdFromHomeScreen
+	     || iSkinChanged
 	     || iDateChanged
 	     || iListMode != prevListMode
 		 || iNodesInUse != prevNodesmode
 		 || iCurrentZoomLevel != prevZoomLevel
 		 || prevDateFormats.iDateFormat != iDateFormats.iDateFormat
 		 || prevDateFormats.iTimeFormat != iDateFormats.iTimeFormat
 		 || prevDateFormats.iAmPmPosition != iDateFormats.iAmPmPosition
-		 || prevDateFormats.iDateSeparator != iDateFormats.iDateSeparator
+		 || prevDateFormats.iDateSeparator.GetNumericValue() != iDateFormats.iDateSeparator.GetNumericValue()
-		 || prevDateFormats.iTimeSeparator != iDateFormats.iTimeSeparator )
+		 || prevDateFormats.iTimeSeparator.GetNumericValue() != iDateFormats.iTimeSeparator.GetNumericValue() )
 		{
 		refreshNeeded = ETrue;
 		iSkinChanged = EFalse;
 		iDateChanged = EFalse;
 		}
 activationData.iFolderId = iAppUi.GetActiveBoxInboxId();
 }
 }
 // NOW WE HAVE A VALID MAILBOX AND FOLDER ID.
+// Tries to create an extension for the Ozone plugin
+CreateExtensionL();
 // CHECK IF MODEL NEEDS TO BE UPDATED
 if ( activationData.iMailBoxId != prevMailBoxId ||
 activationData.iFolderId != prevFolderId ||
 activationData.iRequestRefresh ||
 SetMskL();
 }
 iCurrentClientRect = clientRect;
 	iThisViewActive = ETrue;
+	//emailindicator handling, we dont care if something goes wrong in the mailindicator update. User can still open the mailbox
-	// Set email indicator off.. user has checked the new emails
+	TRAP_IGNORE(TFsEmailStatusPaneIndicatorHandler::StatusPaneMailIndicatorHandlingL( activationData.iMailBoxId.Id()));
-	TFsEmailUiUtility::ToggleEmailIconL(EFalse, activationData.iMailBoxId );
+//Update mailbox widget index status in homescreen
+TFsEmailUiUtility::ToggleEmailIconL(EFalse, activationData.iMailBoxId );
 	iShiftDepressed = EFalse; // clear state just in case
 	// Inform MR observer if needed, special MR case, returning from attachment list
 	iAppUi.MailViewer().CompletePendingMrCommand();
 	if ( aResourceId == R_FSEMAILUI_MAILLIST_MENUPANE )
 	    {
 // Sync/cancel sync
 	    CFSMailBox* activeMailbox = iAppUi.GetActiveMailbox();
 	    TBool supportsSync = activeMailbox->HasCapability( EFSMBoxCapaSupportsSync );
 // flag to hide or show SyncButton
 TBool hideSync = GetLatestSyncState();
 if(activeMailbox->CurrentSyncState()==StartingSync) hideSync=EFalse;
 // hide or show options: Sync/cancel sync
 if ( !supportsSync )
 {
-aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, ETrue );
+				// POP3 behaviour
-aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
+				TFSMailBoxStatus onlineStatus = activeMailbox->GetMailBoxStatus();
-}
+				if( onlineStatus == EFSMailBoxOnline || iMailListModelUpdater->IsUpdating() )
-else if ( hideSync || iMailListModelUpdater->IsUpdating() )
+				  {
-{
+					aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, EFalse );
-aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
+					aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
-}
+				  }
-else
+				else
-{
+					{
-aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, ETrue );
+					aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, ETrue );
-}
+					aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, EFalse );
+					}
+}
+else if ( hideSync || iMailListModelUpdater->IsUpdating() )
+{
+aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
+}
+else
+{
+aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, ETrue );
+}
 		// Saves a focus visibility.
 		iLastFocus = EFalse;
 		if( iFocusedControl == EMailListComponent && IsFocusShown() )
 		    {
 		    iLastFocus = ETrue;
 	{
 FUNC_LOG;
 	iMailList->RemoveAllL();
 	iTreeItemArray.Reset();
 // when we get refresh mail list updates should be fully enabled
 iMailOpened = EFalse;
 	RefreshListItemsL();
 	if ( !iModel->Count() )
 		{
 		iFocusedControl = EControlBarComponent;
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-void CFSEmailUiMailListVisualiser::UpdateTheme()
+void CFSEmailUiMailListVisualiser::UpdateTheme(const TBool aSystemUpdate)
 {
-iSkinChanged = ETrue;
+iSkinChanged = aSystemUpdate;
 TRgb focusedTextColor = iAppUi.LayoutHandler()->ListFocusedStateTextSkinColor();
 TRgb normalTextColor = iAppUi.LayoutHandler()->ListNormalStateTextSkinColor();
 iNewEmailButton->SetNormalTextColor( normalTextColor );
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::HandleForegroundEventL( TBool aForeground )
 	{
 FUNC_LOG;
 if( iMailFolder )
 {
+//emailindicator handling, we dont care if something goes wrong in the mailindicator update. User can still open the mailbox
+TRAP_IGNORE(TFsEmailStatusPaneIndicatorHandler::StatusPaneMailIndicatorHandlingL( iMailFolder->GetMailBoxId().Id()));
+//Update mailbox widget index status in homescreen
 TFsEmailUiUtility::ToggleEmailIconL(EFalse, iMailFolder->GetMailBoxId() );
 }
-if ( aForeground && iFirstStartCompleted ) // Safety
+	if ( iFirstStartCompleted ) // Safety
 	    {
 	    // Update mail list settings and date formats, is done every time
 	    // the user might have changed these in settings, so the list needs to refresh
 	    // Store previous modes
 	    TInt prevListMode = iListMode;
 break;
 }
 }
 	case EAknSoftkeySelect:
 	    {
 	    TIMESTAMP( "Open email selected from message list" );
 	    if ( iFocusedControl == EMailListComponent )
 	        {
 	        CFSEmailUiMailListModelItem* item = dynamic_cast<CFSEmailUiMailListModelItem*>(iModel->Item(HighlightedIndex()));
 	        // MAIL ITEM; OPEN MAIL
 	        if ( item && item->ModelItemType() == ETypeMailItem )
 }
 break;
 	case EFsEmailUiCmdActionsDeleteCalEvent:
 		case EFsEmailUiCmdActionsDelete:
 			{
 			TIMESTAMP( "Delete to selected from message list" );
 			TInt index = HighlightedIndex();
 			CFSEmailUiMailListModelItem* item =
 				dynamic_cast<CFSEmailUiMailListModelItem*>(
 						iModel->Item( index ) );
 			// If selected item is separator (divider) mark/unmark all messages
 			// under it.
-			if ( item && item->ModelItemType() == ETypeSeparator )
-				{
-				MarkItemsUnderSeparatorL( ETrue, index );
-				}
 			// Delete message only if mail list component is focused
 			// or if there are some marked items
 			TInt markedItems( CountMarkedItemsL() );
+const TBool isNode(iMailList->IsNode(iMailList->FocusedItem()));
-			if ( iFocusedControl == EMailListComponent || markedItems )
+if (iFocusedControl == EMailListComponent || markedItems
-				{
+|| isNode)
-				DeleteMessagesL();
+{
-				}
+DeleteMessagesL();
-			}
+}
+}
 break;
 		case EFsEmailUiCmdCompose:
 			{
 			TIMESTAMP( "Create new message selected from message list" );
 			CreateNewMsgL();
 			}
 			break;
 	case EFsEmailUiCmdMessageDetails:
 			{
 		}
 		break;
 	case EFsEmailUiCmdOpen:
 case EFsEmailUiCmdActionsOpen:
 	{
 	TIMESTAMP( "Open email selected from message list" );
 	        if ( iFocusedControl == EMailListComponent )
 	            {
 	            // Opening can happen only when there's exactly one message marked or in focus
 	            if ( actionTargetItems.Count() == 1 )
 	                {
 			    if(!GetLatestSyncState())
 			        {
 			        iAppUi.SyncActiveMailBoxL();
 			        // Sync was started by the user
 			        ManualMailBoxSync(ETrue);
 iAppUi.ManualMailBoxSync( ETrue );
 			        }
 			    }
+			  else
+			    {
+			    //POP3 synchronise
+				iAppUi.DoAutoConnectL();
+				}
 			}
 			break;
 	case EFsEmailUiCmdCancelSync:
 		{
-		TBool supportsSync = iAppUi.GetActiveMailbox()->HasCapability( EFSMBoxCapaSupportsSync );
+TBool supportsSync = iAppUi.GetActiveMailbox()->HasCapability( EFSMBoxCapaSupportsSync );
-		if ( supportsSync )
+if ( supportsSync )
-		    {
+		       {
 	            iAppUi.StopActiveMailBoxSyncL();
 	            // Sync was started by the user
 	            ManualMailBoxSync(ETrue);
 	            iAppUi.ManualMailBoxSync( ETrue );
-		    }
+}
+		     else
+		        {
+		         //POP3
+iAppUi.GetActiveMailbox()->GoOfflineL();
+}
 		}
 		break;
 case EFsEmailUiCmdGoOffline:
 	{
 	   	iAppUi.GetActiveMailbox()->GoOfflineL();
 	    default:
 	break;
 } // switch ( aCommand )
 CleanupStack::PopAndDestroy( &actionTargetItems );
 TIMESTAMP( "Message list selected operation done" );
 }
 // ---------------------------------------------------------------------------
 //
 //
 if ( item && item->ModelItemType() == ETypeMailItem )
 {
 CFSMailMessage* messagePtr = &item->MessagePtr();
 if ( messagePtr )
 {
 TIMESTAMP( "Open email selected from message list" );
 OpenHighlightedMailL();
 return EKeyWasConsumed;
 }
 }
 // SEPARAOR ITEM; COLLAPSE / EXPAND NODE
 if ( messagePtr )
 {
 TIMESTAMP( "Open email selected from message list" );
 OpenHighlightedMailL();
 }
+// Give feedback to user (vibration)
+iTouchFeedBack->InstantFeedback(ETouchFeedbackBasic);
 }
 // SEPARATOR ITEM; COLLAPSE / EXPAND NODE
 else if ( item && item->ModelItemType() == ETypeSeparator )
 {
 ExpandOrCollapseL();
 	textLayout.LayoutText(TRect(0,0,0,0), AknLayoutScalable_Apps::main_sp_fs_ctrlbar_ddmenu_pane_t1(var));
 	iNewEmailButton->SetTextFontL( textLayout.Font()->FontSpecInTwips() );
 	iFolderListButton->SetTextFontL( textLayout.Font()->FontSpecInTwips() );
 	iSortButton->SetTextFontL( textLayout.Font()->FontSpecInTwips() );
-	UpdateTheme();
+	UpdateTheme(EFalse);
 	iNewEmailButton->ShowButtonL();
 	iFolderListButton->ShowButtonL();
 	iSortButton->ShowButtonL();
 	}
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::DeleteMessagesL()
 	{
 FUNC_LOG;
-	TInt markedCount = CountMarkedItemsL();
+const TInt markedCount(CountMarkedItemsL());
+const TFsTreeItemId focusedId(iMailList->FocusedItem());
-	// Delete either marked items or the focused one
-	if ( markedCount )
+// Delete either marked items or the focused one
-		{
+if (markedCount)
-		DeleteMarkedMessagesL();
+{
-		}
+DeleteMarkedMessagesL();
-	else
+}
-		{
+else if (iMailList->IsNode(focusedId))
-		DeleteFocusedMessageL();
+{
-		}
+DeleteMessagesUnderNodeL(focusedId);
+}
+else
+{
+DeleteFocusedMessageL();
+}
 	// Set highlight to control bar if no items after delete
 // <cmail>
 	if ( iModel->Count() == 0 )
 // </cmail>
 			}
 		}
 	}
 // ---------------------------------------------------------------------------
+// DeleteMessagesUnderNodeL
+//
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiMailListVisualiser::DeleteMessagesUnderNodeL(
+const TFsTreeItemId aNodeId)
+{
+FUNC_LOG;
+iModel->GetItemIdsUnderNodeL(aNodeId, iDeleteTask->Entries());
+ConfirmAndStartDeleteTaskL(iDeleteTask);
+}
+// ---------------------------------------------------------------------------
 // DeleteMarkedMessagesL
 //
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::DeleteMarkedMessagesL()
-	{
+{
 FUNC_LOG;
-	RFsTreeItemIdList markedEntries;
+iMailList->GetMarkedItemsL(iDeleteTask->Entries());
-	CleanupClosePushL( markedEntries );
+ConfirmAndStartDeleteTaskL(iDeleteTask);
-	iMailList->GetMarkedItemsL( markedEntries );
+}
-	TInt okToDelete( ETrue );
+// ---------------------------------------------------------------------------
-if ( iAppUi.GetCRHandler()->WarnBeforeDelete() )
+// ConfirmAndStartDeleteTaskL
-{
+//
-HBufC* noteText( NULL );
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiMailListVisualiser::ConfirmAndStartDeleteTaskL(
+TDeleteTask<CFSEmailUiMailListVisualiser>* aTask )
+{
+FUNC_LOG;
+const RFsTreeItemIdList& entries(aTask->Entries());
+if (entries.Count())
+{
+if (ConfirmDeleteL(entries.Count(), entries[0]))
+{
+if (entries.Count() > KMsgDeletionWaitNoteAmount)
+{
+TFsEmailUiUtility::ShowWaitNoteL(iDeletingWaitNote,
+R_FSE_WAIT_DELETING_TEXT, EFalse, ETrue);
+}
+if (iAsyncCallback)
+{
+// Call actual deletion asynchronously because we must give wait
+// note time to show up before deletion begins.
+iAsyncCallback->Cancel();
+iAsyncCallback->Set(TCallBack(DoExecuteDeleteTask, aTask));
+iAsyncCallback->CallBack();
+}
+}
+else
+{
+aTask->Reset();
+}
+}
+}
+// ---------------------------------------------------------------------------
+// DoExecuteDeleteTask
+//
+// ---------------------------------------------------------------------------
+//
+TInt CFSEmailUiMailListVisualiser::DoExecuteDeleteTask( TAny* aSelfPtr )
+{
+FUNC_LOG;
+TRAPD( error,
+reinterpret_cast<TDeleteTask<CFSEmailUiMailListVisualiser>*>(aSelfPtr)->ExecuteL() );
+return error;
+}
+// ---------------------------------------------------------------------------
+// HandleDeleteTaskL
+// This is called asynchronously by ConfirmAndStartDeleteTaskL
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiMailListVisualiser::HandleDeleteTaskL( const RFsTreeItemIdList& aEntries )
+{
+FUNC_LOG;
+// Close wait note if it was used
+if ( iDeletingWaitNote )
+{
+TRAPD( result, HandleDeleteTaskLeavingCodeL(aEntries) );
+// closing the "Deleting" dialog message should not be skipped by leaving
+TRAP_IGNORE( iDeletingWaitNote->ProcessFinishedL() );
+if ( KErrNone != result )
+{
+// Handle error.
+User::Leave( result );
+}
+}
+else
+{
+HandleDeleteTaskLeavingCodeL( aEntries );
+}
+}
+// ---------------------------------------------------------------------------
+// original code HandleDeleteTaskL which may leave - help function to enable
+// calling iDeletingWaitNote->ProcessFinishedL()
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiMailListVisualiser::HandleDeleteTaskLeavingCodeL( const RFsTreeItemIdList& aEntries )
+{
+FUNC_LOG;
+TFSMailMsgId folderId = FolderId();
+TFSMailMsgId mailBox = iAppUi.GetActiveMailboxId();
+RArray<TFSMailMsgId> msgIds;
+CleanupClosePushL( msgIds );
+for ( TInt i = 0; i < aEntries.Count(); i++ )
+{
+msgIds.AppendL( MsgIdFromListId( aEntries[i] ) );
+}
+iAppUi.GetMailClient()->DeleteMessagesByUidL( mailBox, folderId, msgIds );
+// Remove from mail list if not already removed by mailbox events
+RemoveMsgItemsFromListIfFoundL( msgIds );
+CleanupStack::PopAndDestroy(); // msgIds.Close()
+}
+// ---------------------------------------------------------------------------
+// ConfirmDeleteL
+//
+// ---------------------------------------------------------------------------
+//
+TBool CFSEmailUiMailListVisualiser::ConfirmDeleteL(const TInt aItemCount,
+const TFsTreeItemId aItemId) const
+{
+FUNC_LOG;
+TBool result(ETrue);
+if (iAppUi.GetCRHandler()->WarnBeforeDelete())
+{
+HBufC* noteText(NULL);
 // The note depends on the amount and type of message(s)
-if ( markedEntries.Count() == 1 )
+if (aItemCount == 1)
 {
-CFSMailMessage& msgPtr = MsgPtrFromListIdL( markedEntries[0] );
+const CFSMailMessage& msgPtr(MsgPtrFromListIdL(aItemId));
+HBufC* msgSubject = TFsEmailUiUtility::CreateSubjectTextLC(
-HBufC* msgSubject = TFsEmailUiUtility::CreateSubjectTextLC( &msgPtr );
+&msgPtr);
-if ( msgPtr.IsFlagSet( EFSMsgFlag_CalendarMsg ))
+if (msgPtr.IsFlagSet(EFSMsgFlag_CalendarMsg))
 {
-noteText = StringLoader::LoadL( R_FREESTYLE_EMAIL_DELETE_CALEVENT_NOTE, *msgSubject );
+noteText = StringLoader::LoadL(
+R_FREESTYLE_EMAIL_DELETE_CALEVENT_NOTE, *msgSubject);
 }
 else
 {
-noteText = StringLoader::LoadL( R_FREESTYLE_EMAIL_DELETE_MAIL_NOTE, *msgSubject );
+noteText = StringLoader::LoadL(
-}
+R_FREESTYLE_EMAIL_DELETE_MAIL_NOTE, *msgSubject);
-CleanupStack::PopAndDestroy( msgSubject );
+}
-CleanupStack::PushL( noteText );
+CleanupStack::PopAndDestroy(msgSubject);
+CleanupStack::PushL(noteText);
 }
 else // markedEntries.Count() > 1
 {
-noteText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_DELETE_N_MAILS_NOTE, markedEntries.Count() );
+noteText = StringLoader::LoadLC(
+R_FREESTYLE_EMAIL_DELETE_N_MAILS_NOTE, aItemCount);
 }
 // Show the note
-okToDelete = TFsEmailUiUtility::ShowConfirmationQueryL( *noteText );
+result = TFsEmailUiUtility::ShowConfirmationQueryL(*noteText);
-CleanupStack::PopAndDestroy( noteText );
+CleanupStack::PopAndDestroy(noteText);
 }
+return result;
-if ( okToDelete )
-{
-if ( markedEntries.Count() > KMsgDeletionWaitNoteAmount )
-{
-TFsEmailUiUtility::ShowWaitNoteL( iDeletingWaitNote, R_FSE_WAIT_DELETING_TEXT, EFalse, ETrue );
-}
-// <cmail>
-if ( iAsyncCallback )
-{
-// Call actual deletion asynchronously because we must give wait
-// note time to show up before deletion begins.
-iAsyncCallback->Cancel();
-iAsyncCallback->Set( TCallBack(DoDeleteMarkedMessages, this) );
-iAsyncCallback->CallBack();
-}
-// </cmail>
-}
-else
-	{
-		UnmarkAllItemsL();
-	}
-CleanupStack::PopAndDestroy( &markedEntries );
-	}
-// ---------------------------------------------------------------------------
-// DoDeleteMarkedMessages
-//
-// ---------------------------------------------------------------------------
-//
-TInt CFSEmailUiMailListVisualiser::DoDeleteMarkedMessages( TAny* aSelfPtr )
-{
-FUNC_LOG;
-CFSEmailUiMailListVisualiser* self =
-static_cast<CFSEmailUiMailListVisualiser*>( aSelfPtr );
-TRAPD( err,
-RFsTreeItemIdList markedEntries;
-CleanupClosePushL( markedEntries );
-self->iMailList->GetMarkedItemsL( markedEntries );
-// Delete from FW first
-RArray<TFSMailMsgId> msgIds;
-CleanupClosePushL( msgIds );
-for ( TInt i=0 ; i<markedEntries.Count() ; i++ )
-{
-msgIds.Append( self->MsgIdFromListId( markedEntries[i] ) );
-}
-TFSMailMsgId folderId = self->FolderId();
-TFSMailMsgId mailBox = self->iAppUi.GetActiveMailboxId();
-self->iAppUi.GetMailClient()->DeleteMessagesByUidL( mailBox, folderId, msgIds );
-// Remove from mail list if not already removed by mailbox events
-self->RemoveMsgItemsFromListIfFoundL( msgIds );
-CleanupStack::PopAndDestroy( &msgIds );
-CleanupStack::PopAndDestroy( &markedEntries );
-);
-// Close wait note if it was used
-if ( self->iDeletingWaitNote )
-{
-TRAP_IGNORE( self->iDeletingWaitNote->ProcessFinishedL() );
-}
-return err;
 }
 // ---------------------------------------------------------------------------
 // RemoveUnnecessaryNodesL
 //
 	    const TInt modelCount( iModel->Count() );
 	for ( TInt i( 0 ); i < modelCount ; ++i )
 		{
 		CFSEmailUiMailListModelItem* item =
 static_cast<CFSEmailUiMailListModelItem*>( iModel->Item( i ) );
 			// when the item is a separator check whether its MessagePtr is valid (actually it's a reference)
 			if( &(item->MessagePtr()) != NULL)
 				{
 		if ( aMessageId == item->MessagePtr().GetMessageId() )
 			{
 			TModelItemType itemType = item->ModelItemType();
 			TBool separator( aMessageId.IsSeparator() );
 	        confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL(iAppUi.GetActiveMailboxId(),
 	                iMailFolder->GetFolderId(), item->MessagePtr().GetMessageId(), EFSMsgDataEnvelope );
 	        if ( confirmedMsgPtr )
 	            {
 	            iMailOpened = ETrue;
 	            ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
 	            // Pointer confirmed, store Id and delete not needed anymore
 	            TFSMailMsgId confirmedId = confirmedMsgPtr->GetMessageId();
 	      		TBool isCalMessage = confirmedMsgPtr->IsFlagSet( EFSMsgFlag_CalendarMsg );
 	      		TBool isReadMessage = confirmedMsgPtr->IsFlagSet( EFSMsgFlag_Read );
 		if ( item->ModelItemType() == ETypeMailItem )
 			{
 			// Add mark as read / unread options
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdMarkAsUnread, !IsMarkAsUnreadAvailableL() );
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdMarkAsRead, !IsMarkAsReadAvailableL() );
 			// Check support for object mail iten moving
 			TBool supportsMoving = iAppUi.GetActiveMailbox()->HasCapability( EFSMBoxCapaMoveToFolder );
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsMoveMessage, !supportsMoving );
 			// Hide / show follow up
 			TBool supportsFlag = TFsEmailUiUtility::IsFollowUpSupported( *iAppUi.GetActiveMailbox() );
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsFlag, !supportsFlag );
 			// Hide mark if applicable
 			if ( iMailList->IsMarked( iMailList->FocusedItem() ) )
 				{
 				iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdMark, ETrue );
 				}
 			// Hide collapse / expand all
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsCollapseAll, ETrue );
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsExpandAll, ETrue );
 			}
 		else if ( item->ModelItemType() == ETypeSeparator )
 			{
 			// Hide mark as read / unread options
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdMarkAsUnread, ETrue );
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdMarkAsRead, ETrue );
 			// Hide move & follow up
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsMoveMessage, ETrue );
 			iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsFlag, ETrue );
 			// Hide collapse / expand all when applicable
 			if ( iNodesInUse == EListControlSeparatorDisabled || !iModel->Count() )
 				{
 				iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsCollapseAll, ETrue );
 				iStylusPopUpMenu->SetItemDimmed( EFsEmailUiCmdActionsExpandAll, ETrue );
 	   			        {
 			   		ManualMailBoxSync(EFalse);
 	   				}
 		   		    }
 				    break;
 	    			case SyncCancelled:
 	    			    {
 	    			    //If sync was started by user, show the synchronisation indicator
 	    			    if ( iManualMailBoxSync )
 	    			        {
 	    			        ManualMailBoxSync(EFalse);
 	    			        }
 	    			    }
 	    			    break;
 	    			}
 			}
 			}
 		}
 	}
 {
 aLayoutArray.AppendL( iScreenAnchorLayout );
 aLayoutArray.AppendL( iControlBarControl->Visual() );
 }
+// Sets aActiveMailboxId and aActiveFolderId from iMailFolder if available
+TInt CFSEmailUiMailListVisualiser::GetActiveFolderId(TFSMailMsgId& aActiveMailboxId, TFSMailMsgId& aActiveFolderId) const
+{
+if (iMailFolder != NULL)
+{
+aActiveMailboxId = iMailFolder->GetMailBoxId();
+aActiveFolderId = iMailFolder->GetFolderId();
+return KErrNone;
+}
+else
+{
+return KErrNotFound;
+}
+}
+void CFSEmailUiMailListVisualiser::CreateExtensionL()
+{
+CFSMailBox* box = iAppUi.GetActiveMailbox();
+CEmailExtension* ext;
+if (box)
+{
+ext = box->ExtensionL( KEmailMailboxStateExtensionUid );
+}
+if (ext)
+{
+iExtension = reinterpret_cast<CMailboxStateExtension*>( ext );
+iExtension->SetStateDataProvider( this );
+}
+}
 //////////////////////////////////////////////////////////////////
 // Class implementation CMailListUpdater
 ///////////////////////////////////////////////////////////////////
 // -----------------------------------------------------------------------------
 //
 void CDateChangeTimer::RunL()
 {
 FUNC_LOG;
 if (iStatus.Int() != KErrNone)
 {
 	INFO_1("### CDateChangeTimer::RunL (err=%d) ###", iStatus.Int());
 }
 TBool dayChanged = EFalse;
 TInt dayCount = DayCount();
 if (dayCount != iDayCount)
 {
 iDayCount = dayCount;
 dayChanged = ETrue;
 }
 if ( KErrCancel == iStatus.Int() )
 {
 ;
 }
 else if ( KErrAbort == iStatus.Int() ) // System time changed
 {
 if (dayChanged)
 {
 TRAP_IGNORE( iMailListVisualiser.NotifyDateChangedL() );
 {
 // Update mail list and reissue the request for timer event
 TRAP_IGNORE( iMailListVisualiser.NotifyDateChangedL() );
 Start();
 }
 }
 TInt CDateChangeTimer::DayCount()
 {

branch	RCL_3
changeset 10	f5907b1a1053
parent 8	e1b6206813b4
child 11	0396474f30f5