diff -r 000000000000 -r 2f259fa3e83a uifw/AvKon/src/aknenv.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/AvKon/src/aknenv.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,1497 @@ +/* +* Copyright (c) 2002-2008 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: +* +*/ + +#include "aknenv.h" +#include "AknUtils.h" +#include "aknEditStateIndicator.h" +#include "AknSgcc.h" +#include "AknSettingCache.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "AknFontRegistry.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif +// Needed to use MopGetObject +#include + +#include +#include // KUikLayoutState +#include // KAknQwertyInputModeActive +#include "AknDebug.h" +#include // CCoeControlStaticSettings +#include // For font size indices +#include + +#define APPLY_CONE_FONT_EXTRA_LARGE_FACTOR(a) ( a * 4 / 3 ) +#define APPLY_CONE_FONT_EXTRA_SMALL_FACTOR(a) ( a * 3 / 4 ) + +#include "transitionmanager.h" +#include // for Transition effect enumerations + +// TAknLayoutConfigScreenMode is defined like this because +// the name CAknLayoutConfig::TScreenMode can't be used +// in SDK header files (AknEnv.h). This technique essentially +// gives us an alternative name for CAknLayoutConfig::TScreenMode, +// which can be used in a public header. +class TAknLayoutConfigScreenMode : public CAknLayoutConfig::TScreenMode + { +public: + TAknLayoutConfigScreenMode(const CAknLayoutConfig::TScreenMode& aCopy) + : CAknLayoutConfig::TScreenMode(aCopy) + { + } + }; + + +// CAknCommandMediator is an internal class for mediating MSK commands from +// CBA to specified observer. +NONSHARABLE_CLASS( CAknCommandMediator ) + : public CBase, + public MEikCommandObserver + { +public: + CAknCommandMediator() {}; + ~CAknCommandMediator(); + void SetCbaObserverL( CEikButtonGroupContainer& aCba, + MEikCommandObserver& aCommandObserver ); + void InformCbaDeletion( CEikButtonGroupContainer& aCba ); + void RemoveCbaObserver( MEikCommandObserver& aCommandObserver ); + + // From MEikCommandObserver + void ProcessCommandL( TInt aCommandId ); + +private: + + CEikButtonGroupContainer *iCba; + MEikCommandObserver* iCommandObserver; + }; + + +CAknCommandMediator::~CAknCommandMediator() + { + // These should already be deleted when CAknEnv is being deleted. + iCba = NULL; + iCommandObserver = NULL; + } + + +void CAknCommandMediator::ProcessCommandL( TInt aCommandId ) + { + __ASSERT_DEBUG( iCommandObserver, User::Invariant() ); + if ( iCommandObserver ) + { + // Mediate event to the observer. + iCommandObserver->ProcessCommandL( aCommandId ); + } + } + +void CAknCommandMediator::SetCbaObserverL( CEikButtonGroupContainer& aCba, + MEikCommandObserver& aCommandObserver ) + { + // Remove mediator from observing the previously set cba. + if ( iCba && iCba != &aCba ) + { + iCba->RemoveCommandObserver( 3 ); + + iCba = NULL; + iCommandObserver = NULL; + } + + // Update command observer. + if ( &aCba && &aCommandObserver ) + { + aCba.UpdateCommandObserverL( 3, *this ); + + iCba = &aCba; + iCommandObserver = &aCommandObserver; + } + } + +void CAknCommandMediator::InformCbaDeletion( CEikButtonGroupContainer& aCba ) + { + // Check whether the cba, for which the commands are being mediated, + // is being deleted. + if ( iCba == &aCba ) + { + iCba = NULL; + iCommandObserver = NULL; + } + } + +void CAknCommandMediator::RemoveCbaObserver( + MEikCommandObserver& aCommandObserver ) + { + if ( iCommandObserver && iCommandObserver == &aCommandObserver ) + { + __ASSERT_DEBUG( iCba, User::Invariant() ); + iCba->RemoveCommandObserver( 3 ); + + iCba = NULL; + iCommandObserver = NULL; + } + } + + +// const TInt KAknEnvScrollHostGranularity = 1; +const TInt KInitialRunInfoArraySize = 5; +const TInt KAknEnvNoScreenModeLoaded = -1; + +// Avkon Color support +const TUint8 ColorRemapTable[256] = + { + 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0x00, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xd7 + }; + +EXPORT_C void CAknEnv::SetFepMenuObserver(MEikMenuObserver* aObserver) + { + iFepMenuObserver = aObserver; + } + +EXPORT_C MEikMenuObserver* CAknEnv::FepMenuObserver() + { + return iFepMenuObserver; + } + +EXPORT_C MAknEditingStateIndicator* CAknEnv::EditingStateIndicator() + { + return iEditStateIndicator; + } + +EXPORT_C MAknEditingStateIndicator* CAknEnv::SwapEditingStateIndicator(MAknEditingStateIndicator* aIndicator) + { + MAknEditingStateIndicator* indicator = iEditStateIndicator; + iEditStateIndicator = aIndicator; + return indicator; + } + +EXPORT_C void CAknEnv::ExitForegroundAppL() + { + RWsSession& wsSession=CEikonEnv::Static()->WsSession(); + TInt count=wsSession.NumWindowGroups(0); + CArrayFixFlat* wgIds=new(ELeave) CArrayFixFlat(count); + CleanupStack::PushL(wgIds); + // Get list of window group ids from WServ + wsSession.WindowGroupList(0,wgIds); + // Select the first in the list (which will always be the forground app) + TInt wgId = (*wgIds)[0]; + CleanupStack::PopAndDestroy(); // wgIds; + + // Exit app + TApaTask task(wsSession); + task.SetWgId(wgId); + task.SendSystemEvent(EApaSystemEventShutdown); + } + + + +EXPORT_C CAknEnv::CAknEnv() : iWsBufferRequestArray( 1 ), iLastScreenMode(KAknEnvNoScreenModeLoaded) + { + } + +EXPORT_C void CAknEnv::ConstructL() + { + TName threadName=RThread().Name(); + TBool isEiksrvThread=(threadName.CompareC(EIKAPPUI_SERVER_THREAD_NAME)==KErrNone); + + User::LeaveIfError( RAknIconSrvClient::Connect() ); + + iCdlEngRef = CdlEngine::CreateCdlEngineL(); + + iSettingCache = CAknSettingCache::NewL(); + + //if KFeatureIdUiTransitionEffects is not supported, CTransitionManager::NewL returns NULL + iTransitionManager = CTransitionManager::NewL( *iCoeEnv ); + + iStateArray = new(ELeave) CArrayPtrFlat(1); + CAknSgcClient::CreateL(); // owned by CCoeStatic system + TAknPopupFader::CreateStaticL(); // owned by CCoeStatic system + + iRunInfoArray = new( ELeave ) + TBidirectionalState::TRunInfo[KInitialRunInfoArraySize]; + + iRunInfoArrayLength = KInitialRunInfoArraySize; + + SetLayoutRequirementsL(); + LoadAknLayoutL(); + AssertLayoutLoaded(); + iLayout = &AknLayout::CustomisationInstance(); + + // Set the current feature language + if (FeatureManager::FeatureSupported(KFeatureIdJapanese)) + { + iFeatureLanguage = KFeatureIdJapanese; + } + + } + +EXPORT_C CAknEnv* CAknEnv::Static() + { + return (CAknEnv*)CEikonEnv::Static()->Extension(); + } + +EXPORT_C CAknEnv::~CAknEnv() + { + delete iCommandMediator; + delete iTransitionManager; + delete iCdlEngRef; + delete iBusyMsgDialog; + iBusyMsgDialog = NULL; // just in case scheduler callback tries to use this during exit + delete iIdle; + delete iStateArray; + delete iSettingCache; + delete [] iRunInfoArray; + iWsBufferRequestArray.Close(); + RAknIconSrvClient::Disconnect(); + delete iFontRegistry; + FeatureManager::UnInitializeLib(); + } + + +EXPORT_C void CAknEnv::RegisterIntermediateStateL(MAknIntermediateState *aState) + { + iStateArray->AppendL(aState); + } + +EXPORT_C void CAknEnv::UnRegisterIntermediateState(MAknIntermediateState *aState) + { + TInt count = iStateArray->Count(); + TInt i; + for (i=0; iAt(i) == aState) + break; + } + if (iDelete(i); + } + +EXPORT_C void CAknEnv::CloseAllIntermediateStates() + { + delete iIdle; + iIdle = NULL; + iIdle = CIdle::New(EActivePriorityWsEvents+1); + if (iIdle) + iIdle->Start(TCallBack(RealCloseIntermediateStates, this)); + } + +// ----------------------------------------------------------------------------- +// CAknEnv::GetTransparencyEnabled +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CAknEnv::TransparencyEnabled() const + { + return iSettingCache->TransparencyEnabled(); + } + + +TInt CAknEnv::RealCloseIntermediateStates(TAny *aEnvAny) + { + CAknEnv *env = (CAknEnv*)aEnvAny; + TInt count = env->iStateArray->Count(); + for (TInt i=0; iiStateArray->At(i)->CloseState(); + } + env->iStateArray->Reset(); + + // Destroy the CIdle. + delete env->iIdle; + env->iIdle = 0; + return EFalse; + } + +TBool CAknEnv::HasBlank() const + { + return iTransitionManager == NULL; //when there is no effects, there is screenblanker + } + +void CAknEnv::TransitionEvent(TInt aEvent) + { + TransitionEvent(aEvent, KNullUid); + } + +void CAknEnv::TransitionEvent(TInt aEvent, const TUid& aUid) + { + if(iTransitionManager != NULL) + { + switch(aEvent) + { + case AknTransEffect::EEmbeddedApplicationStart: + iTransitionManager->SetEmbedded(); //go trough + case AknTransEffect::EApplicationStartSwitch: + case AknTransEffect::EApplicationStart: + case AknTransEffect::EAppStartupBackground: + iTransitionManager->AppStartup(aEvent, aUid); + break; + case AknTransEffect::EAppStartComplete: + iTransitionManager->AppStartupComplete(); + break; + case AknTransEffect::EApplicationExit: + iTransitionManager->AppExit(aEvent, aUid); + break; + case KAknTransitionDeactivate: + break; + case AknTransEffect::EApplicationActivate: + iTransitionManager->AppSwitch(aEvent); + break; + case KAknTransitionEventAvkon: + iTransitionManager->SetAvkon(); + break; + case KAknTransitionEventFlags: + iTransitionManager->CheckFlags(); + break; + case KAknTransitionExitCancel: + iTransitionManager->CancelExit(); + break; + default: + __ASSERT_DEBUG(0, User::Panic(_L("Unknown transition"), aEvent)); + User::Invariant(); + } + } + } + + +class CMyListBox : public CAknSinglePopupMenuStyleListBox + { +public: + TKeyResponse OfferKeyEventL(const TKeyEvent &aKeyEvent, TEventCode aType) + { + if (aKeyEvent.iCode != EKeyOK) + return CAknSinglePopupMenuStyleListBox::OfferKeyEventL(aKeyEvent, aType); + return EKeyWasConsumed; + } + void ActivateL() + { + STATIC_CAST(CFormattedCellListBoxItemDrawer*,this->View()->ItemDrawer())->FormattedCellData()->SetSubCellAlignmentL(0,CGraphicsContext::ECenter); + + } + }; + +EXPORT_C void CAknEnv::ExecuteEmptyPopupListL(const TDesC *aEmptyText, const TDesC *aPopupTitle, TInt aSoftKeyId) + { + HBufC *message = CCoeEnv::Static()->AllocReadResourceL(R_AVKON_EMPTY_POPUP_LIST_TEXT); + CleanupStack::PushL(message); + + HBufC *emptysoftkey = CCoeEnv::Static()->AllocReadResourceL(R_TEXT_SOFTKEY_EMPTY); + CleanupStack::PushL(emptysoftkey); + + if (!aEmptyText) + { + aEmptyText = message; + } + + CEikFormattedCellListBox *list = new(ELeave)CMyListBox; + CleanupStack::PushL(list); + if (aSoftKeyId == 0) aSoftKeyId = R_AVKON_SOFTKEYS_CANCEL; + + CAknPopupList *popupList = CAknPopupList::NewL(list, aSoftKeyId, AknPopupLayouts::EMenuWindow); + CleanupStack::PushL(popupList); + list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect); + + // Logical to visual conversion is already performed. + list->UseLogicalToVisualConversion( ETrue ); + + // Some viewers use ok_empty; We remove left softkey if right softkey has + // something else than empty. + if (! ( aSoftKeyId == R_AVKON_SOFTKEYS_OK_EMPTY)) + popupList->ButtonGroupContainer()->SetCommandL(0,EAknSoftkeyEmpty, *emptysoftkey); + + CDesCArrayFlat *items = new(ELeave)CDesCArrayFlat(1); + CleanupStack::PushL(items); + + CTextListBoxModel* model=list->Model(); + model->SetItemTextArray(items); + model->SetOwnershipType(ELbmOwnsItemArray); + CleanupStack::Pop(); // items + + list->View()->ItemDrawer()->SetFlags(CTextListItemDrawer::EDisableHighlight); + + list->View()->SetListEmptyTextL(*aEmptyText); + + if (aPopupTitle) + { + popupList->SetTitleL(*aPopupTitle); + } + CleanupStack::Pop(); // popupList + popupList->ExecuteLD(); + + CleanupStack::PopAndDestroy( 3 ); // list, emptysoftkey, message + } + +EXPORT_C void CAknEnv::ExecuteEmptyPopupListL(const TDesC *aEmptyText) + { + ExecuteEmptyPopupListL(aEmptyText,0); + } + +EXPORT_C void CAknEnv::RunAppShutter() + { + CEikonEnv* eikEnv = CEikonEnv::Static(); + CAknAppUi* base = (CAknAppUi*)eikEnv->EikAppUi(); + while (base && base->ContainerAppUi()) + base = (CAknAppUi*)base->ContainerAppUi(); + + CEikAppServer* server = eikEnv->AppServer(); + if (server) + server->NotifyServerExit(EAknCmdExit); + + if (base) + base->RunAppShutter(); + } + +EXPORT_C CAknAppUi* CAknEnv::AppWithShutterRunning() + { + CEikonEnv* eikEnv = CEikonEnv::Static(); + CAknAppUi* app = (CAknAppUi*)eikEnv->EikAppUi(); + do { + if (app->IsAppShutterRunning()) + return app; + app = (CAknAppUi*)app->ContainerAppUi(); + } while (app); + + return NULL; + } + +EXPORT_C void CAknEnv::StopSchedulerWaitWithBusyMessage(CActiveSchedulerWait& aWait) + { + if (aWait.IsStarted()) + { + if (aWait.CanStopNow()) + { + aWait.AsyncStop(); + } + else + { + CEikonEnv* eikEnv = CEikonEnv::Static(); + CEikAppUi* appUi = eikEnv->EikAppUi(); + if (appUi && !appUi->IsDisplayingDialog()) + { + // If the waiting control can't stop the scheduler immediately, try to show + // a busy note to alert the user and prevent them from using the app till the + // scheduler can return. + // Some other service running in your app has started a scheduler wait, but not + // stopped it before this waiting control exited. That service must stop it's scheduler wait + // before this one can stop. + // + // The dialog is stored as member data with a reference count to ensure that it is deleted + // on app exit and that it lasts as long as it should. + CAknEnv* env = Static(); + if (!env->iBusyMsgDialog) + { + TRAP_IGNORE( + { + env->iBusyMsgDialog = new(ELeave) CAknWaitDialog(reinterpret_cast(&env->iBusyMsgDialog), ETrue); + env->iBusyMsgDialog->ExecuteLD(R_SCHEDULER_STOP_BUSY_MESSAGE); + }); + } + env->iBusyMsgCount++; + aWait.AsyncStop(TCallBack(SchedulerStoppedCallBack, env)); + } + } + } + } + +TInt CAknEnv::SchedulerStoppedCallBack(TAny* aThis) + { + CAknEnv* self = static_cast(aThis); + self->DoSchedulerStoppedCallBack(); + return 0; + } + +void CAknEnv::DoSchedulerStoppedCallBack() + { + iBusyMsgCount--; + if (iBusyMsgCount<=0 && iBusyMsgDialog) + { + TRAP_IGNORE(iBusyMsgDialog->ProcessFinishedL()); + } + } + +NONSHARABLE_CLASS(CLBCommandObserver) : public MEikCommandObserver + { +public: + CLBCommandObserver(CEikButtonGroupContainer *aCba, CEikListBox *aListBox); + void ProcessCommandL(TInt aCommandId); + CEikButtonGroupContainer *iCba; + CEikListBox *iListBox; + }; + + +CLBCommandObserver::CLBCommandObserver(CEikButtonGroupContainer *aCba, CEikListBox *aListBox) + : iCba(aCba), iListBox(aListBox) + { + } + +void CLBCommandObserver::ProcessCommandL(TInt aCommandId) + { + // We will be executing this code only when commandid is correct. + // so no need to test for aCommandId. + if (aCommandId == EAknSoftkeyOk) + { + // We need to send a key event that will cause redraw of application state. + // This is because of multi-item fetch in phonebook works kinda odd and + // we need to update it's state. (just need to make sure findbox does + // not eat this key :-) + TKeyEvent keyevent; + keyevent.iCode = EKeyApplicationF; + keyevent.iModifiers = 0; + CEikonEnv::Static()->SimulateKeyEventL(keyevent, EEventKey); + } + + CEikButtonGroupContainer *cba = iCba; + AVKONENV->RemoveCbaObserver(); + // the next call is very likely to delete listbox and cba. + // resend the event to the cba. + STATIC_CAST(MEikCommandObserver*,cba)->ProcessCommandL(aCommandId); + } + + +EXPORT_C void CAknEnv::CreateCbaObserverL(CEikButtonGroupContainer *aCba, CEikListBox *aListBox) + { + RemoveCbaObserver(); + iCbaCommandObserver = new(ELeave)CLBCommandObserver(aCba, aListBox); + TRAPD(error, aCba->UpdateCommandObserverL(0, *iCbaCommandObserver)); + if (error) + { + delete iCbaCommandObserver; + iCbaCommandObserver = NULL; + User::Leave(error); + } + } + +EXPORT_C void CAknEnv::RemoveCbaObserver() + { + if (iCbaCommandObserver) + { + STATIC_CAST(CLBCommandObserver*,iCbaCommandObserver)->iCba->RemoveCommandObserver(0); + delete iCbaCommandObserver; + iCbaCommandObserver = NULL; + } + } + +EXPORT_C void CAknEnv::InformCbaDeletion(CEikButtonGroupContainer *aCba) + { + if (iCbaCommandObserver) + { + if (STATIC_CAST(CLBCommandObserver*, iCbaCommandObserver)->iCba == aCba) + { + RemoveCbaObserver(); + } + } + + if ( iCommandMediator ) + { + iCommandMediator->InformCbaDeletion( *aCba ); + } + } + +// --------------------------------------------------------------------------- +// Creates new command mediator if necessary, and sets it to mediate commands. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknEnv::RequestCommandMediationL( + CEikButtonGroupContainer& aCba, MEikCommandObserver& aCommandObserver ) + { + if ( !iCommandMediator ) + { + iCommandMediator = new ( ELeave ) CAknCommandMediator; + } + + iCommandMediator->SetCbaObserverL( aCba, aCommandObserver ); + } + +EXPORT_C void CAknEnv::EndCommandMediation( + MEikCommandObserver& aCommandObserver ) + { + if ( iCommandMediator ) + { + iCommandMediator->RemoveCbaObserver( aCommandObserver ); + } + } + + +EXPORT_C void CAknEnv::GetCurrentLayoutId(TAknLayoutId& aCurrentLayoutId) const + { + aCurrentLayoutId = iSettingCache->LayoutId(); + } + +EXPORT_C void CAknEnv::GetCurrentGlobalUiZoom(TAknUiZoom& aCurrentGlobalUiZoom) const + { + aCurrentGlobalUiZoom = iSettingCache->GlobalUiZoom(); + } + + +// ----------------------------------------------------------------------------- +// CAknEnv::RequestWsBuffer +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CAknEnv::RequestWsBuffer( TInt aRequestedBufferSize ) + { + TInt ret = KErrGeneral; + + if ( aRequestedBufferSize > 0 ) + { + // Cut down to max size. + if ( aRequestedBufferSize > KAknMaxWsBufferSize ) + { + aRequestedBufferSize = KAknMaxWsBufferSize; + } + + // Generate request ID, they start from 1. + TInt requestID = ++iRequestIdCounter; + + TWsBufferRequest request = {requestID, aRequestedBufferSize}; + ret = iWsBufferRequestArray.Append( request ); + + if ( ret == KErrNone ) + { + if ( aRequestedBufferSize > iCurrentWsBufferRequest ) + { + SetWsBufferSize(); + } + + // return the request ID + ret = requestID; + } + } + + return ret; + } + +// ----------------------------------------------------------------------------- +// CAknEnv::CancelWsBufferRequest +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknEnv::CancelWsBufferRequest( TInt aRequestID ) + { + // Real request IDs are always positive, ignore others. + if ( aRequestID > 0 ) + { + TInt count = iWsBufferRequestArray.Count(); + + for ( TInt i = 0 ; i < count ; i++ ) + { + TWsBufferRequest& request = iWsBufferRequestArray[i]; + + if ( request.iRequestID == aRequestID ) + { + TInt canceledRequestSize = request.iRequestedSize; + iWsBufferRequestArray.Remove( i ); + + // If the canceled request was not lower than the currently + // highest request, set WS buffer size again according to the + // list of requests. + + if ( canceledRequestSize >= iCurrentWsBufferRequest ) + { + SetWsBufferSize(); + } + break; + } + } + } + } + +// ----------------------------------------------------------------------------- +// CAknEnv::SetWsBufferSize +// ----------------------------------------------------------------------------- +// +void CAknEnv::SetWsBufferSize() + { + TInt count = iWsBufferRequestArray.Count(); + + // Only if there are no requests, default to KAknDefaultWsBufferSize. + // This allows requesting also smaller WS buffer sizes for saving RAM. + TInt highestRequest = count ? 0 : KAknDefaultWsBufferSize; + + // Find out the highest request + for ( TInt i = 0 ; i < count ; i++ ) + { + TInt requestedSize = iWsBufferRequestArray[i].iRequestedSize; + + if ( requestedSize > highestRequest ) + { + highestRequest = requestedSize; + } + } + + SetWsBufferSize( highestRequest ); + } + +// ----------------------------------------------------------------------------- +// CAknEnv::SetWsBufferSize +// ----------------------------------------------------------------------------- +// +void CAknEnv::SetWsBufferSize( TInt aRequestedBufferSize ) + { + TRAPD( err, iEikonEnv->WsSession().SetMaxBufferSizeL( + aRequestedBufferSize ) ); + + if ( !iWsBufferRequestArray.Count() ) + { + iCurrentWsBufferRequest = 0; + } + + else if ( err == KErrNone ) + { + iCurrentWsBufferRequest = aRequestedBufferSize; + } + } + +EXPORT_C CAknSettingCache& CAknEnv::SettingCache() const + { + return *iSettingCache; + } + +TBidirectionalState::TRunInfo* CAknEnv::RunInfoArray( TInt& aLength ) const + { + aLength = iRunInfoArrayLength; + return iRunInfoArray; + } + +TInt CAknEnv::PrepareRunInfoArray( const TDesC& aLogicalText ) + { + TBidiLogicalToVisual converter( + aLogicalText, + iRunInfoArray, + iRunInfoArrayLength ) ; + + TInt count = converter.Reorder(); + return SetRequiredRunInfoArraySize( count ); + } + +TInt CAknEnv::SetRequiredRunInfoArraySize( TInt aLength ) + { + TInt ret( KErrNone ); + + if ( iRunInfoArrayLength < aLength ) + { + TBidirectionalState::TRunInfo* array = + new TBidirectionalState::TRunInfo[aLength]; + + if ( array ) + { + delete [] iRunInfoArray; + iRunInfoArray = array; + iRunInfoArrayLength = aLength; + } + else + { + ret = KErrNoMemory; + } + } + + return ret; + } + +struct SStatusPaneEquivResIds + { + TInt iElaf; + TInt iAbrw; + }; + +struct SStatusPaneOrientationEquivResIds + { + TInt iResId; + TInt iEqvivResId; + }; + + +/** +* Mirrored (Arabic & Hebrew) mapping of status pane layout resources. +* +* Note that mirrored status pane layouts are not used anymore, +* so there is no actual mapping here. +*/ +const SStatusPaneEquivResIds KStatusPaneEquivResIds[] = + { + { R_AVKON_STATUS_PANE_LAYOUT_IDLE, R_AVKON_STATUS_PANE_LAYOUT_IDLE }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_STATUS_PANE_LAYOUT_USUAL }, + { R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE, R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE }, + { R_AVKON_STATUS_PANE_LAYOUT_EMPTY, R_AVKON_STATUS_PANE_LAYOUT_EMPTY }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE, R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL, R_AVKON_STATUS_PANE_LAYOUT_SMALL }, + { R_AVKON_STATUS_PANE_LAYOUT_VT, R_AVKON_STATUS_PANE_LAYOUT_VT } + +// {R_AVKON_STATUS_PANE_LAYOUT_IDLE, R_AVKON_STATUS_PANE_LAYOUT_IDLE_MIRRORED}, +// {R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_STATUS_PANE_LAYOUT_USUAL_MIRRORED}, +// {R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE, R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE_MIRRORED}, +// {R_AVKON_STATUS_PANE_LAYOUT_EMPTY, R_AVKON_STATUS_PANE_LAYOUT_EMPTY}, +// {R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE, R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE_MIRRORED}, +// {R_AVKON_STATUS_PANE_LAYOUT_SMALL, R_AVKON_STATUS_PANE_LAYOUT_SMALL}, +// {R_AVKON_STATUS_PANE_LAYOUT_VT, R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED} + }; + + +/** +* Status pane layout resource mapping for landscape orientation with right softkeys. +* Here each of the status pane layout IDs which can not be used in RSK stacon mode are +* mapped to the equivalent RSK stacon mode status pane resource IDs. +*/ +const SStatusPaneOrientationEquivResIds KStatusPaneSoftkeysRightEquivResIds[] = + { + { R_AVKON_STATUS_PANE_LAYOUT_IDLE, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_EXT, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT }, + + { R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_WITH_BATTERY_PANE,R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + + { R_AVKON_STATUS_PANE_LAYOUT_EMPTY, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + + { R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + + { R_AVKON_STATUS_PANE_LAYOUT_VT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT_NO_SOFTKEYS, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT } + }; + + +/** +* Status pane layout resource mapping for landscape orientation with left softkeys. +* Here each of the status pane layout IDs which can not be used in LSK stacon mode are +* mapped to the equivalent LSK stacon mode status pane resource IDs. +*/ +const SStatusPaneOrientationEquivResIds KStatusPaneSoftkeysLeftEquivResIds[] = + { + { R_AVKON_STATUS_PANE_LAYOUT_IDLE, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_EXT, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT }, + + { R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_WITH_BATTERY_PANE,R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + + { R_AVKON_STATUS_PANE_LAYOUT_EMPTY, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + + { R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + + { R_AVKON_STATUS_PANE_LAYOUT_VT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT_NO_SOFTKEYS, R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS, R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT } + }; + + +/** +* Status pane layout resource mapping for landscape orientation with bottom softkeys (flat status pane). +* Here each of the status pane layout IDs which can not be used in landscape BSK mode are +* mapped to the equivalent landscape BSK mode status pane resource IDs. +*/ +const SStatusPaneOrientationEquivResIds KStatusPaneSoftkeysBottomEquivResIds[] = + { + { R_AVKON_STATUS_PANE_LAYOUT_IDLE, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_EXT, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_MIRRORED, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS }, + + { R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_MIRRORED, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_WITH_BATTERY_PANE, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + + { R_AVKON_STATUS_PANE_LAYOUT_VT, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT_NO_SOFTKEYS, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + }; + + +/** +* Status pane layout resource mapping for portrait orientation. +* Here each of the status pane layout IDs which can not be used in portrait mode are +* mapped to the equivalent portrait mode status pane resource IDs. +*/ +const SStatusPaneOrientationEquivResIds KStatusPanePortraitEquivResIds[] = + { +#ifndef __SERIES60_31__ + { R_AVKON_STATUS_PANE_LAYOUT_IDLE, R_AVKON_STATUS_PANE_LAYOUT_IDLE_EXT },// UNCOMMENT this for enablling extended statuspane as default +#else + { R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_STATUS_PANE_LAYOUT_USUAL }, +#endif + +#ifndef __SERIES60_31__ + { R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT }, // UNCOMMENT this for enablling extended statuspane as default +#endif + +#ifndef __SERIES60_31__ + { R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT, R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT }, // UNCOMMENT this for enablling extended statuspane as default + { R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT, R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT }, // UNCOMMENT this for enablling extended statuspane as default +#else + { R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT, R_AVKON_STATUS_PANE_LAYOUT_USUAL }, // COMMENT this for enablling extended statuspane as default + { R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT, R_AVKON_STATUS_PANE_LAYOUT_USUAL }, // COMMENT this for enablling extended statuspane as default +#endif + { R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT, R_AVKON_STATUS_PANE_LAYOUT_IDLE }, + { R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT, R_AVKON_STATUS_PANE_LAYOUT_IDLE }, + { R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_RIGHT, R_AVKON_STATUS_PANE_LAYOUT_EMPTY }, + { R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_LEFT, R_AVKON_STATUS_PANE_LAYOUT_EMPTY }, + + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL, R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE, R_AVKON_STATUS_PANE_LAYOUT_IDLE_EXT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT, R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT_NO_SOFTKEYS, R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS, R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT } + }; + + +/** +* Status pane layout resource mapping for widescreen status pane mode (nHD landscape). +* Here each of the status pane layout IDs which can not be used in nHD mode are +* mapped to the equivalent nHD resource IDs. +*/ +const SStatusPaneOrientationEquivResIds KStatusPaneWidescreenEquivResIds[] = + { + { R_AVKON_STATUS_PANE_LAYOUT_USUAL, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_MIRRORED, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + { R_AVKON_STATUS_PANE_LAYOUT_USUAL_WITH_BATTERY_PANE, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + { R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + { R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + + { R_AVKON_STATUS_PANE_LAYOUT_IDLE, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_EXT, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS }, + { R_AVKON_STATUS_PANE_LAYOUT_IDLE_MIRRORED, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE }, + { R_AVKON_STATUS_PANE_LAYOUT_VT, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE }, + { R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE }, + { R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE }, + { R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT, R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE }, + + { R_AVKON_STATUS_PANE_LAYOUT_SMALL, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + { R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE_MIRRORED, R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL }, + + { R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_RIGHT, R_AVKON_STATUS_PANE_LAYOUT_EMPTY}, + { R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_LEFT, R_AVKON_STATUS_PANE_LAYOUT_EMPTY} + }; + + +static TBool IsAreaSideRightPaneActive() + { + return EFalse; + } + + +EXPORT_C TInt CAknEnv::StatusPaneResIdForCurrentLayout( TInt aResId ) const + { + TInt resId = aResId; + + // static mapping of usual layouts first. + if ( Layout_Meta_Data::IsLandscapeOrientation() ) + { + // Map A&H first if needed + const SStatusPaneEquivResIds* equiv = NULL; + for (TUint ii=0; iiiElaf; + break; + } + } + + // Get the cba location. + CAknLayoutConfig::TScreenMode screenMode = CAknSgcClient::ScreenMode(); + TAknPrivSoftkeyLocation softkeyLocation = screenMode.SoftkeyLocation(); + + + if ( IsAreaSideRightPaneActive() ) + { + for ( TUint ii = 0; + ii < sizeof( KStatusPaneWidescreenEquivResIds ) / + sizeof( *KStatusPaneWidescreenEquivResIds ); + ii++ ) + { + if ( KStatusPaneWidescreenEquivResIds[ii].iResId == resId) + { + resId = KStatusPaneWidescreenEquivResIds[ii].iEqvivResId; + break; + } + } + } + else if (softkeyLocation == EAknPrivSoftkeyLocationRight) + { + for ( TUint ii = 0; + ii < sizeof( KStatusPaneSoftkeysRightEquivResIds ) / + sizeof( *KStatusPaneSoftkeysRightEquivResIds ); + ii++) + { + if (KStatusPaneSoftkeysRightEquivResIds[ii].iResId == resId) + { + resId = KStatusPaneSoftkeysRightEquivResIds[ii].iEqvivResId; + break; + } + } + } + else if (softkeyLocation == EAknPrivSoftkeyLocationLeft) + { + for ( TUint ii = 0; + ii < sizeof( KStatusPaneSoftkeysLeftEquivResIds ) / + sizeof( *KStatusPaneSoftkeysLeftEquivResIds ); + ii++ ) + { + if (KStatusPaneSoftkeysLeftEquivResIds[ii].iResId == resId) + { + resId = KStatusPaneSoftkeysLeftEquivResIds[ii].iEqvivResId; + break; + } + } + } + else if (softkeyLocation == EAknPrivSoftkeyLocationBottom) + { + for ( TUint ii = 0; + ii < sizeof( KStatusPaneSoftkeysBottomEquivResIds ) / + sizeof( *KStatusPaneSoftkeysBottomEquivResIds ); + ii++ ) + { + if (KStatusPaneSoftkeysBottomEquivResIds[ii].iResId == resId) + { + resId = KStatusPaneSoftkeysBottomEquivResIds[ii].iEqvivResId; + break; + } + } + } + } + else + { + for ( TUint ii = 0; + ii < sizeof( KStatusPanePortraitEquivResIds ) / + sizeof( *KStatusPanePortraitEquivResIds ); ii++ ) + { + if (KStatusPanePortraitEquivResIds[ii].iResId == resId) + { + resId = KStatusPanePortraitEquivResIds[ii].iEqvivResId; + break; + } + } + } + // end of static mapping + + const SStatusPaneEquivResIds* equiv = NULL; + for ( TUint ii = 0; + ii < sizeof( KStatusPaneEquivResIds ) / + sizeof( *KStatusPaneEquivResIds ); + ii++ ) + { + if ( KStatusPaneEquivResIds[ii].iElaf == resId || + KStatusPaneEquivResIds[ii].iAbrw == resId ) + { + equiv = &KStatusPaneEquivResIds[ii]; + break; + } + } + + if (!equiv) + { + return resId; + } + + if (iSettingCache->LayoutId() == EAknLayoutIdABRW) + { + return equiv->iAbrw; + } + else + { + return equiv->iElaf; + } + } + +EXPORT_C TBool CAknEnv::LoadAknLayoutL() + { + // Get required layout parameters + CAknLayoutConfig::TScreenMode screenMode = CAknSgcClient::ScreenMode(); + return LoadAknLayoutL(screenMode); + } + +EXPORT_C TBool CAknEnv::LoadAknLayoutL(const TAknLayoutConfigScreenMode& aScreenMode) + { + // Get required layout parameters + TAknLayoutId id; + GetCurrentLayoutId(id); + TAknUiZoom zoom = ResolveCurrentUiZoom(); + + // Check to see if the layout is already loaded + if (id == iLastLayoutId && + aScreenMode.ModeNumber() == iLastScreenMode && + zoom == iLastZoom) + return EFalse; + + return TryLoadAknLayoutL(id, aScreenMode, zoom); + } + +void CAknEnv::ReloadAknLayoutL() + { + // Get layout parameters for the current layout + CAknLayoutConfig::TScreenMode screenMode = CAknSgcClient::ScreenMode(); + TAknLayoutId id; + GetCurrentLayoutId(id); + TAknUiZoom zoom = ResolveCurrentUiZoom(); + + // always load the current layout + TryLoadAknLayoutL(id, screenMode, zoom); + } + + +void CleanupLayoutPacks(TAny* aPtr) + { + RPointerArray* packPtr = (RPointerArray*)aPtr; + packPtr->ResetAndDestroy(); + delete packPtr; + } + +TInt CompareLayoutPacks(const LayoutPack::CInstance& aLeft, const LayoutPack::CInstance& aRight) + { + return aLeft.priority() - aRight.priority(); + } + +TBool CAknEnv::TryLoadAknLayoutL(TAknLayoutId aId, const TAknLayoutConfigScreenMode& aScreenMode, TAknUiZoom aUiZoom) + { + // Load an appropriate layout + TBool layoutLoaded = ETrue; + if (!LoadAknLayoutL(aId, aScreenMode, aUiZoom)) + { + // fall back to normal zoom + if (!LoadAknLayoutL(aId, aScreenMode, EAknUiZoomNormal)) + { + // fall back to western layout + layoutLoaded = LoadAknLayoutL(EAknLayoutIdELAF, aScreenMode, EAknUiZoomNormal); + } + } + + // just in case the current required layout has changed, remember + // the new settings + if (layoutLoaded) + { + iLastLayoutId = aId; + iLastScreenMode = aScreenMode.ModeNumber(); + iLastZoom = aUiZoom; + } + + return layoutLoaded; + } + +TBool CAknEnv::LoadAknLayoutL(TAknLayoutId aId, const TAknLayoutConfigScreenMode& aScreenMode, TAknUiZoom aUiZoom) + { + RPointerArray* bestPacks = new(ELeave) RPointerArray(1); + CleanupStack::PushL(TCleanupItem(CleanupLayoutPacks, bestPacks)); + + CCdlRefs* refs = CdlEngine::FindInstancesLC(LayoutPack::KCdlInterfaceUid); + + TInt count = refs->CountRefs(); + TBool styleMatchAlreadyFound = EFalse; + for (TInt ii=0; iiRef(ii); + LayoutPack::CInstance* pack = LayoutPack::CInstance::NewLC(ref); + if (pack->id() == aId && pack->size() == aScreenMode.PixelsTwipsAndRotation().iPixelSize && pack->zoom() == aUiZoom) + { + TBool styleMatchInNewPack = pack->styleHash() == aScreenMode.ScreenStyleHash(); + if (styleMatchInNewPack && !styleMatchAlreadyFound) + { + bestPacks->ResetAndDestroy(); + styleMatchAlreadyFound = ETrue; + } + if (!styleMatchAlreadyFound || styleMatchInNewPack) + { + bestPacks->AppendL(pack); + CleanupStack::Pop(pack); + continue; // skip the PopAndDestroy below + } + } + CleanupStack::PopAndDestroy(pack); + } + + CleanupStack::PopAndDestroy(refs); + + // now sort the best layout packs in priority order and load them + TLinearOrder order( CompareLayoutPacks ); + bestPacks->Sort(order); + + count = bestPacks->Count(); + if (count) + { + // record the current process SID and the current CDL_Font id + RProcess process; + TSecureId thisProcessId = process.SecureId(); + TCdlRef cdlFontRef = CDL_Font::CustomisationInstance().Ref(); + CCdlRefs* allRefs = CCdlRefs::NewLC(); + for (TInt ii=0; iiappUid()); + if(appUid == 0 || appUid == thisProcessId) + { + // load this layout + CCdlRefs* packRefs = CdlExplorerUtils::CreateRefsLC(*pack, pack->contents()); + allRefs->AppendL(*packRefs); + CleanupStack::PopAndDestroy(packRefs); + } + } + CdlEngine::SetLocalStateL(*allRefs); + CleanupStack::PopAndDestroy(allRefs); + + // set the screen mode for this app + iEikonEnv->ScreenDevice()->SetScreenSizeAndRotation(aScreenMode.PixelsTwipsAndRotation()); + // update the fonts only if the CDL_Font instance has changed + if (cdlFontRef != CDL_Font::CustomisationInstance().Ref()) + { + // Set the CCoeFontProvider font size array + SetConeFontSizeArrayL(); + // Update Font system + iEikonEnv->UpdateSystemFontsL(); + } + } + + CleanupStack::PopAndDestroy(); // CleanupLayoutPacks + + return count; + } + +TAknUiZoom CAknEnv::ResolveCurrentUiZoom() + { + TAknUiZoom zoom = EAknUiZoomAutomatic; + CAknAppUi* app = (CAknAppUi*)iEikonEnv->EikAppUi(); + if(app) + { + zoom = app->LocalUiZoom(); + } + if(zoom == EAknUiZoomAutomatic) + { + GetCurrentGlobalUiZoom(zoom); + } + return zoom; + } + +void CAknEnv::SetLayoutRequirementsL() + { + // set the requirements that loaded layouts have to meet, such as being ROM-only + // These are ordered in terms of most frequently accessed, to speed up lookups. + Layout_Meta_Data::RequireCustomisationL(); + AknLayoutScalable_Avkon::RequireCustomisationL(); + AknLayout::RequireCustomisationL(); + AppLayout::RequireCustomisationL(); + AknLayoutScalable_Apps::RequireCustomisationL(); + AknApacLayout::RequireCustomisationL(); + AppApacLayout::RequireCustomisationL(); + CDL_Font::RequireCustomisationL(); + SkinLayout::RequireCustomisationL(); + LayoutPack::RequireCustomisationL(); + } + +void CAknEnv::AssertLayoutLoaded() + { + // Check that all necessary layouts have customisation instances loaded. + // These are not needed any more since all instances are always loaded. + // __ASSERT_ALWAYS(AknLayout::IsCustomisationStarted(), Panic(EAknPanicLayoutMissing_AknLayout)); + // __ASSERT_ALWAYS(!FeatureManager::FeatureSupported(KFeatureIdAvkonApac) || AknApacLayout::IsCustomisationStarted(), Panic(EAknPanicLayoutMissing_ApacLayout)); + } + + +EXPORT_C void CAknEnv::InstallAknEnvAsExtensionL(CEikonEnv* aEnv) + { + FeatureManager::InitializeLibL(); + CAknEnv* aknEnv = new(ELeave) CAknEnv; + aknEnv->iCoeEnv = aEnv; + aEnv->SetExtension(aknEnv); + aknEnv->iFontRegistry = CAknFontRegistry::NewL(); + } + +CAknFontRegistry& CAknEnv::FontRegistry() const + { + return *iFontRegistry; + } + +EXPORT_C TRgb CAknEnv::AvkonColor(TInt aIndex) + { + return TRgb::Color256(ColorRemapTable[aIndex]); + } + +void CAknEnv::SetConeFontSizeArrayL() const + { + RArray logicalToPixelSizes( TCoeFont::EExtraLarge + 1 ); // Granularity chosen to be the final size + CleanupClosePushL( logicalToPixelSizes ); + + // Three standard text layouts are used for the middle 3 of the 5 members of the pixel size array + // The sizes for the 2 outsize (extra small and extra large) are generated by hand using hardcoded factors + + // Append in order. Extra small and then small: + TAknTextComponentLayout textComponentLay = AknLayoutScalable_Avkon::text_secondary(); + TAknTextLineLayout layout = textComponentLay.LayoutLine(); + TAknFontSpecification spec( layout.FontId() ); + TInt textPaneHeight = spec.TextPaneHeight(); + + logicalToPixelSizes.AppendL( APPLY_CONE_FONT_EXTRA_SMALL_FACTOR(textPaneHeight) ); + logicalToPixelSizes.AppendL( textPaneHeight ); + + // Medium: + textComponentLay = AknLayoutScalable_Avkon::text_primary(); + layout = textComponentLay.LayoutLine(); + spec = TAknFontSpecification( layout.FontId() ); + textPaneHeight = spec.TextPaneHeight(); + + logicalToPixelSizes.AppendL( textPaneHeight ); + + // Large and then Extra Large + textComponentLay = AknLayoutScalable_Avkon::text_title(); + layout = textComponentLay.LayoutLine(); + spec = TAknFontSpecification( layout.FontId() ); + textPaneHeight = spec.TextPaneHeight(); + + logicalToPixelSizes.AppendL( textPaneHeight ); + logicalToPixelSizes.AppendL( APPLY_CONE_FONT_EXTRA_LARGE_FACTOR(textPaneHeight) ); + + // Set this into the environment + // Propagation to all CCoeFontProviders is performed by the framework itself + CCoeControlStaticSettings::SetLogicalToPixelFontSizesL(logicalToPixelSizes); + + logicalToPixelSizes.Reset(); + CleanupStack::PopAndDestroy( &logicalToPixelSizes ); + } + + // Avkon layout +EXPORT_C const AknLayout::CInstance& CAknEnv::AknLayout() const + { + return *iLayout; + } +CArrayPtr* CAknEnv::SystemFontArray() const + { + return iSystemFontArray; + } + +EXPORT_C TBool CAknEnv::SplitViewActive() const + { + return iSplitViewActive; + } + +#ifdef RD_SCALABLE_UI_V2 +void CAknEnv::SplitViewActive( const TBool aSplitViewActive ) + { + iSplitViewActive = aSplitViewActive; + } +#endif // RD_SCALABLE_UI_V2 + +// --------------------------------------------------------------------------- +// Check if the feature language is same. +// --------------------------------------------------------------------------- +TBool CAknEnv::IsFeatureLanguage(TInt aFeatureLanguage) + { + return (iFeatureLanguage == aFeatureLanguage)? ETrue : EFalse; + } + +void CAknEnv::ShutOrHideAppL() + { + CEikonEnv* eikEnv = CEikonEnv::Static(); + CAknAppUi* base = (CAknAppUi*)eikEnv->EikAppUi(); + while (base && base->ContainerAppUi()) + { + base = (CAknAppUi*)base->ContainerAppUi(); + } + + if (base && base->ExitHidesInBackground()) + { + if ( !base->IsAppHiddenInBackground() ) + { + base->ProcessCommandL(EAknCmdHideInBackground); + } + } + else + { + RunAppShutter(); + } + } + +// End of File