diff -r 000000000000 -r f72a12da539e menufw/menufwui/matrixmenu/src/mmappui.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/menufw/menufwui/matrixmenu/src/mmappui.cpp Thu Dec 17 08:40:49 2009 +0200 @@ -0,0 +1,3130 @@ +/* +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Application UI class +* Version : %version: MM_176.1.28.1.52 % << Don't touch! Updated by Synergy at check-out. +* Version : %version: MM_176.1.28.1.52 % << Don't touch! Updated by Synergy at check-out. +* +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for transition effects +#include +#include +#include +#include +#include //flip status enums +#include +#include +#include +#include //stylus popup for long tap event + +#include "mmgui.hrh" +#include "mmguiconstants.h" +#include "mmappui.h" +#include "menudebug.h" +#include "hnengine.h" +#include "hnglobals.h" +#include "hnsuitemodelcontainer.h" +#include "hnmenuitemmodel.h" +#include "hntoolbarmodel.h" +#include "hnbuttonmodel.h" +#include "hnitemmodel.h" +#include "hnconvutils.h" +#include "hnsuitemodel.h" +#include "hnmdbasekey.h" +#include "hnmdkeyfactory.h" +#include "mmwidgetcontainer.h" +#include "mmtemplatelibrary.h" +#include "mmextensionmanager.h" +#include "mmpropertysubscriber.h" +#include "hnitemsorder.h" + +#include "mmnomemory.h" +#include "mmappkeyhandler.h" + +enum TMenuTransEffectContext + { + EMenuOpenFolderEffect = 1001, + EMenuCloseFolderEffect = 1002 + }; + +// ============================ MEMBER FUNCTIONS ============================= + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ConstructL() + { + DEBUG(("_Mm_:CMmAppUi::ConstructL IN")); + MMPERF(("Test Logger speed...")); + MMPERF(("Test Logger speed - DONE")); + MMPERF(("GO!")); + + //set matrix to be system app + iEikonEnv->SetSystem( ETrue ); + + TInt appUiFlags = AknLayoutUtils::PenEnabled() ? + EAknEnableSkin | EAknSingleClickCompatible : + EAknEnableSkin | EAknEnableMSK; + BaseConstructL( appUiFlags ); + iAppUiFactory = CEikonEnv::Static()->AppUiFactory( *this ); + ASSERT( iAppUiFactory ); + + FeatureManager::InitializeLibL(); + iIsKastorEffectStarted = EFalse; + StartLayoutSwitchFullScreen( AknTransEffect::EApplicationStart ); + + RefreshUiPanesL( ETrue ); + Cba()->MakeVisible( EFalse ); + StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL ); + + iDummyTemplateLib = CMmTemplateLibrary::NewL(); + iDummyContainer = CMmWidgetContainer::NewGridContainerL( ClientRect(), + this, iDummyTemplateLib ); + iDummyContainer->SetEmptyTextL( KNullDesC ); + AddToStackL( iDummyContainer, ECoeStackPriorityDefault, + ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + iDummyContainer->MakeVisible( ETrue ); + iDummyContainer->DrawNow(); + + iHNInterface = CHnEngine::NewL( *this ); + iTemplateLibrary = CMmTemplateLibrary::NewL(); + InitializeL(); + + iMmExtManager = CMMExtensionManager::NewL( *this ); + + iKeyboardFlipStatus = EPSHWRMFlipStatusUninitialized; + iSliderEventSubscriber = CMmPropertySubscriber::NewL(KPSUidHWRM, + KHWRMFlipStatus, *this); + + iScreenOn = ETrue; + iSkinChangeNeeded = EFalse; + iSkinChangeInProgress = EFalse; + iHasFocus = ETrue; + + iSkinSrvSession.Connect(this); + iAppkeyHandler = CMmAppkeyHandler::NewL(); + iOptionsMenuIsOpen = EFalse; + + RProperty::Define( KMMenuPSCat, KMMenuLastViewKey, RProperty::EText ); + + MMPERF(("CMmAppUi::ConstructL - HN ready")); + DEBUG(("_Mm_:CMmAppUi::ConstructL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CMmAppUi::IsRootdisplayedL() + { + TBool ret( EFalse ); + if( iHNInterface && iHNInterface->GetSuiteModelsCountL() == KModelCountForRoot ) + { + ret = ETrue; + } + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +CMmAppUi::CMmAppUi() + { + // No implementation required + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +CMmAppUi::~CMmAppUi() + { + DEBUG(("_Mm_:CMmAppUi::~CMmAppUi IN")); + + delete iOutOfMemoryHandler; + if (iCurrentSuiteModel) + { + iCurrentSuiteModel->UnregisterSuiteObserver( this ); + } + delete iToolbar; + iCascadeMenuMap.Close(); + RemoveFromStack( iCurrentContainer ); + RemoveFromStack( iDummyContainer ); + iDummyContainer->MakeVisible( EFalse ); + delete iDummyContainer; + ResetContainerMap(); + iGarbage.ResetAndDestroy(); + delete iHNInterface; + FeatureManager::UnInitializeLib(); + delete iMmExtManager; + delete iSliderEventSubscriber; + delete iTemplateLibrary; + delete iDummyTemplateLib; + delete iAppkeyHandler; + delete iPopupMenu; + iSkinSrvSession.Close(); + + MMPERF(("Matrix closed")); + DEBUG(("_Mm_:CMmAppUi::~CMmAppUi OUT")); + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleResourceChangeL( TInt aType ) + { + CAknAppUi::HandleResourceChangeL( aType ); + + //we're interested in layout change events + //only if container is available + if ( aType == KEikDynamicLayoutVariantSwitch && + iCurrentContainer && iCurrentSuiteModel ) + { + MMPERF(("Layout change START")); + // Do not call StartLayoutSwitchFullScreen(), + // layout switch effect is started automatically + iIsKastorEffectStarted = ETrue; + TInt lastItemIndex = iCurrentContainer->NumberOfItems() - 1; + + TBool makeLastItemVisible = lastItemIndex >= 0 && + iCurrentContainer->ItemIsFullyVisible( lastItemIndex ); + + iCurrentContainer->SetRect( ClientRect() ); + iDummyContainer->SetRect( ClientRect() ); + + // This fixes a problem (view scrolled one row up) that occurs when + // switching from portrait to landscape orientation with scrollbar + // in bottom position. + if ( makeLastItemVisible ) + { + iCurrentContainer->Widget()->View()->SetTopItemIndex( + iCurrentContainer->Widget()->View()-> + CalcNewTopItemIndexSoItemIsVisible( lastItemIndex ) ); + } + + THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); + while( iterator.NextKey() ) + { + CMmWidgetContainer* container = *iterator.CurrentValue(); + if ( container != iCurrentContainer ) + { + container->SetRect( ClientRect() ); + container->HandleResourceChange( aType ); + } + } + ShowSuiteL(); + EndFullScreen(); + MMPERF(("Layout change END")); + } + + if ( aType == KEikMessageFadeAllWindows && iCurrentContainer ) + { + iCurrentContainer->SetIsFaded( ETrue ); + } + else if ( aType == KEikMessageUnfadeWindows && iCurrentContainer ) + { + iCurrentContainer->SetIsFaded( EFalse ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CMmAppUi::ProcessCommandParametersL( TApaCommand aCommand, + TFileName& aDocumentName, + const TDesC8& aTail ) + { + DEBUG(("_Mm_:CMmAppUi::ProcessCommandParametersL IN")); + DEBUG8(("\t_Mm_:tail: %S", &aTail)); + + if ( aTail.Length() ) + { + DEBUG(("\t_Mm_:call HandleMessageL")); + HandleMessageL( aTail ); + } + + TBool result = CEikAppUi::ProcessCommandParametersL( aCommand, + aDocumentName, + aTail ); + + MMPERF(("Matrix started and ready!")); + DEBUG(("_Mm_:CMmAppUi::ProcessCommandParametersL OUT")); + return result; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ProcessCommandL(TInt aCommand) + { + TBool ignoreCommand = EFalse; + + // ignore options click in edit mode and intermediate states for non-touch + if ( aCommand == EAknSoftkeyOptions && iEditModeStatus != ENoEditMode && + !AknLayoutUtils::PenEnabled() ) + { + ignoreCommand = ETrue; + } + + // ignore keyselect for non-touch while in edit mode or stopping edit mode + if ( aCommand == KKeyIdSelect && !AknLayoutUtils::PenEnabled() && + ( iEditModeStatus == ETransitionFromEditMode || IsEditMode() ) ) + { + ignoreCommand = ETrue; + } + + if ( !ignoreCommand ) + { + CAknAppUi::ProcessCommandL( aCommand ); + } + + if (iCurrentContainer && iCurrentContainer == TopFocusedControl() ) + { + iCurrentContainer->HandleTopFocusL(); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ProcessMessageL( TUid /*aUid*/, const TDesC8& aParams ) + { + DEBUG(("_Mm_:CMmAppUi::ProcessMessageL IN")); + DEBUG8(("\t_Mm_:params: %S", &aParams)); + MMPERF(("APA Message Recieved")); + + // fix for the CR 417-35490 + // Handle empty message sends by AVKON after app key press or switch + // to Menu via task swapper. + if( !aParams.Compare( KNullDesC8 ) ) + { + if ( !iAppkeyHandler->IsActive() ) + { + CleanupForExitL( EExitKeyApplication ); + User::LeaveIfError( iCoeEnv->WsSession().SetWindowGroupOrdinalPosition( + CEikonEnv::Static()->RootWin().Identifier(), 0 ) ); + iAppkeyHandler->StartL(); + } + } + + // first refresh model, show afterwords + if ( aParams.Length() ) + { + DEBUG(("\t_Mm_:call HandleMessageL")); + HandleMessageL( aParams ); + } + + MMPERF(("APA Message Processed")); + DEBUG(("_Mm_:CMmAppUi::ProcessMessageL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +MCoeMessageObserver::TMessageResponse CMmAppUi::HandleMessageL( + TUint32 aClientHandleOfTargetWindowGroup, + TUid aMessageUid, + const TDesC8& aMessageParameters ) + { + if ( aMessageUid.iUid == KUidApaMessageSwitchOpenFileValue ) + { + ProcessMessageL( aMessageUid, aMessageParameters ); + return EMessageHandled; + } + else + { + return CAknAppUi::HandleMessageL( + aClientHandleOfTargetWindowGroup, + aMessageUid, + aMessageParameters ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleCommandL( TInt aCommand ) + { + DEBUG(("_Mm_:CMmAppUi::HandleCommandL IN")); + DEBUG(("\t_Mm_:aCommand: %d",aCommand)); + + // in case something has gone wrong + ClearTransitionFromEditModeFlag(); + + switch( aCommand ) + { + case EEikCmdExit: + { + DEBUG(("\t_Mm_:EEikCmdExit")); + // Simply exit + Exit(); + } + break; + + case EMmOptionsExit: + { + MMPERF(("Options->Exit pressed")); + DEBUG(("\t_Mm_:EMmOptionsExit")); + + //Check if it is a folder suite.If Yes really exit. + //Otherwise behave like LSK. + if( iCurrentSuiteModel && + iCurrentSuiteModel->SuiteName().Compare( KFolderSuite) ) + { + if( iCurrentSuiteModel->ExitMode() == EExitModeHide ) + { + // hide and reset menu + TApaTaskList taskList( iCoeEnv->WsSession() ); + TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); + me.SendToBackground(); + CleanupForExitL( EExitKeyApplication ); + } + else + { + StartLayoutSwitchFullScreen( EMenuCloseFolderEffect ); + HandleBackCommandL(); + } + } + else + { + ExitMatrix( EExitReally ); + } + } + break; + + case EAknSoftkeyExit: + { + MMPERF(("SoftkeyExit pressed")); + DEBUG(("\t_Mm_:EAknSoftkeyExit")); + ExitMatrix( EExitToPhone ); + } + break; + + case EAknSoftkeyBack: + { + StartLayoutSwitchFullScreen( EMenuCloseFolderEffect ); + + if( iCurrentSuiteModel && iCurrentSuiteModel->ExitMode() == EExitModeHide ) + { + // hide and reset menu + TApaTaskList taskList( iCoeEnv->WsSession() ); + TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); + me.SendToBackground(); + if ( iCurrentContainer ) + { + iCurrentContainer->MakeVisible( EFalse ); + } + iDummyContainer->MakeVisible( ETrue ); + RefreshCbaL(); + iDummyContainer->DrawNow(); + CleanupForExitL( EExitKeyApplication ); + } + else if( iCurrentSuiteModel ) + { + HandleBackCommandL(); + } + } + break; + + case EAknSoftkeyOk: + case EAknSoftkeyDone: + { + ASSERT( IsEditMode() ); + SetEditModeL( EFalse ); + } + break; + default: + { + ForwardEventToHNL( aCommand ); + } + break; + } + DEBUG(("_Mm_:CMmAppUi::HandleCommandL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleBackCommandL() + { + DEBUG(("_Mm_:CMmAppUi::HandleBackCommandL IN")); + MMPERF(("CMmAppUi::HandleBackCommandL - START")); + DEBUG16(("\t_Mm_:current genre: %S",&iCurrentSuiteModel->SuiteName())); + + iDummyContainer->MakeVisible( ETrue ); + RefreshUiPanesL( ETrue ); + iCurrentContainer->MakeVisible( EFalse ); + iDummyContainer->DrawNow(); + + iHNInterface->HandleBackEventL( iCurrentSuiteModel->SuiteName() ); + + MMPERF(("CMmAppUi::HandleBackCommandL - DONE")); + DEBUG(("_Mm_:CMmAppUi::HandleBackCommandL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +CMmWidgetContainer* CMmAppUi::GetAppropriateContainerToLoadL() + { + CMmWidgetContainer* retContainer = NULL; + if ( iCurrentSuiteModel ) + { + TInt currentSuiteId = iCurrentSuiteModel->GetItemsOrder()->GetSuiteId(); + + CMmWidgetContainer** ret = iContainerMap.Find( currentSuiteId ); + retContainer = (ret) ? *ret : NULL; + + if ( ret && (*ret)->WidgetType() != iCurrentSuiteModel->WidgetType() ) + { + iMakeHightlightedItemFullyVisible = ETrue; + iGarbage.AppendL( *ret ); + iContainerMap.Remove( + iCurrentSuiteModel->GetItemsOrder()->GetSuiteId() ); + retContainer = NULL; + } + } + return retContainer; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ShowSuiteL() + { + DEBUG(("_Mm_:CMmAppUi::ShowSuiteL IN")); +// DEBUG16(("\t_Mm_:current genre: %S", &iCurrentSuiteModel->SuiteName())); + + if ( iCurrentSuiteModel ) + { + CMmWidgetContainer* containerToLoad = GetAppropriateContainerToLoadL(); + TBool makeHandlePresentationChange( ETrue ); + + if (!containerToLoad) + { + makeHandlePresentationChange = CreateNewContainerL( + iCurrentSuiteModel, containerToLoad ); + } + + if( makeHandlePresentationChange ) + { + HandlePresentationChangeL( containerToLoad ); + } + } + + DEBUG(("_Mm_:CMmAppUi::ShowSuiteL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CMmAppUi::CreateNewContainerL( + CHnSuiteModel* aSuiteModel, CMmWidgetContainer*& aContainerToLoad ) + { + TRect rect = ClientRect(); + switch( aSuiteModel->WidgetType() ) + { + case ECoverFlowWidget : + case EGridWidget : + aContainerToLoad = CMmWidgetContainer::NewGridContainerL( + rect, this, iTemplateLibrary ); + break; + case EListWidget : + aContainerToLoad = CMmWidgetContainer::NewListBoxContainerL( + rect, this, iTemplateLibrary ); + break; + case EUnspecified: + default: + return EFalse; + } + aContainerToLoad->SetLongTapObserver(this); + aContainerToLoad->HandleItemAdditionL(); + iContainerMap.InsertL( + aSuiteModel->GetItemsOrder()->GetSuiteId(), + aContainerToLoad ); + return ETrue; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ForwardEventToHNL( TInt aEvent, TInt aItemId, + CLiwGenericParamList* aEventParams ) + { + DEBUG(("\t_Mm_:event ID: %d for item ID %d", aEvent, aItemId)); + + TInt id = iCurrentSuiteModel->IdByIndex( aItemId ); + if ( id >= 0 ) + { + MMPERF(("Handling event %d for item %d - START",aEvent,aItemId)); + + if( aEvent == KKeyIdSelect ) + { + MMPERF(("This is a 'select' event")); + + TInt modelId = iCurrentSuiteModel->IdByIndex( aItemId ); + CHnItemModel* itemModel = + iCurrentSuiteModel->GetItemModel( modelId ); + TInt effect = GetKastorEffectL( itemModel ); + TRect rect = GetKastorRectL( itemModel, aItemId ); + TUid appUid = itemModel->GetItemType() == EItemTypeApplication ? + itemModel->GetItemUid() : KUidMatrixMenuApp; + + if (iScreenOn && IsForeground() && effect + != AknTransEffect::ENone) + { + DEBUG(("_MM_:CMmAppUi::ForwardEventToHNL Foreground")); + GfxTransEffect::BeginFullScreen( + effect, rect, + AknTransEffect::EParameterType, + AknTransEffect::GfxTransParam( appUid ) ); + } + } + + iHNInterface->TriggerHnEventL( aEvent, id, aEventParams ); + MMPERF(("Handling event - END")); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TInt CMmAppUi::GetKastorEffectL( CHnItemModel* aItemModel ) + { + TInt effect( AknTransEffect::ENone ); + if ((IsEditMode() || iEditModeStatus == ETransitionFromEditMode) + && !AknLayoutUtils::PenEnabled()) + { + return effect; + } + switch( aItemModel->GetItemType() ) + { + case EItemTypeApplication: + { + if( !IsEditMode() && !aItemModel->IsDrmExpired() ) + { + if( aItemModel->IsRunning() ) + { + effect = AknTransEffect::EApplicationStartSwitchRect; + } + else + { + effect = AknTransEffect::EApplicationStartRect; + } + } + break; + } + case EItemTypeSuite: + { + if( !IsEditMode() ) + { + effect = EMenuOpenFolderEffect; + iIsKastorEffectStarted = ETrue; + } + break; + } + case EItemTypeParentFolder: + { + effect = EMenuCloseFolderEffect; + iIsKastorEffectStarted = ETrue; + break; + } + case EItemTypeFolder: + { + if (!(IsEditMode() && aItemModel->IsDeleteLocked())) + { + effect = EMenuOpenFolderEffect; + iIsKastorEffectStarted = ETrue; + } + break; + } + case EItemTypeUnknown: + default: + { + effect = AknTransEffect::ENone; + break; + } + } + return effect; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TRect CMmAppUi::GetKastorRectL( CHnItemModel* aItemModel, TInt aItemId ) + { + TRect rect = TRect(); + if( aItemModel->GetItemType() == EItemTypeApplication ) + { + rect = iCurrentContainer->GetItemRectL( aItemId ); + RRegion region; CleanupClosePushL( region ); + StatusPane()->GetShapeL( region, true, true ); + TInt statusPaneHeight = region.BoundingRect().Height(); + rect.iBr.iY += statusPaneHeight; + rect.iTl.iY += statusPaneHeight; + CleanupStack::PopAndDestroy( ®ion ); + } + return rect; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ForwardEventToHNL( TInt aEvent ) + { + DEBUG(("_Mm_:CMmAppUi::ForwardEventToHNL IN")); + DEBUG(("\t_Mm_:event ID: %d", aEvent)); + + if ( iCurrentContainer ) + { + TBool idByContainer = iCurrentContainer->IsHighlightVisible() && + iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; + TInt current = idByContainer ? + iCurrentContainer->GetHighlight() : KErrNotFound; + ForwardEventToHNL( aEvent, current ); + } + + DEBUG(("_Mm_:CMmAppUi::ForwardEventToHNL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::NotifyUiRefreshL( const THnUiRefreshType aRefreshType ) + { + DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL IN")); + DEBUG(("\t_Mm_:refresh type: %d", aRefreshType)); + + switch (aRefreshType) + { + case ERefreshSuite: + TRAPD( err, ShowSuiteL() ); + if ( KErrNoMemory == err ) + { + HandleOutOfMemoryL(); + User::Leave( KErrNoMemory ); + } + break; + case ERefreshToolbar: + RefreshToolbarL(); + break; + case EStartEditMode: + SetEditModeL( ETrue ); + break; + case EStopEditMode: + SetEditModeL( EFalse ); + break; + case EZoomLarge: + SetZoom( EAknUiZoomLarge ); + break; + case EZoomSmall: + SetZoom( EAknUiZoomSmall ); + break; + case EZoomNormal: + SetZoom( EAknUiZoomNormal ); + break; + case EForegroundGain: + { + DEBUG(("_MM_:CMmAppUi::NotifyUiRefreshL Foreground")); + TApaTaskList taskList( iCoeEnv->WsSession() ); + TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); + me.BringToForeground(); + } + break; + case EBackgroundGain: + { + DEBUG(("_MM_:CMmAppUi::NotifyUiRefreshL Foreground")); + TApaTaskList taskList( iCoeEnv->WsSession() ); + TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); + me.SendToBackground(); + } + break; + case ELightOn: + { + DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL - ELightOn")); + iScreenOn = ETrue; + if ( IsForeground() && iCurrentSuiteModel ) + { + iCurrentSuiteModel->SetVisibleL( ETrue ); + } + if ( iCurrentContainer ) + { + iCurrentContainer->HandleForegroundGainedL(); + } + } + break; + case ELightOff: + { + DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL - ELightOff")); + iScreenOn = EFalse; + if (iCurrentContainer) + { + iCurrentContainer->HandleBackgroundGainedL(); + if (IsEditMode() && iCurrentContainer->IsDraggable()) + { + iCurrentContainer->CancelDragL(EFalse); + } + } + if (iCurrentSuiteModel) + { + iCurrentSuiteModel->SetVisibleL(EFalse); + } + if( iMmExtManager ) + { + iMmExtManager->ExecuteActionL(TUid::Null(), KCommandDeleteDialog, NULL ); + } + } + break; + case ERemoveLiwObjects: + { + THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); + while( iterator.NextKey() ) + { + CMmWidgetContainer** container = iterator.CurrentValue(); + (*container)->RemoveLiwObjects(); + } + } + break; + default: + ASSERT( false ); + } + DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::RefreshToolbarL() + { + DEBUG(("_Mm_:CMmAppUi::RefreshToolbarL IN")); + HandleToolbarVisibilityL(); + UpdateToolbarL(); + DEBUG(("_Mm_:CMmAppUi::RefreshToolbarL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::RefreshUiPanesL( TBool aReset ) + { + // refresh status pane + CAknTitlePane* titlePane = + static_cast( + StatusPane()->ControlL( + TUid::Uid( EEikStatusPaneUidTitle ) ) ); + + if( aReset ) + { + titlePane->SetTextL( KNullDesC ); + } + else + { + if ( IsEditMode() && iCurrentSuiteModel ) + { + HBufC* title = NULL; + if ( IsRootdisplayedL() ) + { + title = StringLoader::LoadLC( R_ORG_ROOT_EDITING_TITLE ); + } + else + { + title = StringLoader::LoadLC( + R_ORG_FOLDER_EDITING_TITLE, + iCurrentSuiteModel->Title() ); + } + ASSERT( title ); + titlePane->SetTextL( title->Des() ); + CleanupStack::PopAndDestroy( title ); + } + else if ( iCurrentSuiteModel && iCurrentContainer ) + { + // refresh status pane + titlePane->SetTextL( iCurrentSuiteModel->Title() ); + + // inform AVKON about current suite to allow proper handling + // of AppKey and FSW + RProperty::Set( KMMenuPSCat, KMMenuLastViewKey, iCurrentSuiteModel->SuiteName() ); + } + else + { + titlePane->SetTextL( KNullDesC ); + } + } + + RefreshCbaL(); + SetMiddleSoftKeyL(); + + StatusPane()->DrawNow(); + Cba()->DrawNow(); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::RefreshCbaL() + { + if ( ( iDummyContainer && iDummyContainer->IsVisible() ) || + !iCurrentSuiteModel ) + { + // R_MENU_SOFTKEYS_EMPTY__EMPTY looks much better than + // R_AVKON_SOFTKEYS_EMPTY + Cba()->SetCommandSetL( R_MENU_SOFTKEYS_EMPTY__EMPTY ); + } + else + { + if ( IsEditMode() ) + { + Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? + R_AVKON_SOFTKEYS_OPTIONS_DONE : + R_AVKON_SOFTKEYS_OK_EMPTY__OK ); + } + else if ( IsRootdisplayedL() ) + { + Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? + R_AVKON_SOFTKEYS_OPTIONS_EXIT : + R_AVKON_SOFTKEYS_OPTIONS_EXIT__SELECT ); + } + else if ( iCurrentSuiteModel && + iCurrentSuiteModel->SuiteName().Compare(KParamFolderSuite) ) + { + Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? + R_MENU_SOFTKEYS_OPTIONS_BEXIT : + R_MENU_SOFTKEYS_OPTIONS_BEXIT__SELECT ); + } + else + { + Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? + R_AVKON_SOFTKEYS_OPTIONS_BACK : + R_AVKON_SOFTKEYS_OPTIONS_BACK__SELECT ); + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TKeyResponse CMmAppUi::HandleKeyPressedL( const TKeyEvent &aKeyEvent, + TEventCode aType ) + { + TKeyResponse resp = EKeyWasNotConsumed; + + // handling enter key - touch & non touch + if ( ( aKeyEvent.iScanCode == EStdKeyEnter || + aKeyEvent.iScanCode == EStdKeyNkpEnter || + aKeyEvent.iScanCode == EStdKeyDevice3 ) && aType == EEventKeyDown ) + { + if ( iCurrentContainer->IsHighlightVisible() ) + { + DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - enter")); + ForwardEventToHNL( KKeyIdSelect ); + resp = EKeyWasConsumed; + } + } + + //handling enter key - non touch / edit mode + if ( ( aKeyEvent.iScanCode == EStdKeyEnter || + aKeyEvent.iScanCode == EStdKeyDevice3 ) && + aType == EEventKeyDown && + IsEditMode() && !Layout_Meta_Data::IsPenEnabled() ) + { + DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - enter in edit mode")); + HandleCommandL( EAknSoftkeyOk ); + resp = EKeyWasConsumed; + } + + // handle the key exactly as container does (the same conditions) + if ( ( aKeyEvent.iRepeats > 0 && aType == EEventKey ) || + ( aKeyEvent.iRepeats == 0 && aType == EEventKeyUp ) ) + { + TBool navigationEvent = + aKeyEvent.iScanCode == EStdKeyRightArrow || + aKeyEvent.iScanCode == EStdKeyLeftArrow || + aKeyEvent.iScanCode == EStdKeyUpArrow || + aKeyEvent.iScanCode == EStdKeyDownArrow; + + if ( navigationEvent ) + { + DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - navi event: %d", + aKeyEvent.iScanCode)); + MMPERF(("Rocker navigation - START")); + UpdateToolbarL(); + SetMiddleSoftKeyL(); + resp = EKeyWasConsumed; + MMPERF(("Rocker navigation - END")); + } + else if ( aKeyEvent.iScanCode == EStdKeyBackspace ) + { + // handle clear key event + DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - clear key")); + ForwardEventToHNL( KKeyIdClear ); + resp = EKeyWasConsumed; + } + } + + if( aType == EEventUser ) + { + if ( aKeyEvent.iScanCode == EStdKeyNull && + iCurrentContainer->IsHighlightVisible() ) + { + DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - User press -> forward key:select to HN")); + UpdateToolbarL(); + SetMiddleSoftKeyL(); + ForwardEventToHNL( KKeyIdSelect ); + resp = EKeyWasConsumed; + } + } + + return resp; + } + +// ----------------------------------------------------------------------------- +// +// +// ----------------------------------------------------------------------------- +// +void CMmAppUi::HandleDragStartL( TInt aModelItemIndex ) + { + MMPERF(("CMmAppUi::HandleDragStartL - START")); + + if ( IsEditMode() ) + { + + TInt modelId = iCurrentSuiteModel->IdByIndex( aModelItemIndex ); + if (modelId != KErrNotFound) + { + CHnItemModel *itModel = iCurrentSuiteModel->GetItemModel( modelId ); + if (itModel->GetItemType() == EItemTypeParentFolder) + { + iCurrentContainer->CancelDragL( EFalse ); + } + else + { + iItemDragged = aModelItemIndex; + iIdDragged = iCurrentSuiteModel->IdByIndex( aModelItemIndex ); + } + } + } + MMPERF(("CMmAppUi::HandleDragStartL - STOP")); + } + +// ----------------------------------------------------------------------------- +// +// +// ----------------------------------------------------------------------------- +// +void CMmAppUi::HandleDragOverL( TInt /* aModelItemIndex */ ) + { + MMPERF(("CMmAppUi::HandleDragOverL - START")); + + MMPERF(("CMmAppUi::HandleDragOverL - STOP")); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMmAppUi::HandleDraggedIndexUpdatedL( TInt aModelItemIndex ) + { + MMPERF(("CMmAppUi::HandleDraggedIndexUpdatedL - START")); + iItemDragged = aModelItemIndex; + MMPERF(("CMmAppUi::HandleDraggedIndexUpdatedL - STOP")); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMmAppUi::HandleDragStopL( TInt aModelItemIndex ) + { + MMPERF(("CMmAppUi::HandleDragStopL - START")); + if ( IsEditMode() ) + { + TInt itemId = iCurrentSuiteModel->IdByIndex( aModelItemIndex ); + TMcsItemType typeCurr = + iCurrentSuiteModel->GetItemType( aModelItemIndex ); + TBool isOverFolder = ( AknLayoutUtils::PenEnabled() && + ( typeCurr == EItemTypeParentFolder || typeCurr == EItemTypeFolder ) ); + TBool isDeleteLocked = (itemId != KErrNotFound) ? + iCurrentSuiteModel->GetItemModel( itemId )->IsDeleteLocked(): + EFalse; + + TBuf8< KMaxLength > beforeCustomId; + beforeCustomId.Num( KErrNotFound ); + if ( aModelItemIndex + 1 < iCurrentContainer->NumberOfItems() ) + { + beforeCustomId.Num( iCurrentSuiteModel->GetItemModel( + iCurrentSuiteModel->IdByIndex( aModelItemIndex + 1 ) )->CustomId() ); + } + + TBuf8< KMaxLength > draggedCustomId; + draggedCustomId.Num( KErrNotFound ); + CHnItemModel* draggedModel = iCurrentSuiteModel->GetItemModel( iIdDragged ); + if (draggedModel) + { + draggedCustomId.Num( iCurrentSuiteModel->GetItemModel( iIdDragged )->CustomId() ); + } + + CLiwGenericParamList* eventParameters = CLiwGenericParamList::NewL(); + CleanupStack::PushL( eventParameters ); + CHnMdBaseKey* tempKeys = HnMdKeyFactory::CreateL( + HnEvent::KEventArgNamespace8(), KKeyTypeMap(), KNullDesC8() ); + CleanupStack::PushL( tempKeys ); + + CHnMdBaseKey* baseKey = HnMdKeyFactory::CreateL( + HnEvent::KEventArgNamespace8(), KKeyTypeMap(), KNullDesC8() ); + CleanupStack::PushL( baseKey ); + baseKey->AddSubKeyL( HnMdKeyFactory::CreateL( HnEvent::KDroppedBefore8(), + KKeyTypeInteger(), beforeCustomId ) ); + baseKey->AddSubKeyL( HnMdKeyFactory::CreateL( HnEvent::KDragged8(), + KKeyTypeInteger(), draggedCustomId ) ); + CleanupStack::Pop( baseKey ); + tempKeys->AddSubKeyL( baseKey ); + + tempKeys->ToGenericParamListL( *eventParameters ); + CleanupStack::PopAndDestroy( tempKeys ); + + if ( iIdDragged != itemId + && isOverFolder && !isDeleteLocked) + { + iCurrentSuiteModel->RemoveItemL( iIdDragged ); + if ( iItemDragged < aModelItemIndex ) + { + // indices of all items after iItemDragged have been + // decreased when the dragged item got removed from the + // current suite; prevent highlighted item change + iCurrentSuiteModel->SetSuiteHighlightL( aModelItemIndex - 1 ); + iCurrentContainer->SetManualHighlightL( + iCurrentContainer->GetHighlight() - 1, EFalse ); + } + + iCurrentContainer->HandleItemRemovalL(); + iCurrentContainer->CancelDragL( EFalse ); + + if( typeCurr == EItemTypeParentFolder ) + { + StartLayoutSwitchFullScreen( EMenuCloseFolderEffect ); + } + else + { + StartLayoutSwitchFullScreen( EMenuOpenFolderEffect ); + } + iHNInterface->TriggerHnEventL( KKeyIdMoveInto, itemId, eventParameters ); + iMakeHightlightedItemFullyVisible = ETrue; + } + else if ( iIdDragged == itemId ) + { + iCurrentContainer->CancelDragL( ETrue ); + TBool result = iHNInterface->TriggerHnEventL( KKeyIdMove, itemId, eventParameters ); + // fix for: edit->move, then LSK->Up->LSK->LSK FAST... (short options show up) + if ( result != KErrNone && !AknLayoutUtils::PenEnabled() ) + { + CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); + TLiwGenericParam command(KHnRequest, TLiwVariant( KEvaluateMdModel)); + paramList->AppendL(command); + HandleRequestL(*paramList); + CleanupStack::PopAndDestroy(paramList); + } + } + else + { + iCurrentContainer->CancelDragL( ETrue ); + if (!AknLayoutUtils::PenEnabled()) + { + CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); + TLiwGenericParam command(KHnRequest, TLiwVariant( KEvaluateMdModel)); + paramList->AppendL(command); + HandleRequestL(*paramList); + CleanupStack::PopAndDestroy(paramList); + } + } + + CleanupStack::PopAndDestroy( eventParameters ); + } + MMPERF(("CMmAppUi::HandleDragStopL - STOP")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleEventDraggingActionedL() + { + SetMiddleSoftKeyL(); + UpdateToolbarL(); + iKeyClickLocked = ETrue; + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleListBoxEventL( CEikListBox* /*aListBox*/, + MEikListBoxObserver::TListBoxEvent aEventType ) + { + DEBUG(("_Mm_:CMmAppUi::HandleListBoxEventL IN")); + DEBUG(("\t_Mm_: aEventType = %d", (TInt) aEventType ) ); + + TInt currentHighlight = iCurrentContainer->GetHighlight(); + + DEBUG(("\t_Mm_: CurrentHighlight = %d", currentHighlight ) ); + + if ( aEventType == MEikListBoxObserver::EEventItemDraggingActioned ) + { + DEBUG8(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemDraggingActioned")); + HandleEventDraggingActionedL(); + } + else if ( aEventType == MEikListBoxObserver::EEventPenDownOnItem ) + { + DEBUG(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemClicked")); + HandleHighlightItemPenDownL( iCurrentContainer->GetHighlight() ); + } + else if ( aEventType == MEikListBoxObserver::EEventItemDoubleClicked ) + { + DEBUG(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemDoubleClicked")); + HandleHighlightItemDoubleClickedL( iCurrentContainer->GetHighlight() ); + } + else if ( aEventType == MEikListBoxObserver::EEventItemSingleClicked ) + { + DEBUG(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemSingleClicked")); + HandleHighlightItemSingleClickedL( iCurrentContainer->Widget()->CurrentItemIndex() ); + } + else if ( aEventType == MEikListBoxObserver::EEventPanningStarted ) + { + iKeyClickLocked = ETrue; + } + + DEBUG(("_Mm_:CMmAppUi::HandleListBoxEventL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleLongTapEventL( const TPoint& aPenEventLocation ) + { + TBool popupMenuDisplayed(EFalse); + if (iPopupMenu) + { + delete iPopupMenu; + iPopupMenu = NULL; + } + iPopupMenu = CAknStylusPopUpMenu::NewL(this,aPenEventLocation); + + if ( AknLayoutUtils::LayoutMirrored() ) + { + iPopupMenu->SetPosition( aPenEventLocation, + CAknStylusPopUpMenu::EPositionTypeRightBottom ); + } + else + { + iPopupMenu->SetPosition( aPenEventLocation, + CAknStylusPopUpMenu::EPositionTypeLeftBottom ); + } + + if( iCurrentSuiteModel == iHNInterface->GetLastSuiteModelL() + && iCurrentContainer->IsHighlightVisible() + && iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1 ) + { + MMPERF(("CMmAppUi::DynInitMenuPaneL - START")); + //fill the main menu structure, look for cascade menus + //reset the helper hash map + iCascadeMenuMap.Close(); + + MHnMenuItemModelIterator* menuIterator = + iCurrentSuiteModel->GetMenuStructureL( + iCurrentSuiteModel->IdByIndex( + iCurrentContainer->GetHighlight() ) ); + + // check if there is a menu structure available + // for the specified item + if ( menuIterator ) + { + //create item sorting helper objects + RArray positionArray; + CleanupClosePushL( positionArray ); + RHashMap menuItemMap; + CleanupClosePushL( menuItemMap ); + + while ( menuIterator->HasNextSpecific() ) + { + CHnMenuItemModel* childItem = menuIterator->GetNextSpecific(); + CEikMenuPaneItem::SData childData; + childData.iCommandId = childItem->Command(); + childData.iText = childItem->NameL(). + Left( CEikMenuPaneItem::SData::ENominalTextLength ); + childData.iFlags = 0; + childData.iCascadeId = 0; + + positionArray.AppendL( childItem->Position() ); + menuItemMap.InsertL( childItem->Position(), childData ); + } + + positionArray.Sort(); + + //add items in correct order + for ( TInt i = 0; i < positionArray.Count(); ++i ) + { + iPopupMenu-> + AddMenuItemL( + menuItemMap.FindL( positionArray[i] ).iText, + menuItemMap.FindL( positionArray[i] ).iCommandId ); + } + + if (positionArray.Count()>0) + { + iPopupMenu->ShowMenu(); + popupMenuDisplayed = ETrue; + } + CleanupStack::PopAndDestroy( &menuItemMap ); + CleanupStack::PopAndDestroy( &positionArray ); + } + MMPERF(("CMmAppUi::DynInitMenuPaneL - STOP")); + } + + if ( !popupMenuDisplayed && iCurrentContainer + && iCurrentContainer == TopFocusedControl() ) + { + iCurrentContainer->HandleTopFocusL( EFalse ); + HandleHighlightItemSingleClickedL( + iCurrentContainer->Widget()->CurrentItemIndex() ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleHighlightItemDoubleClickedL( TInt aIndex ) + { + if ( iKeyClickLocked ) + return; + + if ( iCurrentSuiteModel->WidgetType() == EListWidget + && iCurrentContainer->GetPreviousHighlight() == aIndex ) + { + ForwardEventToHNL( KKeyIdSelect, aIndex ); + } + else if ( iCurrentSuiteModel->WidgetType() == EGridWidget && FlipOpen() ) + { + ForwardEventToHNL( KKeyIdSelect, aIndex ); + } + else if ( iCurrentSuiteModel->WidgetType() == EGridWidget + && IsEditMode() && iCurrentContainer->GetPreviousHighlight() == aIndex + && !iCurrentContainer->IsDraggable()) + { + ForwardEventToHNL( KKeyIdSelect, aIndex ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleHighlightItemPenDownL( TInt /* aIndex */ ) + { + DEBUG(("CMmAppUi::HandleHighlightItemPenDownL - IN")); + UpdateToolbarL(); + SetMiddleSoftKeyL(); + iKeyClickLocked = EFalse; + DEBUG(("CMmAppUi::HandleHighlightItemPenDownL - OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleHighlightItemSingleClickedL( TInt aIndex ) + { + if ( !iKeyClickLocked && !IsFaded() ) + { + ForwardEventToHNL( KKeyIdSelect, aIndex ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ResetContainerMap() + { + THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); + while( iterator.NextKey() ) + { + CMmWidgetContainer** container = iterator.CurrentValue(); + delete *container; + iterator.RemoveCurrent(); + } + iContainerMap.Close(); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ResetContainerMapToRootL() + { + TInt err( KErrNone ); + CHnSuiteModel* currentSuite = iHNInterface->GetLastSuiteModelL(); + + // there is a loaded suite configuration + if( currentSuite ) + { + TInt id( currentSuite->GetItemsOrder()->GetSuiteId() ); + TRAP( err, iCurrentContainer = iContainerMap.FindL( id ) ); + + // configuration loaded but there is no container + if( err != KErrNone ) + { + HandleSuiteModelInitializedL( currentSuite ); + } + else if( iContainerMap.Count() > 0 ) + { + THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); + while( iterator.NextKey() ) + { + CMmWidgetContainer** container = iterator.CurrentValue(); + if( iCurrentContainer != *container ) + { + RemoveFromStack( *container ); + iGarbage.AppendL( *container ); + iterator.RemoveCurrent(); + } + } + } + } + else + { + ResetContainerMap(); + InitializeL(); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleMessageL( const TDesC8& aMessage ) + { + if ( IsEditMode() ) + { + SetEditModeL( EFalse ); + } + + if ( aMessage.Find( KRootWithPref ) != KErrNotFound ) + { + RemoveFromStack( iCurrentContainer ); + iDummyContainer->MakeVisible( ETrue ); + RefreshCbaL(); + iGarbage.ResetAndDestroy(); + ResetContainerMap(); + iCurrentSuiteModel = NULL; + iCurrentContainer = NULL; + } + + TRAPD( err, iHNInterface->LoadSuitesFromUriL( aMessage ) ); + + if ( err && iCurrentContainer && ( aMessage.Find( KSetFocusWithPref ) == KErrNotFound ) ) + { + HandleSuiteEventL( ESuiteModelInitialized, iHNInterface->GetLastSuiteModelL() ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::DynInitMenuPaneL( TInt aResourceId, + CEikMenuPane* aMenuPane ) + { + aMenuPane->EnableMarqueeL( ETrue ); + if( iCurrentSuiteModel == iHNInterface->GetLastSuiteModelL() ) + { + switch ( aResourceId ) + { + case R_MAIN_MENU_PANE: + { + MMPERF(("CMmAppUi::DynInitMenuPaneL - START")); + //fill the main menu structure, look for cascade menus + //reset the helper hash map + iCascadeMenuMap.Close(); + + MHnMenuItemModelIterator* menuIterator = NULL; + TBool ignoreItemSpecific( EFalse ); + if ( iCurrentSuiteModel ) + { + TInt itemId( KErrNotFound ); + TBool suiteModelHasItems = iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; + TBool highlightVisible = iCurrentContainer->IsHighlightVisible(); + if ( !highlightVisible && suiteModelHasItems ) + { +// if there is no highlight, but there are items, show menuitems for logically +// current suite highlight fetched from suite model. + TInt suiteHighlight = iCurrentSuiteModel->GetSuiteHighlight(); + ASSERT( suiteHighlight != KErrNotFound ); + itemId = iCurrentSuiteModel->IdByIndex( suiteHighlight ); + ignoreItemSpecific = ETrue; + } + else + { + TBool idByContainer = highlightVisible && suiteModelHasItems; + itemId = idByContainer ? + iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ) : + iCurrentSuiteModel->IdByIndex( KErrNotFound ); + } + menuIterator = iCurrentSuiteModel->GetMenuStructureL( itemId ); + } + + // check if there is a menu structure available + // for the specified item + if ( menuIterator ) + { + //create item sorting helper objects + RArray positionArray; + CleanupClosePushL( positionArray ); + RHashMap menuItemMap; + CleanupClosePushL( menuItemMap ); + + //get original (rss defined) items positions + for ( TInt i = 0; i < aMenuPane->NumberOfItemsInPane(); ++i ) + { + //multiply to make space for suite defined entries + //first item has 100th conceptual position + positionArray.AppendL( ( i + 1 ) * KMenuPosMultiplier ); + //store items, position as the key + menuItemMap.InsertL( ( i + 1 ) * KMenuPosMultiplier, + aMenuPane-> + ItemData( aMenuPane->MenuItemCommandId( i ) ) ); + } + + //get custom menu items and their positions + while ( menuIterator->HasNext() ) + { + CHnMenuItemModel* menuItem = menuIterator->GetNext(); + if ( !menuItem->IsItemSpecific() || !ignoreItemSpecific ) + { + CEikMenuPaneItem::SData menuData; + menuData.iCommandId = menuItem->Command(); + menuData.iText = menuItem->NameL(). + Left( CEikMenuPaneItem::SData::ENominalTextLength ); + menuData.iFlags = 0; + + //check for children + MHnMenuItemModelIterator* childIterator = + menuItem->GetMenuStructure(); + if ( childIterator->HasNext() ) + { + //this is a cascade item + //one menu item can contain only one cascade menu + //check if there are available cascade menu containers + TInt freeResource = GetNextCascadeMenuResourceId(); + if ( freeResource != KErrNotFound ) + { + //error checking + if( !iCascadeMenuMap.Insert( freeResource, + childIterator ) ) + { + //add item only if there is an + //available resource + menuData.iCascadeId = freeResource; + } + } + } + else + { + //normal entry + menuData.iCascadeId = 0; + } + positionArray.AppendL( menuItem->Position() ); + menuItemMap.InsertL( menuItem->Position(), menuData ); + } + } + + aMenuPane->Reset(); + positionArray.Sort(); + + //add items in correct order + for ( TInt i = 0; i < positionArray.Count(); ++i ) + { + aMenuPane-> + AddMenuItemL( + ( menuItemMap.FindL( positionArray[i] ) ) ); + } + + CleanupStack::PopAndDestroy( &menuItemMap ); + CleanupStack::PopAndDestroy( &positionArray ); + } + MMPERF(("CMmAppUi::DynInitMenuPaneL - STOP")); + } + break; + + case R_CASCADE_MENU_PANE_1: + case R_CASCADE_MENU_PANE_2: + case R_CASCADE_MENU_PANE_3: + { + //realod cascade menu map + ReloadCascadeMenuMapL(); + //fill the cascade menu panes + MHnMenuItemModelIterator* childIteratorPtr = + iCascadeMenuMap.FindL( aResourceId ); + + // check if child iterator available + if ( childIteratorPtr ) + { + childIteratorPtr->Reset(); + + //create item sorting helper objects + RArray positionArray; + CleanupClosePushL( positionArray ); + RHashMap menuItemMap; + CleanupClosePushL( menuItemMap ); + + while ( childIteratorPtr->HasNext() ) + { + CHnMenuItemModel* childItem = childIteratorPtr->GetNext(); + + CEikMenuPaneItem::SData childData; + childData.iCommandId = childItem->Command(); + childData.iText = childItem->NameL(). + Left( CEikMenuPaneItem::SData::ENominalTextLength ); + childData.iFlags = 0; + childData.iCascadeId = 0; + + positionArray.AppendL( childItem->Position() ); + menuItemMap.InsertL( childItem->Position(), childData ); + } + + positionArray.Sort(); + //add items in correct order + for ( TInt i = 0; i < positionArray.Count(); ++i ) + { + aMenuPane->AddMenuItemL( + ( menuItemMap.FindL( positionArray[i] ) ) ); + } + + CleanupStack::PopAndDestroy( &menuItemMap ); + CleanupStack::PopAndDestroy( &positionArray ); + } + } + break; + + default: + break; + } + } + else if( aResourceId == R_MAIN_MENU_PANE ) + { + aMenuPane->SetItemDimmed( EMmOptionsExit, ETrue ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ReloadCascadeMenuMapL() + { + iCascadeMenuMap.Close(); + MHnMenuItemModelIterator* menuIterator = NULL; + if ( iCurrentSuiteModel ) + { + TBool idByContainer = iCurrentContainer->IsHighlightVisible() && + iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; + TInt itemId = idByContainer ? + iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ) : + iCurrentSuiteModel->IdByIndex( KErrNotFound ); + menuIterator = iCurrentSuiteModel->GetMenuStructureL( itemId ); + } + + if ( menuIterator ) + { + while ( menuIterator->HasNext() ) + { + CHnMenuItemModel* menuItem = menuIterator->GetNext(); + + MHnMenuItemModelIterator* childIterator = + menuItem->GetMenuStructure(); + if ( childIterator->HasNext() ) + { + TInt freeResource = GetNextCascadeMenuResourceId(); + if ( freeResource != KErrNotFound ) + { + iCascadeMenuMap.Insert( freeResource, childIterator ); + } + } + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TInt CMmAppUi::GetNextCascadeMenuResourceId() + { + //if needed add additional placeholders in matrixmenu.rss + //next add additional cases in this method and the + //CMmAppUi::DynInitMenuPaneL + + TInt freeResource( KErrNotFound ); + switch ( iCascadeMenuMap.Count() ) + { + case 0: + { + freeResource = R_CASCADE_MENU_PANE_1; + } + break; + case 1: + { + freeResource = R_CASCADE_MENU_PANE_2; + } + break; + case 2: + { + freeResource = R_CASCADE_MENU_PANE_3; + } + break; + default: + break; + } + return freeResource; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleWidgetChangeRefreshL( + CMmWidgetContainer* aWidgetContainer ) + { + DEBUG(("_Mm_:CMmAppUi::HandleWidgetChangeRefreshL IN")); + + CMmWidgetContainer* previousContainer = iCurrentContainer; + if (previousContainer) + { + previousContainer->SetObserver(NULL); + RemoveFromStack(previousContainer); + } + + iCurrentContainer = aWidgetContainer; + iCurrentContainer->Widget()->View()->SetDisableRedraw(ETrue); + iDummyContainer->MakeVisible( ETrue ); + RefreshCbaL(); + iCurrentContainer->SetZoom( iZoom ); + iCurrentContainer->SetFlipOpenL( FlipOpen() ); + iCurrentContainer->SetEditModeL( IsEditMode() ); + iCurrentContainer->SetSuiteModelL( iCurrentSuiteModel ); + iCurrentContainer->HandleResourceChange( KAknsMessageSkinChange ); + iCurrentContainer->HandleResourceChange( KUidValueCoeColorSchemeChangeEvent ); + iCurrentContainer->SetEmptyTextL( iCurrentSuiteModel->EmptyText() ); + iCurrentContainer->SetHasFocusL( iHasFocus ); + iCurrentContainer->SetIsFaded( IsFaded() ); + iCurrentContainer->SetObserver( this ); + + if ( previousContainer && previousContainer->WidgetType() != iCurrentContainer->WidgetType() + && previousContainer->GetSuiteModelL() == iCurrentContainer->GetSuiteModelL() ) + { + iCurrentSuiteModel->SetSuiteHighlightL( KErrNotFound ); + } + + AddToStackL( iCurrentContainer ); + if ( previousContainer ) + { + previousContainer->MakeVisible( EFalse ); + } + + DEBUG(("_Mm_:CMmAppUi::HandleWidgetChangeRefreshL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleNoWidgetChangeRefreshL() + { + if ( iCurrentSuiteModel ) + { + iCurrentContainer->Widget()->View()->SetDisableRedraw(ETrue); + iCurrentContainer->SetZoom( iZoom ); + iCurrentContainer->SetFlipOpenL( FlipOpen() ); + iCurrentContainer->SetEditModeL( IsEditMode() ); + iCurrentContainer->SetSuiteModelL( iCurrentSuiteModel ); + iCurrentContainer->SetEmptyTextL( iCurrentSuiteModel->EmptyText() ); + iCurrentContainer->SetHasFocusL( iHasFocus ); + iCurrentContainer->SetIsFaded( IsFaded() ); + iCurrentContainer->SetObserver(this); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CMmAppUi::IsEditMode() + { + return (iEditModeStatus == EEditMode + || iEditModeStatus == ETransitionToEditMode); + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandlePresentationChangeL( + CMmWidgetContainer* aWidgetContainer ) + { + DEBUG(("_Mm_:CMmAppUi::HandlePresentationChangeL IN")); + + if ( iToolbar && iToolbar->IsShown() ) + { + iToolbar->SetToolbarVisibility( EFalse ); + } + + if( iCurrentContainer != aWidgetContainer ) + { + if( iCurrentContainer && aWidgetContainer && + iCurrentContainer->WidgetType() != aWidgetContainer->WidgetType() ) + { + StartLayoutSwitchFullScreen(); + } + HandleWidgetChangeRefreshL( aWidgetContainer ); + } + else + { + HandleNoWidgetChangeRefreshL(); + } + + if( iCurrentContainer ) + { + iCurrentContainer->SetRect(ClientRect()); + iDummyContainer->SetRect(ClientRect()); + if( IsForeground() ) + { + // should be called before MakeVisible (and after SetRect or SetupLayout, + // so that default highlight is displayed correctly when zoomed) + ApplyHighlightFromModelL(); + + // There is defferences in code because behaviour in non-touch edit mode + // and non-touch edit mode is different. + if (!AknLayoutUtils::PenEnabled()) + { + // While starting non-touch edit mode we have to scroll view in case when + // higlighted item is placed on top/bottow row of view and there + // are more rows over/under one to show all needed indicator arrows. + // DrawNow() method caused jumping both scrollbar and view to old positions. + iCurrentContainer->MakeVisible(ETrue); + iCurrentContainer->Widget()->View()->SetDisableRedraw(EFalse); + iCurrentContainer->SetEditModeL(IsEditMode()); + iDummyContainer->MakeVisible(EFalse); + } + else + { + // For touch normal mode we have to redraw container in case + // we back "parent folder" which was edited in edit mode. + // Thanks to DrawNow() method we avoid drawing items's backdrop icons + // and switching between edit mode's and normal mode's views + iCurrentContainer->SetEditModeL(IsEditMode()); + iCurrentContainer->MakeVisible(ETrue); + + // cache widget position so that we can restore it after DrawNow(), which + // changes it for no apparent reason when using list view. + iCurrentContainer->CacheWidgetPosition(); + + // draw container before effects gets snapshot + iCurrentContainer->DrawNow(); + iCurrentContainer->Widget()->View()->SetDisableRedraw(EFalse); + iDummyContainer->MakeVisible(EFalse); + + // restore the correct widget position + iCurrentContainer->RestoreWidgetPosition(); + } + + // refresh changed items only + iCurrentContainer->DrawView(); + RefreshUiPanesL(); + RefreshToolbarL(); + } + else + { + iCurrentContainer->SetupWidgetLayoutL(); + iCurrentContainer->Widget()->View()->SetDisableRedraw( EFalse ); + ApplyHighlightFromModelL(); + } + } + + MMPERF(("CMmAppUi::HandlePresentationChangeL - model swapped")); + DEBUG(("_Mm_:CMmAppUi::HandlePresentationChangeL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::OfferToolbarEventL( TInt aCommand ) + { + TInt itemId = iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ); + CHnItemModel* itemModel = iCurrentSuiteModel->GetItemModel( itemId ); + ASSERT( itemModel ); + const CHnToolbarModel* toolbarModel = itemModel->GetToolbarModel(); + ASSERT( toolbarModel ); + const CHnButtonModel* buttonModel = toolbarModel->GetButton( aCommand ); + ASSERT( buttonModel ); + + ForwardEventToHNL( buttonModel->GetEventId() ); + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TInt CMmAppUi::ExecuteExtensionActionL( const TUid aUid , const TDesC& aCommand, + CLiwGenericParamList* aEventParamList ) + { + return iMmExtManager->ExecuteActionL( aUid, aCommand, aEventParamList); + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleToolbarVisibilityL() + { + TBool suiteModelHasToolbar = + iCurrentSuiteModel && iCurrentSuiteModel->HasToolbar(); + + if ( suiteModelHasToolbar ) + { + if ( iToolbar ) + { + // could have gotten hidden during view change + iToolbar->SetToolbarVisibility( ETrue ); + } + else + { + iToolbar = CAknToolbar::NewL( R_GLOBAL_TOOLBAR ); + iToolbar->SetToolbarObserver( this ); + iToolbar->SetToolbarVisibility( ETrue ); + + // substract the toolbar from display's visible area + TRect remainingArea( ClientRect() ); + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + remainingArea.Resize( 0, -iToolbar->Size().iHeight ); + iCurrentContainer->SetRect( remainingArea ); + } + } + else if ( !suiteModelHasToolbar && iToolbar ) + { + iToolbar->SetToolbarVisibility( EFalse ); + delete iToolbar; + iToolbar = NULL; + iCurrentContainer->SetRect( ClientRect() ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::UpdateToolbarL() + { + // drop toolbar handling if there should be none + if ( iToolbar && iCurrentSuiteModel->HasToolbar() ) + { + iToolbar->RemoveItem( EMmToolbarControl1 ); + iToolbar->RemoveItem( EMmToolbarControl2 ); + iToolbar->RemoveItem( EMmToolbarControl3 ); + + TInt itemId = iCurrentSuiteModel->IdByIndex( iCurrentContainer->Widget()->CurrentItemIndex() ); + CHnItemModel* itemModel = iCurrentSuiteModel->GetItemModel( itemId ); + if ( !itemModel ) + { + return; + } + const CHnToolbarModel* toolbarModel = itemModel->GetToolbarModel(); + + CAknButton* button( NULL ); + for ( TInt i = 0; i < KNumOfButtonsInToolbar; ++i ) + { + const CHnButtonModel* buttonModel = toolbarModel->GetButton( i ); + // get button icon and help text from model + if ( buttonModel ) + { + CGulIcon* originalIcon = buttonModel->GetIcon(); + CGulIcon* iconCopy( NULL ); + if ( originalIcon && originalIcon->Bitmap() ) + { + // create a copy of the icon if exists, + // CAknButton takes ownership of the icon but we + // want to reuse it, + // also duplicate bitmaps for proper scaling + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL( bitmap ); + bitmap->Duplicate( originalIcon->Bitmap()->Handle() ); + + CFbsBitmap* mask( NULL ); + if ( originalIcon->Mask() ) + { + mask = new (ELeave) CFbsBitmap; + CleanupStack::PushL( mask ); + mask->Duplicate( originalIcon->Mask()->Handle() ); + } + + iconCopy = CGulIcon::NewL( bitmap, mask ); + if ( mask ) + { + CleanupStack::Pop( mask ); + } + CleanupStack::Pop( bitmap ); + CleanupStack::PushL( iconCopy ); + } + button = CAknButton::NewL( iconCopy, + NULL, + NULL, + NULL, + KNullDesC, + buttonModel->GetButtonText(), + 0, + 0 ); + if ( iconCopy ) + { + CleanupStack::Pop( iconCopy ); + } + CleanupStack::PushL( button ); + button->SetDimmed( buttonModel->GetDimmed() ); + } + else + { + button = CAknButton::NewLC(); + } + iToolbar->AddItemL( button, + EAknCtButton, + EMmToolbarControl1 + i, + 0 ); + CleanupStack::Pop( button ); + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::SetEditModeL( TBool aIsEditMode ) + { + MMPERF(("CMmAppUi::SetEditModeL %d - START",aIsEditMode)); + if ( IsEditMode() != aIsEditMode && iCurrentSuiteModel ) + { + + // stops moving items. This must be called when leaving non-touch edit mode to save + // the current visible order of the items. In non-touch it is called only once when completing editing + + iHNInterface->SetEditModeL(aIsEditMode); + iCurrentContainer->StopMovingL(); + + if ( aIsEditMode ) + { + iEditModeStatus = ETransitionToEditMode; + } + else + { + if ( iEditModeStatus == ETransitionToEditMode ) + { + iEditModeStatus = EFastTransitionFromEditMode; + } + else + { + iEditModeStatus = ETransitionFromEditMode; + } + } + + HandleHighlightOffsetL( aIsEditMode ? EOffsetNext : EOffsetPrevious ); + iCurrentSuiteModel->SetSuiteHighlightL( + AdjustEditModeHighlightL( iCurrentSuiteModel->GetSuiteHighlight() ) ); + + // update the container at the end when highlight is proper, + // this will ensure correct focus/unfocus action handling + iCurrentContainer->CacheWidgetPosition(); + iCurrentContainer->SetEditModeL( IsEditMode() ); + + if ( iCurrentContainer->IsHighlightVisible() ) + { + iMakeHightlightedItemFullyVisible = ETrue; + } + + RefreshUiPanesL(); + + //disable redraw so that no redrawing events coming from window server cause redrawing until + //everything is ready to draw. Then iCurrentContainer->DrawNow in HandlePresentationChangeL is called + if (IsEditMode()) + { + iCurrentContainer->Widget()->View()->SetDisableRedraw(ETrue); + } + } + + MMPERF(("CMmAppUi::SetEditModeL - STOP")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleWsEventL( const TWsEvent& aEvent, + CCoeControl* aDestination ) + { + DEBUG(("_Mm_:CMmAppUi::HandleWsEventL %d - IN", aEvent.Type())); + + if ( aEvent.Type() == KAknUidValueEndKeyCloseEvent ) + { + // return when the red key was pressed + MMPERF(("End key pressed")); + DEBUG(("_Mm_:CMmAppUi::HandleWsEventL - End key")); + ExitMatrix( EExitToIdle ); + return; + } + + TEventCode type = static_cast< TEventCode >( aEvent.Type() ); + + if ( ( type == EEventFocusLost || type == KAknFullOrPartialForegroundLost ) + && iCurrentContainer ) + { + iCurrentContainer->CacheWidgetPosition(); + } + + // base's HandleWsEventL needs to be called before foreground handling, + // otherwise the screen saver will be turned off + CAknAppUi::HandleWsEventL( aEvent, aDestination ); + + // refreshes toolbar when pen down event was invoked + if ( type == EEventPointer ) + { + if ( iCurrentSuiteModel ) + { + RefreshToolbarL(); + } + } + else if ( type == EEventFocusGained ) + { + HandleFocusGainedL(); + } + else if ( type == EEventFocusLost ) + { + HandleFocusLostL(); + } + else if ( type == KAknFullOrPartialForegroundGained ) + { + HandleFullOrPartialForegroundGainedL(); + } + else if( type == KAknFullOrPartialForegroundLost ) + { + HandleFullOrPartialForegroundLostL(); + } + + DetectOptionsMenuOpenDisplayChangeL(); + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TErrorHandlerResponse CMmAppUi::HandleError(TInt aError, + const SExtendedError& /*aExtErr*/, + TDes& /*aErrorText*/, + TDes& /*aContextText*/ ) + { + if( aError == KErrNoMemory ) + { + TRAP_IGNORE( ResetToInitialStateL( ) ); + } + return EErrorNotHandled; + } + + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleSuiteEventL ( + THnCustomSuiteEvent aCustomSuiteEvent, CHnSuiteModel* aModel ) + { + + DEBUG(("_Mm_:CMmAppUi::HandleSuiteEventL %d - IN",aCustomSuiteEvent)); + switch ( aCustomSuiteEvent ) + { + case ESuitePushedToStack: + { + aModel->RegisterSuiteObserverL( this, EPriorityMuchLess ); + } + break; + case ESuitePoppedFromStack: + { + + } + break; + case ESuiteModelInitialized: + { + HandleSuiteModelInitializedL( aModel ); + } + break; + default: + break; + } + + if ( iCurrentSuiteModel == aModel ) + { + //We are interested in the following event + //only if they come from the current suite. + TBool redraw = (iScreenOn && IsForeground()) ? ETrue : EFalse; + switch (aCustomSuiteEvent) + { + case ESuiteModelDestroyed: + { + iCurrentContainer->PrepareForGarbage(); + iGarbage.AppendL(iCurrentContainer); + iContainerMap.Remove( + iCurrentSuiteModel->GetItemsOrder()->GetSuiteId()); + RemoveFromStack(iCurrentContainer); + iDummyContainer->MakeVisible( ETrue ); + iCurrentContainer->SetObserver(NULL); + iCurrentSuiteModel = NULL; + iCurrentContainer = NULL; + } + break; + case ESuiteItemsAdded: + { + //we need consistent view/state before item is added + //so draggind should be cancelled + if( IsEditMode() && iCurrentContainer->IsDraggable() ) + { + iCurrentContainer->CancelDragL( EFalse ); + iCurrentContainer->DrawNow(); + } + HandleNumberOfItemsChangedL( EItemsAdded ); + } + break; + case ESuiteItemsRemoved: + { + //we need consistent view/state before item is removed + //so draggind should be cancelled + if( IsEditMode() && iCurrentContainer->IsDraggable() ) + { + iCurrentContainer->CancelDragL( EFalse ); + iCurrentContainer->DrawNow(); + } + HandleNumberOfItemsChangedL( EItemsRemoved ); + } + break; + case ESuiteItemsUpdated: + { + ClearTransitionFromEditModeFlag(); + iCurrentContainer->DrawView(); + } + break; + case ESuiteHighlightChanged: + { + iCurrentContainer->SetManualHighlightL( + iCurrentSuiteModel->GetSuiteHighlight(), redraw ); + } + break; + default: + break; + } + } + DEBUG(("_Mm_:CMmAppUi::HandleSuiteEventL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ClearTransitionFromEditModeFlag() + { + if ( iEditModeStatus == ETransitionFromEditMode || + iEditModeStatus == EFastTransitionFromEditMode ) + { + iEditModeStatus = ENoEditMode; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TInt CMmAppUi::AdjustEditModeHighlightL( TInt aOriginalHighlight ) + { + if ( AknLayoutUtils::PenEnabled() ) + { + if ( !iCurrentContainer->IsHighlightVisible() + && iEditModeStatus == ETransitionToEditMode ) + { + aOriginalHighlight = KErrNotFound ; + } + } + return aOriginalHighlight; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleOutOfMemoryL() + { + if( !iOutOfMemoryHandler ) + { + iOutOfMemoryHandler = CMmNoMemory::NewL(); + } + iOutOfMemoryHandler->Start(); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ResetToInitialStateL() + { + iDummyContainer->MakeVisible( ETrue ); + iDummyContainer->DrawNow(); + RefreshCbaL(); + + if (iCurrentSuiteModel) + { + iCurrentSuiteModel->UnregisterSuiteObserver( this ); + } + RemoveFromStack( iCurrentContainer ); + ResetContainerMap(); + iGarbage.ResetAndDestroy(); + delete iHNInterface; + iHNInterface = NULL; + delete iMmExtManager; + iMmExtManager = NULL; + delete iSliderEventSubscriber; + iSliderEventSubscriber = NULL; + delete iTemplateLibrary; + iTemplateLibrary = NULL; + + iCurrentSuiteModel = NULL; + iCurrentContainer = NULL; + iContainerMap.Close(); + iEditModeStatus = ENoEditMode; + + GfxTransEffect::AbortFullScreen(); + iIsKastorEffectStarted = EFalse; + + RefreshUiPanesL(); + Cba()->MakeVisible( EFalse ); + StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL ); + + iHNInterface = CHnEngine::NewL( *this ); + iTemplateLibrary = CMmTemplateLibrary::NewL(); + InitializeL(); + + iMmExtManager = CMMExtensionManager::NewL( *this ); + + iKeyboardFlipStatus = EPSHWRMFlipStatusUninitialized; + + iScreenOn = ETrue; + iSkinChangeNeeded = EFalse; + iSkinChangeInProgress = EFalse; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleSuiteModelInitializedL( CHnSuiteModel* aModel ) + { + StatusPane()->MakeVisible( ETrue ); + Cba()->MakeVisible( ETrue ); + + if ( aModel == iHNInterface->GetLastSuiteModelL() ) + { + TBool showOpenFolderEffect(iCurrentSuiteModel + && (iCurrentSuiteModel->CustomId() != aModel->CustomId() + || iCurrentSuiteModel->WidgetType() + != aModel->WidgetType())); + if( showOpenFolderEffect ) + { + StartLayoutSwitchFullScreen( EMenuOpenFolderEffect ); + } + + if ( iCurrentSuiteModel ) + { + iCurrentSuiteModel->SetVisibleL( EFalse ); + DEBUG16(("\t\t_Mm_:SetVisible EFalse - %S", + &(iCurrentSuiteModel->SuiteName()))); + } + iCurrentSuiteModel = aModel; + ShowSuiteL(); + iGarbage.ResetAndDestroy(); + + if ( iEditModeStatus == ETransitionToEditMode ) + { + iEditModeStatus = EEditMode; + } + else if ( iEditModeStatus == ETransitionFromEditMode ) + { + iEditModeStatus = ENoEditMode; + } + + if (iScreenOn && IsForeground()) + { + iCurrentSuiteModel->SetVisibleL( ETrue ); + DEBUG16(("\t\t_Mm_:SetVisible ETrue - %S", + &(iCurrentSuiteModel->SuiteName()))); + } + + HideMenuPaneIfVisibleL(); + EndFullScreen(); + } + else + { + if( iHNInterface->SuiteModelLoadedL( + aModel->GetItemsOrder()->GetSuiteId() ) ) + { + CMmWidgetContainer* containerToLoad = NULL; + TBool created( CreateNewContainerL( aModel, containerToLoad ) ); + if( created ) + { + containerToLoad->Widget()->View()->SetDisableRedraw( ETrue ); + containerToLoad->SetFlipOpenL( FlipOpen() ); + containerToLoad->SetEditModeL( IsEditMode() ); + containerToLoad->SetSuiteModelL( aModel ); + containerToLoad->SetEmptyTextL( aModel->EmptyText() ); + containerToLoad->SetObserver( this ); + containerToLoad->SetRect( ClientRect() ); + containerToLoad->MakeVisible( EFalse ); + } + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HideMenuPaneIfVisibleL() + { + if ( iEikonEnv->AppUiFactory()->MenuBar()->IsDisplayed() ) + { + iEikonEnv->AppUiFactory()->MenuBar()->StopDisplayingMenuBar(); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ExitMatrix( TExitType aExitType ) + { + DEBUG(("_Mm_:CMmAppUi::ExitMatrix - IN")); + DEBUG(("\t_Mm_:Exit type: %d",aExitType)); + + if ( aExitType == EExitReally ) + { + // Calling PrepareHomescreenForMatrixExitL instead of ShowHomescreenL + // allows for avoiding a bug that would occur if appkey was pressed + // immediately after exiting the menu via Options->Exit. + // The bug would be that on pressing the appkey homescreen would be + // displayed and then the menu would appear again on the screen for + // a fraction of second causing an ugly and confusing flicker effect. + TRAP_IGNORE( PrepareHomescreenForMatrixExitL() ); +// ShowHomescreenL( aExitType ); + //if we got exit cmd from OS, let's really exit. + Exit(); + } + else + { + GfxTransEffect::AbortFullScreen(); + iIsKastorEffectStarted = EFalse; + StartLayoutSwitchFullScreen( AknTransEffect::EApplicationExit ); + + TRAP_IGNORE( ShowHomescreenL( aExitType ) ); + TRAP_IGNORE( CleanupForExitL( EExitKeyRed ) ); + } + + DEBUG(("_Mm_:CMmAppUi::ExitMatrix - OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::CleanupForExitL( TExitKeyType aExitKey ) + { + DEBUG(("_Mm_:CMmAppUi::CleanupForExitL - IN")); + + // closing all dialogs opened in ui extensions before exit + iMmExtManager->ExecuteActionL( TUid::Null(), KCommandDeleteDialog, NULL ); + if( IsDisplayingDialog() ) + { + AknDialogShutter::ShutDialogsL( *iEikonEnv ); + } + + if ( IsEditMode() && iCurrentContainer ) + { + DEBUG(("\t_Mm_:Edit Mode turned off")); + iCurrentContainer->CancelDragL( EFalse ); + SetEditModeL( EFalse ); + } + + // reset model - revert to root if current view is not a suite view + CHnSuiteModel* model = iHNInterface->GetLastSuiteModelL(); + if ( model && aExitKey == EExitKeyApplication ) + { + TBool topSuiteIsBeingEvaluated = + !model->GetItemsOrder()->IsSuiteReadyToShow(); + TBool topSuiteChanged = ResetToRootL(); + model = NULL; // ResetToRootL might have deleted the model + TBool presentationChangeExpected = topSuiteChanged || topSuiteIsBeingEvaluated; + + TBool mustDrawImmediately = + !presentationChangeExpected || !iDummyContainer->IsVisible(); + + if ( iCurrentContainer && mustDrawImmediately ) + { + DEBUG(("\t_Mm_:Top item index reset")); + iCurrentContainer->ResetWidgetPosition(); + iCurrentContainer->Widget()->UpdateScrollBarsL(); + iCurrentContainer->MakeVisible( ETrue ); + iCurrentContainer->DrawNow(); + } + } + + DEBUG(("_Mm_:CMmAppUi::CleanupForExitL - OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ShowHomescreenL( TExitType aExitType ) + { + TInt appToShowUid(0); + TInt idleid(0); + if (aExitType == EExitToIdle) + { + User::LeaveIfError(RProperty::Get(KPSUidAiInformation, KActiveIdleUid, + appToShowUid)); + OpenAppL(TUid::Uid(appToShowUid)); + } + else if (KErrNone == RProperty::Get(KPSUidUikon, KUikVideoCallTopApp, + idleid)) + { + // Possible error code not relevant, as we have valid id anyway + if (idleid != KVideoCallAppUid) // idle or phone + { + OpenAppL(TUid::Uid(KPhoneAppUid)); + } + else + { + CreateActivateViewEventL(TVwsViewId(TUid::Uid(idleid), + TUid::Uid(idleid)), KNullUid, KNullDesC8()); + } + } + else + { + OpenAppL(TUid::Uid(KPhoneAppUid)); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::PrepareHomescreenForMatrixExitL() + { + TBool succeeded( EFalse ); + + CAknTaskList* taskList = CAknTaskList::NewL( iCoeEnv->WsSession() ); + TApaTask task = taskList->FindRootApp( TUid::Uid( KPhoneAppUid ) ); + delete taskList; + + if ( task.Exists() ) + { + succeeded = !iCoeEnv->WsSession().SetWindowGroupOrdinalPosition( + task.WgId(), 1 ); + } + + if( !succeeded ) + { + ShowHomescreenL( EExitReally ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::OpenAppL( const TUid aUid ) + { + DEBUG(("_Mm_:CMmAppUi::OpenAppL - IN")); + DEBUG(("\t_Mm_:aUid: 0x%x",aUid.iUid)); + + // Get the correct application data + CAknTaskList* taskList = CAknTaskList::NewL( iCoeEnv->WsSession() ); + TApaTask task = taskList->FindRootApp( aUid ); + delete taskList; + + if ( task.Exists() ) + { + CAknSgcClient::MoveApp( task.WgId(), ESgcMoveAppToForeground ); + } + else + { + // Task doesn't exist, launch a new instance of an application + TApaAppInfo appInfo; + TApaAppCapabilityBuf capabilityBuf; + RApaLsSession lsSession; + User::LeaveIfError( lsSession.Connect() ); + CleanupClosePushL( lsSession ); + User::LeaveIfError( lsSession.GetAppInfo( appInfo, aUid ) ); + User::LeaveIfError( + lsSession.GetAppCapability( capabilityBuf, aUid ) ); + + TApaAppCapability& caps = capabilityBuf(); + TFileName appName = appInfo.iFullName; + CApaCommandLine* cmdLine = CApaCommandLine::NewLC(); + cmdLine->SetExecutableNameL( appName ); + + if ( caps.iLaunchInBackground ) + { + cmdLine->SetCommandL( EApaCommandBackground ); + } + else + { + cmdLine->SetCommandL( EApaCommandRun ); + } + + User::LeaveIfError( lsSession.StartApp( *cmdLine ) ); + + CleanupStack::PopAndDestroy( cmdLine ); + CleanupStack::PopAndDestroy( &lsSession ); + } + + DEBUG(("_Mm_:CMmAppUi::OpenAppL - OUT")); + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::InitializeL() + { + DEBUG(("_MM_:CMmAppUi::InitializeL IN")); + CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); + CLiwDefaultMap* map = CLiwDefaultMap::NewLC(); + + HBufC* suiteName = StringLoader::LoadLC( R_MENU_TITLE ); + + paramList->AppendL( TLiwGenericParam( KParamSuiteName8, + TLiwVariant( KParamFolderSuite ) ) ); + map->InsertL( KParamSuiteName8, TLiwVariant( suiteName ) ); + map->InsertL( KParamFolderId8, TLiwVariant( KParamFolderId ) ); + map->InsertL( KParamRemoveLocked8, TLiwVariant( KParamFalse ) ); + map->InsertL( KParentFolderId8, TLiwVariant( KParamFolderId ) ); + map->InsertL( KTmpParentFolderId8, TLiwVariant( KParamFolderId ) ); + paramList->AppendL( TLiwGenericParam( KParams8, TLiwVariant( map ) ) ); + + iHNInterface->InitializeL( *paramList ); + + CleanupStack::PopAndDestroy( suiteName ); + CleanupStack::PopAndDestroy( map ); + CleanupStack::PopAndDestroy( paramList ); + DEBUG(("_MM_:CMmAppUi::InitializeL OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::SetMiddleSoftKeyL() + { + DEBUG(("_Mm_:CMmAppUi::SetMiddleSoftKeyL - IN")); + if ( iCurrentSuiteModel && !AknLayoutUtils::PenEnabled() && !IsEditMode() ) + { + DEBUG(("\t_Mm_:suite highlight: %d", + iCurrentSuiteModel->GetSuiteHighlight())); + + TBool idByContainer = iCurrentContainer->IsHighlightVisible() && + iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; + TInt itemId = idByContainer ? + iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ) : + iCurrentSuiteModel->IdByIndex( KErrNotFound ); + CHnItemModel* itemModel = iCurrentSuiteModel->GetItemModel( itemId ); + + CHnButtonModel* mskModel = NULL; + + if ( itemModel ) + { + mskModel = itemModel->GetMiddleSoftKey(); + } + + if ( mskModel ) + { + TInt event = (mskModel->GetEventId() == KErrNotFound) ? + KKeyIdSelect : mskModel->GetEventId(); + Cba()->SetCommandL( CEikButtonGroupContainer::EMiddleSoftkeyPosition, + event, mskModel->GetButtonText()); + } + else + { + // reset to default + RefreshCbaL(); + } + } + DEBUG(("_Mm_:CMmAppUi::SetMiddleSoftKeyL - OUT")); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::StartLayoutSwitchFullScreen( TInt aKastorEffect ) + { + if( ( !iIsKastorEffectStarted && iScreenOn && IsForeground() ) || + aKastorEffect == AknTransEffect::EApplicationStart || + aKastorEffect == AknTransEffect::EApplicationExit ) + { + DEBUG(("_MM_:CMmAppUi::StartLayoutSwitchFullScreen Foreground")); + TUid uid1( KUidMatrixMenuApp ); + TUid uid2( KUidMatrixMenuApp ); + if ( aKastorEffect == AknTransEffect::EApplicationExit ) + { + uid2 = TUid::Null(); + } + + AknTransEffect::TParamBuffer params = AknTransEffect::GfxTransParam( + uid1, uid2, AknTransEffect::TParameter::EFlagNone ); + + GfxTransEffect::BeginFullScreen( aKastorEffect, TRect(), + AknTransEffect::EParameterType, params ); + + iIsKastorEffectStarted = ETrue; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::EndFullScreen() + { + if( iIsKastorEffectStarted && iScreenOn ) + { + DEBUG(("_MM_:CMmAppUi::EndFullScreen Foreground")); + GfxTransEffect::EndFullScreen(); + iIsKastorEffectStarted = EFalse; + } + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleRequestL( const CLiwGenericParamList& aParam, + CLiwGenericParamList* aOutput ) + { + iHNInterface->HandleRequestL( aParam, aOutput ); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::PropertyChangedL(TInt aValue) + { + iKeyboardFlipStatus = (EPSHWRMFlipStatus)aValue; + + if ( iCurrentContainer ) + { + if( iKeyboardFlipStatus == EPSHWRMFlipOpen ) + { + TBool wasHighlightVisible = iCurrentContainer->IsHighlightVisible(); + iCurrentContainer->SetFlipOpenL( ETrue ); + if ( IsForeground() && !IsEditMode() && !wasHighlightVisible ) + { + iCurrentContainer->SetDefaultHighlightL( ETrue ); + } + } + else if( iKeyboardFlipStatus == EPSHWRMFlipClosed ) + { + iCurrentContainer->SetFlipOpenL( EFalse ); + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CMmAppUi::FlipOpen() + { + return iKeyboardFlipStatus == EPSHWRMFlipOpen; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::SetZoom( TAknUiZoom aZoom ) + { + if ( iZoom != aZoom) + { + if ( iCurrentContainer ) + { + iCurrentContainer->HandleZoomChanged( aZoom ); + } + } + iZoom = aZoom; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CMmAppUi::ResetToRootL() + { + TBool resetConsumed( EFalse ); + if( iHNInterface && iCurrentSuiteModel && + !IsRootdisplayedL() ) + { + RemoveFromStack( iCurrentContainer ); + iDummyContainer->MakeVisible( ETrue ); + iHNInterface->HandleBackEventL( + iCurrentSuiteModel->SuiteName(), + iHNInterface->GetSuiteModelsCountL() - 1 ); + ResetContainerMapToRootL(); + if( iCurrentContainer ) + { + iCurrentContainer->ResetWidgetPosition(); + iCurrentContainer->SetZoom( iZoom ); + AddToStackL( iCurrentContainer ); + } + RefreshUiPanesL( ETrue ); + resetConsumed = ETrue; + } + return resetConsumed; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::SkinContentChanged() + { + iSkinChangeNeeded = ETrue; + iSkinChangeInProgress = ETrue; + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::SkinConfigurationChanged( + const TAknsSkinStatusConfigurationChangeReason aReason) + { + DEBUG(("_Mm_:CMmAppUi::SkinConfigurationChanged IN - aReason:%d iSkinChangeNeeded:%d iSkinChangeInProgress:%d", aReason, iSkinChangeNeeded, iSkinChangeInProgress)); + switch (aReason) + { + case EAknsSkinStatusConfigurationMerged:// = 1, + { + iSkinChangeNeeded = ETrue; + iSkinChangeInProgress = ETrue; + } + break; + case EAknsSkinStatusConfigurationDeployed:// = 2, + { + iSkinChangeInProgress = EFalse; + if (IsForeground()) + { + TRAPD( err, RefreshIconsL()); + if (!err) + { + iSkinChangeNeeded = ETrue; + } + } + } + break; + default: + { + + } + } + DEBUG(("_Mm_:CMmAppUi::SkinConfigurationChanged OUT - aReason:%d iSkinChangeNeeded:%d iSkinChangeInProgress:%d", aReason, iSkinChangeNeeded, iSkinChangeInProgress)); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::SkinPackageChanged(const TAknsSkinStatusPackageChangeReason /*aReason*/) + { + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::RefreshIconsL() + { + iSkinChangeNeeded = EFalse; + CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); + TLiwGenericParam command(KHnRequest, TLiwVariant( KRefreshIcons)); + paramList->AppendL(command); + HandleRequestL(*paramList); + CleanupStack::PopAndDestroy(paramList); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleHighlightOffsetL( TInt aOffset ) + { + if( AknLayoutUtils::PenEnabled() ) + { + iHNInterface->TriggerHnEventL( KKeyIdMoveHighlight, aOffset, NULL ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleNumberOfItemsChangedL( TItemsChangeType aChange ) + { + iCurrentContainer->NumberOfItemsChangedL( aChange ); + TBool scrollConsumed( EFalse ); + scrollConsumed = + iCurrentContainer->ScrollToItemL( iCurrentSuiteModel->GetSuiteHighlight() ); + if ( !scrollConsumed || !AknLayoutUtils::PenEnabled() ) + { + iCurrentContainer->DrawNow(); + } + RefreshUiPanesL(); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::ApplyHighlightFromModelL() + { + if ( iCurrentSuiteModel && iCurrentContainer ) + { + TInt highlightedItemIndex = iCurrentSuiteModel->GetSuiteHighlight(); + iCurrentContainer->RestoreWidgetPosition(); + + iCurrentContainer->SetManualHighlightL( + highlightedItemIndex, EFalse ); + if ( iMakeHightlightedItemFullyVisible && + !iCurrentContainer->ItemIsFullyVisible( highlightedItemIndex ) ) + { + iCurrentContainer->ScrollToItemL( highlightedItemIndex ); + } + iCurrentContainer->CacheWidgetPosition(); + iMakeHightlightedItemFullyVisible = EFalse; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleFocusGainedL() + { + DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " + "- EEventFocusGained")); + + iHasFocus = ETrue; + + // Tricky: lack of iCurrentSuiteModel indicates that suite evaluation is in + // progress - do not call HandlePresentationChangeL if evalution has not + // finished. + if ( iCurrentContainer && !iCurrentContainer->IsVisible() && + iCurrentSuiteModel ) + { + HandlePresentationChangeL( iCurrentContainer ); + } + + if ( iCurrentSuiteModel && iCurrentContainer ) + { + iDummyContainer->MakeVisible( EFalse ); + iCurrentContainer->MakeVisible( ETrue ); + iCurrentContainer->DrawNow(); + } + if( IsForeground() ) + { + RefreshUiPanesL(); + } + if ( iCurrentContainer ) + { + iCurrentContainer->SetHasFocusL( ETrue ); + } + if ( iCurrentSuiteModel ) + { + iCurrentSuiteModel->SetVisibleL( ETrue ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleFocusLostL() + { + DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " + "- EEventFocusLost")); + + iHasFocus = EFalse; + + if( iCurrentContainer ) + { + //This is needed in case some popup is displayed + //while touching item in grid. Highlight + //should be reset to normal then. + if( AknLayoutUtils::PenEnabled() ) + { + if( iCurrentContainer->WidgetType() == EGridWidget + && !FlipOpen() && !IsEditMode() ) + { + iCurrentContainer->Widget()->View()->ItemDrawer()-> + SetFlags( CListItemDrawer::EDisableHighlight ); + } + iCurrentContainer->Widget()->View()-> + ItemDrawer()->ClearFlags( CListItemDrawer::EPressedDownState ); + iCurrentContainer->Widget()->View()->DrawItem( + iCurrentContainer->Widget()->CurrentItemIndex() ) ; + } + if( IsEditMode() && iCurrentContainer->IsDraggable() ) + { + iCurrentContainer->CancelDragL( EFalse ); + iCurrentContainer->DrawNow(); + } + iCurrentContainer->SetHasFocusL( EFalse ); + } + if ( iCurrentSuiteModel ) + { + iCurrentSuiteModel->SetVisibleL( EFalse ); + } + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleFullOrPartialForegroundGainedL() + { + DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " + "- KAknFullOrPartialForegroundGained")); + if (iCurrentContainer && iCurrentSuiteModel ) + { + iCurrentContainer->HandleForegroundGainedL(); + iDummyContainer->MakeVisible( EFalse ); + iCurrentContainer->MakeVisible( ETrue ); + RefreshUiPanesL(); + } + if (iSkinChangeNeeded && !iSkinChangeInProgress) + { + MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); + if (skinInstance && !skinInstance->IsUpdateInProgress()) + { + RefreshIconsL(); + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::HandleFullOrPartialForegroundLostL() + { + DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " + "- KAknFullOrPartialForegroundLost")); + iMmExtManager->ExecuteActionL( + TUid::Null(), KCommandDeleteDialog, NULL ); + if ( iCurrentContainer ) + { + iCurrentContainer->HandleBackgroundGainedL(); + if ( !IsRootdisplayedL() || IsEditMode() || + iEditModeStatus == ETransitionFromEditMode ) + { + iDummyContainer->MakeVisible( ETrue ); + RefreshUiPanesL( ETrue ); + iCurrentContainer->MakeVisible( EFalse ); + iDummyContainer->DrawNow(); + } + if ( IsRootdisplayedL() ) + { + iCurrentContainer->RestoreWidgetPosition(); + iCurrentContainer->CacheWidgetPosition(); + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CMmAppUi::DetectOptionsMenuOpenDisplayChangeL() + { + CEikMenuBar* menuBar = iAppUiFactory->MenuBar(); + TBool optionsMenuIsOpen = menuBar && menuBar->IsDisplayed(); + if ( !!iOptionsMenuIsOpen != !!optionsMenuIsOpen ) + { + iOptionsMenuIsOpen = optionsMenuIsOpen; + if ( iCurrentContainer ) + { + iCurrentContainer->HandleOptionsMenuVisibilityChangeL( + iOptionsMenuIsOpen ); + } + } + } + +// End of File