/*

* 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 <apgtask.h>

#include <aknintermediate.h>

#include <coeaui.h>

#include <coemain.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <eikfrlb.h>

#include <eikfrlbd.h>

#include <aknPopup.h>

#include <aknlists.h>

#include <eiklbv.h>

#include <eiklbi.h>

#include <AknWaitDialog.h>

#include <AknLayout.lag>

#include <bidivisual.h>

#include <aknconsts.h>

#include <AknBidiTextUtils.h>

#include <CdlEngine.h>

#include <CdlRefs.h>

#include <AknLayout2DataDef.h>

#include <LayoutPack.cdl.h>

#include <CdlExplorer.h>

#include <aknlayout.cdl.h>

#include <aknapaclayout.cdl.h>

#include <applayout.cdl.h>

#include <appapaclayout.cdl.h>

#include <skinlayout.cdl.h>

#include <cdlfont.cdl.h>

#include "AknFontRegistry.h"

#include <barsread.h>

#include <AknPriv.hrh>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <featmgr.h>

#include <AknIconSrvClient.h>

#include <AknServerApp.h>

#include <AknFontSpecification.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

// Needed to use MopGetObject

#include <coemop.h>

#include <e32property.h>

#include <UikonInternalPSKeys.h>    // KUikLayoutState

#include <AvkonInternalCRKeys.h>    // KAknQwertyInputModeActive

#include "AknDebug.h"

#include <coecntss.h>               // CCoeControlStaticSettings

#include <coefont.h>                // For font size indices

#include <AknLayoutConfig.h>

#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<akntranseffect.h> // 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<TInt>* wgIds=new(ELeave) CArrayFixFlat<TInt>(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<MAknIntermediateState>(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; i<count; i++)

        {

        if (iStateArray->At(i) == aState)

            break;

        }

    if (i<count)

        iStateArray->Delete(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; i<count; i++)

        {

        env->iStateArray->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();

            }