--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emailuis/emailui/src/FreestyleEmailUiLauncherGridVisualiser.cpp Wed Sep 01 12:28:57 2010 +0100
@@ -0,0 +1,2868 @@
+/*
+* 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;
+ }
+ }
+