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

equal deleted inserted replaced

-:8466d47a6819
+:12c456ceeff2
 /*
 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 * Contributors:
 *
 * Description:  FreestyleEmailUi folder list view implementation
 *
 */
 // SYSTEM INCLUDES
 #include "emailtrace.h"
 #include <AknUtils.h>
 #include <StringLoader.h>
 #include <eikcolib.h>
 #include <alf/alfdecklayout.h>
 #include <alf/alftextvisual.h>
 #include <alf/alfcontrolgroup.h>
 #include <alf/alfbrusharray.h>
+#include <alf/alfshadowborderbrush.h>
 #include <alf/alfevent.h>
 #include <alf/alfframebrush.h>
 #include <alf/alfstatic.h>
 // GENERIC LIST COMPONENT INCLUDES
 #include "FreestyleEmailUiLayoutData.h"
 #include "FreestyleEmailUiShortcutBinding.h"
 #include "ESMailSettingsPlugin.h"
 #include "FreestyleEmailUiStatusIndicator.h"
-// REMOVE WHEN DONE TESTING:
-//#include "CSimpleAOTest.h"
 // Defines the order of the folders in UI
 enum TFSEmailUiFolderListPriorities
 	{
 EFolderListPriorityInbox = 1,
 EFolderListPriorityDrafts,
 EFolderListIconServerFolders,
 	EFolderListIconMoreFolders,
 EFolderListIconEmailAccount
 	};
+// Defines the order of the sort list icons in the sort icon array
+enum TFsEmailUiSortListIcons
+	{
+	ESortListAttachmentAscIcon = 0,
+	ESortListAttachmentDescIcon,
+	ESortListDateAscIcon,
+	ESortListDateDescIcon,
+	ESortListFollowAscIcon,
+	ESortListFollowDescIcon,
+	ESortListPriorityAscIcon,
+	ESortListPriorityDescIcon,
+	ESortListSenderAscIcon,
+	ESortListSenderDescIcon,
+	ESortListSubjectAscIcon,
+	ESortListSubjectDescIcon,
+	ESortListUnreadAscIcon,
+	ESortListUnreadDescIcon
+	};
 // List level for the root folders
 static const TInt KListRootLevel( 1 );
 // List supports three levels, so basically root folder + two levels of subfolders
 static const TInt KListLastBasicLevel( KListRootLevel + 2 );
+const TInt KDefaultShadowBorderWidth( 15 );
+const TReal KShadowBorderOpacity( 0.08 );
 // Constants for drawing header text
 const TReal KFSHeaderTextBackgroundOpacity = 0.3f;
 const TAlfTimedValue KFSVisible( 1 );
 const TAlfTimedValue KFSInvisible( 0 );
 // ---------------------------------------------------------------------------
 // Constructor
 // ---------------------------------------------------------------------------
 //
 CFSEmailUiFolderListVisualiser::CFSEmailUiFolderListVisualiser( CAlfEnv& aEnv,
 CFreestyleEmailUiAppUi& aAppUi,
 CAlfControlGroup& aControlGroup )
 : CFsEmailUiViewBase( aControlGroup, aAppUi ),
 iEnv( aEnv ),
 iFullScreen( ETrue ),
 iPreviousListLevel( KListRootLevel ),
 iWaitingToGoOnline(EFalse),
 iNoConnectNeeded(ETrue)
 	{
 FUNC_LOG;
 	}
 // ---------------------------------------------------------------------------
 // Destructor
 // ---------------------------------------------------------------------------
 //
 CFSEmailUiFolderListVisualiser::~CFSEmailUiFolderListVisualiser()
 	iModel = NULL;
 	delete iBackgroundBrush;
 	iBackgroundBrush = NULL;
+	delete iShadowBrush;
 	// No need for ResetAndDestroy because list items are owned by generic list
 	iListItemVisulizers.Close();
 //delete iNotifierTest;
 delete iTreeList;
 iTreeList = NULL;
 iIconArray.Close();
+iSortIconArray.Close();
 if ( iAsyncCallback )
 {
 iAsyncCallback->Cancel();
 delete iAsyncCallback;
 void CFSEmailUiFolderListVisualiser::DoFirstStartL()
 {
 FUNC_LOG;
 iControl = CFSEmailUiFolderListControl::NewL( iEnv, *this );
 iModel = new (ELeave) CFSEmailUiFolderListModel();
 UpdateListSizeAttributes();
 //LoadIconsL();
 TRect mainPaneRect;
 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
 iFaderLayout = CAlfDeckLayout::AddNewL( *iControl );
 iFaderLayout->SetRect( mainPaneRect );
 iParentLayout = CAlfAnchorLayout::AddNewL( *iControl );
 iParentLayout->SetRect( iScreenRect );
 iParentLayout->SetFlags( EAlfVisualFlagManualLayout );
 iParentLayout->EnableBrushesL();
 SetAnchors();
 iFaderVisual = CAlfImageVisual::AddNewL( *iControl, iParentLayout );
 iHeaderLayout = CAlfDeckLayout::AddNewL( *iControl, iParentLayout );
 iHeaderLayout->SetFlags( EAlfVisualFlagAutomaticLocaleMirroringEnabled );
 iHeaderTextVisual = CAlfTextVisual::AddNewL( *iControl, iHeaderLayout );
 iHeaderTextVisual->SetWrapping( CAlfTextVisual::ELineWrapTruncate );
 iHeaderTextVisual->SetTextL( KNullDesC );
 TRgb headerTextColor( KRgbBlack );
 AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),
 headerTextColor, KAknsIIDFsTextColors, EAknsCIFsTextColorsCG10 );
 iHeaderTextVisual->SetColor( headerTextColor );
 iHeaderTextVisual->SetTextStyle( iAppUi.LayoutHandler()->
 FSTextStyleFromLayoutL( AknLayoutScalable_Apps::main_sp_fs_ctrlbar_pane_t1( 0 ) ).Id() );
 iHeaderTextVisual->SetAlign( EAlfAlignHLeft, EAlfAlignVCenter );
 }
 	iHeaderTextVisual->SetOpacity( KFSInvisible );
 	iHeaderLayout->SetOpacity( KFSInvisible );
 iListLayout = CAlfDeckLayout::AddNewL( *iControl, iParentLayout );
 iListLayout->SetFlags(EAlfVisualFlagLayoutUpdateNotification|EAlfVisualFlagAutomaticLocaleMirroringEnabled);
 iTreeVisualizer = CFsTreeVisualizerBase::NewL(iControl, *iListLayout);
 iTreeVisualizer->SetItemExpansionDelay( iAppUi.LayoutHandler()->ListItemExpansionDelay() );
 iTreeVisualizer->SetScrollTime( iAppUi.LayoutHandler()->ListScrollingTime() );
 iTreeVisualizer->SetFadeInEffectTime( iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime() );
 iTreeVisualizer->SetFadeOutEffectTime( iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime() );
 iTreeVisualizer->SetItemSeparatorSize( TSize(0, 0) );
 iTreeVisualizer->SetExpandCollapseAllOnLongTap( EFalse );
 iTreeList = CFsTreeList::NewL( *iTreeVisualizer, iEnv );
 // Compared to S60 3.2.3 in S60 5.0 Alf offers the key events in
 // opposite order.
 ControlGroup().AppendL( iControl );
 ControlGroup().AppendL( iTreeList->TreeControl() );
 iTreeList->AddObserverL(*this);
 iTreeList->SetLoopingType( EFsTreeListLoopingJumpToFirstLast );
 iTreeList->SetScrollbarVisibilityL( EFsScrollbarAuto );
 iAppUi.LayoutHandler()->SetListMarqueeBehaviour( iTreeList );
 iAppUi.LayoutHandler()->FolderListIndentation(iScreenRect) );
 iTreeVisualizer->SetSelectorPropertiesL(
 iAppUi.FsTextureManager()->NewListSelectorBrushL(), 1.0,
 CFsTreeVisualizerBase::EFsSelectorMoveSmoothly );
 iAsyncCallback = new (ELeave) CAsyncCallBack( CActive::EPriorityStandard );
 //iNotifierTest = CSimpleAOTest::NewL();
 iFirstStartCompleted = ETrue;
 }
 //
 TUid CFSEmailUiFolderListVisualiser::Id() const
 	{
 FUNC_LOG;
 	return FolderListId;
 	}
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::PrepareFolderListL
 // ---------------------------------------------------------------------------
 //
 SetAnchors();
 ResizeListIcons();
 // Show empty screen when offline
 CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
 if( iModel->Count() == 0 )
 {
 cba->SetCommandSetL( R_FREESTYLE_EMAUIL_UI_SK_OPTIONS_BACK );
 }
 if( iMoveOrCopyInitiated )
 {
 iTreeVisualizer->SetEmptyListTextL( KNullDesC );
 iTreeVisualizer->RefreshListViewL();
 }
 	}
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::PopulateFolderListL
 }
 	iParentLayout->SetRect(iScreenRect);
 CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
 	if( iModel->Count() > 0 )
 	    {
 cba->SetCommandSetL( R_FREESTYLE_EMAUIL_UI_SK_OPTIONS_BACK__SELECT );
 	    }
 if( iMoveOrCopyInitiated )
 {
 HBufC* emptyListText = StringLoader::LoadLC(
 R_FREESTYLE_EMAIL_UI_FOLDER_LIST_NO_FOLDERS_AVAILABLE );
 iTreeVisualizer->SetEmptyListTextL( *emptyListText );
 CleanupStack::PopAndDestroy( emptyListText );
 iTreeVisualizer->RefreshListViewL();
 }
 	}
 // ---------------------------------------------------------------------------
 TInt CFSEmailUiFolderListVisualiser::DoPopulateFolderList( TAny* aSelfPtr )
 {
 FUNC_LOG;
 CFSEmailUiFolderListVisualiser* self =
 static_cast< CFSEmailUiFolderListVisualiser* >( aSelfPtr );
 TRAPD( err,
 self->PopulateFolderListL();
 if ( self->iCustomMessageId == KFolderListMoveMessage ||
 self->iCustomMessageId == KFolderListMoveMessages ||
 self->iCustomMessageId == KFolderListCopyMessage ||
 self->iCustomMessageId == KFolderListCopyMessages )
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::HidePopupL()
 	{
 FUNC_LOG;
 iParentLayout->SetRect( iCtrlButtonRect, iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime() );
 TAlfTimedValue bgOpacity;
 	// Hiding delay was removed to get rid of flickering if changing between
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::DoShowInPopupL
 // ---------------------------------------------------------------------------
 //
-/*void CFSEmailUiFolderListVisualiser::DoShowInPopupL()*/
 void CFSEmailUiFolderListVisualiser::DoShowInPopupL(
 MFsControlButtonInterface* aButton,
 MFSEmailUiFolderListCallback* aFolderCallback,
 MFSEmailUiSortListCallback* aSortCallback )
 	{
 FUNC_LOG;
 if ( ( aFolderCallback == NULL && aSortCallback == NULL ) ||
 aButton == NULL )
 {
 return;
 }
 // In case of popup we are not moving or copying messages,
 // so there's no need to connect the mailbox
 iNoConnectNeeded = ETrue;
 iCallback = aFolderCallback;
 iSortListCallback = aSortCallback;
 const TPoint buttonPos( aButton->Pos().Target() );
 const TSize buttonSize( aButton->Size().Target().AsSize() );
 // TRect from where to start the transformation effect
-iCtrlButtonRect.SetRect( buttonPos, buttonSize );
+TRect cbr = iAppUi.LayoutHandler()->GetControlBarRect();
+iCtrlButtonRect.SetRect( buttonPos + cbr.iTl, buttonSize );
 iFullScreen = EFalse;
 LoadIconsL();
 if ( !iFirstStartCompleted )
 {
 DoFirstStartL();
 }
 		}
 	PrepareFolderListL();
 PopulateFolderListL();
 const TInt paddingValue(
 iAppUi.LayoutHandler()->DropDownMenuListPadding() );
 const TAlfMetric paddingMetric( paddingValue );
 iParentLayout->SetPadding( paddingMetric );
 	// Set list background
 TRect outerRect( iScreenRect );
 outerRect.Shrink( paddingValue, paddingValue );
 iBackgroundBrush->SetFrameRectsL( outerRect, iScreenRect );
 		}
-	// Append brush if it's not yet appended. Currently this is our only
+	   // Append brush if it's not yet appended. Currently this is our only
-	// brush so if brush count is more than zero, this brush is already
+	    // brush so if brush count is more than zero, this brush is already
-	// appended. If other brush(es) are added later, this implementation
+	    // appended. If other brush(es) are added later, this implementation
-	// need to be changed.
+	    // need to be changed.
-if ( iParentLayout->Brushes()->Count() == 0 )
+	    if ( iParentLayout->Brushes()->Count() == 0 )
-{
+	        {
-	// Keep the ownership of the brush to avoid unneeded object
+	        // Keep the ownership of the brush to avoid unneeded object
-	// deletion / reconstruction
+	        // deletion / reconstruction
-	iParentLayout->Brushes()->AppendL( iBackgroundBrush, EAlfDoesNotHaveOwnership );
+	        iParentLayout->Brushes()->AppendL( iBackgroundBrush, EAlfDoesNotHaveOwnership );
-}
+	        }
+	if( !iShadowBrush )
+	    {
+iShadowBrush = CAlfShadowBorderBrush::NewL(
+iEnv, TAlfMetric( KDefaultShadowBorderWidth ) );
+iShadowBrush->SetOpacity( KShadowBorderOpacity );
+iShadowBrush->SetLayer( EAlfBrushLayerBackground );
+iParentLayout->Brushes()->AppendL( iShadowBrush,
+EAlfDoesNotHaveOwnership );
+	    }
 	SetPopupSoftkeysL();
 	// SetRect need to be called also here, otherwise the list layout might
 	// be wrong in mirrored layout
-//iParentLayout->SetRect( iScreenRect );
 iParentLayout->SetRect( iCtrlButtonRect );
 opacity.SetValueNow( 1 );
 //opacity.SetTarget( 1, iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime() );
 iParentLayout->SetOpacity( opacity );
 iParentLayout->SetRect( iScreenRect, iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime() );
 iParentLayout->UpdateChildrenLayout();
 iTreeList->DisableKineticScrolling( ETrue );
 iTreeList->ShowListL( ETrue );
 iTreeList->SetFocusedL( ETrue );
+iFocusVisible = iAppUi.IsFocusShown();
+iTreeVisualizer->SetFocusVisibility( iFocusVisible );
 iPopupListShown = ETrue;
 	}
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::ShowInPopupL
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::ShowSortListPopupL
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::ShowSortListPopupL(
-const TFSMailSortField aCurrentSortOrder,
+const TFSMailSortCriteria aCurrentSortCriteria,
 	const TFSFolderType aFolderType,
 	MFSEmailUiSortListCallback* aCallback,
 	MFsControlButtonInterface* aButton )
 	{
 FUNC_LOG;
-iCurrentSortOrder = aCurrentSortOrder;
+iCurrentSortCriteria = aCurrentSortCriteria;
 iCurrentFolderType = aFolderType;
 DoShowInPopupL( aButton, NULL, aCallback );
 	}
 // ---------------------------------------------------------------------------
 	{
 FUNC_LOG;
 iFullScreen = ETrue;
 LoadIconsL();
 if ( !iFirstStartCompleted )
 	    {
 	    DoFirstStartL();
 	    }
 	// Set title pane text
 	iAppUi.SetActiveMailboxNameToStatusPaneL();
 // Different effect is used when opening folder selection list
 iAnimateNextActivation = ( aCustomMessageId == KFolderListSelectFolder );
 // Create header image visual if not yet created
 if( !iHeaderImageVisual )
 {
 // Hide text visual
 iTitleCaptionVisible = EFalse;
 iHeaderTextVisual->SetOpacity( KFSInvisible );
 }
 // Set flag for moving or copying
 iMoveOrCopyInitiated = (aCustomMessageId == KFolderListMoveMessage ||
 aCustomMessageId == KFolderListMoveMessages ||
 aCustomMessageId == KFolderListCopyMessage ||
 aCustomMessageId == KFolderListCopyMessages);
 TFolderListActivationData subView;
 TPckgBuf<TFolderListActivationData> viewData( subView );
 viewData.Copy( aCustomMessage );
 iCallback = viewData().iCallback;
 iCurrentFolderType = viewData().iSourceFolderType;
 	iTreeList->HideListL();
 	// Clear padding when shown in full screen
 	const TAlfMetric padding( 0 );
 	iParentLayout->SetPadding( padding );
 	iListLayout->SetPadding( padding );
 PrepareFolderListL();
 // Remove need to be called for all brushes before Reset, otherwise the
 // brush resources are not completely freed from server side -> brushes
 // keep "hanging" there and make future drawing slower.
 while( iParentLayout->Brushes()->Count() > 0 )
 {
 iParentLayout->Brushes()->Remove( 0 );
 }
 	iParentLayout->Brushes()->Reset();
 	TAlfTimedValue layoutOpacity = iHeaderLayout->Opacity();
 	layoutOpacity.SetTarget( 1, iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime()/2 );
 	iHeaderLayout->SetOpacity( layoutOpacity );
 	TAlfTimedValue bgImageOpacity = iListBgImageVisual->Opacity();
 	bgImageOpacity.SetTarget( 1, iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime()/2 );
 	iListBgImageVisual->SetOpacity( bgImageOpacity );
 	// Reset the variables used in horizontal scrolling
 	iPreviousListRect = iListLayout->DisplayRectTarget();
 iPreviousListLevel = KListRootLevel;
 iParentLayout->SetRect( iScreenRect );
 iTreeList->ShowListL();
 TAlfTimedValue opacity;
 opacity.SetValueNow( 1 );
 // See if we are already connected
 CFSMailBox* mb = iAppUi.GetActiveMailbox();
 // Just in case, shouldn't happen
 User::LeaveIfNull( mb );
 TFSMailBoxStatus onlineStatus = mb->GetMailBoxStatus();
 // If we are not moving or copying messages, there's no need to connect
 // the mailbox. In case of move/copy we need to check the mailbox
 // capability to see if we need to connect the mailbox before showing the
 {
 // If we come here it means that the mailbox is offline but connection
 // is needed for this operation, so we need to connect first
 ConnectToMailboxL();
 }
+FocusVisibilityChange( iAppUi.IsFocusShown() );
 	}
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::OfferToolbarEventL
 // ---------------------------------------------------------------------------
 //
 TInt CFSEmailUiFolderListVisualiser::ToolbarResourceId() const
 {
 return R_FREESTYLE_EMAIL_UI_TOOLBAR_FOLDER_LIST;
 }
 // ---------------------------------------------------------------------------
 // Deactivate this view
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::ChildDoDeactivate()
 void CFSEmailUiFolderListVisualiser::SetFocusToCurrentSortItemL()
 {
 FUNC_LOG;
 if ( iFirstStartCompleted ) // Safety
 {
-for ( TInt i=0; i < iModel->Count() ; i++ )
+for ( TInt i = 0; i < iModel->Count(); i++ )
-{
+	{
-CFSEmailUiFolderListItem* modelItem = iModel->ItemByIndex( i );
+	CFSEmailUiFolderListItem* modelItem = iModel->ItemByIndex( i );
-if ( modelItem && ( modelItem->iSortField == iCurrentSortOrder ) )
+	if ( modelItem && ( modelItem->iSortField == iCurrentSortCriteria.iField ) )
-{
+		{
-iTreeVisualizer->SetFocusedItemL( modelItem->iListId, EFalse );
+		iTreeVisualizer->SetFocusedItemL( modelItem->iListId, EFalse );
-break;
+		break;
-}
+		}
-}
+	}
+		// Bold the focused item's text
+		TInt arraySize = iListItemVisulizers.Count();
+		for( TInt i = 0; i < arraySize; i++ )
+			{
+			TFsTreeItemId id = iTreeList->FocusedItem();
+			if ( iListItemVisulizers[ i ] == &( iTreeList->ItemVisualizer( id ) ) )
+				{
+				iListItemVisulizers[i]->SetTextBold( ETrue );
+				break;
+				}
+			}
 }
 }
 // ---------------------------------------------------------------------------
 // In case of folder list popup, this function sets focus to current folder,
 {
 CFSEmailUiFolderListItem* modelItem = iModel->ItemByIndex( i );
 if ( modelItem && ( modelItem->iFolderId == iCurrentFolderId ) )
 {
 itemToFocus = modelItem->iListId;
 break;
 }
 }
 iTreeVisualizer->SetFocusedItemL( itemToFocus, EFalse );
 }
 }
 	              !modelItem->iFolderId.IsNullId() && // Filter mailbox and sort items
 	              modelItem->iFolderId == iLatestSelectedMoveFolderId )
 	             {
 	             match = ETrue;
 	             iTreeVisualizer->SetFocusedItemL( modelItem->iListId );
 	             break;
 	             }
 	         }
 	     if ( match )
 	         {
 // ---------------------------------------------------------------------------
 //
 TBool CFSEmailUiFolderListVisualiser::OfferEventL(const TAlfEvent& aEvent)
 {
 FUNC_LOG;
 TBool result( EFalse );
 if ( aEvent.IsKeyEvent() && aEvent.Code() == EEventKey )
 {
 // Swap left and right with mirrored layout
-TInt scanCode = aEvent.KeyEvent().iScanCode;
+TInt scanCode( aEvent.KeyEvent().iScanCode );
 if ( AknLayoutUtils::LayoutMirrored() )
 {
-if ( scanCode == EStdKeyLeftArrow ) scanCode = EStdKeyRightArrow;
+if( scanCode == EStdKeyLeftArrow )
-else if ( scanCode == EStdKeyRightArrow ) scanCode = EStdKeyLeftArrow;
+{
-}
+scanCode = EStdKeyRightArrow;
+}
+else if( scanCode == EStdKeyRightArrow )
+{
+scanCode = EStdKeyLeftArrow;
+}
+}
+// Handle possible focus visibility change
+if( ( scanCode == EStdKeyRightArrow ) ||
+( scanCode == EStdKeyLeftArrow ) ||
+( scanCode == EStdKeyUpArrow ) ||
+( scanCode == EStdKeyDownArrow ) ||
+( scanCode == EStdKeyEnter ) ||
+( scanCode == EStdKeyDeviceA ) ||
+( scanCode == EStdKeyDevice3 ) )
+{
+// If the focus was not active already, ignore the key press
+if( !iAppUi.SetFocusVisibility( ETrue ) )
+{
+return ETrue;
+}
+}
 switch ( scanCode )
 {
 case EStdKeyDevice3:	// CENTER CLICK
 case EStdKeyEnter:		// ENTER
 	{
 	// Check is the sort list open
 	else if( !iFullScreen && iSortListCallback )
 		{
 		HandleSelectionL( EFSEmailUiCtrlBarResponseSwitchList );
 		}
 	           	}
 break;
 	        case EStdKeyRightArrow:
 	{
 	// Check is the folder list open
 	}
 				break;
 default:
 	       	    // Check keyboard shortcuts.
 	       	    TInt shortcutCommand =
 	       	        iAppUi.ShortcutBinding().CommandForShortcutKey( aEvent.KeyEvent(),
 	       	                                                         CFSEmailUiShortcutBinding::EContextFolderList );
 	       	    if ( shortcutCommand != KErrNotFound )
 	       	        {
 	            HandleCommandL( shortcutCommand );
 	       	        result = ETrue;
 	       	        }
 break;
 }
 }
 return result;
 }
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::HandlePointerEventL
 // ---------------------------------------------------------------------------
 //
 TBool CFSEmailUiFolderListVisualiser::HandlePointerEventL(const TAlfEvent& aEvent)
 {
-// Handle pointer events to fadervisual. If the list is shown in popup, then
+TBool eventHandled( EFalse );
-// the popup will be closed.
-if ((aEvent.Visual() == iFaderVisual || aEvent.Visual() == iFaderLayout) && aEvent.PointerEvent().iType == TPointerEvent::EButton1Down && iPopupListShown)
+if( ( aEvent.Visual() == iFaderVisual || aEvent.Visual() == iFaderLayout ) &&
-{
+( aEvent.PointerEvent().iType == TPointerEvent::EButton1Down  ) &&
+( iPopupListShown ) )
+{
+iAppUi.SetFocusVisibility( EFalse );
 HandleSelectionL( EFSEmailUiCtrlBarResponseCancel );
+eventHandled = ETrue;
 }
 else
 {
-return iTreeList->TreeControl()->OfferEventL(aEvent);
+// Handle pointer events to fadervisual. If the list is shown in popup,
-}
+// then the popup will be closed.
-return ETrue;
+if( ( aEvent.IsPointerEvent() ) &&
+( aEvent.PointerEvent().iType == TPointerEvent::EButton1Up ) )
+{
+eventHandled = iTreeList->TreeControl()->OfferEventL(aEvent);
+// Hide focus visibility always after pointer up event.
+iAppUi.SetFocusVisibility( EFalse );
+}
+else
+	{
+	eventHandled = iTreeList->TreeControl()->OfferEventL(aEvent);
+	}
+}
+return eventHandled;
 }
 // ---------------------------------------------------------------------------
 // CFSEmailUiFolderListVisualiser::DynInitMenuPaneL
 // ---------------------------------------------------------------------------
 if ( aResourceId == R_FSEMAILUI_FOLDERLIST_MENUPANE )
 {
 if ( FeatureManager::FeatureSupported( KFeatureIdFfCmailIntegration ) )
 	   {
 	   // remove help support in pf5250
 	   aMenuPane->SetItemDimmed( EFsEmailUiCmdHelp, ETrue);
 	   }
 // OFFLINE/ONLINE MENU SELECTION
 if( iMoveOrCopyInitiated )
 {
 TFSMailBoxStatus onlineStatus = iAppUi.GetActiveMailbox()->GetMailBoxStatus();
 aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnline, onlineStatus == EFSMailBoxOnline );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOffline, onlineStatus == EFSMailBoxOffline );
 }
 else
 {
 aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnline, ETrue );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOffline, ETrue );
 }
 // select option
 aMenuPane->SetItemDimmed( EFsEmailUiCmdSelect, iModel->Count() == 0 );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsCollapseAll, AllNodesCollapsed() );
 aMenuPane->SetItemDimmed( EFsEmailUiCmdActionsExpandAll, AllNodesExpanded() );
 }
 // Add shortcut hints
 iAppUi.ShortcutBinding().AppendShortcutHintsL( *aMenuPane,
 CFSEmailUiShortcutBinding::EContextFolderList );
 }
 	}
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::HandleSelectionL( TFSEmailUiCtrlBarResponse aSelection )
 {
 FUNC_LOG;
 // If popup is not open or the view is not active, then do nothing
 if ( !(iPopupListShown || IsViewActive()) )
 {
 return;
 }
 TBool popupHiddenAlready(EFalse);
 switch( aSelection )
 {
 case EFSEmailUiCtrlBarResponseSelect:
 {
 HidePopupL();
 }
 iAppUi.FolderPopupClosed();
 }
 if ( !iFullScreen && iSortListCallback )
 {
 iSortListCallback->SortOrderChangedL( EFSMailDontCare, aSelection );
 iSortListCallback = NULL;
 }
 		return GetRootParent( parentId );
 		}
 	}
 // ---------------------------------------------------------------------------
 // Override the default transition effect in case full screen mode is launched
 // from popup mode.
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::DoTransitionEffect( TBool aDirectionOut )
 {
 FUNC_LOG;
 if ( !aDirectionOut && IsFullScreen() && iAnimateNextActivation )
 {
 TInt rectTransitionTime = iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime();
 TInt opacityTransitionTime = iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime() / 2;
 TAlfTimedValue opacity;
 opacity.SetValueNow( 0 );
 opacity.SetTarget( 1, opacityTransitionTime );
 iParentLayout->SetOpacity( opacity );
 // Do animated enlargening from popup window rect to full screen rect
 iParentLayout->SetRect( FolderListRectInThisResolution() );
 iParentLayout->SetRect( iScreenRect, rectTransitionTime );
 }
 else
 {
 switch(aCommand)
 {
 // Key presses
 case EAknSoftkeySelect:
+{
+// If focus is not visible, make it visible
+// otherwise fall through ( call HandleSelectionL )
+if( !iFocusVisible )
+{
+iAppUi.SetFocusVisibility( ETrue );
+break;
+}
+}
 case EAknSoftkeyOpen:
 case EFsEmailUiCmdOpen:
 case EFsEmailUiCmdSelect:
 {
 HandleSelectionL( EFSEmailUiCtrlBarResponseSelect );
 }
 break;
 case EAknSoftkeyBack:
 case EEikBidCancel:
 {
 HandleSelectionL( EFSEmailUiCtrlBarResponseCancel );
 }
 }
 break;
 case EFsEmailUiCmdActionsExpandAll:
 {
 TFsTreeItemId prevId = iTreeList->FocusedItem();
 iTreeVisualizer->ExpandAllL();
 if ( prevId != KFsTreeRootID && prevId != KFsTreeNoneID )
 {
 iTreeVisualizer->SetFocusedItemL( prevId );
 }
 {
 CESMailSettingsPlugin::TSubViewActivationData activationData;
 activationData.iAccount = iAppUi.GetActiveMailbox()->GetId();
 activationData.iSubviewId = 1;
 activationData.iLaunchFolderSettings = ETrue;
 TUid pluginUid = iAppUi.GetActiveMailbox()->GetSettingsUid();
 // register plugin view if not exists so that activation can be made
 if ( !iAppUi.View( pluginUid ) )
 {
 CESMailSettingsPlugin* plugin = CESMailSettingsPlugin::NewL( pluginUid );
 CleanupStack::PushL( plugin );
 iAppUi.AddViewL( plugin );
 CleanupStack::Pop( plugin );
 }
 TUid messageId = TUid::Uid( CESMailSettingsPlugin::EActivateMailSettingsSubview );
 const TPckgBuf<CESMailSettingsPlugin::TSubViewActivationData> pluginMessagePkg( activationData );
 iAppUi.EnterPluginSettingsViewL( pluginUid, messageId, pluginMessagePkg );
 // Hide list to avoid it flashing when returning back
 iTreeList->HideListL();
 }
 break;
 }
 break;
 case EFsEmailUiCmdExit:
 {
 iAppUi.Exit();
 }
 break;
 case EFsEmailUiCmdGoToTop:
 {
 GoToTopL();
 }
 break;
 case EFsEmailUiCmdGoToBottom:
 {
 GoToBottomL();
 }
 break;
 case EFsEmailUiCmdPageUp:
 {
 TKeyEvent simEvent = { EKeyPageUp, EStdKeyPageUp, 0, 0 };
 iCoeEnv->SimulateKeyEventL( simEvent, EEventKey );
 }
 break;
 case EFsEmailUiCmdPageDown:
 {
 TKeyEvent simEvent = { EKeyPageDown, EStdKeyPageDown, 0, 0 };
 iCoeEnv->SimulateKeyEventL( simEvent, EEventKey );
 }
 if ( !AllNodesCollapsed() )
 {
 HandleCommandL( EFsEmailUiCmdActionsCollapseAll );
 }
 else
 {
 HandleCommandL( EFsEmailUiCmdActionsExpandAll );
 }
 }
 break;
 default:
 break;
 }
 }
 }
 // ---------------------------------------------------------------------------
 // Handle call to callback function
 if( focusedItem == KFsTreeNoneID )
 	{
 	return ETrue;
 	}
 if( focusedItem == iMoreFoldersItemId )
 	{
 //HidePopupL();
 iFullScreen = ETrue;
 		TFolderListActivationData tmp;
 	    tmp.iCallback = iCallback;
 		const TPckgBuf<TFolderListActivationData> pkgOut( tmp );
 		iAppUi.EnterFsEmailViewL( FolderListId, KFolderListSelectFolder, pkgOut );
 return EFalse;
 	}
 CFSEmailUiFolderListItem* modelItem = iModel->ItemByListId( focusedItem );
 	if( !modelItem ) // Safety check, shouldn't be possible
 		{
 		return EFalse;
 		}
 	if( iCallback )
 		{
 		const TFSMailMsgId& selectedFolderId = modelItem->iFolderId;
 		const TFSMailMsgId& selectedMailboxId = modelItem->iMailboxId;
 if( !selectedFolderId.IsNullId() )
 	{
 		if ( iCustomMessageId == KFolderListMoveMessage ||
 			 iCustomMessageId == KFolderListMoveMessages ||
 		     iCustomMessageId == KFolderListCopyMessage ||
 		     iCustomMessageId == KFolderListCopyMessages )
 			{
 			iLatestSelectedMoveFolderId = selectedFolderId;
 			}
 	       	iCallback->FolderSelectedL( selectedFolderId, EFSEmailUiCtrlBarResponseSelect );
 	}
 else if( !selectedMailboxId.IsNullId() )
 	{
 	iCallback->MailboxSelectedL( selectedMailboxId );
 iSortListCallback->SortOrderChangedL( modelItem->iSortField, EFSEmailUiCtrlBarResponseSelect );
 // Set callback to NULL after callback is called so that the
 // same callback is not reused unintentionally.
 iSortListCallback = NULL;
 		}
 return ETrue;
 	}
 // ---------------------------------------------------------------------------
 // Append node to list by getting the item data from resource
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::SetHeaderTextByResourceIdL(
 TInt aResourceId )
 	{
 FUNC_LOG;
 if ( iFirstStartCompleted ) // Safety
 {
 HBufC* headingText = StringLoader::LoadLC( aResourceId );
 SetHeaderTextAttributesL();
 iHeaderTextVisual->SetTextL( *headingText );
 CleanupStack::PopAndDestroy( headingText );
 }
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::SetHeaderTextAttributesL()
 {
 iHeaderTextVisual->SetOpacity( KFSVisible );
 CAlfTextStyle* textStyle = iAppUi.LayoutHandler()->FSTextStyleFromIdL(
 EFSFontTypeNormalBold );
 iHeaderTextVisual->SetTextStyle ( textStyle->Id() );
 iHeaderTextVisual->SetColor( iAppUi.LayoutHandler()->
 ListNormalStateTextSkinColor() );
 iHeaderTextVisual->SetPadding(
 iAppUi.LayoutHandler()->TitleCaptionPadding() );
 if( iHeaderTextVisual->Brushes() )
 {
 iHeaderTextVisual->Brushes()->Reset();
 // CFSEmailUiFolderListVisualiser::ConnectMailbox
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::ConnectToMailboxL()
 {
 	CFSMailBox* mb = iAppUi.GetActiveMailbox();
-	TDesC* mbName = &mb->GetName();
 iWaitingToGoOnline = ETrue;
 mb->GoOnlineL();
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::DisconnectFromMailboxL()
 {
 iAppUi.GetActiveMailbox()->GoOfflineL();
 iWaitingToGoOnline = EFalse;
 }
 // ---------------------------------------------------------------------------
 		// </cmail>
 if( iFullScreen )
 {
 // Append lines to the model
 AppendActiveMailboxFoldersL();
 // Update toolbar button statuses.
 UpdateToolbarButtons();
 }
 else
 {
 //Mailboxes needed to be at the top followed by seperator
 AppendMailboxesL();
 // Append lines to the model followed by seperator
 AppendActiveMailboxFoldersL();
 AppendSeparatorLineL();
 // Append the folder list view selector
 AppendMoreFoldersL();
 }
 }
 	}
 // ---------------------------------------------------------------------------
 // Construct sort list data
 iTreeList->RemoveAllL();
 iListItemVisulizers.Reset();
 iModel->RemoveAll();
 iMoreFoldersItemId = KFsTreeNoneID;
 // Append lines to the model
 AppendSortListItemsL();
 }
 	}
 // ---------------------------------------------------------------------------
 // Append active mailbox's folders
 {
 iActiveMailbox = iAppUi.GetActiveMailbox();
 if( iActiveMailbox )
 {
 AppendSubfoldersL( TFSMailMsgId(), KFsTreeRootID, ETrue );
 }
 }
 	}
 // ---------------------------------------------------------------------------
 // Compare two mail folders, used in sorting done with TLinearOrder
 		}
 	else
 		{
 		TDesC& nameOfFirst = aFirst.GetFolderName();
 		TDesC& nameOfSecond = aSecond.GetFolderName();
 		return nameOfFirst.CompareC( nameOfSecond );
 		}
 	}
 // ---------------------------------------------------------------------------
 	}
 void CFSEmailUiFolderListVisualiser::AppendSortListItemsL()
 	{
 FUNC_LOG;
-	TFsTreeItemId itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_DATE, KFsTreeRootID, NULL, EFalse );
+// Select correct icon depending on the selected sort criteria
+CAlfTexture* icon( NULL );
+icon = iCurrentSortCriteria.iField == EFSMailSortByDate ?
+	   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+		   iSortIconArray[ ESortListDateDescIcon ] :
+		   iSortIconArray[ ESortListDateAscIcon ] :
+		   iSortIconArray[ ESortListDateDescIcon ];
+	TFsTreeItemId itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_DATE, KFsTreeRootID, icon, EFalse );
 	iModel->AppendL( itemId, EFSMailSortByDate );
 	switch( iCurrentFolderType )
 		{
 		case EFSSentFolder:
 		case EFSDraftsFolder:
 		case EFSOutbox:
 			{
-			itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_RECIPIENT, KFsTreeRootID, NULL, EFalse );
+		    icon = iCurrentSortCriteria.iField == EFSMailSortByRecipient ?
+		    	   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+				   iSortIconArray[ ESortListSenderDescIcon ] :
+				   iSortIconArray[ ESortListSenderAscIcon ] :
+				   iSortIconArray[ ESortListSenderDescIcon ];
+			itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_RECIPIENT, KFsTreeRootID, icon, EFalse );
 			iModel->AppendL( itemId, EFSMailSortByRecipient );
 			}
 			break;
 		default:
 			{
-			itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_SENDER, KFsTreeRootID, NULL, EFalse );
+		    icon = iCurrentSortCriteria.iField == EFSMailSortBySender ?
+		    	   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+				   iSortIconArray[ ESortListSenderDescIcon ] :
+				   iSortIconArray[ ESortListSenderAscIcon ] :
+				   iSortIconArray[ ESortListSenderDescIcon ];
+			itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_SENDER, KFsTreeRootID, icon, EFalse );
 			iModel->AppendL( itemId, EFSMailSortBySender );
 			}
 			break;
 		}
-	itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_SUBJECT, KFsTreeRootID, NULL, EFalse );
+	icon = iCurrentSortCriteria.iField == EFSMailSortBySubject ?
+		   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+		   iSortIconArray[ ESortListSubjectDescIcon ] :
+		   iSortIconArray[ ESortListSubjectAscIcon ] :
+		   iSortIconArray[ ESortListSubjectDescIcon ];
+	itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_SUBJECT, KFsTreeRootID, icon, EFalse );
 	iModel->AppendL( itemId, EFSMailSortBySubject );
 	if ( TFsEmailUiUtility::IsFollowUpSupported( *iAppUi.GetActiveMailbox() ) )
 		{
-		itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_FLAG, KFsTreeRootID, NULL, EFalse );
+		icon = iCurrentSortCriteria.iField == EFSMailSortByFlagStatus ?
+			   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+			   iSortIconArray[ ESortListFollowDescIcon ] :
+			   iSortIconArray[ ESortListFollowAscIcon ] :
+			   iSortIconArray[ ESortListFollowDescIcon ];
+		itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_FLAG, KFsTreeRootID, icon, EFalse );
 		iModel->AppendL( itemId, EFSMailSortByFlagStatus );
 		}
-	itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_PRIORITY, KFsTreeRootID, NULL, EFalse );
+	icon = iCurrentSortCriteria.iField == EFSMailSortByPriority ?
+		   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+		   iSortIconArray[ ESortListPriorityDescIcon ] :
+		   iSortIconArray[ ESortListPriorityAscIcon ] :
+		   iSortIconArray[ ESortListPriorityDescIcon ];
+	itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_PRIORITY, KFsTreeRootID, icon, EFalse );
 	iModel->AppendL( itemId, EFSMailSortByPriority );
 	if ( iCurrentFolderType != EFSSentFolder &&
 		 iCurrentFolderType != EFSDraftsFolder &&
 		 iCurrentFolderType != EFSOutbox )
 		{
-		itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_UNREAD, KFsTreeRootID, NULL, EFalse );
+		icon = iCurrentSortCriteria.iField == EFSMailSortByUnread ?
+			   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+			   iSortIconArray[ ESortListUnreadDescIcon ] :
+			   iSortIconArray[ ESortListUnreadAscIcon ] :
+			   iSortIconArray[ ESortListUnreadDescIcon ];
+		itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_UNREAD, KFsTreeRootID, icon, EFalse );
 		iModel->AppendL( itemId, EFSMailSortByUnread );
 		}
 	// Allow scroll bar refresh only for the last item
-	itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_ATTACHMENT, KFsTreeRootID, NULL, ETrue );
+	icon = iCurrentSortCriteria.iField == EFSMailSortByAttachment ?
+		   iCurrentSortCriteria.iOrder == EFSMailAscending ?
+		   iSortIconArray[ ESortListAttachmentDescIcon ] :
+		   iSortIconArray[ ESortListAttachmentAscIcon ] :
+		   iSortIconArray[ ESortListAttachmentDescIcon ];
+	itemId = AppendItemToListFromResourceL( R_FREESTYLE_EMAIL_UI_SORT_BY_ATTACHMENT, KFsTreeRootID, icon, ETrue );
 	iModel->AppendL( itemId, EFSMailSortByAttachment );
 	}
 // ---------------------------------------------------------------------------
 // Recursive function to get the folder's subfolder data
 FUNC_LOG;
 	RPointerArray<CFSMailFolder> folders;
 CleanupResetAndDestroyClosePushL( folders );
 	iActiveMailbox->ListFolders( aFolder, folders );
 	TLinearOrder<CFSMailFolder> order(
 		CFSEmailUiFolderListVisualiser::CompareFolders );
 	folders.Sort( order );
 	// First check which folders are not shown, and remove those from the list.
 // Skip this folder
 delete folders[i];
 folders.Remove(i);
 }
 	    }
 	TBool allowItemRefresh = EFalse;
 	while( folders.Count() > 0 )
 		{
 		// If last item of this level is to be refreshed, and we are in the
 		// last item, allow the refresh. If this last item is leaf folder,
 			aResourceId = R_FREESTYLE_EMAIL_UI_FOLDER_LIST_INBOX;
 			aIcon = iIconArray[EFolderListIconInbox];
 			}
 		else
 			{
 			aResourceId = R_FREESTYLE_EMAIL_UI_DROPDOWN_LIST_INBOX;
 			// Get branded mailbox icon
 			aIcon = &iAppUi.FsTextureManager()->TextureByMailboxIdL( iActiveMailbox->GetId().PluginId(),
 																	 iActiveMailbox->GetId().Id(),
 																     iListIconSize);
 			}
 		found = ETrue;
 		}
 	else if( aFolderType == EFSOutbox )
 		{
 		if( iFullScreen )
 			aIcon = iIconArray[EFolderListIconOutbox];
 			}
 		else
 			{
 			aResourceId = R_FREESTYLE_EMAIL_UI_DROPDOWN_LIST_OUTBOX;
 			}
 		found = ETrue;
 		}
 	else if( aFolderType == EFSDraftsFolder )
 		{
 		if( iFullScreen )
 			aIcon = iIconArray[EFolderListIconDrafts];
 			}
 		else
 			{
 			aResourceId = R_FREESTYLE_EMAIL_UI_DROPDOWN_LIST_DRAFTS;
 			}
 		found = ETrue;
 		}
 	else if( aFolderType == EFSSentFolder )
 		{
 		if( iFullScreen )
 			aIcon = iIconArray[EFolderListIconDeleted];
 			}
 		else
 			{
 			aResourceId = R_FREESTYLE_EMAIL_UI_DROPDOWN_LIST_DELETED;
 			}
 		found = ETrue;
 		}
 	return found;
 	}
 //
 TBool CFSEmailUiFolderListVisualiser::ShowThisTypeOfFolderL(
 	CFSMailFolder* aFolder ) const
 	{
 FUNC_LOG;
 	if( iCustomMessageId == KFolderListMoveMessage ||
 	iCustomMessageId == KFolderListMoveMessages )
 		{
 		// When moving or copying message(s), hide Outbox from list
 		if( aFolder->GetFolderType() == EFSOutbox )
 			{
 		{
 		// Append non-standard folders only if in Fullscreen
 		if( iFullScreen )
 			{
 			// For other folders get the name from the folder object
 			nodeId = AppendNodeToListL(
 			        &aFolder->GetFolderName(),
 			        aParentNode,
 			        iIconArray[EFolderListIconInboxSubfolders],
 			        aFolder->GetUnreadCount());
 FUNC_LOG;
 	RPointerArray<CFSMailBox> mailboxes;
 CleanupResetAndDestroyClosePushL( mailboxes );
 	TFSMailMsgId id;
 iAppUi.GetMailClient()->ListMailBoxes( id, mailboxes );
 TInt count = mailboxes.Count();
 	while( mailboxes.Count() > 0 )
 		{
 		if( !( mailboxes[0]->GetId() == iAppUi.GetActiveMailboxId() ) )
 			{
 			MFSMailBrandManager& brandManager = iAppUi.GetMailClient()->GetBrandManagerL();
 			CAlfTexture* mailBoxTexture;
 			CGulIcon* mailboxIcon( NULL );
 			TRAPD( err, mailboxIcon = brandManager.GetGraphicL( EFSMailboxIcon, mailboxes[0]->GetId() ) );
 			if ( err == KErrNone && mailboxIcon )
 				{
 				CleanupStack::PushL( mailboxIcon );
 				AknIconUtils::SetSize(mailboxIcon->Bitmap(), iListIconSize);
 			    AknIconUtils::SetSize(mailboxIcon->Mask(), iListIconSize);
 			    // Create texture into TextureManager, If not already existing
 			    iAppUi.FsTextureManager()->CreateBrandedMailboxTexture( mailboxIcon,
 			    		                                                mailboxes[0]->GetId().PluginId(),
 			    		                                                mailboxes[0]->GetId().Id(),
 			    		                                                iListIconSize);
 			    // Get branded mailbox icon
 			    mailBoxTexture = &iAppUi.FsTextureManager()->TextureByMailboxIdL( mailboxes[0]->GetId().PluginId(),
 			    		                                                          mailboxes[0]->GetId().Id(),
 			    		                                                          iListIconSize);
 				CleanupStack::PopAndDestroy( mailboxIcon );
 				}
 			else
 				{
 				mailBoxTexture = iIconArray[EFolderListIconEmailAccount];
 {
 // Note that ownership of the mailbox object is NOT transferred
 // to model anymore, so we need to delete it here in all cases
 iModel->AppendL( itemId, mailboxes[0] );
 }
 			}
 		delete mailboxes[0];
 mailboxes.Remove(0);
 		}
 	//There is more then 1 mailbox so we add the seperator at the end
 	if( count > 1 )
 		{
 		AppendSeparatorLineL();
 		}
 CleanupStack::PopAndDestroy( &mailboxes );
 	}
 // ---------------------------------------------------------------------------
 FUNC_LOG;
 	CFsSeparatorData* data = CFsSeparatorData::NewL();
 	CFsSeparatorVisualizer* visualizer( NULL );
 visualizer = CFsSeparatorVisualizer::NewL(*iTreeList->TreeControl());
 // We use the default size of the separator, but we need to save it
 // here to have it available later when calculating the list height
 iListSeparatorHeight = visualizer->Size().iHeight;
 // This should never be the last item in the list, so disable the refresh
 iTreeList->InsertItemL( *data, *visualizer, KFsTreeRootID, KErrNotFound, EFalse);
 iModel->IncreaseSeparatorCount();
 	}
 // ---------------------------------------------------------------------------
 // Append separator between active mailbox's folders and other mailboxes
 TFsTreeItemId CFSEmailUiFolderListVisualiser::AppendNodeToListL( TDesC* aItemData, TFsTreeItemId aParentNode, CAlfTexture* aIcon, TUint aUnreadCnt )
 	{
 FUNC_LOG;
 CFsTreePlainOneLineNodeData* plainItemData;
 CFsTreePlainOneLineNodeVisualizer* plainNodeVisualizer;
 HBufC* itemDispName = HBufC::NewLC(aItemData->Length() + KFmtUnRdCntMaxLength);
 itemDispName->Des().Copy(*aItemData);
 if( aUnreadCnt > 0 )
 {
 itemDispName->Des().AppendFormat(KFormatUnreadCnt, aUnreadCnt);
 }
 	CreatePlainNodeLC2( itemDispName, plainItemData, plainNodeVisualizer, aIcon );
 	// We assume that node can never be the last item to be drawn, there will
 	// always be leaf folder under it. So we can always deny scroll bar update.
 TFsTreeItemId nodeId = iTreeList->InsertNodeL( *plainItemData, *plainNodeVisualizer, aParentNode, KErrNotFound, EFalse);
 CleanupStack::Pop( 2 ); // plainItemData & plainNodeVisualizer
 	CleanupStack::PopAndDestroy( itemDispName );
 // ---------------------------------------------------------------------------
 // Append leaf to list by getting the item data from resource
 // ---------------------------------------------------------------------------
 //
 TFsTreeItemId CFSEmailUiFolderListVisualiser::AppendItemToListFromResourceL( TInt aResourceId,
 																			 TFsTreeItemId aParentNode,
 																			 CAlfTexture* aIcon,
 																			 TBool aAllowRefresh,
 																			 TUint aUnreadCnt)
 	{
 FUNC_LOG;
 	HBufC* headingText = StringLoader::LoadLC( aResourceId );
 	TFsTreeItemId itemId = AppendItemToListL( headingText, aParentNode, aIcon, aAllowRefresh,  aUnreadCnt);
 	CleanupStack::PopAndDestroy( headingText );
 	return itemId;
 // ---------------------------------------------------------------------------
 // Append leaf to list
 // ---------------------------------------------------------------------------
 //
 TFsTreeItemId CFSEmailUiFolderListVisualiser::AppendItemToListL( TDesC* aItemData,
 																 TFsTreeItemId aParentNode,
 																 CAlfTexture* aIcon,
 TBool aAllowRefresh,
 TUint aUnreadCnt)
 	{
 FUNC_LOG;
 CFsTreePlainOneLineItemData* plainItemData;
 CFsTreePlainOneLineItemVisualizer* plainItemVisualizer;
 HBufC* itemDispName = HBufC::NewLC(aItemData->Length() + KFmtUnRdCntMaxLength);
 itemDispName->Des().Copy(*aItemData);
 if( aUnreadCnt > 0 )
 {
 itemDispName->Des().AppendFormat(KFormatUnreadCnt, aUnreadCnt);
 }
 CreatePlainItemLC2( itemDispName, plainItemData, plainItemVisualizer, aIcon );
 TFsTreeItemId itemId = iTreeList->InsertItemL( *plainItemData, *plainItemVisualizer, aParentNode, KErrNotFound, aAllowRefresh);
 CleanupStack::Pop( 2 ); // plainItemData & plainItemVisualizer
 	CleanupStack::PopAndDestroy( itemDispName );
 	if( itemId != KFsTreeNoneID )
 		{
 		iListItemVisulizers.Append( plainItemVisualizer );
 		}
 	return itemId;
 	}
 // ---------------------------------------------------------------------------
 // Create plain leaf item
 CAlfTexture* aIcon )
 	{
 FUNC_LOG;
 aItemData = CFsTreePlainOneLineItemData::NewL();
 CleanupStack::PushL( aItemData );
 aItemData->SetDataL( *aItemDataBuff );
 if( aIcon )
 	{
 		aItemData->SetIcon( *aIcon );
 	}
 {
 aItemVisualizer->SetLayoutHints( CFsTreeItemVisualizerBase::EFolderLayout );
 }
 else
 {
 aItemVisualizer->SetLayoutHints( CFsTreeItemVisualizerBase::EPopupLayout );
 }
 SetItemVisualizerPropertiesL( aItemVisualizer );
 	}
 // ---------------------------------------------------------------------------
 // Create plain node itme
 CAlfTexture* aIcon )
 	{
 FUNC_LOG;
 aItemData = CFsTreePlainOneLineNodeData::NewL();
 CleanupStack::PushL( aItemData );
 aItemData->SetDataL( *aItemDataBuff );
 if( aIcon )
 	{
 		aItemData->SetIconExpanded( *aIcon );
 		aItemData->SetIconCollapsed( *aIcon );
 	}
 aNodeVisualizer = CFsTreePlainOneLineNodeVisualizer::NewL( *iTreeList->TreeControl() );
 CleanupStack::PushL( aNodeVisualizer );
 // Set folder view specific layouts to be used
 if ( iFullScreen )
 {
 aNodeVisualizer->SetLayoutHints( CFsTreeItemVisualizerBase::EFolderLayout );
 }
 else
 {
 aNodeVisualizer->SetLayoutHints( CFsTreeItemVisualizerBase::EPopupLayout );
 }
 SetItemVisualizerPropertiesL( aNodeVisualizer );
 	}
 void CFSEmailUiFolderListVisualiser::SetItemVisualizerPropertiesL( MFsTreeItemVisualizer* aItemVisualizer )
 	{
 FUNC_LOG;
 	aItemVisualizer->SetFlags(aItemVisualizer->Flags() & ~KFsTreeListItemManagedLayout);
 	    aItemVisualizer->SetSize(TSize(iScreenRect.Width(), iListItemHeight));
 }
 aItemVisualizer->SetExtendable( EFalse );
 	// Set correct skin text colors for the list items
 	TRgb focusedColor = iAppUi.LayoutHandler()->ListFocusedStateTextSkinColor();
 	// If list is in full screen, it has general list background, so we use
 	// general list text color. If it's not in full screen, we use dropdown
 	// menu specific text color.
 	TRgb normalColor = KRgbBlack;
 		}
 	else
 		{
 		normalColor = iAppUi.LayoutHandler()->DropdownMenuTextColor();
 		}
 aItemVisualizer->SetFocusedStateTextColor( focusedColor );
 aItemVisualizer->SetNormalStateTextColor( normalColor );
 	// Set font size
 aItemVisualizer->SetFontHeight( iAppUi.LayoutHandler()->ListItemFontHeightInTwips( !iFullScreen ) );
 	// Set node bolded
 	aItemVisualizer->SetTextBold( EFalse );
 	}
 {
 // get popup rect in local coordinates
 TRect popupRect( iScreenRect );
 // translate to screen coorinates
 popupRect.Move( iEnv.PrimaryDisplay().VisibleArea().iTl );
 // check if the event happened outside of the popup
 if ( !popupRect.Contains( position ) )
 {
 HandleSelectionL( EFSEmailUiCtrlBarResponseCancel );
 iConsumeUntilNextUpEvent = eventHandled = ETrue;
 }
 {
 iConsumeUntilNextUpEvent = EFalse;
 }
 eventHandled = ETrue;
 }
 }
 return eventHandled;
 }
 // Handle foreground event (called by FreestyleEmailUiMailListVisualiser)
 void CFSEmailUiFolderListVisualiser::HandleForegroundEventL()
 	 	AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, iScreenRect );
 	 	iScreenRect.SetRect( 0, 0, iScreenRect.Width(), iScreenRect.Height() );
 }
 	else
 		{
+TRect cbr = iAppUi.LayoutHandler()->GetControlBarRect();
 		if( iCallback )
 			{
 			iCtrlButtonRect = iCallback->FolderButtonRect();
+iCtrlButtonRect.Move( cbr.iTl );
 			iScreenRect = FolderListRectInThisResolution();
 			}
 		else if ( iSortListCallback )
 			{
 iCtrlButtonRect = iSortListCallback->SortButtonRect();
-			iScreenRect = SortListRectInThisResolution();
+iCtrlButtonRect.Move( cbr.iTl );
+iScreenRect = SortListRectInThisResolution();
 			}
 		else
 		    {
 		    // Do nothing. This happens if HandleDynamicVariantSwitch() is called while the popup list is not visible.
 		    }
 		}
 	iListIconSize = iAppUi.LayoutHandler()->FolderListIconSize( !iFullScreen );
 	}
 void CFSEmailUiFolderListVisualiser::LoadIconsL()
 	{
 FUNC_LOG;
 	iIconArray.Reset();
 	if ( iFullScreen )
 	    {
 // NOTE: Must be appended same order as are in TFsEmailUiFolderListIcons!
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListInboxTexture ) );   			// EFolderListIconInbox
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListInboxSubfoldersTexture ) );	// EFolderListIconInboxSubfolders
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListOutboxTexture ) );  			// EFolderListIconOutbox
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListDraftsTexture ) );  			// EFolderListIconDrafts
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListSentTexture ) );    			// EFolderListIconSent
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListMoreFoldersTexture ) ); 		// EFolderListIconMoreFolders
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListEmailAccountTexture ) ); 	// EFolderListIconEmailAccount
 	    }
 	else
 	    {
 // NOTE: Must be appended same order as are in TFsEmailUiFolderListIcons!
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListInboxTexturePopup ) );            // EFolderListIconInbox
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListInboxSubfoldersTexturePopup ) );  // EFolderListIconInboxSubfolders
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListOutboxTexturePopup ) );           // EFolderListIconOutbox
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListDraftsTexturePopup ) );           // EFolderListIconDrafts
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListSentTexturePopup ) );             // EFolderListIconSent
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListDeletedItemsTexturePopup ) );     // EFolderListIconDeleted
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListServerFoldersTexturePopup ) );    // EFolderListIconServerFolders
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListMoreFoldersTexturePopup ) );      // EFolderListIconMoreFolders
 iIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( EFolderListEmailAccountTexturePopup ) );     // EFolderListIconEmailAccount
+	    // NOTE: Must be appended same order as are in TFsEmailUiSortListIcons!
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListAttachmentAscTexture ) );       // ESortListAttachmentAscIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListAttachmentDescTexture ) );      // ESortListAttachmentDescIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListDateAscTexture ) );       		 // ESortListDateAscIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListDateDescTexture ) );       	 // ESortListDateDescIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListFollowAscTexture ) );       	 // ESortListFollowAscIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListFollowDescTexture ) );        	 // ESortListFollowDescIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListPriorityAscTexture ) );         // ESortListPriorityAscIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListPriorityDescTexture ) );        // ESortListPriorityDescIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListSenderAscTexture ) );       	 // ESortListSenderAscIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListSenderDescTexture ) );       	 // ESortListSenderDescIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListSubjectAscTexture ) );       	 // ESortListSubjectAscIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListSubjectDescTexture ) );       	 // ESortListSubjectDescIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListUnreadAscTexture ) );       	 // ESortListUnreadAscIcon
+iSortIconArray.AppendL( &iAppUi.FsTextureManager()->TextureByIndex( ESortListUnreadDescTexture ) );       	 // ESortListUnreadDescIcon
 	    }
 	}
 void CFSEmailUiFolderListVisualiser::ResizeListIcons()
 	{
 		// Then resize used branded mailbox icons
 		//       Branded mailbox icons are not stored anymore in our own
 		//       array, instead those are owned by texture manager. So
 		//       those should be resized by other means. But currently
 		//       there is no way to do it (see above comment).
+		// Then resize sort list icons
+		TInt arraySizeSort = iSortIconArray.Count();
+		for( TInt i = 0; i < arraySizeSort; i++ )
+			{
+			iSortIconArray[i]->Size().SetSize( iListIconSize.iWidth, iListIconSize.iHeight );
+			}
 		}
 	}
 // ---------------------------------------------------------------------------
 // Resizes the list items without recreating all items
 //
 void CFSEmailUiFolderListVisualiser::AdaptScreenRectToListContent()
 	{
 FUNC_LOG;
 const TInt popupHeight( iScreenRect.Height() );
 const TInt separatorHeight( iListSeparatorHeight *
 iModel->SeparatorCount() );
 const TInt itemCount( iTreeList->Count() - iModel->SeparatorCount() );
 TInt visibleItemCount( ( popupHeight - separatorHeight ) /
 iListItemHeight );
 visibleItemCount = Min( visibleItemCount, itemCount );
 iScreenRect.SetHeight( visibleItemCount * iListItemHeight +
 separatorHeight +
 iAppUi.LayoutHandler()->DropDownMenuListPadding() * 2 +
 iAppUi.LayoutHandler()->ControlBarListPadding().iY );
 	AdjustWidthByContent( iScreenRect );
 	}
 // ---------------------------------------------------------------------------
 // Adjusts list width according to content.
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::AdjustWidthByContent( TRect& aRect ) const
 {
+const TRect oldButtonRect( iScreenRect );
 const TInt buttonWidth( iCtrlButtonRect.Width() );
 const TInt currentWidth( aRect.Width() );
 // only do adjusting if the buttonWidth is smaller than current popup width
 if ( buttonWidth < currentWidth )
 {
+TBool landscape( Layout_Meta_Data::IsLandscapeOrientation() );
 TAknLayoutRect scrollPane;
 scrollPane.LayoutRect( aRect,
 AknLayoutScalable_Apps::sp_fs_scroll_pane_cp01( 6 ) );
 const TInt scrollPaneWidth( scrollPane.Rect().Width() );
 TAknLayoutText textLayout;
 textLayout.LayoutText( aRect,
 AknLayoutScalable_Apps::list_single_dyc_row_text_pane_t1( 0 ) );
 const CFont& font( *(textLayout.Font()) );
 const TInt padding(
 else
 {
 aRect.Move( -aRect.iTl.iX + iCtrlButtonRect.iTl.iX, 0 );
 }
 }
+// Keep the right edge position unchanged
+if( landscape )
+{
+aRect.Move( oldButtonRect.iBr.iX - aRect.iBr.iX, 0 );
+}
 }
 }
 }
 else
 {
 }
 else
 {
 iListHeaderHeight = 0;
 }
 TSize mainPaneSize;
 AknLayoutUtils::LayoutMetricsSize(AknLayoutUtils::EMainPane, mainPaneSize);
 // Set anchor for background visual
 iParentLayout->SetAnchor(EAlfAnchorTopLeft,
 0,
 EAlfAnchorOriginLeft,
 EAlfAnchorOriginTop,
 EAlfAnchorOriginRight,
 EAlfAnchorOriginTop,
 EAlfAnchorMetricAbsolute,
 EAlfAnchorMetricAbsolute,
 TAlfTimedPoint(mainPaneSize.iWidth,mainPaneSize.iHeight));
 	// Set anchor for header text visual
 	iParentLayout->SetAnchor(EAlfAnchorTopLeft,
 					1,
 					EAlfAnchorOriginLeft,
 					EAlfAnchorOriginTop,
 FUNC_LOG;
 TInt topLevelCount = iTreeList->CountChildren( KFsTreeRootID );
 if ( topLevelCount )
 {
 TFsTreeItemId topId = iTreeList->Child(KFsTreeRootID, 0);
 iTreeVisualizer->SetFocusedItemL( topId );
 }
 }
 // ---------------------------------------------------------------------------
 // Moves the focus to the bottommost item
 {
 FUNC_LOG;
 // There may be arbitrary number of nested sub folders. Make sure we focus
 // the bottommost visible subfolder.
 TFsTreeItemId bottomId = KFsTreeRootID;
 while ( iTreeList->IsNode(bottomId) &&
 iTreeList->IsExpanded(bottomId) &&
 iTreeList->CountChildren(bottomId) )
 {
 bottomId = iTreeList->Child( bottomId, iTreeList->CountChildren(bottomId)-1 );
 }
 if ( bottomId != KFsTreeRootID )
 {
 iTreeVisualizer->SetFocusedItemL( bottomId );
 }
 }
 // ---------------------------------------------------------------------------
 // Updates the toolbar buttons (sets the dimmed status of the collapse
 TBool CFSEmailUiFolderListVisualiser::AllNodesCollapsed() const
 {
 FUNC_LOG;
 TFsTreeItemId itemId = KFsTreeNoneID;
 TInt count = iTreeList->CountChildren(KFsTreeRootID);
 	// If top level is collapsed, then everything is collapsed. There's no need
 	// to crawl any deeper in the tree hierarchy.
 	for ( TInt i=0 ; i<count ; ++i )
 	    {
 	    itemId = iTreeList->Child( KFsTreeRootID, i );
 	         iTreeList->IsExpanded(itemId) )
 	        {
 	        return EFalse;
 	        }
 	    }
 	return ETrue;
 }
 // ---------------------------------------------------------------------------
 // Tells if all expandable nodes are expanded
 TBool CFSEmailUiFolderListVisualiser::AllNodesExpanded( TFsTreeItemId aParentNodeId ) const
 {
 FUNC_LOG;
 // We must crawl through the whole tree to see, if there are any collapsed nodes
 // at any level. We do this with recursive depth-first-search.
 TFsTreeItemId itemId = KFsTreeNoneID;
 TInt count = iTreeList->CountChildren(aParentNodeId);
 for ( TInt i=0 ; i<count ; ++i )
 {
 itemId = iTreeList->Child( aParentNodeId, i );
 if ( iTreeList->IsNode(itemId) )
 {
 {
 return EFalse;
 }
 }
 }
 	return ETrue;
 }
 // ---------------------------------------------------------------------------
 // Does a horizontal scrolling for the list by resizing and moving the list
 TFsTreeItemId focusedId = iTreeList->FocusedItem();
 if ( focusedId > KFsTreeRootID )
 {
 // Get the list level
 TUint level = iTreeList->Level( focusedId );
 // Little optimisation, handle all levels up to KListLastBasicLevel
 // as root level because horizontal scroll amount is same for all
 if( level <= KListLastBasicLevel )
 {
 level = KListRootLevel;
 }
 // Recalculate the list rect only if level has changed or if
 // recalculation is forced by parameter (e.g. in case of
 // dynamic variant switch)
 if( ( level != iPreviousListLevel ) || aForceRecalculation )
 {
 TRect listRect = iListLayout->DisplayRectTarget();
 // Calulate list rect by taking x-coordinates from iScreenRect
 // and y-coordinates from list layouts target rect (to take
 // into account the list header)
 listRect.SetRect( iScreenRect.iTl.iX, listRect.iTl.iY,
 iScreenRect.iBr.iX, listRect.iBr.iY );
 if( level > KListLastBasicLevel )
 {
 // Calculate rect according to current level
 TInt rectChange = (level - KListLastBasicLevel) * iTreeList->Indentation();
 listRect.SetWidth( iScreenRect.Width() + rectChange );
 listRect.Move( -rectChange, 0 );
 }
 // Set the list rect only if it has changed from previous
 // (because list refresh causes a little twitch)
 if( listRect != iPreviousListRect )
 {
 iListLayout->SetRect( listRect, iAppUi.LayoutHandler()->CtrlBarListFadeEffectTime() );
 iTreeVisualizer->RefreshListViewL();
 iPreviousListRect = listRect;
 }
 iPreviousListLevel = level;
 }
 }
 }
 }
 // enable collapsing.
 Toolbar()->SetItemDimmed( EFsEmailUiTbCmdCollapseAll, EFalse, ETrue );
 Toolbar()->SetItemDimmed( EFsEmailUiTbCmdExpandAll, ETrue, ETrue );
 break;
 }
+case EFsFocusVisibilityChange:
+{
+iAppUi.SetFocusVisibility( EFalse );
+break;
+}
+default:
+{
+// No need to handle other events.
+break;
+}
 }
 }
 // ---------------------------------------------------------------------------
 // HandleMailBoxEventL
 //
 void CFSEmailUiFolderListVisualiser::HandleMailBoxEventL( TFSMailEvent aEvent,
 TFSMailMsgId aMailboxId, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 FUNC_LOG;
 // Handle the event
 if ( iMoveOrCopyInitiated &&
 iFirstStartCompleted &&
 aMailboxId == iAppUi.GetActiveMailboxId() &&
 iAppUi.CurrentActiveView() == this )
 {
 		if ( aEvent == TFSEventMailboxOnline )
 			{
 if( iWaitingToGoOnline )
 {
 PrepareFolderListL();
 PopulateFolderListL();
 if ( iModel->Count() )
 {
 SetFocusToLatestMovedFolderL();
 }
+iTreeList->SetFocusedL( ETrue );
+iWaitingToGoOnline = EFalse;
 }
 			}
 		else if ( aEvent == TFSEventMailboxOffline )
 			{
 // Empty the list when disconnected if connection is needed for
 			}
 }
 }
 // ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFSEmailUiFolderListVisualiser::FocusVisibilityChange( TBool aVisible )
+{
+FUNC_LOG;
+CFsEmailUiViewBase::FocusVisibilityChange( aVisible );
+iTreeVisualizer->SetFocusVisibility( aVisible );
+}
+// ---------------------------------------------------------------------------
 // CbaButtonPressed
 // Check if aPosition is on CBA touch area
 // ---------------------------------------------------------------------------
 //
 TBool CFSEmailUiFolderListVisualiser::CbaButtonPressed( TPoint aPosition )
 {
 TBool cbaPressed( EFalse );
 TRect leftCbaRect = TRect();
 TRect rightCbaRect = TRect();
 GetCbaRects( leftCbaRect, rightCbaRect );
 if ( leftCbaRect.Contains( aPosition ) ||
 rightCbaRect.Contains( aPosition ))
 // Resolve CBA touch areas from layouts
 // ---------------------------------------------------------------------------
 //
 void CFSEmailUiFolderListVisualiser::GetCbaRects( TRect& aLeftCbaRect, TRect& aRightCbaRect )
 {
 TBool rightPaneActive( IsAreaSideRightPaneActive() );
 TBool bskLandscape( Layout_Meta_Data::IsLandscapeOrientation() &&
 !rightPaneActive );
 TRect screen;
 AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screen );
 if ( rightPaneActive )
 {
 TAknWindowComponentLayout rightAreaLayout(
 AknLayoutScalable_Avkon::area_side_right_pane( 0 ) );
 TAknLayoutRect layoutRect;
 // Read right (top in landscape) softkey layout.
 layoutRect.LayoutRect(
 screen,
 TAknWindowComponentLayout::Compose(
 rightAreaLayout,
 AknLayoutScalable_Avkon::sctrl_sk_bottom_pane() ).LayoutLine() );
 TRect bottomSKRect( layoutRect.Rect() );
 // Read left (bottom in landscape) softkey layout.
 layoutRect.LayoutRect(
 screen,
 TAknWindowComponentLayout::Compose(
 rightAreaLayout,
 AknLayoutScalable_Avkon::sctrl_sk_top_pane() ).LayoutLine() );
 aLeftCbaRect = layoutRect.Rect();
 layoutRect.LayoutRect(
 topSKRect,
 AknLayoutScalable_Avkon::aid_touch_sctrl_top().LayoutLine() );
 aRightCbaRect = layoutRect.Rect();
 }
 else
 {
 TAknWindowComponentLayout applicationWindow(
 AknLayoutScalable_Avkon::application_window( 0 ) );
 TAknLayoutRect cbarect;
 cbarect.LayoutRect(
 screen,
 applicationWindow,
 TAknWindowComponentLayout::Compose(
 AknLayoutScalable_Avkon::area_bottom_pane( bskLandscape ? 2 : 1 ),
 AknLayoutScalable_Avkon::control_pane() ) ).LayoutLine() );
 aLeftCbaRect = cbarect.Rect();
 }
 }
 // ---------------------------------------------------------------------------
 // IsAreaSideRightPaneActive
 // Checks if right side pane is active.
 TBool CFSEmailUiFolderListVisualiser::IsAreaSideRightPaneActive()
 {
 // Currently the widescreen status pane layout is in use only
 // when pen input (touch) is enabled.
 TBool result = EFalse;
 if ( Layout_Meta_Data::IsLandscapeOrientation() &&
 Layout_Meta_Data::IsPenEnabled() )
 {
 if ( iAvkonEnv->StatusPaneResIdForCurrentLayout(
 AknStatuspaneUtils::CurrentStatusPaneLayoutResId() ) ==
 R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS )

changeset 1	12c456ceeff2
parent 0	8466d47a6819
child 2	5253a20d2a1e