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

equal deleted inserted replaced

-:6b8f3b30d0ec
+:efd4f1afd43e
 // CONST VALUES
 const TInt KControlBarTransitionTime = 250;
 const TInt KMaxPreviewPaneLength = 60;
 const TInt KMsgUpdaterTimerDelay = 2500000; // Time to update list, 2,5sec
+const TInt KNewMailTimerDelay = 20; // sleeping timer to start processing new messages
+const TInt KNewMailMaxBatch = 7;    // number of new mails inserted into list at once
 static const TInt KMsgDeletionWaitNoteAmount = 5;
 _LIT( KMissingPreviewDataMarker, "..." );
 static const TInt KMaxItemsFethed = 1000;
 static const TInt KCMsgBlock = 15;
-static const TInt KCMsgMaxBlock = 120;
+static const TInt KCMsgBlockSort = 50;
 // ---------------------------------------------------------------------------
 // Generic method for deleting a pointer and setting it NULL.
 // ---------------------------------------------------------------------------
 //
 //
 template <class T> void TDeleteTask<T>::Reset()
 {
 iEntries.Reset();
 }
 // CMailListModelUpdater
-// ---------------------------------------------------------------------------
-// Constructor
+// ---------------------------------------------------------------------------
+// CMailListModelUpdater::NewL
+// ---------------------------------------------------------------------------
+//
+CMailListModelUpdater* CMailListModelUpdater::NewL()
+{
+CMailListModelUpdater* self = new (ELeave) CMailListModelUpdater();
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop( self );
+return self;
+}
+// ---------------------------------------------------------------------------
+// CMailListModelUpdater::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CMailListModelUpdater::ConstructL()
+{
+User::LeaveIfError( iTimer.CreateLocal() );
+}
+// ---------------------------------------------------------------------------
+// CMailListModelUpdater::CMailListModelUpdater
 // ---------------------------------------------------------------------------
 //
 CMailListModelUpdater::CMailListModelUpdater() : CActive(EPriorityStandard)
 {
 CActiveScheduler::Add(this);
-}
+iBlockSize = KCMsgBlock;
+}
-// ---------------------------------------------------------------------------
-// Destructor
+// ---------------------------------------------------------------------------
+// CMailListModelUpdater::~CMailListModelUpdater
 // ---------------------------------------------------------------------------
 //
 CMailListModelUpdater::~CMailListModelUpdater()
 {
 iObserver = NULL;
 Cancel();
 iSorting.Close();
+iTimer.Close();
 }
 // ---------------------------------------------------------------------------
 // Returns arrays for sorting parameters. Updater owns the arrays because
 // it has to stay alive as long as the iterator is being used.
 // ---------------------------------------------------------------------------
 // Update the mail list model from given iterator. Update progress will be
 // informed to the observer.
 // ---------------------------------------------------------------------------
 //
-void CMailListModelUpdater::UpdateModelL(MObserver& aObserver, MFSMailIterator* aIterator)
+void CMailListModelUpdater::UpdateModelL(MObserver& aObserver,
+MFSMailIterator* aIterator, TInt aBlockSize)
 {
 Cancel();
 iObserver = &aObserver;
 iIterator = aIterator;
 Signal(EInitialize);
+iBlockSize = aBlockSize;
 }
 // ---------------------------------------------------------------------------
 // Internal method. Sets new state and signals itself.
 // ---------------------------------------------------------------------------
 //
-void CMailListModelUpdater::Signal(TState aState, TInt aError)
+void CMailListModelUpdater::Signal(TState aState, TInt /*aError*/)
 {
+const TInt KDelayInMicroSeconds = 5 * 1000; // 5 ms
+// timer used to get CAknWaitDialog animation working
 iState = aState;
-iStatus = KRequestPending;
+iTimer.After(iStatus, KDelayInMicroSeconds);
 SetActive();
-TRequestStatus* status = &iStatus;
-User::RequestComplete(status, aError);
+//iState = aState;
+//iStatus = KRequestPending;
+//SetActive();
+//TRequestStatus* status = &iStatus;
+//User::RequestComplete(status, aError);
 }
 // ---------------------------------------------------------------------------
 // Initialization state. Reset update and call UpdateBeginL() for the observer.
 // ---------------------------------------------------------------------------
 //
 void CMailListModelUpdater::InitializeL()
 {
-iBlockSize = KCMsgBlock;
 iParentId = KFsTreeRootID;
 iId = TFSMailMsgId();
 iItemsFetched = 0;
 iObserver->UpdateBeginL();
 Signal(EFetch);
 // fetch state again OR proceed to finalizing state.
 // ---------------------------------------------------------------------------
 //
 void CMailListModelUpdater::FetchL()
 {
-RPointerArray<CFSMailMessage> messages(iBlockSize);
+TInt blockSize = iBlockSize;
+if ( iItemsFetched == 0 )
+{
+blockSize = KCMsgBlock;
+}
+RPointerArray<CFSMailMessage> messages(blockSize);
 CleanupClosePushL(messages);
-const TBool moreMessages(iIterator->NextL(iId, iBlockSize, messages));
-iBlockSize = Min(KCMsgMaxBlock, iBlockSize * 2);
+const TBool moreMessages(iIterator->NextL(iId, blockSize, messages));
 if (messages.Count() > 0)
 {
 iItemsFetched += messages.Count();
 iId = messages[messages.Count() - 1]->GetMessageId();
 iObserver->UpdateProgressL(iParentId, messages);
 }
 CleanupStack::PopAndDestroy(); // messages.Close()
 if (moreMessages && iItemsFetched < KMaxItemsFethed)
 {
 Signal(EFetch);
 }
 else
 break;
 }
 }
 else
 {
-iObserver->UpdateErrorL(error);
+User::Leave(error);  // causes RunError to be called
 }
 }
 // ---------------------------------------------------------------------------
 // Update has been cancelled. Inform the observer and free resources.
 if (iObserver)
 {
 iObserver->UpdateCancelled(IsUpdating());
 }
 Reset();
-}
+iTimer.Cancel();
+}
+// ---------------------------------------------------------------------------
+// CMailListModelUpdater::RunError
+// ---------------------------------------------------------------------------
+//
+TInt CMailListModelUpdater::RunError(TInt aError)
+{
+if ( aError != KErrNone )
+{
+TRAP_IGNORE( iObserver->UpdateErrorL( aError ) );
+}
+return aError;
+}
 // ---------------------------------------------------------------------------
 // Static constructor.
 // ---------------------------------------------------------------------------
 //
 	{
 FUNC_LOG;
 	BaseConstructL( R_FSEMAILUI_MAIL_LIST_VIEW );
-	iMailListModelUpdater = new (ELeave) CMailListModelUpdater();
+	iMailListModelUpdater = CMailListModelUpdater::NewL();
 	// Don't construct this anywhere else than here.
 	// Don't delete this until in the destructor to avoid NULL checks.
 iModel = CFSEmailUiMailListModel::NewL( &iAppUi );
 	iAsyncCallback = new (ELeave) CAsyncCallBack( CActive::EPriorityStandard );
 	iAsyncRedrawer = new (ELeave) CAsyncCallBack( CActive::EPriorityLow );
 	iLastFocus = EFalse;
 iDeleteTask = new (ELeave) TDeleteTask<CFSEmailUiMailListVisualiser> (*this, HandleDeleteTaskL);
+iNewMailTimer = CFSEmailUiGenericTimer::NewL( this );
 	iTouchFeedBack = MTouchFeedback::Instance();
 	}
 // ---------------------------------------------------------------------------
 // Set empty text
 HBufC* emptyText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_EMPTY_MSG_LIST_TEXT );
 iMailTreeListVisualizer->SetEmptyListTextL( *emptyText );
 CleanupStack::PopAndDestroy( emptyText );
-TRgb normalColor = iAppUi.LayoutHandler()->ListNormalStateTextSkinColor();
+iFocusedTextColor = iAppUi.LayoutHandler()->ListFocusedStateTextSkinColor();
-iMailTreeListVisualizer->RootNodeVisualizer()->SetNormalStateTextColor( normalColor );
+iNormalTextColor = iAppUi.LayoutHandler()->ListNormalStateTextSkinColor();
+iNodeTextColor = iAppUi.LayoutHandler()->ListNodeTextColor();
+iMailTreeListVisualizer->RootNodeVisualizer()->SetNormalStateTextColor( iNormalTextColor );
 // Set page up and page down keys
 iMailTreeListVisualizer->AddCustomPageUpKey( EStdKeyPageUp );
 iMailTreeListVisualizer->AddCustomPageDownKey( EStdKeyPageDown );
 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;
+DeleteSortWaitNote();
+delete iNewMailTimer;
+iNewMailIds.Close();
 }
 void CFSEmailUiMailListVisualiser::PrepareForExit()
 {
 FUNC_LOG;
 iMailListModelUpdater->Cancel();
 if ( iMsgNoteTimer )
 {
-iMsgNoteTimer->Cancel();
+// delete also cancels timer
 SafeDelete(iMsgNoteTimer);
 }
 if ( iDateChangeTimer )
 {
-iDateChangeTimer->Cancel();
+// delete also cancels timer
 SafeDelete(iDateChangeTimer);
 }
 if ( iMailListUpdater )
 {
-iMailListUpdater->Stop();
+// delete also cancels timer
 SafeDelete(iMailListUpdater);
 }
 if ( iAsyncRedrawer )
 {
-iAsyncRedrawer->Cancel();
 SafeDelete(iAsyncRedrawer);
 }
 if ( iAsyncCallback )
 {
-iAsyncCallback->Cancel();
 SafeDelete(iAsyncCallback);
 }
 if ( iMailList )
 {
 iMailList->RemoveObserver( *this );
 }
 if ( iControlBarControl )
 {
 iControlBarControl->RemoveObserver( *this );
 }
+if ( iNewMailTimer )
+{
+// delete also cancels timer
+SafeDelete( iNewMailTimer );
+}
 SafeDelete(iMailFolder);
 iTreeItemArray.Reset();
 	// Reset, not delete to avoid NULL checks.
 iModel->Reset();
 // Resources freed, new start required
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::UpdateErrorL(TInt aError)
 {
 FUNC_LOG;
+DeleteSortWaitNote();
 User::Leave(aError);
 }
 // ---------------------------------------------------------------------------
 // @see CMailListModelUpdater::MObserver::UpdateBeginL
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::UpdateBeginL()
 {
 FUNC_LOG;
+iMailList->BeginUpdate();
+iMailList->RemoveAllL();
+iTreeItemArray.Reset();
 iModel->Reset();
-iTreeItemArray.Reset();
+iMailList->EndUpdateL();
+SetListAndCtrlBarFocusL();
 }
 // ---------------------------------------------------------------------------
 // @see CMailListModelUpdater::MObserver::UpdateProgressL
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::UpdateProgressL(TFsTreeItemId& aParentId, RPointerArray<CFSMailMessage>& aMessages)
 {
 FUNC_LOG;
 const TInt itemsInModel(iModel->Count());
 CreateModelItemsL(aMessages);
 RefreshListItemsL(aParentId, itemsInModel, iModel->Count());
 }
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::UpdateCompleteL()
 {
 FUNC_LOG;
+TBool sorting = EFalse;
+if ( iSortWaitNote )
+{
+sorting = ETrue;
+}
+DeleteSortWaitNote();
 if ( !iModel->Count() )
 {
 iFocusedControl = EControlBarComponent;
 }
 else
 {
 iMailList->SetFocusedItemL( iTreeItemArray[0].iListItemId );
 }
 }
 SetListAndCtrlBarFocusL();
-if(!CheckAutoSyncSettingL())
+if( !CheckAutoSyncSettingL() && !sorting )
 {
 iAppUi.StartMonitoringL();
 }
 TIMESTAMP( "Locally stored messages fetched for message list" );
 }
 // ---------------------------------------------------------------------------
 // @see CMailListModelUpdater::MObserver::UpdateCancelled
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::UpdateCancelled(const TBool aForceRefresh)
 {
 FUNC_LOG;
 iForceRefresh = aForceRefresh;
+DeleteSortWaitNote();
+}
+// ---------------------------------------------------------------------------
+// CFSEmailUiMailListVisualiser::DeleteSortWaitNote
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiMailListVisualiser::DeleteSortWaitNote()
+{
+if ( iSortWaitNote )
+{
+TRAP_IGNORE( iSortWaitNote->ProcessFinishedL() );
+iSortWaitNote = NULL;
+}
+}
+// ---------------------------------------------------------------------------
+// Asynchronous mail list model sort.
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiMailListVisualiser::SortMailListModelAsyncL()
+{
+FUNC_LOG;
+DeleteSortWaitNote();
+TBool ret = UpdateMailListModelAsyncL( KCMsgBlockSort );
+if ( ret )
+{
+TFsEmailUiUtility::ShowWaitNoteL( iSortWaitNote, R_FSE_WAIT_SORTING_TEXT, EFalse, ETrue );
+}
 }
 // ---------------------------------------------------------------------------
 // Asynchronous mail list model update.
 // ---------------------------------------------------------------------------
 //
-void CFSEmailUiMailListVisualiser::UpdateMailListModelAsyncL()
+TBool CFSEmailUiMailListVisualiser::UpdateMailListModelAsyncL(TInt aBlockSize)
 {
 FUNC_LOG;
+TBool ret = EFalse;
 if ( iMailFolder )
 {
 TFSMailDetails details( EFSMsgDataEnvelope );
 RArray<TFSMailSortCriteria>& sorting(iMailListModelUpdater->Sorting());
 sorting.AppendL( iCurrentSortCriteria );
 secondarySortCriteria.iField = EFSMailSortByDate;
 secondarySortCriteria.iOrder = EFSMailDescending;
 sorting.AppendL( secondarySortCriteria );
 }
 // List all or maximum number of messages
-iMailListModelUpdater->UpdateModelL(*this, iMailFolder->ListMessagesL(details, sorting));
+iMailListModelUpdater->UpdateModelL(*this, iMailFolder->ListMessagesL(details, sorting), aBlockSize);
+ret = ETrue;
 }
 else
 {
 UpdateCompleteL();
 }
+return ret;
 }
 // ---------------------------------------------------------------------------
 //
 //
 		{
 		if (iModel->Count())
 		    {
 		    CFSMailMessage* nextMessage = aMessages[0];
 		    CFSEmailUiMailListModelItem* previousMessage(static_cast<CFSEmailUiMailListModelItem*>(iModel->Item(iModel->Count() - 1)));
-TBool needANewDivider =
+if ( previousMessage ) // Safety
-!MessagesBelongUnderSameSeparatorL( previousMessage->MessagePtr(), *nextMessage );
+{
-if ( needANewDivider )
+TBool needANewDivider =
-{
+!MessagesBelongUnderSameSeparatorL( previousMessage->MessagePtr(), *nextMessage );
-newItem = CreateSeparatorModelItemLC( *nextMessage );
+if ( needANewDivider )
-iModel->AppendL( newItem );
+{
-CleanupStack::Pop( newItem );
+newItem = CreateSeparatorModelItemLC( *nextMessage );
+iModel->AppendL( newItem );
+CleanupStack::Pop( newItem );
+}
 }
 }
 		else
 		    {
 	    newItem = CreateSeparatorModelItemLC( *aMessages[0] );
 {
 // Set extended status before inserting messages
 SetMailListItemsExtendedL();
 TInt count(0);
 count = aMessages.Count();
 for ( TInt i = 0 ; i < count ; ++i )
 {
 // Make sure we don't add duplicate items.
 TInt existingIdx = ItemIndexFromMessageId( aMessages[i] );
 if ( existingIdx < 0 )
 {
-CFSMailMessage* msgPtr = iAppUi.GetMailClient()->GetMessageByUidL( iAppUi.GetActiveMailboxId(),
+iNewMailIds.Append( aMessages[ i ] );
-iMailFolder->GetFolderId(),
+}
-aMessages[i] ,
+}
-EFSMsgDataEnvelope );
-if (msgPtr == NULL)
+// if iNewMailIds is not empty - start timer
-{
+if ( !iNewMailTimer->IsActive() && iNewMailIds.Count() )
-User::Leave(KErrNotFound);
+{
-}
+iNewMailTimer->Start( KNewMailTimerDelay );
-CleanupStack::PushL( msgPtr );
+}
-//first item - show scrollbar
+}
-//last item - updete scrollbar
+}
-TBool allowRefresh = ( i == 0 || i == count - 1 );
-InsertNewMessageL( msgPtr, allowRefresh );
-CleanupStack::Pop( msgPtr ); // ownership transferred to model
+// ---------------------------------------------------------------------------
-}
+// TimerEventL
-}
+//
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiMailListVisualiser::TimerEventL( CFSEmailUiGenericTimer* /*aTriggeredTimer*/ )
+{
+TInt count = Min( KNewMailMaxBatch, iNewMailIds.Count() );
+CFSMailClient* mailClient = iAppUi.GetMailClient();
+for ( TInt i = 0; i < count; i++ )
+{
+CFSMailMessage* msgPtr = mailClient->GetMessageByUidL( iAppUi.GetActiveMailboxId(),
+iMailFolder->GetFolderId(),
+iNewMailIds[ 0 ],
+EFSMsgDataEnvelope );
+if ( msgPtr != NULL )
+{
+CleanupStack::PushL( msgPtr );
+//first item - show scrollbar
+//last item - update scrollbar
+TBool allowRefresh = ( i == 0 || i == count - 1 );
+InsertNewMessageL( msgPtr, allowRefresh );
+CleanupStack::Pop( msgPtr ); // ownership transferred to model
+}
+// pop processed id from the queue, this is single thread operation
+iNewMailIds.Remove( 0 );
+}
+// if timer stoped then restart if more messages available
+if ( iNewMailIds.Count() && ! iNewMailTimer->IsActive() )
+{
+iNewMailTimer->Start( KNewMailTimerDelay );
 }
 }
 // ---------------------------------------------------------------------------
 // InsertNewMessageL
 	TInt newCount(0);
 	for ( TInt i=0; i<iModel->Count();i++)
 		{
 		CFSEmailUiMailListModelItem* item =
 			static_cast<CFSEmailUiMailListModelItem*>(iModel->Item(i));
-		if ( item->ModelItemType() == ETypeMailItem )
+		if ( item && item->ModelItemType() == ETypeMailItem )
 			{
 			if ( !item->MessagePtr().IsFlagSet(EFSMsgFlag_Read) )
 				{
 				newCount++;
 				}
 // NOW WE HAVE A VALID MAILBOX AND FOLDER ID.
 // Tries to create an extension for the Ozone plugin
 CreateExtensionL();
+// if mailbox changed stop timer driven insertion of new mails into list
+if ( activationData.iMailBoxId != prevMailBoxId )
+{
+iNewMailTimer->Cancel();
+iNewMailIds.Reset();
+}
 // CHECK IF MODEL NEEDS TO BE UPDATED
 if ( activationData.iMailBoxId != prevMailBoxId ||
 activationData.iFolderId != prevFolderId ||
 activationData.iRequestRefresh ||
 iForceRefresh )
 {
 UpdateMailListModelL();
 }
 else
 {
-UpdateMailListModelAsyncL();
+UpdateMailListModelAsyncL( KCMsgBlockSort );
 }
 }
 else if(refreshState == EFocusChangeNeeded)
 {//Move focus to the beginning of the list
 TInt firstIndex(0);
-TFsTreeItemId firstItemId = iMailList->Child( KFsTreeRootID, firstIndex );
+TFsTreeItemId firstItemId(KFsTreeNoneID);
+if ( iMailList->CountChildren( KFsTreeRootID ) )
+{
+firstItemId = iMailList->Child( KFsTreeRootID, firstIndex );
+}
 iMailTreeListVisualizer->SetFocusedItemL( firstItemId, EFalse );
 //if the view is already active don't update the list so it won't "blink"
 //when the view is activated.
 if(!iThisViewActive)
 {
 iMailList->ShowListL();
 }
 }
 // THE CORRECT FOLDER IS ALREADY OPEN. CHECK IF SOME PARTIAL UPDATE IS NEEDED.
 else
 {
 iMailList->ShowListL();
 if ( !iMailList->IsNode(iTreeItemArray[i].iListItemId ) &&
 iMailList->IsMarked( iTreeItemArray[i].iListItemId ))
 {
 CFSEmailUiMailListModelItem* item =
 static_cast<CFSEmailUiMailListModelItem*>( Model()->Item(i) );
-CFSMailMessage* confirmedMsgPtr(0);
+if ( item ) // Safety
-confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL(iAppUi.GetActiveMailboxId(),
-iMailFolder->GetFolderId(), item->MessagePtr().GetMessageId(), EFSMsgDataEnvelope );
-TBool isReadMessage = confirmedMsgPtr->IsFlagSet( EFSMsgFlag_Read );
-delete confirmedMsgPtr;
-if ( !isReadMessage )
 {
-ret = EFalse;
+CFSMailMessage* confirmedMsgPtr(0);
-break;
+confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL(iAppUi.GetActiveMailboxId(),
+iMailFolder->GetFolderId(), item->MessagePtr().GetMessageId(), EFSMsgDataEnvelope );
+TBool isReadMessage = confirmedMsgPtr->IsFlagSet( EFSMsgFlag_Read );
+delete confirmedMsgPtr;
+if ( !isReadMessage )
+{
+ret = EFalse;
+break;
+}
 }
 }
 }
 		}
 return ret;
 if ( !iMailList->IsNode(iTreeItemArray[i].iListItemId ) &&
 iMailList->IsMarked( iTreeItemArray[i].iListItemId ))
 {
 CFSEmailUiMailListModelItem* item =
 static_cast<CFSEmailUiMailListModelItem*>( Model()->Item(i) );
-CFSMailMessage* confirmedMsgPtr(0);
+if ( item ) // Safety
-confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL(iAppUi.GetActiveMailboxId(),
-iMailFolder->GetFolderId(), item->MessagePtr().GetMessageId(), EFSMsgDataEnvelope );
-TBool isReadMessage = confirmedMsgPtr->IsFlagSet( EFSMsgFlag_Read );
-delete confirmedMsgPtr;
-if ( isReadMessage )
 {
-ret = EFalse;
+CFSMailMessage* confirmedMsgPtr(0);
-break;
+confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL(iAppUi.GetActiveMailboxId(),
+iMailFolder->GetFolderId(), item->MessagePtr().GetMessageId(), EFSMsgDataEnvelope );
+TBool isReadMessage = confirmedMsgPtr->IsFlagSet( EFSMsgFlag_Read );
+delete confirmedMsgPtr;
+if ( isReadMessage )
+{
+ret = EFalse;
+break;
+}
 }
 }
 }
 }
 return ret;
 // ---------------------------------------------------------------------------
 //
 TFsTreeItemId CFSEmailUiMailListVisualiser::InsertListItemL( TInt aModelIndex,
 TFsTreeItemId aParentNodeId,
 TInt aChildIdx, /*= KErrNotFound*/
-TBool aAllowRefresh )
+TBool aAllowRefresh /*= ETrue*/ )
 {
 FUNC_LOG;
-TRect screenRec( iAppUi.ClientRect() );
 CFsTreePlainTwoLineItemData* itemData = NULL;
 CFsTreePlainTwoLineItemVisualizer* itemVisualizer = NULL;
-TRgb focusedColor = iAppUi.LayoutHandler()->ListFocusedStateTextSkinColor();
-TRgb normalColor = iAppUi.LayoutHandler()->ListNormalStateTextSkinColor();
 CFSEmailUiMailListModelItem* item =
 static_cast<CFSEmailUiMailListModelItem*>( iModel->Item(aModelIndex) );
 // Create data
 itemData = CFsTreePlainTwoLineItemData::NewL();
 	TBool previewOn = ( iListMode == EListControlTypeDoubleLinePreviewOn ||
 iListMode == EListControlTypeSingleLinePreviewOn );
 	itemVisualizer->SetPreviewPaneOn( previewOn );
 	itemVisualizer->SetExtendable( ETrue );
-itemVisualizer->SetFocusedStateTextColor( focusedColor );
+	// Set correct skin text colors for the list items
-itemVisualizer->SetNormalStateTextColor( normalColor );
+	itemVisualizer->SetFocusedStateTextColor( iFocusedTextColor );
+itemVisualizer->SetNormalStateTextColor( iNormalTextColor );
 // Set font height
 itemVisualizer->SetFontHeight( iAppUi.LayoutHandler()->ListItemFontHeightInTwips() );
 //Update icons and text bolding
 static_cast<CFsTreePlainTwoLineItemData*>( iTreeItemArray[idx].iTreeItemData );
 if ( data->PreviewPaneData() == KMissingPreviewDataMarker )
 {
 CFSEmailUiMailListModelItem* modelItem =
 static_cast<CFSEmailUiMailListModelItem*>( iModel->Item(idx) );
-CFSMailMessage& msgRef = modelItem->MessagePtr();
+if ( modelItem ) // For safety
-UpdatePreviewPaneTextForItemL( aListItemId, &msgRef );
-if ( aUpdateItem )
 {
-iMailTreeListVisualizer->UpdateItemL( aListItemId );
+CFSMailMessage& msgRef = modelItem->MessagePtr();
+UpdatePreviewPaneTextForItemL( aListItemId, &msgRef );
+if ( aUpdateItem )
+{
+iMailTreeListVisualizer->UpdateItemL( aListItemId );
+}
 }
 }
 }
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiMailListVisualiser::CreatePlainNodeL( const TDesC* aItemDataBuff,
 CFsTreePlainOneLineNodeData* &aItemData,
 CFsTreePlainOneLineNodeVisualizer* &aNodeVisualizer ) const
-	{
+{
 FUNC_LOG;
 aItemData = CFsTreePlainOneLineNodeData::NewL();
 CleanupStack::PushL( aItemData );
 aItemData->SetDataL( *aItemDataBuff );
-	aItemData->SetIconExpanded( iAppUi.FsTextureManager()->TextureByIndex( EListTextureNodeExpanded ));
+aItemData->SetIconExpanded( iAppUi.FsTextureManager()->TextureByIndex( EListTextureNodeExpanded ));
 aItemData->SetIconCollapsed( iAppUi.FsTextureManager()->TextureByIndex( EListTextureNodeCollapsed ));
 aNodeVisualizer = CFsTreePlainOneLineNodeVisualizer::NewL(*iMailList->TreeControl());
 CleanupStack::PushL( aNodeVisualizer );
-TRect screenRect = iAppUi.ClientRect();
 TInt nodeHeight = iAppUi.LayoutHandler()->OneLineListNodeHeight();
-aNodeVisualizer->SetSize( TSize(screenRect.Width(), nodeHeight) );
+// use cached client rect instead of iAppUi.ClientRect() to save time
+// ASSERT in debug to be sure that rects are these same
+__ASSERT_DEBUG( iAppUi.ClientRect() == iCurrentClientRect, User::Invariant() );
+aNodeVisualizer->SetSize( TSize(iCurrentClientRect.Width(), nodeHeight) );
 aNodeVisualizer->SetExtendable(EFalse);
-	// Set correct skin text colors for the list items
+// Set correct skin text colors for the list items
-	TRgb focusedColor = iAppUi.LayoutHandler()->ListFocusedStateTextSkinColor();
+aNodeVisualizer->SetFocusedStateTextColor( iFocusedTextColor );
-	TRgb normalColor = iAppUi.LayoutHandler()->ListNodeTextColor();
+aNodeVisualizer->SetNormalStateTextColor( iNodeTextColor );
-aNodeVisualizer->SetFocusedStateTextColor( focusedColor );
+// Set font height
-aNodeVisualizer->SetNormalStateTextColor( normalColor );
+aNodeVisualizer->SetFontHeight( iAppUi.LayoutHandler()->ListItemFontHeightInTwips() );
-	// Set font height
+// Set font always bolded in nodes
-	aNodeVisualizer->SetFontHeight( iAppUi.LayoutHandler()->ListItemFontHeightInTwips() );
+aNodeVisualizer->SetTextBold( ETrue );
-	// Set font always bolded in nodes
-	aNodeVisualizer->SetTextBold( ETrue );
 //<cmail>
 CAlfBrush* titleDividerBgBrush =
 iAppUi.FsTextureManager()->TitleDividerBgBrushL();
 // ownership is not transfered
-	aNodeVisualizer->SetBackgroundBrush( titleDividerBgBrush );
+aNodeVisualizer->SetBackgroundBrush( titleDividerBgBrush );
 //</cmail>
-	CleanupStack::Pop( aNodeVisualizer );
+CleanupStack::Pop( aNodeVisualizer );
-	CleanupStack::Pop( aItemData );
+CleanupStack::Pop( aItemData );
-	}
+}
 // ---------------------------------------------------------------------------
 //
 //
 // ---------------------------------------------------------------------------
 UpdateThemeL();
 }
 else if ( aType == EScreenLayoutChanged )
 {
 UpdateButtonTextsL();
+iAppUi.FsTextureManager()->ClearTextureByIndex( EListControlBarMailboxDefaultIcon );
+iFolderListButton->SetIconL( iAppUi.FsTextureManager()->TextureByIndex( EListControlBarMailboxDefaultIcon ) );
+iAppUi.FsTextureManager()->ClearTextureByIndex( EListTextureCreateNewMessageIcon );
+iNewEmailButton->SetIconL( iAppUi.FsTextureManager()->TextureByIndex( EListTextureCreateNewMessageIcon ) );
+iAppUi.FsTextureManager()->ClearTextureByIndex( GetSortButtonTextureIndex() );
+iSortButton->SetIconL( iAppUi.FsTextureManager()->TextureByIndex( GetSortButtonTextureIndex() ) );
+ScaleControlBarL();
 }
 }
 // ---------------------------------------------------------------------------
 // Update texts for command area buttons
 //
 void CFSEmailUiMailListVisualiser::UpdateThemeL(const TBool aSystemUpdate)
 {
 iSkinChanged = iSkinChanged || aSystemUpdate;
-TRgb focusedTextColor = iAppUi.LayoutHandler()->ListFocusedStateTextSkinColor();
+iFocusedTextColor = iAppUi.LayoutHandler()->ListFocusedStateTextSkinColor();
-TRgb normalTextColor = iAppUi.LayoutHandler()->ListNormalStateTextSkinColor();
+iNormalTextColor = iAppUi.LayoutHandler()->ListNormalStateTextSkinColor();
+iNodeTextColor = iAppUi.LayoutHandler()->ListNodeTextColor();
-iNewEmailButton->SetNormalTextColor( normalTextColor );
-iNewEmailButton->SetFocusedTextColor( focusedTextColor );
+iNewEmailButton->SetNormalTextColor( iNormalTextColor );
+iNewEmailButton->SetFocusedTextColor( iFocusedTextColor );
-iFolderListButton->SetNormalTextColor( normalTextColor );
-iFolderListButton->SetFocusedTextColor( focusedTextColor );
+iFolderListButton->SetNormalTextColor( iNormalTextColor );
+iFolderListButton->SetFocusedTextColor( iFocusedTextColor );
-iSortButton->SetNormalTextColor( normalTextColor );
-iSortButton->SetFocusedTextColor( focusedTextColor );
+iSortButton->SetNormalTextColor( iNormalTextColor );
+iSortButton->SetFocusedTextColor( iFocusedTextColor );
 //sometimes theme wasn't properly refreshed on buttons, this helps
 iNewEmailButton->HideButton();
 iNewEmailButton->ShowButtonL();
 if ( iModel->Count() )
 {
 CFSEmailUiMailListModelItem* item =
 static_cast<CFSEmailUiMailListModelItem*>( iModel->Item( HighlightedIndex() ) );
-if ( item->ModelItemType() == ETypeMailItem )  // Separators are not markable
+if ( item && item->ModelItemType() == ETypeMailItem )  // Separators are not markable
 {
 if ( iMailList->IsMarked( iMailList->FocusedItem() ) )
 {
 iMailList->MarkItemL( iMailList->FocusedItem(), EFalse );
 iListMarkItemsState = EFalse;
 if ( iModel->Count() )
 // </cmail>
 {
 CFSEmailUiMailListModelItem* selectedItem =
 static_cast<CFSEmailUiMailListModelItem*>( iModel->Item( aIndex ));
-CFSMailMessage& msgPtr = selectedItem->MessagePtr();
+if ( selectedItem ) // Safety
-TBool msgWasReadBefore = msgPtr.IsFlagSet( EFSMsgFlag_Read );
+{
-if ( aRead != msgWasReadBefore )
+CFSMailMessage& msgPtr = selectedItem->MessagePtr();
-{
+TBool msgWasReadBefore = msgPtr.IsFlagSet( EFSMsgFlag_Read );
-if ( aRead )
+if ( aRead != msgWasReadBefore )
 {
-// Send flags, local and server
+if ( aRead )
-msgPtr.SetFlag( EFSMsgFlag_Read );
+{
-}
+// Send flags, local and server
-else
+msgPtr.SetFlag( EFSMsgFlag_Read );
-{
+}
-// Send flags, local and server
+else
-msgPtr.ResetFlag( EFSMsgFlag_Read );
+{
-}
+// Send flags, local and server
-msgPtr.SaveMessageL();  // Save flag
+msgPtr.ResetFlag( EFSMsgFlag_Read );
+}
-// Switch icon to correct one if mail list is visible
+msgPtr.SaveMessageL();  // Save flag
-TBool needRefresh = ( iAppUi.CurrentActiveView()->Id() == MailListId );
-UpdateMsgIconAndBoldingL( aIndex, needRefresh);
+// Switch icon to correct one if mail list is visible
+TBool needRefresh = ( iAppUi.CurrentActiveView()->Id() == MailListId );
-if ( iCurrentSortCriteria.iField == EFSMailSortByUnread )
+UpdateMsgIconAndBoldingL( aIndex, needRefresh);
-{
-// Attribute affecting the current sorting order has been changed.
+if ( iCurrentSortCriteria.iField == EFSMailSortByUnread )
-// Thus, the list order may now be incorrect.
+{
-iListOrderMayBeOutOfDate = ETrue;
+// Attribute affecting the current sorting order has been changed.
+// Thus, the list order may now be incorrect.
+iListOrderMayBeOutOfDate = ETrue;
+}
 }
 }
 }
 }
 if ( aIndex >= 0 && aIndex < iModel->Count() )
 // </cmail>
 {
 CFSEmailUiMailListModelItem* modelItem =
 static_cast<CFSEmailUiMailListModelItem*>( Model()->Item( aIndex ) );
-if ( modelItem->ModelItemType() == ETypeMailItem )
+if ( modelItem && modelItem->ModelItemType() == ETypeMailItem )
 {
 // This is beacause message deleted event migh have occured.
 CFSMailMessage* confirmedMsgPtr = NULL;
 TRAP_IGNORE( confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL( iAppUi.GetActiveMailboxId(),
 iMailFolder->GetFolderId(),
 	if ( iModel->Count() )
 // </cmail>
 		{
 		CFSEmailUiMailListModelItem* item =
 			static_cast<CFSEmailUiMailListModelItem*>( Model()->Item( HighlightedIndex() ) );
-		if ( item->ModelItemType() == ETypeMailItem )
+		if ( item && item->ModelItemType() == ETypeMailItem )
 			{
 			// This is beacause message deleted event migh have occured.
 			CFSMailMessage* confirmedMsgPtr = NULL;
 			TRAP_IGNORE( confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL( iAppUi.GetActiveMailboxId(),
 								                                                     iMailFolder->GetFolderId(),
 		if ( mailItemIdx >= 0 )
 			{
 			CFSEmailUiMailListModelItem* item =
 				static_cast<CFSEmailUiMailListModelItem*>( Model()->Item( mailItemIdx ) );
-			// Update all flags
+if ( item ) // For safety
-			TUint32 prevFlags = item->MessagePtr().GetFlags();
+{
-			TUint32 newFlags = aMsgPtr->GetFlags();
+// Update all flags
-			if ( prevFlags != newFlags )
+TUint32 prevFlags = item->MessagePtr().GetFlags();
-			    {
+TUint32 newFlags = aMsgPtr->GetFlags();
-			    item->MessagePtr().ResetFlag( prevFlags );
+if ( prevFlags != newFlags )
-			    item->MessagePtr().SetFlag( newFlags );
+{
+item->MessagePtr().ResetFlag( prevFlags );
-			    // Save changed flags in internal model array
+item->MessagePtr().SetFlag( newFlags );
-			    item->MessagePtr().SaveMessageL();
-			    }
+// Save changed flags in internal model array
+item->MessagePtr().SaveMessageL();
-			// Update the list item graphics
+}
-			UpdateMsgIconAndBoldingL( mailItemIdx );
-			}
+// Update the list item graphics
+UpdateMsgIconAndBoldingL( mailItemIdx );
+}
+}
 		}
 	}
 // ---------------------------------------------------------------------------
 // UpdateMsgIconAndBoldingL
 if ( 0 <= aItemIdx && aItemIdx < iModel->Count() )
 // </cmail>
 {
 CFSEmailUiMailListModelItem* item =
 			static_cast<CFSEmailUiMailListModelItem*>(iModel->Item(aItemIdx));
-	if ( item->ModelItemType() == ETypeMailItem )
+	if ( item && item->ModelItemType() == ETypeMailItem )
 	    {
 	    msgId = item->MessagePtr().GetMessageId();
 	    }
 }
 const TInt modelCount( iModel->Count() );
 for( TInt i( 0 ) ; i < modelCount ; ++i )
 {
 CFSEmailUiMailListModelItem* item =
 static_cast<CFSEmailUiMailListModelItem*>( iModel->Item( i ) );
-if ( aListId == item->CorrespondingListId() )
+if ( item && aListId == item->CorrespondingListId() )
 {
 msgId = item->MessagePtr().GetMessageId();
 // if list id points to separator
 // set flag on. This is made for improving focus handling.
 if( item->ModelItemType() == ETypeSeparator )
 	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( item && &(item->MessagePtr()) != NULL)
-				{
+{
-		if ( aMessageId == item->MessagePtr().GetMessageId() )
+if ( aMessageId == item->MessagePtr().GetMessageId() )
-			{
-			TModelItemType itemType = item->ModelItemType();
-			TBool separator( aMessageId.IsSeparator() );
-			// Because separator and the first message after separator
-			// have same message id, we need to separate these cases
-			// and that is made with separator flag which is stored to
-			// TFSMailMsgId object. If separator flag is on item need to be
-			// separator if it is not on item needs to be mail item.
-			if( ( separator && itemType == ETypeSeparator ) ||
-			    ( !separator && itemType == ETypeMailItem ) )
 {
-idx = i;
+TModelItemType itemType = item->ModelItemType();
-break;
+TBool separator( aMessageId.IsSeparator() );
+// Because separator and the first message after separator
+// have same message id, we need to separate these cases
+// and that is made with separator flag which is stored to
+// TFSMailMsgId object. If separator flag is on item need to be
+// separator if it is not on item needs to be mail item.
+if( ( separator && itemType == ETypeSeparator ) ||
+( !separator && itemType == ETypeMailItem ) )
+{
+idx = i;
+break;
+}
 }
-			}
+}
-		}
+}
-}
 		}
 	return idx;
 }
 // ---------------------------------------------------------------------------
 const TInt count = iModel->Count();
 for ( TInt i=0; i < count; i++ )
 	{
 	const CFSEmailUiMailListModelItem* item =
 		    static_cast<const CFSEmailUiMailListModelItem*>( iModel->Item(i) );
-	if ( aItemId == item->CorrespondingListId() )
+	if ( item && aItemId == item->CorrespondingListId() )
 		{
 		ret = i;
 		break;
 		}
 	}
 	iFocusedControl = EControlBarComponent;
 	iMailList->SetFocusedL( EFalse );
 iControlBarControl->SetFocusByIdL( iSortButtonId );
+SortMailListModelAsyncL();  // sort can take long time
 // <cmail>
-	if ( iMailListUpdater )
+	//if ( iMailListUpdater )
-	    {
+	//    {
 	// Start updating mail list with sorting parameter.
-	iMailListUpdater->StartL( ETrue );
+//	iMailListUpdater->StartL( ETrue );
-	    }
+	//    }
 // </cmail>
 	SetMskL();
 	}
 // ---------------------------------------------------------------------------
 	TInt idx = ModelIndexFromListId( aMailItem );
 	if ( idx >= 0 )
 	    {
 	    CFSEmailUiMailListModelItem* item =
 	        static_cast<CFSEmailUiMailListModelItem*>( Model()->Item(idx) );
-	    if ( item->ModelItemType() == ETypeMailItem )
+	    if ( item && item->ModelItemType() == ETypeMailItem )
 	        {
 	        // First make sure that the highlighted message really exists in the store
 	        // Get confirmed msg ptr
 	        CFSMailMessage* confirmedMsgPtr(0);
 	        confirmedMsgPtr = iAppUi.GetMailClient()->GetMessageByUidL(iAppUi.GetActiveMailboxId(),
 // </cmail>
 {
 		CFSEmailUiMailListModelItem* item =
 			static_cast<CFSEmailUiMailListModelItem*>( iModel->Item( HighlightedIndex() ) );
-		if ( item->ModelItemType() == ETypeMailItem )  // Separators are not markable
+		if ( item && item->ModelItemType() == ETypeMailItem )  // Separators are not markable
 		    {
 			if ( !iListMarkItemsState )
 				{
 			iMailList->MarkItemL( iMailList->FocusedItem(), EFalse );
 				}

branch	RCL_3
changeset 20	efd4f1afd43e
parent 18	6b8f3b30d0ec
child 22	d620048b4810