/*
* Copyright (c) 2007-2010 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".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  FreestyleEmailUi main grid implementation
*
*/


// SYSTEM INCLUDE FILES
#include "emailtrace.h"
#include <coemain.h>
#include <StringLoader.h>
#include <AknUtils.h>
#include <AknsUtils.h>
#include <AknsSkinInstance.h>
#include <apgcli.h> // RApaLsSession
#include <e32math.h>
#include <FreestyleEmailUi.rsg>
#include <touchlogicalfeedback.h>
#include <alf/alfutil.h>
#include <alf/alfenv.h>
#include <alf/alfevent.h>
#include <alf/alftextvisual.h>
#include <aknnotewrappers.h>
#include <freestyleemailui.mbg>
#include <gulicon.h>
#include <akntoolbar.h>
#include "cfsmailmessage.h"
#include <alf/alfframebrush.h>
#include "cfsmailbox.h"
#include "cfsmailclient.h"
#include <hlplch.h>
#include <akntitle.h>
#include <centralrepository.h>
#include <alf/alfanchorlayout.h>
#include <alf/alfbrusharray.h>
#include <alf/alfstatic.h>
#include <alf/alfgencomponent.h>
#include <alf/alfconstants.h>
#include "fsalfscrollbarlayout.h"
#include <csxhelp/cmail.hlp.hrh>
#include <featmgr.h>
#include <coecntrl.h>

#include <aknmessagequerydialog.h>
#include <aknstyluspopupmenu.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <aknlayoutscalable_apps.cdl.h>
#include <layoutmetadata.cdl.h>
#include <touchfeedback.h>
#include <aknphysics.h>

// INTERNAL INCLUDE FILES
#include "FSEmailBuildFlags.h"
#include "FreestyleEmailUiConstants.h"
#include "FreestyleEmailUiLiterals.h"
#include "FreestyleEmailUiLauncherGrid.h"
#include "FreestyleEmailUiLauncherGridVisualiser.h"
#include "FreestyleEmailUi.hrh"
#include "FreestyleEmailUiLayoutHandler.h"
#include "FreestyleEmailUiTextureManager.h"
#include "FreestyleEmailUiMailListVisualiser.h"
#include "FreestyleEmailUiShortcutBinding.h"
#include "FSDelayedLoader.h"

// Utility clean up function
void CleanupEComArray( TAny* aArray );

// CONSTANT VALUES
const TReal KDefaultCaptionOpacity = 1.0;
const TInt KDefaultSelection = 0;
const TInt KSelectTransitionTimeMs = 300;
const TInt KIconScalingTransitionTimeMs = 350;
const TInt KStartupAnimationTime = 0;
const TReal KScaleSelected = 1.0;
const TReal KScaleNotSelected = 0.77;


CFSEmailUiLauncherGridVisualiser* CFSEmailUiLauncherGridVisualiser::NewL(CAlfEnv& aEnv,
												 CFSEmailUiLauncherGrid* aControl,
												 CFreestyleEmailUiAppUi* aAppUi,
												 CAlfControlGroup& aControlGroup,
												 TInt aColumns, TInt aRows)
    {
    FUNC_LOG;
    CFSEmailUiLauncherGridVisualiser* self = CFSEmailUiLauncherGridVisualiser::NewLC(aEnv, aControl, aAppUi, aControlGroup, aRows, aColumns);
    CleanupStack::Pop(self);
    return self;
    }

CFSEmailUiLauncherGridVisualiser* CFSEmailUiLauncherGridVisualiser::NewLC(CAlfEnv& aEnv,
												  CFSEmailUiLauncherGrid* aControl,
												  CFreestyleEmailUiAppUi* aAppUi,
												  CAlfControlGroup& aControlGroup,
												  TInt aColumns, TInt aRows)
    {
    FUNC_LOG;
    CFSEmailUiLauncherGridVisualiser* self = new (ELeave) CFSEmailUiLauncherGridVisualiser(aEnv, aControl, aAppUi, aControlGroup);
    CleanupStack::PushL(self);
    self->ConstructL(aColumns, aRows);
    return self;
    }

CFSEmailUiLauncherGridVisualiser::CFSEmailUiLauncherGridVisualiser(CAlfEnv& aEnv,
											 CFSEmailUiLauncherGrid* aControl,
										     CFreestyleEmailUiAppUi* aAppUi,
										     CAlfControlGroup& aControlGroup)
    : CFsEmailUiViewBase(aControlGroup, *aAppUi),
    iEnv( aEnv ),
    iVisibleRows( 0 ),
    iVisibleColumns( 0 ),
    iRowCount( 0 ),
    iFirstVisibleRow( 0 ),
    iRowHeight( 0 ),
    iColumnWidth( 0 ),
	iSelector( 0 ),
	iStartupAnimation( 0 ),
	iStartupEffectStyle( 0 ),
  	iWizardWaitnoteShown( EFalse ),
  	iPointerAction( EFalse ),
    iIsDragging( EFalse ),
    iScrolled( EFalse ),
    iLaunchWizardExecuted( EFalse )
    {
    FUNC_LOG;
    iItemIdInButtonDownEvent.iItemId = KErrNotFound;
    iItemIdInButtonDownEvent.iLaunchSelection = EFalse;
    iControl = aControl;
    }

void CFSEmailUiLauncherGridVisualiser::ConstructL( TInt aColumns, TInt aRows )
    {
    FUNC_LOG;
    BaseConstructL( R_FSEMAILUI_MAINUI_VIEW );
    iVisibleRows = aRows;
    iVisibleColumns = aColumns;
    iConstructionCompleted = EFalse;
    iDoubleClickLock = EFalse;
    iUiOperationLaunched = EFalse;

    iMailboxDeleter = CFSEmailUiMailboxDeleter::NewL( *iAppUi.GetMailClient(), *this );

    // Create startup timer
    iStartupCallbackTimer = CFSEmailUiGenericTimer::NewL( this );

    iCurrentLevel.iParentPos.iY = 0; 
    iCurrentLevel.iParentPos.iX = 0;

    if ( CAknPhysics::FeatureEnabled() )
        {
        iPhysics = CAknPhysics::NewL(*this, NULL);
        }
    }

// ----------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::DoFirstStartL()
// Purpose of this function is to do first start only when grid is really
// needed to be shown. Implemented to make app startup faster.
// ----------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::DoFirstStartL()
    {
    FUNC_LOG;
    iPluginIdIconIdPairs.Reset();

    TRect mainPaneRect;
    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane,
									   mainPaneRect );

    TAknLayoutRect scrollBarRect;
    scrollBarRect.LayoutRect( mainPaneRect,
    	AknLayoutScalable_Avkon::aid_size_touch_scroll_bar() );
    TRect gridRect = mainPaneRect;
    gridRect.iBr.iX -= scrollBarRect.Rect().Width();

    iVisibleRows = iAppUi.LayoutHandler()->GridRowsInThisResolution();
    iVisibleColumns = iAppUi.LayoutHandler()->GridColumnsInThisResolution();

    iStartupAnimation = ETrue;
    iCurrentLevel.iSelected = KDefaultSelection;
    CAlfTextureManager& manager = iEnv.TextureManager();

    iParentLayout = CAlfDeckLayout::AddNewL( *iControl );
    iParentLayout->SetFlags( EAlfVisualFlagLayoutUpdateNotification );

    // Widget layout divides the screen between grid and scroll bar
    iWidgetLayout = CAlfAnchorLayout::AddNewL( *iControl, iParentLayout );
	TSize displaySize = mainPaneRect.Size();
    iWidgetLayout->SetSize( displaySize );

    // Constructed here, updated later, #0 item in iWidgetLayout
    ConstructScrollbarL( iWidgetLayout );

    // Grid layout is constructed here, #1 item in iWidgetLayout
    iCurrentLevel.iGridLayout =
		CAlfGridLayout::AddNewL( *iControl, iVisibleColumns, iVisibleRows,
								 iWidgetLayout );
    iCurrentLevel.iGridLayout->EnableScrollingL( ETrue );
    iCurrentLevel.iGridLayout->SetFlags( EAlfVisualFlagAutomaticLocaleMirroringEnabled );

    // Selector is added to iGridLayout
    iSelector = iControl->AppendLayoutL( EAlfLayoutTypeLayout,
										 iCurrentLevel.iGridLayout );
    iSelector->SetFlags( EAlfVisualFlagManualLayout );

    iRingMovementXFunc = CAlfTableMappingFunction::NewL( iEnv );
    iRingMovementYFunc = CAlfTableMappingFunction::NewL( iEnv );

    TAlfTimedPoint selectorPos = iSelector->Pos();
    selectorPos.iX.SetMappingFunctionIdentifier( iRingMovementXFunc->MappingFunctionIdentifier() );
    selectorPos.iY.SetMappingFunctionIdentifier( iRingMovementYFunc->MappingFunctionIdentifier() );
    iSelector->SetPos( selectorPos );

    UpdateFocusVisibility();
    iSelectorImageVisual = CAlfImageVisual::AddNewL( *iControl, iSelector );
    iSelectorImageVisual->SetScaleMode( CAlfImageVisual::EScaleFit );

    const TInt var( Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0 );

    // Use layout data instead of hard-coded values
    TAknLayoutRect itemRect;
    itemRect.LayoutRect( gridRect,
    	AknLayoutScalable_Apps::cell_cmail_l_pane( var, 0, 0 ) );
    iSelectorImageVisual->SetSize( itemRect.Rect().Size() );
    iSelectorImageVisual->EnableBrushesL();
    CAlfFrameBrush* brush = iAppUi.FsTextureManager()->GridSelectorBrushL();
    iSelectorImageVisual->Brushes()->AppendL( brush, EAlfDoesNotHaveOwnership );
    iStartupEffectStyle = EFalse;

    iAiwSHandler = CAiwServiceHandler::NewL();
    iAiwSHandler->AttachL( R_AIW_INTEREST_LAUNCH_SETUP_WIZARD );

    if( !iStylusPopUpMenu )
        {
        // Construct the long tap pop-up menu.
        TPoint point( 0, 0 );
        iStylusPopUpMenu = CAknStylusPopUpMenu::NewL( this , point );
		TResourceReader reader;
		iCoeEnv->CreateResourceReaderLC( reader,
			R_STYLUS_POPUP_MENU_LAUNCHER_GRID_VIEW );
		iStylusPopUpMenu->ConstructFromResourceL( reader );
		CleanupStack::PopAndDestroy(); // reader
        }
    
    iCoeControl = new( ELeave )CCoeControl;
    // Initial visual layout update is done when the view gets activated.
    iRefreshNeeded = ETrue;

    UpdatePhysicsL(); // init sizes for scrooling
    
    // First start toggle
    iConstructionCompleted = ETrue;
    }

// ---------------------------------------------------------------------------
// HandleButtonReleaseEventL is called when Launcher grid visualiser
// gets pointer event that indicates that button is released.
// function should decide if focus should still be drawn or not.
// ---------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::HandleButtonReleaseEvent()
    {
    iItemIdInButtonDownEvent.iItemId = KErrNotFound;
    iItemIdInButtonDownEvent.iLaunchSelection = EFalse;

    UpdateFocusVisibility();

	if( !IsFocusShown() )
		{
        // No items are focused anymore. Shrink the icon.
		ResizeItemIcon( ETrue );
		}
	else
	    {
        // Reset selected icon size back to normal
        ResizeItemIcon( EFalse );
	    }
    }

// ---------------------------------------------------------------------------
// Reduces icon size of seleceted item
// Called when grag event is made.
// ---------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::ResizeItemIcon( TBool aReduce )
    {
    TInt selectedItem( iCurrentLevel.iSelected );
    TInt count = iCurrentLevel.iItemVisualData.Count();
    if ( selectedItem < 0 || selectedItem >= count )
        {
        return;  // incorrect index
        }
    
    if( selectedItem >= 0 )
        {
        TReal transition( KScaleNotSelected );
        if( !aReduce )
            {
            transition = KScaleSelected;
            }
        TAlfTimedValue scaleValue;
        scaleValue.SetTarget( transition, KIconScalingTransitionTimeMs * 2 );
        iCurrentLevel.iItemVisualData[selectedItem].iImage->SetScale( scaleValue );
        if ( !iScrolled )
            {
            HandleRowMovement( EDirectionTouch, selectedItem );
            }
        }
    }

CFSEmailUiLauncherGridVisualiser::~CFSEmailUiLauncherGridVisualiser()
    {
    FUNC_LOG;
    
    if ( iStartupCallbackTimer )
    	{
    	iStartupCallbackTimer->Cancel();
    	delete iStartupCallbackTimer;
    	}
    
    iPluginIdIconIdPairs.Reset();
    iIconArray.Close();
    iMailboxRequestIds.Close();
    iLauncherItems.ResetAndDestroy();
    iLauncherItemUids.Close();
    iCurrentLevel.iItemVisualData.Close();
    iCurrentLevel.iItems.Close();
    DetachSelectorMappingFunctions();
    delete iRingMovementXFunc;
    delete iRingMovementYFunc;
    delete iModel;
    delete iAiwSHandler;
    delete iScrollbar;
    delete iMailboxDeleter;
    delete iStylusPopUpMenu;
    delete iCoeControl;
    delete iPhysics;
    }

void CFSEmailUiLauncherGridVisualiser::CreateModelL()
    {
    FUNC_LOG;

    RArray<TBool> itemInModel;
    CleanupClosePushL( itemInModel );
    iIconArray.Reset();

	iPluginTextureId = EGridPluginIconFirst;
	iPluginIdIconIdPairs.Reset();

    delete iModel;
    iModel = NULL;
    iModel = new (ELeave) CFSEmailUiLauncherGridModel();
    iModel->ConstructL();
	CAlfTexture* iconTexture = 0;

	// Get item ordering from resources
    TResourceReader reader;
    iEikonEnv->CreateResourceReaderLC( reader, R_FSEMAILUI_LAUNCHER_GRID );

    UpdateLauncherItemListL();
	MFSMailBrandManager& brandManager = iAppUi.GetMailClient()->GetBrandManagerL();

    for ( TInt i = 0; i < iLauncherItems.Count(); i++ )
        {
        itemInModel.Append( EFalse );
        }

    TInt count = reader.ReadInt16();

    TRect mainPaneRect;
    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);

    TAknLayoutRect scrollBarRect;
    scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::aid_size_touch_scroll_bar());
    TRect gridRect = mainPaneRect;
    gridRect.iBr.iX -= scrollBarRect.Rect().Width();

    TInt var = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;
    TAknLayoutRect itemRect;
    itemRect.LayoutRect(gridRect, AknLayoutScalable_Apps::cell_cmail_l_pane(var,0,0));

    TAknLayoutRect gridIconLRect;
    gridIconLRect.LayoutRect(itemRect.Rect(), AknLayoutScalable_Apps::cell_cmail_l_pane_g1(var));
    TSize iconSize = gridIconLRect.Rect().Size();

    for ( TInt itemIndex = 0; itemIndex < count; itemIndex++ )
        {
        TInt itemId = reader.ReadInt16();
        switch ( itemId )
            {
            case EDefaultMailboxItem:
                {

                RPointerArray<CFSMailBox> mailBoxes;
                CleanupResetAndDestroyClosePushL( mailBoxes );
                TFSMailMsgId id;
                TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                    id,
                    mailBoxes );

                if ( mailBoxes.Count() > 0 )
                    {
                    // Try to get branded graphic
                    CGulIcon* mbIcon(0);
		         	TRAPD( err, mbIcon = brandManager.GetGraphicL( EFSMailboxIcon, mailBoxes[0]->GetId() ) );
					if ( err == KErrNone && mbIcon )
						{
						CleanupStack::PushL( mbIcon );
				    	AknIconUtils::SetSize(mbIcon->Bitmap(), iconSize);
					    AknIconUtils::SetSize(mbIcon->Mask(), iconSize);

					    // Create texture into TextureManager, If not already existing
					    // Note: size(0,0) means original icon size
					    iAppUi.FsTextureManager()->CreateBrandedMailboxTexture( mbIcon,
					    		                                                 mailBoxes[0]->GetId().PluginId(),
					    		                                                 mailBoxes[0]->GetId().Id(),
					    		                                                 TSize(0,0));
					    // Get branded mailbox icon
					    iconTexture = &iAppUi.FsTextureManager()->TextureByMailboxIdL( mailBoxes[0]->GetId().PluginId(),
					    		                                                        mailBoxes[0]->GetId().Id(),
					    		                                                        TSize(0,0));

						CleanupStack::PopAndDestroy( mbIcon );
						}
					else
						{
	                    iconTexture = &iAppUi.FsTextureManager()->TextureByIndex( EGridInboxTexture );
						}

   			        iIconArray.AppendL( iconTexture );

   			        // Branded mailbox name is nowadays set in new mailbox event
   			        // handling, so we don't need to use brand manager here anymore.
   			        iModel->AddL(
                        EShortcut,
                        EDefaultMailboxItem,
                        mailBoxes[0]->GetName(),
                        *iconTexture,
                        mailBoxes[0]->GetId(),
                        mailBoxes[0]->GetStandardFolderId( EFSInbox ) );

   			        iAppUi.SubscribeMailboxL( mailBoxes[0]->GetId() );
                    }

                CleanupStack::PopAndDestroy( &mailBoxes );
                }
                break;
            case EOtherMailboxItems:
                {
                RPointerArray<CFSMailBox> mailBoxes;
                CleanupResetAndDestroyClosePushL( mailBoxes );
                TFSMailMsgId id;
                TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                    id,
                    mailBoxes );

                for ( TInt i = 1; i < mailBoxes.Count(); i++ )
                    {
                   // Try to get branded graphic
                    CGulIcon* mbIcon(0);
		         	TRAPD( err, mbIcon = brandManager.GetGraphicL( EFSMailboxIcon,  mailBoxes[i]->GetId() ) );
					if ( err == KErrNone && mbIcon )
						{
						CleanupStack::PushL( mbIcon );
				    	AknIconUtils::SetSize(mbIcon->Bitmap(), iconSize);
					    AknIconUtils::SetSize(mbIcon->Mask(), iconSize);

					    // Create texture into TextureManager, If not already existing
					    iAppUi.FsTextureManager()->CreateBrandedMailboxTexture( mbIcon,
					    		                                                 mailBoxes[i]->GetId().PluginId(),
					    		                                                 mailBoxes[i]->GetId().Id(),
					    		                                                 TSize(0,0));
					    // Get branded mailbox icon
					    iconTexture = &iAppUi.FsTextureManager()->TextureByMailboxIdL( mailBoxes[i]->GetId().PluginId(),
					    		                                                        mailBoxes[i]->GetId().Id(),
					    		                                                        TSize(0,0));
						CleanupStack::PopAndDestroy( mbIcon );
						}
					else
						{
	                    iconTexture = &iAppUi.FsTextureManager()->TextureByIndex( EGridInboxTexture );
						}
  	                iIconArray.AppendL( iconTexture );
                    // Branded mailbox name is nowadays set in new mailbox event
                    // handling, so we don't need to use brand manager here anymore.
                    iModel->AddL(
                        EShortcut,
                        EDefaultMailboxItem,
                        mailBoxes[i]->GetName(),
                        *iconTexture,
                        mailBoxes[i]->GetId(),
                        mailBoxes[i]->GetStandardFolderId( EFSInbox ) );

                    iAppUi.SubscribeMailboxL( mailBoxes[i]->GetId() );
                    }

                CleanupStack::PopAndDestroy( &mailBoxes );
                }
                break;
            case EDirectoryItem:
                {
                RPointerArray<CFSMailBox> mailBoxes;
                CleanupResetAndDestroyClosePushL( mailBoxes );
                TFSMailMsgId id;
                TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                    id,
                    mailBoxes );

                for ( TInt i = 0; i < mailBoxes.Count(); i++ )
                    {
                    if ( TFsEmailUiUtility::IsRemoteLookupSupported( *mailBoxes[i] ) )
                        {
                        HBufC* text = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_GRIDITEM_DIRECTORY );
                        iconTexture = &iAppUi.FsTextureManager()->TextureByIndex( EGridDirectoryTexture );
                        iModel->AddL(EShortcut, EDirectoryItem, *text, *iconTexture );
                        CleanupStack::PopAndDestroy( text );
                        iIconArray.AppendL( iconTexture );
                        break;
                        }
                    }

                CleanupStack::PopAndDestroy( &mailBoxes );
                }
                break;
            case ESettingsItem:
                {
                HBufC* text = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_GRIDITEM_SETTINGS );
                iconTexture = &iAppUi.FsTextureManager()->TextureByIndex( EGridSettingsTexture );
                iModel->AddL(EShortcut, ESettingsItem, *text, *iconTexture );
                CleanupStack::PopAndDestroy( text );
                iIconArray.AppendL( iconTexture );
                }
                break;
            case EAddNewMailboxItem:
                {
                HBufC* text = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_GRIDITEM_ADD_NEW_MAILBOX );
                iconTexture = &iAppUi.FsTextureManager()->TextureByIndex( EGridAddNewBoxTexture );
                iModel->AddL(EShortcut, EAddNewMailboxItem, *text, *iconTexture );
                CleanupStack::PopAndDestroy( text );
                iIconArray.AppendL( iconTexture );
                }
                break;
            case EHelpItem:
                {
     		   // remove help support in pf5250
        	    if (! FeatureManager::FeatureSupported( KFeatureIdFfCmailIntegration ) )
        		   {
                   HBufC* text = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_GRIDITEM_HELP );
                   iconTexture = &iAppUi.FsTextureManager()->TextureByIndex( EGridHelpTexture );
                   iModel->AddL(EShortcut, EHelpItem, *text, *iconTexture );
                   CleanupStack::PopAndDestroy( text );
                   iIconArray.AppendL( iconTexture );
        		   }
                }
                break;
            case EIntellisyncFileSyncItem:
            case EIntellisyncTravelInfoItem:
            case EIntellisyncBackupItem:
            case EIntellisyncRestoreItem:
            case EIntellisyncUpgradeItem:
           	case EIntellisyncRemoteControlItem:
                {
                for ( TInt i = 0; i < iLauncherItems.Count(); i++ )
                    {
                    if ( iLauncherItems[i]->Id() == itemId )
                        {
                        itemInModel[i] = ETrue;
                        AddItemToModelL( iLauncherItems[i], i );
                        break;
                        }
                    }
                }
                break;
            default:
                break;
            }
        }

    CleanupStack::PopAndDestroy(); // reader internal state

    // Rest of the launcher items
    for ( TInt i = 0; i < iLauncherItems.Count(); i++ )
        {
        if ( ! itemInModel[i] )
            {
            AddItemToModelL( iLauncherItems[i], i );
            }
        }

    CleanupStack::PopAndDestroy( &itemInModel );
	}

void CFSEmailUiLauncherGridVisualiser::CreateCaptionForApplicationL(TUid aUid,
                                                TDes& aCaption,
                                                TBool aShortCaption)
    {
    FUNC_LOG;
    RApaLsSession ls;
    User::LeaveIfError( ls.Connect() );
    TApaAppInfo appInfo;
    TInt ret = ls.GetAppInfo( appInfo, aUid );
    if ( ret == KErrNone )
        {
        if ( !aShortCaption )
            {
            aCaption = appInfo.iCaption;
            }
        else
            {
            aCaption = appInfo.iShortCaption;
            }
        }
    ls.Close();
    }


TUid CFSEmailUiLauncherGridVisualiser::Id() const
	{
    FUNC_LOG;
	return AppGridId;
	}

void CFSEmailUiLauncherGridVisualiser::ChildDoActivateL(const TVwsViewId& aPrevViewId,
                     TUid /*aCustomMessageId*/,
                     const TDesC8& /*aCustomMessage*/)
    {
    FUNC_LOG;
    if ( !iConstructionCompleted )
        {
        DoFirstStartL();
        }

    if( iAppUi.CurrentFixedToolbar() )
        {
        iAppUi.CurrentFixedToolbar()->SetToolbarVisibility( EFalse );
        }

    // For initial mailbox query
	TBool startedFromOds = EFalse;
	// NULL wizard started parameter every time when activated again.
	iDoubleClickLock = EFalse;

    if ( aPrevViewId.iAppUid.iUid == 0 &&
        iAppUi.CurrentActiveView() != this )
        {
        // Started from wizard do not show query
        startedFromOds = ETrue;
        // This view activation has not come through according normal view
        // activation procedure, so we should ignore this by activating
        // the currently active view again. This has been made to
        // avoid problems when ODS setup is completed.
        if ( iAppUi.CurrentActiveView()->Id() == MailListId )
            {
            TMailListActivationData tmp;
            tmp.iReturnAfterWizard = ETrue;
            const TPckgBuf<TMailListActivationData> pkgOut( tmp );
            iAppUi.EnterFsEmailViewL( MailListId, KStartListReturnToPreviousFolder, pkgOut );
            }
        else if ( iAppUi.CurrentActiveView()->Id() == MailViewerId )
            {
            TMsgViewerActivationData tmp;
            const TPckgBuf<TMsgViewerActivationData> pkgOut( tmp );
            iAppUi.EnterFsEmailViewL( MailViewerId, KStartViewerReturnToPreviousMsg,  pkgOut);
            }
        else
            {
            iAppUi.EnterFsEmailViewL( iAppUi.CurrentActiveView()->Id() );
            }

        return;
        }

    if ( iRefreshNeeded )
        {
        CreateModelL();
        RescaleIconsL();
        VisualLayoutUpdatedL();
        }
    else
        {
        // scroll bar needs to be updated manually anyway
        UpdateScrollBarRangeL();
        }

    SetDefaultStatusPaneTextL();

    // Mailbox query is called here but shown only once in appui if needed
    // doNotshowQuery is ETrue when started from wizard
  	if ( !iFirstStartComplete )
  		{
  		iFirstStartComplete = ETrue;
	  	iAppUi.GridStarted( startedFromOds );
	    iAppUi.ShowMailboxQueryL();
  		}
  	else
  	    {
  	    // Ensure that FSMailServer is running, but don't do it on first
  	    // activation, as it's done anyway in AppUi's ConstructL
  	    TFsEmailUiUtility::EnsureFsMailServerIsRunning( iEikonEnv->WsSession() );
  	    }

    if( iRowCount > iVisibleRows )
        {
        iScrollbar->MakeVisible(ETrue);
        }
    else
        {
        iScrollbar->MakeVisible(EFalse);
        }

    iAppUi.HideTitlePaneConnectionStatus();

  	// Erase the navigation history when main grid activated. This is the default view
  	// of the application and back navigation is never possible from here. The view stack
  	// might be in inconsistent state because of some unexpected error in view switching.
  	// Erasing the history helps recovering from such situations.
  	iAppUi.EraseViewHistory();
  	FocusVisibilityChange( iAppUi.IsFocusShown() );
  	UpdateFocusVisibility();
    }

void CFSEmailUiLauncherGridVisualiser::ChildDoDeactivate()
    {
    FUNC_LOG;
    iScrollbar->MakeVisible(EFalse);
    }

void CFSEmailUiLauncherGridVisualiser::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)
	{
    FUNC_LOG;

	if ( aResourceId == R_FSEMAILUI_MAINUIGRID_MENUPANE )
		{
	    if ( FeatureManager::FeatureSupported( KFeatureIdFfCmailIntegration ) )
		   {
		   // remove help support in pf5250
		   aMenuPane->SetItemDimmed( EFsEmailUiCmdHelp, ETrue);
		   }

	    TFSLauncherGridMailboxStatus mbStatus = CheckMailboxStatusL();

	    // Checks if a device has a keyboard or not.
		if( !IsFocusShown() )
			{
			if( mbStatus.iMailboxCount <= 0 )
				{
				// If no mailboxes configured, dim all mailbox related items.
				aMenuPane->SetItemDimmed( EFsEmailUiCmdDeleteMailbox, ETrue );
				}

		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdOpen, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdSyncAll, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOffline, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOfflineAll, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnline, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnlineAll, ETrue );
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdAbout, ETrue );
			}
		else
			{
		   	aMenuPane->SetItemDimmed( EFsEmailUiCmdAbout, ETrue );

		   	if( mbStatus.iMailboxCount <= 0 )
		   	    {
		   	    // If no mailboxes configured, dimm all mailbox related items
		   	    aMenuPane->SetItemDimmed( EFsEmailUiCmdDeleteMailbox, ETrue );
	            aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, ETrue);
	            aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
	            aMenuPane->SetItemDimmed( EFsEmailUiCmdSyncAll, ETrue );
	            aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnline, ETrue );
	            aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnlineAll, ETrue );
	            aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOffline, ETrue );
	            aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOfflineAll, ETrue );
		   	    }
		   	else
		   	    {
		   	    // Handle items related to sync cancelling
		   	    if( mbStatus.iMailboxesSyncing == 0 )
		   	        {
		   	        // All mailboxes are already not syncing
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdCancelSync, ETrue );
		   	        }

	            // Handle items related to sync starting
		   	    if( mbStatus.iMailboxesSyncing == mbStatus.iMailboxCount )
		   	        {
		   	        // All mailboxes are already syncing
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdSyncAll, ETrue );
		   	        }
		   	    else if( mbStatus.iMailboxCount == 1 )
		   	        {
		   	        // Only one mailbox configured, dimm "Synchronise all"
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdSyncAll, ETrue );
		   	        }
		   	    else
		   	        {
		   	        // Several mailboxes configured, dimm "Synchronise"
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
		   	        }

	            // Handle items related to online
		   	    if( mbStatus.iMailboxesOnline == mbStatus.iMailboxCount )
		   	        {
		   	        // All mailboxes are already online
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnline, ETrue );
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnlineAll, ETrue );
		   	        }
		   	    else if( mbStatus.iMailboxCount == 1 )
		   	        {
	                // Only one mailbox configured, dimm "Connect all"
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnlineAll, ETrue );
		   	        }
		   	    else
		   	        {
	                // Several mailboxes configured, dimm "Connect"
	                aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOnline, ETrue );
		   	        }

	            // Handle pop accounts that can't sync
	            RPointerArray<CFSMailBox> mailBoxes;
	            CleanupResetAndDestroyClosePushL( mailBoxes );
	            TFSMailMsgId id;
	            bool onlyPop = true;
	            TInt err = iAppUi.GetMailClient()->ListMailBoxes(
	                id,
	                mailBoxes );

                for ( TInt i = 0; i < mailBoxes.Count(); i++ )
                    {
                    if (mailBoxes[i]->HasCapability( EFSMBoxCapaSupportsSync ))
                        {
                        onlyPop = false;
                        }
                    }

                if (onlyPop)
                    {
                    aMenuPane->SetItemDimmed( EFsEmailUiCmdSync, ETrue );
                    aMenuPane->SetItemDimmed( EFsEmailUiCmdSyncAll, ETrue );
                    }

                CleanupStack::PopAndDestroy( &mailBoxes );

                // Handle items related to offline
                if( mbStatus.iMailboxesOffline == mbStatus.iMailboxCount )
                    {
                    // All mailboxes are already offline
                    aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOffline, ETrue );
                    aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOfflineAll, ETrue );
                    }
                else if( mbStatus.iMailboxCount == 1 )
                    {
                    // Only one mailbox configured, dimm "Disconnect all"
                    aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOfflineAll, ETrue );
                    }
                else
                    {
                    // Several mailboxes configured, dimm "Disconnect"
                    aMenuPane->SetItemDimmed( EFsEmailUiCmdGoOffline, ETrue );
                    }
                }

            // Add shortcut hints
            iAppUi.ShortcutBinding().AppendShortcutHintsL( *aMenuPane,
    	                             CFSEmailUiShortcutBinding::EContextMainGrid );
            }
        }
	}

void CFSEmailUiLauncherGridVisualiser::HandleCommandL( TInt aCommand )
    {
    FUNC_LOG;

    switch ( aCommand )
        {
		case EAknSoftkeyOpen:
			{
			if( !iAppUi.IsFocusShown() )
				{
				// No need to handle return value
                iAppUi.SetFocusVisibility( ETrue );
                UpdateFocusVisibility();
                ResizeItemIcon( EFalse );
				break;
				}
			}
       	case EFsEmailUiCmdOpen:
			{
			SelectL();
			break;
			}
		case EFsEmailUiCmdDeleteMailbox:
			{
			// Deletion by using the option menu.
			iMailboxDeleter->DeleteMailboxL();
			break;
			}
		case EFsEmailUiCmdDeleteSelectedMailbox:
			{
			// Deletion by using the long tap pop-up menu.
			iMailboxDeleter->DeleteMailboxL( iMailboxToDelete );

	    	// Hide the focus.
	        iAppUi.SetFocusVisibility( EFalse );
	        HandleButtonReleaseEvent(); // Finishes the focus removal.
	        iStylusPopUpMenuLaunched = EFalse;
	        UpdateGridOffset();
			break;
			}
		case EFsEmailUiCmdSync:
        case EFsEmailUiCmdSyncAll:
			{
            RPointerArray<CFSMailBox> mailBoxes;
            CleanupResetAndDestroyClosePushL( mailBoxes );
            TFSMailMsgId id;
            TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                id,
                mailBoxes );

            for ( TInt i = 0; i < mailBoxes.Count(); i++ )
                {
                iAppUi.SubscribeMailboxL( mailBoxes[i]->GetId() );
                mailBoxes[i]->GetMailBoxStatus();
                mailBoxes[i]->RefreshNowL( iAppUi );
                }

            CleanupStack::PopAndDestroy( &mailBoxes );
			}
            break;
		case EFsEmailUiCmdCancelSync:
			{
            RPointerArray<CFSMailBox> mailBoxes;
            CleanupResetAndDestroyClosePushL( mailBoxes );
            TFSMailMsgId id;
            TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                id,
                mailBoxes );

            for ( TInt i = 0; i < mailBoxes.Count(); i++ )
                {
                iAppUi.SubscribeMailboxL( mailBoxes[i]->GetId() );
                mailBoxes[i]->CancelSyncL();
                }

            CleanupStack::PopAndDestroy( &mailBoxes );
			}
            break;

		case EFsEmailUiCmdGoOffline:
        case EFsEmailUiCmdGoOfflineAll:
			{
            if (aCommand == EFsEmailUiCmdGoOfflineAll)
            	{
                iAppUi.ManualMailBoxDisconnectAll(ETrue);
            	}
            RPointerArray<CFSMailBox> mailBoxes;
            CleanupResetAndDestroyClosePushL( mailBoxes );
            TFSMailMsgId id;
            TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                id,
                mailBoxes );

            for ( TInt i = 0; i < mailBoxes.Count(); i++ )
                {
                iAppUi.SubscribeMailboxL( mailBoxes[i]->GetId() );
                mailBoxes[i]->GoOfflineL();
                }

            CleanupStack::PopAndDestroy( &mailBoxes );
			}
            break;
		case EFsEmailUiCmdGoOnline:
        case EFsEmailUiCmdGoOnlineAll:
			{
            if (aCommand == EFsEmailUiCmdGoOnlineAll)
            	{
               	iAppUi.ManualMailBoxConnectAll(ETrue);
            	}
            RPointerArray<CFSMailBox> mailBoxes;
            CleanupResetAndDestroyClosePushL( mailBoxes );
            TFSMailMsgId id;
            TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                id,
                mailBoxes );

            for ( TInt i = 0; i < mailBoxes.Count(); i++ )
                {
                iAppUi.SubscribeMailboxL( mailBoxes[i]->GetId() );
                mailBoxes[i]->GoOnlineL();
                }

            CleanupStack::PopAndDestroy( &mailBoxes );
			}
            break;
       	case EFsEmailUiCmdAbout:
			{
			DisplayProductInfoL();
			}
			break;
       	case EFsEmailUiCmdHelp:
			{
            TFsEmailUiUtility::LaunchHelpL( KFSE_HLP_LAUNCHER_GRID );
			}
			break;
       	case KErrCancel:
       		{
        	// The pop-up menu was closed. Hide the focus.
            iAppUi.SetFocusVisibility( EFalse );
            HandleButtonReleaseEvent(); // Finishes the focus removal.
	        iStylusPopUpMenuLaunched = EFalse;
       		break;
       		}
        case EFsEmailUiCmdHide:
        case EEikCmdExit:
        case EAknSoftkeyExit:
        case EFsEmailUiCmdExit:
            {
            iAppUi.Exit();
            }
            break;
        default:
            break;
        } // switch ( aCommand )
    }

TBool CFSEmailUiLauncherGridVisualiser::OfferEventL(const TAlfEvent& aEvent)
    {
    FUNC_LOG;
    if ( aEvent.IsKeyEvent() && aEvent.Code() == EEventKey )
        {
        // If wait note is being shown while a mailbox is being created,
        // then do not react to key presses.
        if ( iWizardWaitnoteShown )
            {
            return ETrue; // key consumed
            }

        // Swap right and left controls in mirrored layout
        TInt scanCode = aEvent.KeyEvent().iScanCode;
        if ( AknLayoutUtils::LayoutMirrored() )
            {
            if (scanCode == EStdKeyRightArrow) scanCode = EStdKeyLeftArrow;
            else if (scanCode == EStdKeyLeftArrow ) scanCode = EStdKeyRightArrow;
            }

        if ((scanCode == EStdKeyRightArrow)
        		|| (scanCode == EStdKeyLeftArrow)
        		|| (scanCode == EStdKeyUpArrow)
        		|| (scanCode == EStdKeyDownArrow)
        		|| (scanCode == EStdKeyEnter)
        		|| (scanCode == EStdKeyDeviceA)
        		|| (scanCode ==EStdKeyDevice3))
        	{
            TBool scrolled = iScrolled;
            if ( iScrolled )
                {
                iScrolled = EFalse;
                SetFocusedItemL( iFirstVisibleRow * iVisibleColumns );
                }
            
            //iCurrentLevel.iSelected = 
        	if ( !iAppUi.SetFocusVisibility( ETrue ) ||
        	     scrolled )
        		{
				// focus is now activated. ignore key press.
				UpdateFocusVisibility();
				ResizeItemIcon( EFalse );
				return ETrue;
        		}
        	}

        switch(scanCode)
            {
            case EStdKeyRightArrow:
                MoveSelection(EDirectionRight);
                return ETrue;
            case EStdKeyLeftArrow:
                MoveSelection(EDirectionLeft);
                return ETrue;
            case EStdKeyUpArrow:
                MoveSelection(EDirectionUp);
                return ETrue;
            case EStdKeyDownArrow:
                MoveSelection(EDirectionDown);
                return ETrue;
            case EStdKeyEnter:
            case EStdKeyDeviceA:
            case EStdKeyDevice3:
            	HandleButtonReleaseEvent();
                SelectL();
                return ETrue;
            default:
	       	    // Check keyboard shortcuts.
	       	    TInt shortcutCommand =
	       	        iAppUi.ShortcutBinding().CommandForShortcutKey( aEvent.KeyEvent(),
	       	                                                         CFSEmailUiShortcutBinding::EContextMainGrid );
	       	    if ( shortcutCommand != KErrNotFound )
	       	        {
       	            HandleCommandL( shortcutCommand );
	       	        return ETrue;
	       	        }
               return EFalse;
            }
        }
    return EFalse; // was not consumed
    }


// ---------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::HandlePointerEventL
//
// ---------------------------------------------------------------------------
//
TBool CFSEmailUiLauncherGridVisualiser::HandlePointerEventL(
	const TAlfEvent& aEvent )
    {
    FUNC_LOG;
    if( !IsViewActive() )
        {
        return EFalse;
        }
    TPointerEvent::TType type = aEvent.PointerEvent().iType;
    TInt id = FindPointedItem( aEvent );

    switch( type )
        {
        case TPointerEvent::EButton1Down:
            {
            iPreviousPosition = iOriginalPosition = aEvent.PointerEvent().iParentPosition;
            iPointerAction = ETrue;
            iIsDragging = EFalse;

            if( iPhysics )
                {
                iPhysics->StopPhysics();
                iPhysics->ResetFriction();
                iStartTime.HomeTime();
                UpdatePhysicsL();
                iTotalDragging = 0;
                }            
            if ( id != KErrNotFound)
                {
                // tactile feedback
                MTouchFeedback* feedback = MTouchFeedback::Instance();
                if ( feedback )
                    {
                    feedback->InstantFeedback( ETouchFeedbackBasic );
                    }

                iItemIdInButtonDownEvent.iItemId = id;
                iItemIdInButtonDownEvent.iLaunchSelection = ETrue;
                SetFocusedItemL( id );
                UpdateFocusVisibility();
                }
            break;
            }
        case TPointerEvent::EButton1Up:
            {
            if( iIsDragging && iPhysics )
                {
                TPoint drag( iOriginalPosition - aEvent.PointerEvent().iParentPosition ); 
                iPhysics->StartPhysics( drag, iStartTime );
                iIsDragging = EFalse;
                iPointerAction = EFalse;
                iTotalDragging = 0;
                }
            else if ( id != KErrNotFound )
                {
                if ( iStylusPopUpMenuLaunched )
                    {
                    // A pop-up menu was launched. Do not open the selected
                    // item.
                    iItemIdInButtonDownEvent.iLaunchSelection = EFalse;
                    break;
                    }

                // Hide focus always after pointer up event.
                iAppUi.SetFocusVisibility( EFalse );

                // If key was released on item that had focus
                // trigger selection.
                if( iItemIdInButtonDownEvent.iItemId == id &&
                    iItemIdInButtonDownEvent.iLaunchSelection )
                    {
                    HandleButtonReleaseEvent();
                    // LAUNCH OPENING. This may leave if user cancels the
                    // operation
                    SelectL();
                    }
                else
                    {
                    HandleButtonReleaseEvent();
                    }
                }
            else if( iItemIdInButtonDownEvent.iItemId != KErrNotFound )
                {
                iItemIdInButtonDownEvent.iLaunchSelection = EFalse;
                ResizeItemIcon( ETrue );

                // Hide focus always after pointer up event.
                iAppUi.SetFocusVisibility( EFalse );
                iItemIdInButtonDownEvent.iItemId = KErrNotFound;
                HandleButtonReleaseEvent();
                }
            else
                {
                iAppUi.SetFocusVisibility( EFalse );
                }
			break;
            }
        case TPointerEvent::EDrag:
            {
            if( iPhysics )
                {
                TPoint position = aEvent.PointerEvent().iParentPosition;
                TPoint delta( 0, iPreviousPosition.iY - position.iY );
                iTotalDragging = iTotalDragging + delta.iY;
                if (Abs(iTotalDragging) >= iPhysics->DragThreshold() || iIsDragging )
                    {
                    // Hide focus always when dragging.
                    HandleButtonReleaseEvent();
 
                    iIsDragging = ETrue;
                
                    iPhysics->RegisterPanningPosition( delta );
                    iScrolled = ETrue;
                    }
                // Save current position as previous pos for future calculations
                iPreviousPosition = position;                
                }
            break;
            }
        case TPointerEvent::EButtonRepeat:
          	{
           	if (!iIsDragging && id != KErrNotFound )
           	    {
   	            // Check the type of the currently selected item.
    			TInt itemType = iCurrentLevel.iItems[id].iId;

				if ( itemType == EDefaultMailboxItem ||
					 itemType == EOtherMailboxItems )
   					{
   					// The selected item is a mail box. Launch the pop-up
   					// menu.
   	            	LaunchStylusPopupMenu( id );
    				}
           	    }
           	break;
            }
        default:
            {
            break;
            }
        }
    return ETrue;
    }

// ---------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::FindPointedItem
//
// ---------------------------------------------------------------------------
//
TInt CFSEmailUiLauncherGridVisualiser::FindPointedItem( const TAlfEvent& aEvent )
    {
    FUNC_LOG;
    TInt result = KErrNotFound;

    TInt count = iCurrentLevel.iItemVisualData.Count();
    const TPoint pos = aEvent.PointerEvent().iParentPosition;

    for ( TInt a = 0; count > a; a++ )
        {
        const TRect rect( iCurrentLevel.iItemVisualData[a].iBase->DisplayRect() );
        if ( rect.Contains( pos ) )
            {
            result = a;
            break;
            }
        }

    return result;
    }

// ---------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::SetFocusedItemL
//
// ---------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::SetFocusedItemL( TInt aId )
    {
    FUNC_LOG;
    TInt oldSelection = iCurrentLevel.iSelected;

    HandleRowMovement( EDirectionTouch, aId );

    FocusItem( EFalse, oldSelection );
    FocusItem( ETrue, iCurrentLevel.iSelected );
    MoveSelectorToCurrentItem( EDirectionTouch );
    }

void CFSEmailUiLauncherGridVisualiser::MoveSelection( TDirection aDir )
    {
    FUNC_LOG;
    // NULL double click flag just be sure that the UI does not
    // go into state that wizard cannot be started.
    iDoubleClickLock = EFalse;
    // Store old selection
    TInt oldSelection = iCurrentLevel.iSelected;
    TInt itemCount = iCurrentLevel.iItemVisualData.Count();

    HandleRowMovement( aDir, iCurrentLevel.iSelected );

    // Set the correct icon focuses (i.e. enlarged)
    if ( aDir != EDirectionNone && oldSelection >= 0 && oldSelection < itemCount )
        {
        FocusItem( EFalse, oldSelection );
        }
    FocusItem( ETrue, iCurrentLevel.iSelected );

    // Move the selector over the newly focused icon
    MoveSelectorToCurrentItem( aDir );
    UpdateFocusVisibility();
    }


void CFSEmailUiLauncherGridVisualiser::HandleRowMovement( TDirection aDir, TInt aSelected )
    {
    FUNC_LOG;
    // NULL double click flag just be sure that the UI does not
    // go into state that wizard cannot be started.
    iDoubleClickLock = EFalse;
    // Store old selection
    TInt oldSelection = iCurrentLevel.iSelected;
    TInt itemCount = iCurrentLevel.iItemVisualData.Count();
    TInt oldX = 0;
    TInt oldY = 0;
    if (itemCount <= 1)
        {
        iCurrentLevel.iSelected = 0;
        }
    else
        {
        oldX = oldSelection % iVisibleColumns;
        oldY = (oldSelection-oldX) / iVisibleColumns;

        switch( aDir )
            {
            case EDirectionRight:
                iCurrentLevel.iSelected++;
                if ( iCurrentLevel.iSelected >= itemCount )
                    {
                    iCurrentLevel.iSelected = 0;
                    }
                break;

            case EDirectionLeft:
                iCurrentLevel.iSelected--;
                if ( iCurrentLevel.iSelected < 0 )
                    {
                    iCurrentLevel.iSelected = itemCount-1;
                    }
                break;

            case EDirectionUp:
                iCurrentLevel.iSelected -= iVisibleColumns; // one row up
                if ( iCurrentLevel.iSelected < 0 )
                    {
                    iCurrentLevel.iSelected += (iRowCount*iVisibleColumns);
                    if ( iCurrentLevel.iSelected >= itemCount )
                        {
                        // Wrapping is about to move the cursor on empty spot.
                        // To be consistent with S60 app grid, move selection to the last item.
                        iCurrentLevel.iSelected = itemCount-1;
                        }
                    }
                break;

            case EDirectionDown:
                iCurrentLevel.iSelected += iVisibleColumns; // one row down
                if ( iCurrentLevel.iSelected >= itemCount )
                    {
                    if ( oldY < iRowCount-1 )
                        {
                        iCurrentLevel.iSelected = itemCount-1;
                        }
                    else
                        {
                        iCurrentLevel.iSelected %= (iRowCount*iVisibleColumns);
                        }
                    }
                break;

            case EDirectionReset:
                iCurrentLevel.iSelected = KDefaultSelection;
                break;

            case EDirectionNone:
                break;

            case EDirectionTouch:
                iCurrentLevel.iSelected = aSelected;
                break;

            }

        if ( iCurrentLevel.iSelected < 0 )
            {
            iCurrentLevel.iSelected = 0;
            }
        if ( iCurrentLevel.iSelected >= itemCount )
            {
            iCurrentLevel.iSelected = itemCount - 1;
            }
        }
    if (!iPointerAction)
        {
        TInt x = iCurrentLevel.iSelected % iVisibleColumns;
        TInt y = (iCurrentLevel.iSelected-x) / iVisibleColumns;
        ScrollToRow( y );
        }
    }


void CFSEmailUiLauncherGridVisualiser::MoveSelectorToCurrentItem( TDirection aDir )
    {
    FUNC_LOG;
    TInt count = iCurrentLevel.iItemVisualData.Count();
    if ( iCurrentLevel.iSelected < 0 || iCurrentLevel.iSelected >= count )
        {
        return;  // incorrect index
        }
    
    TAlfRealPoint curPos = iSelector->Pos().ValueNow(); // this is the wrapped value of the current position
    iSelector->SetPos( curPos, 0 ); // wrap position now

    // Calculate where are we heading
    CAlfVisual* selectedBase = iCurrentLevel.iItemVisualData[iCurrentLevel.iSelected].iBase;
    TPoint displayPos = selectedBase->LocalToDisplay( selectedBase->Pos().Target() );
    TPoint targetPos = iSelector->DisplayToLocal( displayPos );

    // Check if we need to wrap the selector over the edge of the screen
    TPoint ringWrapOffset( 0, 0 );
    const TInt KGridWrapWidth = (iVisibleColumns+2)*iColumnWidth;
    const TInt KGridWrapHeight = (iRowCount+2)*iRowHeight;

    if ( aDir == EDirectionRight && ( targetPos.iX <= curPos.iX || iCurrentLevel.iSelected == 0 ) )
        {
        ringWrapOffset.iX = KGridWrapWidth;
        }
    else if ( aDir == EDirectionLeft && ( targetPos.iX >= curPos.iX  || iCurrentLevel.iSelected == iCurrentLevel.iItems.Count()-1 ) )
        {
        ringWrapOffset.iX = -KGridWrapWidth;
        }
    else if ( aDir == EDirectionUp && targetPos.iY > curPos.iY )
        {
        ringWrapOffset.iY = -KGridWrapHeight;
        }
    else if ( aDir == EDirectionDown && targetPos.iY < curPos.iY )
        {
        ringWrapOffset.iY = KGridWrapHeight;
        }
    targetPos += ringWrapOffset;

    // Animate the movement to the new position
    TInt animTime = KSelectTransitionTimeMs;
    if ( aDir == EDirectionReset || aDir == EDirectionNone || aDir == EDirectionTouch )
        {
        animTime = KStartupAnimationTime;
        }
    iSelector->SetPos( targetPos, animTime );
    }

void CFSEmailUiLauncherGridVisualiser::FocusItem( TBool aHasFocus, TInt aItem )
    {
    FUNC_LOG;
    if ( iCurrentLevel.iItemVisualData.Count() <= aItem ||
         aItem < 0 )
        {
        // Invalid item index
        return;
        }

    if( aHasFocus && ( IsFocusShown() || iItemIdInButtonDownEvent.iItemId >= 0 ) )
        {
        TAlfTimedValue scaleValue;
        scaleValue.SetTarget( KScaleSelected, KIconScalingTransitionTimeMs );
        iCurrentLevel.iItemVisualData[aItem].iImage->SetScale( scaleValue );
        }
    else
        {
        TAlfTimedValue scaleValue;
        scaleValue.SetTarget( KScaleNotSelected, KIconScalingTransitionTimeMs * 2 );
        iCurrentLevel.iItemVisualData[aItem].iImage->SetScale( scaleValue );
        }
    }


void CFSEmailUiLauncherGridVisualiser::ScrollToRow( TInt aRow )
    {
    FUNC_LOG;
	const TInt KScrollTransitionTimeMs = KSelectTransitionTimeMs;
	TReal offset( 0.0 );

    if ( aRow >= iRowCount || aRow < 0 )
        {
        // Invalid row
        return;
        }

    if ( iFirstVisibleRow + iVisibleRows - 1 < aRow )
        {
        // Scroll downwards
        iFirstVisibleRow = aRow - iVisibleRows + 1 ;
        }
    else if ( iFirstVisibleRow > aRow )
        {
        // Scroll upwards
        if ( aRow == 0 )
            {
            iFirstVisibleRow = 0;
            }
        else
            {
            iFirstVisibleRow = aRow;
            }
        }


    offset = iFirstVisibleRow * iRowHeight;

    TAlfTimedPoint alfScrollOffset;
    alfScrollOffset.iY.SetTarget( offset , KScrollTransitionTimeMs );
    iCurrentLevel.iGridLayout->SetScrollOffset(alfScrollOffset);
    iScrollbarModel.SetFocusPosition(offset);
    TRAP_IGNORE( iScrollbar->SetModelL(&iScrollbarModel) );
    iScrollbar->DrawNow();
    }

void CFSEmailUiLauncherGridVisualiser::RefreshLauncherViewL()
    {
    FUNC_LOG;
    if ( iConstructionCompleted )
        {
        iDoubleClickLock = EFalse;
        TInt count = iCurrentLevel.iItemVisualData.Count();

        CreateModelL();
        PopulateL( iCurrentLevel );
        SetRingWrapLimits();
        if ( count != iCurrentLevel.iItemVisualData.Count() )
            {
            MoveSelection( EDirectionReset );
            }
        else
            {
            FocusItem( ETrue, iCurrentLevel.iSelected );
            }
        UpdateScrollBarRangeL();
        }
    }

TBool CFSEmailUiLauncherGridVisualiser::UiOperationLaunched()
    {
    FUNC_LOG;
    return iUiOperationLaunched;
    }

void CFSEmailUiLauncherGridVisualiser::PopulateL( TLevel& aLevel )
    {
    FUNC_LOG;

    if ( iConstructionCompleted )
        {
        for( TInt i = 0; i < aLevel.iItemVisualData.Count(); i++ )
            {
            aLevel.iItemVisualData[i].iBase->RemoveAndDestroyAllD();
            }

        aLevel.iItemVisualData.Reset();
        aLevel.iItems.Reset();

	    TRect mainPaneRect;
	    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);

	    TAknLayoutRect scrollBarRect;
	    scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::aid_size_touch_scroll_bar());
	    TRect gridRect = mainPaneRect;
	    gridRect.iBr.iX -= scrollBarRect.Rect().Width();

	    TInt var = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

	    TAknLayoutRect itemRect;
	    itemRect.LayoutRect(gridRect, AknLayoutScalable_Apps::cell_cmail_l_pane(var, 0, 0));

	    TRect itemrc = itemRect.Rect();
	    itemrc.SetRect(TPoint(0,0), itemRect.Rect().Size());

	    TAknLayoutRect gridIconRect;
	    gridIconRect.LayoutRect(itemrc, AknLayoutScalable_Apps::cell_cmail_l_pane_g1(var));

	    TAknLayoutText gridText;
	    gridText.LayoutText(itemrc, AknLayoutScalable_Apps::cell_cmail_l_pane_t1(0));

        if ( aLevel.iParent >= 0 )
            {
            iModel->FindChildren( aLevel.iParent, aLevel.iItems );

            for ( TInt i = 0; i < aLevel.iItems.Count(); i++ )
                {
                TItemVisualData newItem;

                newItem.iBase = CAlfAnchorLayout::AddNewL( *iControl, aLevel.iGridLayout );
                newItem.iBase->SetTactileFeedbackL( ETouchEventStylusDown,  ETouchFeedbackBasic );

                // Set anchors for text.
                newItem.iBase->SetAnchor(
                    EAlfAnchorTopLeft,
                    0,
                    EAlfAnchorOriginLeft,
                    EAlfAnchorOriginTop,
                    EAlfAnchorMetricAbsolute,
                    EAlfAnchorMetricAbsolute,
                    TAlfTimedPoint( gridText.TextRect().iTl.iX, gridText.TextRect().iTl.iY ) );// 0, gridIconSize+KTopMargin ) );
                newItem.iBase->SetAnchor(
                    EAlfAnchorBottomRight,
                    0,
                    EAlfAnchorOriginLeft,
                    EAlfAnchorOriginTop,
                    EAlfAnchorMetricAbsolute,
                    EAlfAnchorMetricAbsolute,
                    TAlfTimedPoint( gridText.TextRect().iBr.iX, gridText.TextRect().iBr.iY ) );//0, iRowHeight ) );

                // Set anchors for image
                newItem.iBase->SetAnchor(
                    EAlfAnchorTopLeft,
                    1,
                    EAlfAnchorOriginLeft,
                    EAlfAnchorOriginTop,
                    EAlfAnchorMetricAbsolute,
                    EAlfAnchorMetricAbsolute,
                    TAlfTimedPoint( gridIconRect.Rect().iTl.iX, gridIconRect.Rect().iTl.iY ) ); //-gridIconSize/2, KTopMargin ) );
                newItem.iBase->SetAnchor(
                    EAlfAnchorBottomRight,
                    1,
                    EAlfAnchorOriginLeft,
                    EAlfAnchorOriginTop,
                    EAlfAnchorMetricAbsolute,
                    EAlfAnchorMetricAbsolute,
                    TAlfTimedPoint( gridIconRect.Rect().iBr.iX, gridIconRect.Rect().iBr.iY ) ); //gridIconSize/2, gridIconSize+KTopMargin ) );

                newItem.iText = CAlfTextVisual::AddNewL( *iControl, newItem.iBase );
                newItem.iText->EnableShadow( EFalse );

				TRgb itemColor( KRgbGray );

			    // text #9 application grid unfocused application title texts #215
				if( AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),
					itemColor, KAknsIIDQsnTextColors,
					EAknsCIQsnTextColorsCG9 ) != KErrNone )
					{
					itemColor = gridText.Color();
					}

				newItem.iText->SetColor( itemColor );
                newItem.iText->SetTextL( *aLevel.iItems[i].iCaption );

                TAlfTimedValue opacity;
                opacity.SetValueNow ( KDefaultCaptionOpacity );
                newItem.iText->SetOpacity( opacity );

                newItem.iText->SetTextStyle( iAppUi.LayoutHandler()->FSTextStyleFromLayoutL(AknLayoutScalable_Apps::cell_cmail_l_pane_t1(var)).Id() );//FSTextStyleFromIdL( EFSFontTypeSmall )->Id() );
                newItem.iText->SetWrapping( CAlfTextVisual::ELineWrapTruncate );
                TAlfAlignHorizontal alfAlign;
                switch( gridText.Align() )
                    {
                    case ELeft: 
                        alfAlign = EAlfAlignHLeft;
                        break;
                    case ECenter:
                        alfAlign = EAlfAlignHCenter;
                        break;
                    case ERight:
                        alfAlign = EAlfAlignHRight;
                        break;
                    default:
                        alfAlign = EAlfAlignHCenter;
                    }
                newItem.iText->SetAlign( alfAlign, EAlfAlignVCenter );

                newItem.iImage = CAlfImageVisual::AddNewL( *iControl, newItem.iBase );
                newItem.iImage->SetScaleMode( CAlfImageVisual::EScaleFit );
                newItem.iImage->SetImage( TAlfImage( *aLevel.iItems[i].iIconTexture ) );
                newItem.iImage->SetFlag( EAlfVisualFlagManualSize );

                newItem.iImage->SetSize( gridIconRect.Rect().Size() );
                newItem.iImage->SetScale( KScaleNotSelected );

                User::LeaveIfError( aLevel.iItemVisualData.Append( newItem ) );
                }
            }

        // Set columns and rows
        iVisibleRows = AknLayoutScalable_Apps::cell_cmail_l_pane_ParamLimits(var).LastRow() + 1;
        iVisibleColumns = AknLayoutScalable_Apps::cell_cmail_l_pane_ParamLimits(var).LastColumn() + 1;

        iRowCount = ( iCurrentLevel.iItemVisualData.Count() + iVisibleColumns - 1 ) / iVisibleColumns;

        aLevel.iGridLayout->MoveToFront();
        }
    }

void CFSEmailUiLauncherGridVisualiser::SelectL()
	{
    FUNC_LOG;
	if ( !iAppUi.ViewSwitchingOngoing() )
		{
        iPointerAction = EFalse;
        iItemIdInButtonDownEvent.iItemId = KErrNotFound;
        UpdateFocusVisibility();

		CFSEmailLauncherItem* launcherItem =
		    iCurrentLevel.iItems[iCurrentLevel.iSelected].iLauncherItem;
		if ( launcherItem )
		    {
	        launcherItem->ExecuteActionL();
		    }
		else
		    {
		    iUiOperationLaunched = ETrue;
			switch ( iCurrentLevel.iItems[iCurrentLevel.iSelected].iId )
				{
				case EDefaultMailboxItem:
				case EOtherMailboxItems:
					{
					TMailListActivationData tmp;
					tmp.iFolderId = iCurrentLevel.iItems[iCurrentLevel.iSelected].iMailBoxInboxId;
					tmp.iMailBoxId = iCurrentLevel.iItems[iCurrentLevel.iSelected].iMailBoxId;
					const TPckgBuf<TMailListActivationData> pkgOut( tmp );
					iAppUi.ShowTitlePaneConnectionStatus();
					iAppUi.EnterFsEmailViewL( MailListId, KStartListWithFolderId, pkgOut );
					}
					break;
				case EDirectoryItem:
				    {
				    // TO prevent accidental double clicks of the directory item,
				    // prevents multiple RCL windows to be seen
                    if ( !iDoubleClickLock )
                        {
                        // Lock to make sure that wizard is not started twice in a row
                        iDoubleClickLock = ETrue;
                        RPointerArray<CFSMailBox> mailBoxes;
                        CleanupResetAndDestroyClosePushL( mailBoxes );
                        TFSMailMsgId id;
                        TInt err = iAppUi.GetMailClient()->ListMailBoxes(
                            id,
                            mailBoxes );

                        // Remove mailboxes that doesn't support RCL
                        for ( TInt i = mailBoxes.Count()-1; i >= 0 ; i-- )
                            {
                            if ( !TFsEmailUiUtility::IsRemoteLookupSupported( *mailBoxes[i] ) )
                                {
                                delete mailBoxes[i];
                                mailBoxes.Remove( i );
                                }
                            }

                        CFSMailBox* mailBox = NULL;
                        if( mailBoxes.Count() == 1 )
                            {
                            // Only one mailbox with RCL support so we use that
                            mailBox = mailBoxes[0];
                            }
                        else if( mailBoxes.Count() > 1 )
                            {
                            // Several mailboxes that support RCL so we need to
                            // ask the user which one to use
                            mailBox = ShowMailboxSelectionQueryL( mailBoxes );
                            }

                        if ( mailBox )
                            {
                            CFsDelayedLoader::InstanceL()->GetContactHandlerL()->LaunchRemoteLookupL( *mailBox );
                            }
                        iDoubleClickLock = EFalse;
                        CleanupStack::PopAndDestroy( &mailBoxes );
                        }
				    }
					break;
	            case ESettingsItem:
	                {
	                TInt tmp = 0;
	                const TPckgBuf<TInt> pkgBuf( tmp );
	      			iAppUi.EnterFsEmailViewL(
	      					SettingsViewId,
	      					TUid::Uid(KMailSettingsOpenMainList),
	      					pkgBuf );
	                }
	            	break;
	            case EAddNewMailboxItem:
	                {
                    // To prevent accidental double clicks of the wizard item
	                // wizard would crash without this - moved to function
	                    LaunchWizardL();
	                }
	            	break;
	            case EHelpItem:
	                {
                    // To prevent accidental double clicks of the help item
                    // Help app might crash without this
	                if ( !iDoubleClickLock )
	                    {
	                    iDoubleClickLock = ETrue;
	                    TFsEmailUiUtility::LaunchHelpL( KFSE_HLP_LAUNCHER_GRID );
	                    }
	                }
	            	break;
				default:
					return;
				}
		    }
		}
	}


void CFSEmailUiLauncherGridVisualiser::HandleForegroundEventL( TBool aForeground )
    {
    FUNC_LOG;

    UpdateFocusVisibility();

    // Toggle safety lock always when receiving foreground back.
    if ( aForeground && iDoubleClickLock && iFirstStartComplete )
        {
        iDoubleClickLock = EFalse;
        }
    UpdateGridOffset();
    }

void CFSEmailUiLauncherGridVisualiser::GetParentLayoutsL(
        RPointerArray<CAlfVisual>& aLayoutArray ) const
    {
    aLayoutArray.AppendL( iParentLayout );
    }

// hide or show CAlfVisuals ( used for activation or deactivation )
void CFSEmailUiLauncherGridVisualiser::FadeOut(TBool aDirectionOut)
	{
	if ( iParentLayout != NULL )
		{
	    TAlfTimedValue timedValue( 0, 0 );
	    if ( !aDirectionOut )
	        {
	        timedValue.SetTarget( 1, 0 );
	        }
	    iParentLayout->SetOpacity( timedValue );
		}
	}

// -----------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::ShowMailboxSelectionQueryL
// -----------------------------------------------------------------------------
CFSMailBox* CFSEmailUiLauncherGridVisualiser::ShowMailboxSelectionQueryL(
        const RPointerArray<CFSMailBox>& aMailBoxes )
    {
    FUNC_LOG;
    CDesCArrayFlat* array = new (ELeave) CDesCArrayFlat( 2 );
    CleanupStack::PushL( array );

    for( TInt i = 0; i < aMailBoxes.Count(); i++ )
        {
        array->AppendL( aMailBoxes[i]->GetName() );
        }

    TInt selectedOption;
    CAknListQueryDialog* dlg = new ( ELeave ) CAknListQueryDialog( &selectedOption );
    dlg->PrepareLC( R_FSEMAILUI_LAUNCHER_GRID_MAILBOX_SELECTION_DIALOG  );

    dlg->SetItemTextArray( array );
    dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );

    CFSMailBox* mailbox = NULL;
    if( dlg->RunLD() )
        {
        // safety check.
        if( selectedOption >= 0 &&
            selectedOption < aMailBoxes.Count() )
            {
            mailbox = aMailBoxes[selectedOption];
            }
        }

    CleanupStack::PopAndDestroy( array );
    return mailbox;
    }

void CFSEmailUiLauncherGridVisualiser::LaunchWizardL()
    {
    FUNC_LOG;
    // Start wizard.

    // Make sure that FSMailServer is running, so that the mailbox is added
    // also to MCE. It should be enough to do it here, because it takes some
    // time from wizard startup until the actual mailbox is created, so the
    // serve has some time to get itself up and running before that.
    TFsEmailUiUtility::EnsureFsMailServerIsRunning( iEikonEnv->WsSession() );
    //we are calling DoFirstStarL() method because in case User goes to GeneralSettings->Email
    //iAiwSHandler isnt constructed and in that case EmailUi panics
    if ( !iConstructionCompleted )
        {
        DoFirstStartL();
        }

    if ( ! iLaunchWizardExecuted  ) // prevent reentrant calling
        {
        iLaunchWizardExecuted = ETrue;
        TRAPD( err, iAiwSHandler->ExecuteServiceCmdL( KAiwCmdSettingWizardFsEmail.iUid,
                                          iAiwSHandler->InParamListL(),
                                          iAiwSHandler->OutParamListL() ) );
       // ExecuteServiceCmdL is synchronous - uses CActiveSchedulerWait
        iLaunchWizardExecuted = EFalse;
        User::LeaveIfError( err );
        }

    }

void CFSEmailUiLauncherGridVisualiser::GoToInboxL( TFSMailMsgId& aMailboxId, TFSMailMsgId& aMailboxInboxId )
    {
    FUNC_LOG;
	TMailListActivationData tmp;

	tmp.iMailBoxId = aMailboxId;
	tmp.iFolderId = aMailboxInboxId;

	const TPckgBuf<TMailListActivationData> pkgOut( tmp );

	iAppUi.EnterFsEmailViewL( MailListId, KStartListWithFolderId, pkgOut );
    }

void CFSEmailUiLauncherGridVisualiser::RescaleIconsL()
	{
    FUNC_LOG;
    if ( iConstructionCompleted )
        {
		TRect mainPaneRect;
	    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
	    TInt var = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

	    TAknLayoutRect scrollBarRect;
	    scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::aid_size_touch_scroll_bar());
	    TRect gridRect = mainPaneRect;
	    gridRect.iBr.iX -= scrollBarRect.Rect().Width();

	    TAknLayoutRect itemRect;
	    itemRect.LayoutRect(gridRect, AknLayoutScalable_Apps::cell_cmail_l_pane(var, 0, 0));

	    TAknLayoutRect gridIconRect;
	    gridIconRect.LayoutRect(itemRect.Rect(), AknLayoutScalable_Apps::cell_cmail_l_pane_g1(var));

	   	//TInt gridIconSize = iAppUi.LayoutHandler()->GridIconSize();
		TSize iconSize = gridIconRect.Rect().Size();
		//iconSize.SetSize( gridIconSize, gridIconSize );

        // Scale bitmaps
        for( TInt i = 0 ; i < iIconArray.Count() ; i++ )
            {
            iIconArray[i]->Size().SetSize( iconSize.iWidth, iconSize.iHeight );
            }
        // Scale visuals
        for ( TInt item = 0; item < iCurrentLevel.iItemVisualData.Count() ; item++ )
            {
            iCurrentLevel.iItemVisualData[item].iImage->SetSize( iconSize );
            }
        }
	}

void CFSEmailUiLauncherGridVisualiser::AddItemToModelL( CFSEmailLauncherItem* aItem, TInt aPluginArrayIndex )
    {
    FUNC_LOG;
    if ( iConstructionCompleted && aItem->IsVisible() )
        {
        HBufC* launcherItemText = aItem->Caption( EFalse ).AllocLC();
        CAknIcon* launcherItemIcon = aItem->Icon();

        if ( launcherItemIcon )
            {
            TRect mainPaneRect;
            AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);

            TAknLayoutRect scrollBarRect;
            scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::aid_size_touch_scroll_bar());
            TRect gridRect = mainPaneRect;
            gridRect.iBr.iX -= scrollBarRect.Rect().Width();

            TInt var = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

            TAknLayoutRect itemRect;
            itemRect.LayoutRect(gridRect, AknLayoutScalable_Apps::cell_cmail_l_pane(var, 0, 0));

            TAknLayoutRect gridIconRect;
            gridIconRect.LayoutRect(itemRect.Rect(), AknLayoutScalable_Apps::cell_cmail_l_pane_g1(var));

            TSize iconSize = gridIconRect.Rect().Size();

            const CFbsBitmap* bitmap = launcherItemIcon->Bitmap();
            const CFbsBitmap* mask = launcherItemIcon->Mask();

			// First add plugin id and icon id pair to array, needed in provide bitmap
			TPluginIdIconIdPair idPair;
			idPair.iPluginArrayIndex = aPluginArrayIndex;
			idPair.iIconId = iPluginTextureId;
			iPluginIdIconIdPairs.Append( idPair );

			// Create texture, goes to provide bitmap
			CAlfTexture* texture = &CAlfStatic::Env().TextureManager().CreateTextureL( iPluginTextureId, this, EAlfTextureFlagDefault );
			// Update texture id
			iPluginTextureId++; // Id is updated dynamically
			// Set initial size
  			texture->Size().SetSize( iconSize.iHeight, iconSize.iWidth );
           iModel->AddL(
                EShortcut,
                aItem->Id(),
                *launcherItemText,
                *texture,
                0,
                aItem );
	        iIconArray.AppendL( texture );
            }
        else
            {
            CAlfTexture* texture = &iAppUi.FsTextureManager()->TextureByIndex( EGridInboxTexture );

            iModel->AddL(
                EShortcut,
                aItem->Id(),
                *launcherItemText,
                *texture,
                0,
                aItem );
            iIconArray.AppendL( texture );
            }

        CleanupStack::PopAndDestroy( launcherItemText );
        }
    }

void CFSEmailUiLauncherGridVisualiser::VisualLayoutUpdatedL()
    {
    FUNC_LOG;
    if ( iConstructionCompleted )
        {
	    iCurrentLevel.iParent = 0;

	    TRect mainPaneRect;
	    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
	    TInt var = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

	    TAknLayoutRect scrollBarRect;

	    scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Apps::scroll_pane_cp03());

	    TRect gridRect = mainPaneRect;
	    gridRect.iBr.iX -= scrollBarRect.Rect().Width();

	    TAknLayoutRect cellRect;
	    cellRect.LayoutRect(gridRect, AknLayoutScalable_Apps::aid_size_cell_cmail_l(var, 0, 0));

	    TAknLayoutRect itemRect;
	    itemRect.LayoutRect(gridRect, AknLayoutScalable_Apps::cell_cmail_l_pane(var, 0, 0));

	    TAknLayoutRect gridIconRect;
	    gridIconRect.LayoutRect(itemRect.Rect(), AknLayoutScalable_Apps::cell_cmail_l_pane_g1(var));

	    TAknLayoutRect selectorRect;
	    selectorRect.LayoutRect(itemRect.Rect(), AknLayoutScalable_Apps::grid_highlight_pane_cp018(var));

	    CFSEmailUiLayoutHandler* layoutHandler = iAppUi.LayoutHandler();
	    iSelectorImageVisual->SetSize( selectorRect.Rect().Size() );

	    TSize displaySize = mainPaneRect.Size();

	    TInt columns = iVisibleColumns = AknLayoutScalable_Apps::cell_cmail_l_pane_ParamLimits(var).LastColumn() + 1; 
	    TInt rows = iVisibleRows = AknLayoutScalable_Apps::cell_cmail_l_pane_ParamLimits(var).LastRow() + 1; 

        iCurrentLevel.iGridLayout->SetSize( gridRect.Size() );
        iCurrentLevel.iGridLayout->SetColumnsL( columns );
        iCurrentLevel.iGridLayout->SetRowsL( rows );

        PopulateL( iCurrentLevel );
        UpdateScrollBarRangeL();

        TInt scrollbarWidth = scrollBarRect.Rect().Width();
        if( iRowCount > iVisibleRows )
            {
            iScrollbar->MakeVisible(ETrue);
            }
        else
            {
            iScrollbar->MakeVisible(EFalse);
            }

        TInt scrollbarTopLeftX = displaySize.iWidth - scrollbarWidth;
        TInt scrollbarTopLeftY = 0;
        TInt scrollbarBottomRightX = displaySize.iWidth;
        TInt scrollbarBottomRightY = displaySize.iHeight;
        TInt gridTopLeftX = 0;
        TInt gridTopLeftY = 0;
        TInt gridBottomRightX = displaySize.iWidth - scrollbarWidth;
        TInt gridBottomRightY = displaySize.iHeight;

        if ( AknLayoutUtils::LayoutMirrored() )
            {
            // Mirrored layout
            scrollbarTopLeftX = 0;
            scrollbarTopLeftY = 0;
            scrollbarBottomRightX = scrollbarWidth;
            scrollbarBottomRightY = displaySize.iHeight;
            gridTopLeftX = scrollbarWidth;
            gridTopLeftY = 0;
            gridBottomRightX = displaySize.iWidth;
            gridBottomRightY = displaySize.iHeight;
            }

        // Set anchors for the scroll bar
        iWidgetLayout->SetAnchor(
            EAlfAnchorTopLeft,
            0,
            EAlfAnchorOriginLeft,
            EAlfAnchorOriginTop,
            EAlfAnchorMetricAbsolute,
            EAlfAnchorMetricAbsolute,
            TAlfTimedPoint( scrollbarTopLeftX, scrollbarTopLeftY ) );
        iWidgetLayout->SetAnchor(
            EAlfAnchorBottomRight,
            0,
            EAlfAnchorOriginLeft,
            EAlfAnchorOriginTop,
            EAlfAnchorMetricAbsolute,
            EAlfAnchorMetricAbsolute,
            TAlfTimedPoint( scrollbarBottomRightX, scrollbarBottomRightY ) );

        // Set anchors for the grid
        iWidgetLayout->SetAnchor(
            EAlfAnchorTopLeft,
            1,
            EAlfAnchorOriginLeft,
            EAlfAnchorOriginTop,
            EAlfAnchorMetricAbsolute,
            EAlfAnchorMetricAbsolute,
            TAlfTimedPoint( gridTopLeftX, gridTopLeftY ) );
        iWidgetLayout->SetAnchor(
            EAlfAnchorBottomRight,
            1,
            EAlfAnchorOriginLeft,
            EAlfAnchorOriginTop,
            EAlfAnchorMetricAbsolute,
            EAlfAnchorMetricAbsolute,
            TAlfTimedPoint( gridBottomRightX, gridBottomRightY ) );

        iParentLayout->UpdateChildrenLayout();

        TSize gridSize = iCurrentLevel.iGridLayout->Size().IntTarget().AsSize();
        iColumnWidth = gridSize.iWidth / iVisibleColumns;
        iRowHeight = gridSize.iHeight / iVisibleRows;

        // Selector ring wrap limits can be calculated when row and column sizes are known.
        SetRingWrapLimits();
        MoveSelection( EDirectionNone );

        TRect scrollbarRect;
        scrollbarRect.SetRect(scrollbarTopLeftX, scrollbarTopLeftY, scrollbarBottomRightX, scrollbarBottomRightY);
        scrollbarRect.Move(mainPaneRect.iTl);
        iScrollbar->SetRect(scrollbarRect);
        iScrollbar->DrawDeferred();
        iRefreshNeeded = EFalse;
        }
    }

void CFSEmailUiLauncherGridVisualiser::SetRingWrapLimits()
    {
    FUNC_LOG;
    if ( iConstructionCompleted )
        {
        iRingMovementXFuncMappingDataProvider.SetStart(-iColumnWidth);
        iRingMovementXFuncMappingDataProvider.SetEnd((iVisibleColumns+1)*iColumnWidth);
        iRingMovementYFuncMappingDataProvider.SetStart(-iRowHeight);
        iRingMovementYFuncMappingDataProvider.SetEnd((iRowCount+1)*iRowHeight);

        iRingMovementXFunc->SetMappingTableValues( -(iVisibleColumns+2)*iColumnWidth, (iVisibleColumns*2+2)*iColumnWidth, &iRingMovementXFuncMappingDataProvider );
        iRingMovementYFunc->SetMappingTableValues( -(iRowCount+2)*iRowHeight, (iRowCount*2+2)*iRowHeight, &iRingMovementYFuncMappingDataProvider );
        }
    }

void CFSEmailUiLauncherGridVisualiser::DisplayProductInfoL()
	{
    FUNC_LOG;
	//Load the texts from resource
	HBufC* text_1 = StringLoader::LoadLC( R_DISCLAIMER_PART_1 );
	HBufC* text_2 = StringLoader::LoadLC( R_DISCLAIMER_PART_2 );
    HBufC* text_3 = StringLoader::LoadLC( R_DISCLAIMER_PART_3 );
    HBufC* text_4 = StringLoader::LoadLC( R_DISCLAIMER_PART_4 );
    HBufC* text_5 = StringLoader::LoadLC( R_DISCLAIMER_PART_5 );
    HBufC* text_6 = StringLoader::LoadLC( R_DISCLAIMER_PART_6 );
    HBufC* text_7 = StringLoader::LoadLC( R_DISCLAIMER_PART_7 );
    HBufC* text_8 = StringLoader::LoadLC( R_DISCLAIMER_PART_8 );
    HBufC* text_9 = StringLoader::LoadLC( R_DISCLAIMER_PART_9 );
    HBufC* text_10 = StringLoader::LoadLC( R_DISCLAIMER_PART_10 );
    HBufC* text_11 = StringLoader::LoadLC( R_DISCLAIMER_PART_11 );

    //Create a buffer for dialog content
    HBufC* text = HBufC::NewLC( text_1->Length() + text_2->Length() + text_3->Length() +
                                text_4->Length() + text_5->Length() + text_6->Length() +
                                text_7->Length() + text_8->Length() + text_9->Length() +
                                text_10->Length() + text_11->Length() );
    //Copy the disclaimer text parts to dialog content
    text->Des() += *text_1;
    text->Des() += *text_2;
    text->Des() += *text_3;
    text->Des() += *text_4;
    text->Des() += *text_5;
    text->Des() += *text_6;
    text->Des() += *text_7;
    text->Des() += *text_8;
    text->Des() += *text_9;
    text->Des() += *text_10;
    text->Des() += *text_11;

    CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *text );
    CleanupStack::PopAndDestroy( text );
    CleanupStack::PopAndDestroy( text_11 );
    CleanupStack::PopAndDestroy( text_10 );
    CleanupStack::PopAndDestroy( text_9 );
    CleanupStack::PopAndDestroy( text_8 );
    CleanupStack::PopAndDestroy( text_7 );
    CleanupStack::PopAndDestroy( text_6 );
    CleanupStack::PopAndDestroy( text_5 );
    CleanupStack::PopAndDestroy( text_4 );
    CleanupStack::PopAndDestroy( text_3 );
    CleanupStack::PopAndDestroy( text_2 );
    CleanupStack::PopAndDestroy( text_1 );
    dlg->PrepareLC( R_DISCLAIMER_MESSAGE );

    //Create heading for the dialog, load and create the heading text
    CAknPopupHeadingPane* headingPane = dlg->Heading();
    HBufC* appName = StringLoader::LoadLC(R_FSEMAIL_APP_NAME );
    HBufC* version = StringLoader::LoadLC( R_DISCLAIMER_FSEMAIL_VERSION );
    HBufC* title = HBufC::NewLC(version->Length() + appName->Length() + 1);
    title->Des() += *appName;
    title->Des() += KSpace;
    title->Des() += *version;
    headingPane->SetTextL( *title );
    CleanupStack::PopAndDestroy( title );
    CleanupStack::PopAndDestroy( version );
    CleanupStack::PopAndDestroy( appName );
    dlg->ButtonGroupContainer().SetCommandSetL( R_AVKON_SOFTKEYS_OK_EMPTY );
    //show dialog
    TInt ret = dlg->RunLD();
	}

void CFSEmailUiLauncherGridVisualiser::HandleDynamicVariantSwitchL( CFsEmailUiViewBase::TDynamicSwitchType aType )
	{
    FUNC_LOG;

	CFsEmailUiViewBase::HandleDynamicVariantSwitchL( aType );

    if ( iConstructionCompleted )
        {
        iItemIdInButtonDownEvent.iItemId = KErrNotFound;

	    TRect mainPaneRect;
	    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
	    TInt var = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

	    TAknLayoutRect scrollBarRect;
	    scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::aid_size_touch_scroll_bar());
	    TRect gridRect = mainPaneRect;
	    gridRect.iBr.iX -= scrollBarRect.Rect().Width();

	    TAknLayoutRect cellRect;
	    cellRect.LayoutRect(gridRect, AknLayoutScalable_Apps::aid_size_cell_cmail_l(var, 0, 0));

		TSize displaySize = cellRect.Rect().Size();
        iParentLayout->SetSize( displaySize );
        RescaleIconsL();
        VisualLayoutUpdatedL();

        UpdateFocusVisibility();
        
        // Stylus pop-up menu is closed during Layout switching
        if( iStylusPopUpMenuLaunched )
            {
            TRAP_IGNORE(iStylusPopUpMenu->HandleControlEventL(iCoeControl,
                    MCoeControlObserver::EEventRequestExit ));

            iStylusPopUpMenuLaunched = EFalse;
            }
       
        }
 	}

void CFSEmailUiLauncherGridVisualiser::HandleDynamicVariantSwitchOnBackgroundL( CFsEmailUiViewBase::TDynamicSwitchType aType )
    {
    FUNC_LOG;
    iRefreshNeeded = ETrue;

    CFsEmailUiViewBase::HandleDynamicVariantSwitchOnBackgroundL( aType );
    }

void CFSEmailUiLauncherGridVisualiser::HandleContentChangeL()
    {
    FUNC_LOG;
    if ( iConstructionCompleted )
        {
        CreateModelL();
        if ( iAppUi.CurrentActiveView() == this )
            {
            VisualLayoutUpdatedL();
            }
        else
            {
            iRefreshNeeded = ETrue;
            }
        }
    }

void CFSEmailUiLauncherGridVisualiser::ConstructScrollbarL( CAlfLayout* aParent )
	{
    FUNC_LOG;
	CAlfLayout::AddNewL(*iControl, aParent);
	iScrollbar = new (ELeave) CAknDoubleSpanScrollBar(0);
	iScrollbar->ConstructL(ETrue, this, 0, CEikScrollBar::EVertical, 1000);
    TRect mainPaneRect;
    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
    TRect scrollbarRect = aParent->DisplayRectTarget();
    scrollbarRect.Move(mainPaneRect.iTl);
    iScrollbar->SetRect(scrollbarRect);

    iScrollbar->MakeVisible(EFalse);
    iScrollbar->SetModelL(&iScrollbarModel);
	}

void CFSEmailUiLauncherGridVisualiser::UpdateScrollBarRangeL()
	{
    FUNC_LOG;

    TRect mainPaneRect;
    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
    TAknLayoutRect scrollBarRect;
    scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::aid_size_touch_scroll_bar());

    iScrollbarModel.SetScrollSpan(iRowCount * (scrollBarRect.Rect().Height() / iVisibleRows));
    iScrollbarModel.SetWindowSize(scrollBarRect.Rect().Height());  
	iScrollbarModel.SetFocusPosition(iFirstVisibleRow);
	iScrollbar->SetModelL(&iScrollbarModel);
	iScrollbar->DrawNow();
	}

void CFSEmailUiLauncherGridVisualiser::HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType)
    {
    FUNC_LOG;
    if( iPhysics )
        {
        iPhysics->StopPhysics();
        iPhysics->ResetFriction();
        }
    
    if (aScrollBar == iScrollbar)
         {
         switch( aEventType )
             {
             case EEikScrollHome :
                 //Jump to beginning
                 break;
             case EEikScrollEnd :
                 //Jump to end
                 break;
             default:
                 iScrolled = ETrue;
                 iAppUi.SetFocusVisibility( EFalse );
                 if ( iSelector )
                     {
                     TAlfTimedValue selectorOpacity;
                     selectorOpacity.SetValueNow( 0 );
                     iSelector->SetOpacity( selectorOpacity );
                     }                 
                 iFirstVisibleRow = iCurrentLevel.iParentPos.iY/iRowHeight;
                 TReal offset = aScrollBar->ThumbPosition() + 1;
                 TAlfTimedPoint alfScrollOffset;
                 alfScrollOffset.iY.SetTarget( offset , 0);
				 iCurrentLevel.iGridLayout->SetScrollOffset(alfScrollOffset);
                 iCurrentLevel.iParentPos.iY = offset;
                 break;
             }
         }
    }

void CFSEmailUiLauncherGridVisualiser::UpdateLauncherItemListL()
    {
    FUNC_LOG;

    // Read info about all implementations into infoArray
    RImplInfoPtrArray infoArray;
    CleanupResetAndDestroyClosePushL( infoArray );
    CFSEmailLauncherItem::ListAllImplementationsL( infoArray );

    RArray<TBool> itemsFoundArray;
    CleanupClosePushL( itemsFoundArray );

    itemsFoundArray.ReserveL( iLauncherItemUids.Count() );
    for ( TInt i = 0; i < iLauncherItemUids.Count(); i++ )
        {
        itemsFoundArray.Append( EFalse );
        }

    // Iterate through all launcher item implementations in info array
    TInt const infoCount = infoArray.Count();
    for ( TInt infoIndex = 0; infoIndex < infoCount; infoIndex++ )
        {
        TUid implementationUid = infoArray[infoIndex]->ImplementationUid();

        // Check whether item can be found from current laucher items
        TBool itemFound = EFalse;
        for ( TInt itemIndex = 0; itemIndex < iLauncherItemUids.Count(); itemIndex++ )
            {
            if ( iLauncherItemUids[itemIndex] == implementationUid )
                {
                itemsFoundArray[itemIndex] = ETrue;
                itemFound = ETrue;
                break;
                }
            }

        if ( !itemFound )
            {
            // Add new item to the end of the laucher item array
            CFSEmailLauncherItem* launcherItem = NULL;
            TRAPD( error, launcherItem = CFSEmailLauncherItem::NewL( implementationUid, this ) );
            if ( error == KErrNone )
                {
                iLauncherItems.Append( launcherItem );
                iLauncherItemUids.Append( implementationUid );
                }
            }
        }

    // Remove all launcher items not found from the info array
    for ( TInt i = itemsFoundArray.Count() - 1 ; i >= 0; --i )
        {
        if ( !itemsFoundArray[i] )
            {
            delete iLauncherItems[i];
            iLauncherItems.Remove( i );
            iLauncherItemUids.Remove( i );
            }
        }

    // Clean up
    CleanupStack::Pop( &itemsFoundArray );
    itemsFoundArray.Close();
    CleanupStack::PopAndDestroy( &infoArray );
    }

/**
 * Sets application title when leaving this view
 */
void CFSEmailUiLauncherGridVisualiser::SetDefaultStatusPaneTextL()
	{
    FUNC_LOG;
	iAppUi.ResetTitlePaneTextL();
	}

void CFSEmailUiLauncherGridVisualiser::SetWizardWaitnoteShown( TBool aWaitnoteShown )
    {
    FUNC_LOG;
    iWizardWaitnoteShown = aWaitnoteShown;
    }

/**
 * Check status of all configured mailboxes
 */
TFSLauncherGridMailboxStatus CFSEmailUiLauncherGridVisualiser::CheckMailboxStatusL()
    {
    FUNC_LOG;
    RPointerArray<CFSMailBox> mailBoxes;
    CleanupResetAndDestroyClosePushL( mailBoxes );
    TFSMailMsgId id;
    TInt err = iAppUi.GetMailClient()->ListMailBoxes(
        id,
        mailBoxes );

    TFSLauncherGridMailboxStatus returnStatus;
    returnStatus.iMailboxCount = mailBoxes.Count();
    // Reset counters
    returnStatus.iMailboxesOnline = returnStatus.iMailboxesOffline = returnStatus.iMailboxesSyncing = 0;

    for ( TInt i = 0; i < mailBoxes.Count(); i++ )
        {
        // First check online/offline status
        TFSMailBoxStatus onOffStatus = mailBoxes[i]->GetMailBoxStatus();
        if( onOffStatus == EFSMailBoxOffline )
            {
            returnStatus.iMailboxesOffline++;
            }
        else if( onOffStatus == EFSMailBoxOnline )
            {
            returnStatus.iMailboxesOnline++;
            }

        // Then check sync state
        TSSMailSyncState latestSyncstate = mailBoxes[i]->CurrentSyncState();
        if( latestSyncstate == InboxSyncing ||
            latestSyncstate == StartingSync ||
            latestSyncstate == EmailSyncing )
            {
            returnStatus.iMailboxesSyncing++;
            }
        }

    CleanupStack::PopAndDestroy( &mailBoxes );
    return returnStatus;
    }

// Bitmap provider for grid ecom plugins icons
void CFSEmailUiLauncherGridVisualiser::ProvideBitmapL(TInt aId, CFbsBitmap*& aBitmap, CFbsBitmap*& aMaskBitmap)
	{
    FUNC_LOG;
    TRect mainPaneRect;
    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
    TInt var = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

    TAknLayoutRect scrollBarRect;
    scrollBarRect.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::aid_size_touch_scroll_bar());
    TRect gridRect = mainPaneRect;
    gridRect.iBr.iX -= scrollBarRect.Rect().Width();

    TAknLayoutRect itemRect;
    itemRect.LayoutRect(gridRect, AknLayoutScalable_Apps::cell_cmail_l_pane(var, 0, 0));

    TAknLayoutRect gridIconRect;
    gridIconRect.LayoutRect(itemRect.Rect(), AknLayoutScalable_Apps::cell_cmail_l_pane_g1(var));

	CAknIcon* launcherItemIcon(0);
	for ( TInt i=0; i<iPluginIdIconIdPairs.Count(); i++ )
		{
		if ( aId == iPluginIdIconIdPairs[i].iIconId )
			{
			launcherItemIcon = iLauncherItems[iPluginIdIconIdPairs[i].iPluginArrayIndex]->Icon();
			}
		}

	if ( launcherItemIcon )
		{
		// Set bitmap size
		TSize iconSize = gridIconRect.Rect().Size();
		if( launcherItemIcon->Bitmap() )
            {
            AknIconUtils::DisableCompression( launcherItemIcon->Bitmap() );
            AknIconUtils::SetSize( launcherItemIcon->Bitmap(), iconSize, EAspectRatioPreserved );
            }
        if( launcherItemIcon->Mask() )
            {
            AknIconUtils::DisableCompression( launcherItemIcon->Mask());
            AknIconUtils::SetSize( launcherItemIcon->Mask(), iconSize, EAspectRatioPreserved );
            }
        // Create duplicate sof original for alf
        CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
     	bitmap->Duplicate( launcherItemIcon->Bitmap()->Handle() );
	    CFbsBitmap* mask = new (ELeave) CFbsBitmap;
     	mask->Duplicate( launcherItemIcon->Mask()->Handle() );

        aBitmap = bitmap;
  		aMaskBitmap = mask;
		}
	else
		{
		User::Leave(KErrNotFound); // Leave as icon is not found, should not go here
		}
	}

void CFSEmailUiLauncherGridVisualiser::SetRefreshNeeded()
	{
    FUNC_LOG;
	iRefreshNeeded = ETrue;
	iDoubleClickLock = EFalse;
	}

TReal32 CFSEmailUiLauncherGridVisualiser::TRingMovementFuncMappingDataProvider::MapValue(TReal32 aValue, TInt /*aMode*/) const
    {
    FUNC_LOG;
    AlfUtil::WrapValue(aValue, iStart, iEnd);
    return aValue;
    }

void CFSEmailUiLauncherGridVisualiser::DetachSelectorMappingFunctions()
    {
    FUNC_LOG;
    if ( iSelector )
        {
        TAlfTimedPoint selectorPos;
        selectorPos.iX.SetMappingFunctionIdentifier( 0 );
        selectorPos.iY.SetMappingFunctionIdentifier( 0 );
        iSelector->SetPos( selectorPos );
        }
    }


// -----------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::UpdateFocusVisibility()
// Updates the selector and the text color of a focused item.
// -----------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::UpdateFocusVisibility()
    {
    const TBool showFocus =	( IsFocusShown() ||
							  iItemIdInButtonDownEvent.iItemId >= 0 );

    // Update the selector.
    if ( iSelector )
        {
        TAlfTimedValue selectorOpacity;

        if ( showFocus )
            {
            selectorOpacity.SetValueNow( 1 );
            }
        else
            {
            selectorOpacity.SetValueNow( 0 );
            }

        iSelector->SetOpacity( selectorOpacity );
        }

    // Update the text color of the previously and newly selected items. 
	TRgb normalColor( KRgbGray );
	TRgb focusedColor( KRgbGray );

	if ( ( AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), normalColor,
								      KAknsIIDQsnTextColors,
								      EAknsCIQsnTextColorsCG9 ) != KErrNone ) ||
		 ( AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), focusedColor,
									  KAknsIIDQsnTextColors,
									  EAknsCIQsnTextColorsCG11 ) != KErrNone ) )
		{
		// No colors available.
		return;
		}

	CAlfTextVisual* textVisual = NULL;
	const TInt itemCount( iCurrentLevel.iItemVisualData.Count() );

	// Set the colors of the captions not focused to normal and if an item is
	// focused, set the color of its caption using the highlighted theme color.
	for ( TInt i = 0; i < itemCount; ++i )
		{
		textVisual = iCurrentLevel.iItemVisualData[i].iText;

		if ( textVisual )
			{
		    if ( showFocus && iCurrentLevel.iSelected == i )
		        {
                textVisual->SetColor( focusedColor );
		        }
		    else
		        {
                textVisual->SetColor( normalColor );
		        }
			}
		}
    }


void CFSEmailUiLauncherGridVisualiser::FlipStateChangedL( TBool aKeyboardFlipOpen )
    {
    CFsEmailUiViewBase::FlipStateChangedL( aKeyboardFlipOpen );
    UpdateFocusVisibility();
    }

void CFSEmailUiLauncherGridVisualiser::MailboxDeletionComplete()
    {
    TRAP_IGNORE( HandleContentChangeL() );
    }

void CFSEmailUiLauncherGridVisualiser::FocusVisibilityChange( TBool aVisible )
	{
    CFsEmailUiViewBase::FocusVisibilityChange( aVisible );
    UpdateFocusVisibility();
    ResizeItemIcon( !aVisible );
	}

// -----------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::ViewPositionChanged
// From MAknPhysicsObserver
// -----------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::ViewPositionChanged(
        const TPoint& aNewPosition,
        TBool /*aDrawNow*/,
        TUint /*aFlags*/ )
    {
    FUNC_LOG;

    // controls must be created first
    if ( !iConstructionCompleted )
        {
        return;
        }

    TRect mainPaneRect;
    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
    iCurrentLevel.iParentPos.iY = aNewPosition.iY - mainPaneRect.Height()/2;
    TAlfTimedPoint alfScrollOffset;
    alfScrollOffset.iY.SetTarget( iCurrentLevel.iParentPos.iY , 0 );
    iCurrentLevel.iGridLayout->SetScrollOffset(alfScrollOffset);
    iScrollbarModel.SetFocusPosition( iCurrentLevel.iParentPos.iY );
    TRAP_IGNORE( iScrollbar->SetModelL(&iScrollbarModel) );
    iScrollbar->DrawNow();
    iFirstVisibleRow = iCurrentLevel.iParentPos.iY/iRowHeight;
    if ( iFirstVisibleRow < 0 )
        {
        iFirstVisibleRow = 0;
        }
    else if ( iFirstVisibleRow > iRowCount )
        {
        iFirstVisibleRow = iRowCount;
        }
    }

// -----------------------------------------------------------------------------
// CNcsComposeViewContainer::PhysicEmulationEnded
// From MAknPhysicsObserver
// -----------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::PhysicEmulationEnded()
    {
    FUNC_LOG;
    }

// -----------------------------------------------------------------------------
// CNcsComposeViewContainer::ViewPosition
// From MAknPhysicsObserver
// -----------------------------------------------------------------------------
//
TPoint CFSEmailUiLauncherGridVisualiser::ViewPosition() const
    {
    FUNC_LOG;
    TRect mainPaneRect;
    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
    TInt current = iCurrentLevel.iParentPos.iY;
    TInt viewCentre = mainPaneRect.Size().iHeight / 2;
    TPoint point( 0, current + viewCentre );
    return point;
    }

// ----------------------------------------------------------------------------
// LaunchStylusPopupMenuL()
// Launches and displays the pop-up menu invoked by a long tap event.
// ----------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::LaunchStylusPopupMenu(
	const TInt aItemId )
	{
    TInt count = iCurrentLevel.iItemVisualData.Count();
    if ( aItemId < 0 || aItemId >= count )
        {
        return;  // incorrect index
        }
    
    count = iCurrentLevel.iItems.Count();
    if ( aItemId < 0 || aItemId >= count )
        {
        return;  // incorrect index
        }
	// Get the ID of the mailbox in case the user wants to delete it.
	iMailboxToDelete = iCurrentLevel.iItems[aItemId].iMailBoxId;

	// Get the item position and use it to determine the position of the menu.
	const TRect rect(
		iCurrentLevel.iItemVisualData[aItemId].iBase->DisplayRect() );
	TPoint position( rect.iTl.iX + rect.Width() / 2,
					 rect.iTl.iY + rect.Height() / 2 );
	iStylusPopUpMenu->SetPosition( position );

	// Display the menu.
	iStylusPopUpMenu->ShowMenu();
	iStylusPopUpMenuLaunched = ETrue;
	}

void CFSEmailUiLauncherGridVisualiser::HandleAppForegroundEventL( TBool aForeground )
    {
    FUNC_LOG;
    
    // If the view is not visible try to visualise it after a while
    if ( aForeground && !iWasActiveControlGroup )
        {
        iStartupCallbackTimer->Cancel(); // just in case
        iStartupCallbackTimer->SetPriority( CActive::EPriorityIdle );
        iStartupCallbackTimer->Start( 200 );
        }

	UpdateGridOffset();
    CFsEmailUiViewBase::HandleAppForegroundEventL( aForeground );	
    }

// ----------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::TimerEventL()
// Fire timer callback
// ----------------------------------------------------------------------------
void CFSEmailUiLauncherGridVisualiser::TimerEventL( CFSEmailUiGenericTimer* /* aTriggeredTimer */ )
    {
    FUNC_LOG;

    // if view is still active then 
    if ( iAppUi.CurrentActiveView() && iAppUi.CurrentActiveView()->Id() == Id() )	  
        {
        iWasActiveControlGroup = ETrue;
        CFsEmailUiViewBase::HandleAppForegroundEventL( ETrue );
        }

    iStartupCallbackTimer->Cancel();
    }

// ---------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::UpdatePhysicsL()
// ---------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::UpdatePhysicsL()
    {
    FUNC_LOG;
    if ( iPhysics )
        {
        TRect mainPaneRect;
        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPaneRect );
        const TSize viewSize( mainPaneRect.Size() );        
        const TSize worldSize( 0, iRowCount * iRowHeight );
        iPhysics->InitPhysicsL( worldSize, viewSize, EFalse );
        }
    }

// ---------------------------------------------------------------------------
// CFSEmailUiLauncherGridVisualiser::UpdateGridOffset()
// ---------------------------------------------------------------------------
//
void CFSEmailUiLauncherGridVisualiser::UpdateGridOffset()
	{
	if ( iConstructionCompleted )
		{
        TAlfTimedPoint alfScrollOffset;
        alfScrollOffset.iY.SetTarget( 1.0 , 0);
        iCurrentLevel.iGridLayout->SetScrollOffset(alfScrollOffset);
        iCurrentLevel.iParentPos.iY = 1.0;
		}
	}

