/*

* Copyright (c) 2006-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:   Implements CHuiStatic, static data access and utility 

*                functions such as timing.

*

*/

#include "uiacceltk/HuiStatic.h"  // Class definition

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiEnv.h"

#include "HuiRenderPlugin.h"

#include "huistatictlsdata.h"

#include "uiacceltk/HuiProbe.h"

#include <e32math.h>

#include <eikenv.h>

#include <flogger.h>

#include <AknsUtils.h>

#include <AknUtils.h>

#include <AknBidiTextUtils.h>

#include <bidivisual.h>

#include "alfappfwproxyops.h"

// Global writeable data, used in HW instead of TLS which relatively slow

#ifndef __WINSCW__

TTlsData globalWriteableData;

#endif

void CleanupWg(TAny* aWg)

    {   

    RWindowGroup* wg = static_cast<RWindowGroup*>(aWg);

    delete wg;

    }

/** Dummy implementation for HuiProbe, to be used when external probe is not set */

NONSHARABLE_CLASS(TFakeProbe) : public MHuiProbe

    {

public:

    virtual void ReportObjectLifeCycleEvent(const MHuiSessionObject&, TLifecycleEvent) {}

    virtual void ReportProgramFlowEvent(TProgramFlowPoint, TProgramFlowEvent) {}

    virtual void ReportProgramFlowEvent(const MHuiSessionObject&, TProgramFlowPoint, TProgramFlowEvent) {}

    void ReportFrameRate(TInt) const {}

    void AssociateWithCurrentSession(MHuiSessionObject&) {}

    };

NONSHARABLE_CLASS(CAppFwProxy): public CBase

    {

public:

    class CAlfLayoutListener: public CActive

        {

        public:

        CAlfLayoutListener(CAppFwProxy& aNotif):CActive(CActive::EPriorityStandard), iNotif(aNotif)

            {

            CActiveScheduler::Add(this);

            iStatus = KErrNotFound;    

            }

        ~CAlfLayoutListener()

            {

            Cancel();    

            }

        void RunL()

            {           

            iNotif.iLayoutMirrored = (iStatus.Int() > 0);         

            SetActive();

            TAlfCommandParams params={EAlfIsMirrorred,0,0,0};

            TPckgC<TAlfCommandParams> pkg(params);

            TBuf8<1> awkwardApiDummy;

            iNotif.iNotif.StartNotifierAndGetResponse(iStatus,TUid::Uid(KAlfAppFwProxyUid), pkg, awkwardApiDummy);            }

        void DoCancel()

            {

            // just wait for notifier completion    

            User::WaitForRequest(iStatus);    

            }    

        private:

            CAppFwProxy& iNotif;

            };    

    CAppFwProxy():iLayoutMirrored(KErrNotFound)

        {}

    ~CAppFwProxy()

        {

        if (iConnected)

            {

            iNotif.Close();

            delete iLayoutUpdateAo;

			}

		}

    TBool Connect()

        {

        if (!iConnected)

            {

            // perhaps should check also whether eikon server / notifier server exists..

            iConnected = (iNotif.Connect() == KErrNone);

            }

        return iConnected;

        }

    TBool LayoutMirrored()

        {                

        if ( Connect() && iLayoutMirrored == KErrNotFound)

            {

            TRequestStatus status;

            TAlfCommandParams params={EAlfIsMirrorred,0,0,0};

            TPckgC<TAlfCommandParams> pkg(params);

            TBuf8<1> awkwardApiDummy;

            iNotif.StartNotifierAndGetResponse(status,TUid::Uid(KAlfAppFwProxyUid), pkg, awkwardApiDummy);

            User::WaitForRequest(status);

            // order updates

            iLayoutUpdateAo = new CAlfLayoutListener(*this);

            if (iLayoutUpdateAo)

                {

                TRAP_IGNORE(iLayoutUpdateAo->RunL());

                }

            iLayoutMirrored = (status.Int() > 0);

            }

        return iLayoutMirrored==KErrNotFound?EFalse:iLayoutMirrored;    

        }

    TInt SoftKeyOrientation()

        {

        TInt ret = 0;

        if ( Connect() )

            {

            TRequestStatus status;

            TAlfCommandParams params={EAlfCbaLocation,0,0,0};

            TPckgC<TAlfCommandParams> pkg(params);

            TBuf8<1> awkwardApiDummy;

            iNotif.StartNotifierAndGetResponse(status,TUid::Uid(KAlfAppFwProxyUid), pkg, awkwardApiDummy);

            User::WaitForRequest(status);

            ret = status.Int();

            }

        return ret;    

        }

    TRect LayoutMetricsRect(TInt aType)

        {

        TRect ret=TRect(0,0,0,0);

        if ( Connect() )

            {

            TRequestStatus status;

            TAlfCommandParams params={EAlfLayoutMetricsRect,aType,0,0};

            TPckgC<TAlfCommandParams> pkg(params);

            TPckg<TRect> retpkg(ret);

            iNotif.StartNotifierAndGetResponse(status,TUid::Uid(KAlfAppFwProxyUid), pkg, retpkg);

            User::WaitForRequest(status);

            }

        return ret;    

        }

    TInt GetCachedColor(TRgb& aRgb, const TAknsItemID& aID,

            const TInt aIndex )

        {

        if ( Connect() )

            {

            TRequestStatus status;

            TAlfCommandParams params={EAlfGetCachedColor,aID.iMajor,aID.iMinor,aIndex};

            TPckgC<TAlfCommandParams> pkg(params);

            TPckg<TRgb> retpkg(aRgb);

            iNotif.StartNotifierAndGetResponse(status,TUid::Uid(KAlfAppFwProxyUid), pkg, retpkg);

            User::WaitForRequest(status);

            return status.Int();

            }

        return KErrCouldNotConnect;    

        }

    void GetSkinBitmapL(CFbsBitmap* aBitmap, CFbsBitmap* aMask, const TAknsItemID& aID, const TDesC& aFileName, TInt aBitmapId, 

                        TInt aMaskId, const TSize& aSize, TScaleMode aScaleMode)

        {

        if ( Connect() )

            {

            TRequestStatus status;

            TAlfCommandParams2 params={EAlfGetSkinBitmap,aID.iMajor,aID.iMinor,aBitmapId,aMaskId,aFileName, aSize, aScaleMode};

            TPckgC<TAlfCommandParams2> pkg(params);

            TInt2 handles = {0,0};

            TPckg<TInt2> retpkg(handles);

            iNotif.StartNotifierAndGetResponse(status,TUid::Uid(KAlfAppFwProxyUid), pkg, retpkg);

            User::WaitForRequest(status);

            User::LeaveIfError(status.Int());

            if (!handles.iInt1)

                {

                User::Leave(KErrNotFound); 

                }   

            User::LeaveIfError(aBitmap->Duplicate(handles.iInt1));

            if ( aMask && handles.iInt2 )

                {

                User::LeaveIfError(aMask->Duplicate(handles.iInt2));                    

                }

            }

        }

    void GetSkinBackgroundBitmapL(CFbsBitmap* aBitmap, const TAknsItemID& aID )

        {

        if ( Connect() )

            {

            TRequestStatus status;

            TAlfCommandParams params={EAlfGetSkinBackgroundBitmap,aID.iMajor,aID.iMinor,0};

            TPckgC<TAlfCommandParams> pkg(params);

            TInt handle = 0;

            TPckg<TInt> retpkg(handle);

            iNotif.StartNotifierAndGetResponse(status,TUid::Uid(KAlfAppFwProxyUid), pkg, retpkg);

            User::WaitForRequest(status);

            User::LeaveIfError(status.Int());

            User::LeaveIfError(aBitmap->Duplicate(handle));

            }

        }

    void GetCachedSkinItemDataArrayL(const TAknsItemID& aID, TInt aType, TAlfCachedSkinItemArray& aArray)  

        {

        if ( Connect() )

            {

            TRequestStatus status;

            TAlfCommandParams params={EGetCachedSkinItemData,aID.iMajor,aID.iMinor,aType};

            TPckgC<TAlfCommandParams> pkg(params);

            TPckg<TAlfCachedSkinItemArray> retpkg(aArray);

            iNotif.StartNotifierAndGetResponse(status,TUid::Uid(KAlfAppFwProxyUid), pkg, retpkg);

            User::WaitForRequest(status);

            User::LeaveIfError(status.Int());

            }

        }

    void GetListOfWindowGroupsL(TRequestStatus& aStatus, TPtr8& aPtr)

        {

        if ( Connect() )

            {

            TAlfCommandParams params={EGetListOfWindowGroups,0,0,0};

            TPckgC<TAlfCommandParams> pkg(params);

            iNotif.StartNotifierAndGetResponse(aStatus,TUid::Uid(KAlfAppFwProxyUid), pkg, aPtr);

            }        

        }    

    public: 

        TBool iLayoutMirrored;

        RNotifier iNotif;

        TBool iConnected;

        CAlfLayoutListener* iLayoutUpdateAo;

    };

CHuiStatic* CHuiStatic::NewLC(CHuiEnv* aPrimaryEnv)

    {

    CHuiStatic* self = new (ELeave) CHuiStatic();

    CleanupStack::PushL(self);

    self->ConstructL(aPrimaryEnv);

    return self;

    }

CHuiStatic* CHuiStatic::NewL(CHuiEnv* aPrimaryEnv)

    {

    CHuiStatic* self = NewLC(aPrimaryEnv);

    CleanupStack::Pop(self);

    return self;

    }

CHuiStatic::CHuiStatic()

    {

    }

void CHuiStatic::ConstructL(CHuiEnv* aPrimaryEnv)

    {

    iData = new (ELeave) TTlsData();

    iData->iPrimaryEnv = aPrimaryEnv;

    iData->iIdCounter = -1;

    iData->iTimeFactor = 1.0;

    iData->iIsFirstUpdateTime = ETrue;

    iData->iFirstUpdateTime.UniversalTime();

    iData->iUniversalTime.UniversalTime();

    iData->iRealUniversalTime.UniversalTime();

    iData->iLastFpsTime.UniversalTime();

    iData->DoInitL(); // make sure that we have infra even CCoeEnv was not there

    // Re-construct the virtual table for iFakeProbe

    iData->iFakeProbe = new (ELeave) TFakeProbe;

    iData->iAppFwProxy = new (ELeave) CAppFwProxy;

    //Register for environment change ( here system time change ) event notification

    iChangeNotifier = CEnvironmentChangeNotifier::NewL(0, TCallBack(CHuiStatic::SettingChangedCallBack, this));

    iChangeNotifier->Start();

#ifndef __WINSCW__

    globalWriteableData = *iData;

#else

    Dll::SetTls(iData);

#endif

#ifndef WIN32

#ifdef HUI_DEBUG_WITH_PRINTF

    EnableLogging();

#endif

#endif

    }

CHuiStatic::~CHuiStatic()

    {

    if(iData)

        {

        if(iData->iFakeProbe)

            {

            delete iData->iFakeProbe;

            iData->iFakeProbe = NULL;

            }

        iData->iLogFile.Close();

        delete iData->iAppFwProxy;

        iData->Disconnect();

        }

    iChangeNotifier->Cancel();

    delete iChangeNotifier;

#ifdef __WINSCW__

    Dll::FreeTls();

#endif

    delete iData;

    }

EXPORT_C TTlsData* CHuiStatic::Data()

    {

#ifndef __WINSCW__

    return &globalWriteableData;

#else

    return static_cast<TTlsData*>(Dll::Tls());

#endif

    }

void CHuiStatic::UpdateTime(TTlsData* aData)

    {

    ASSERT( aData );

    // Updates the toolkit's time counters. This includes the toolkit's

    // realtime clock, the internal absolute clock (which is affected by the

    // time factor), the amount of elapsed time since last UpdateTime()

    // invocation, and the amount of elapsed time since the first UpdateTime()

    // invocation (which was done in the beginning of the first refresh).

    if(aData->iIsFirstUpdateTime)

        {

        aData->iIsFirstUpdateTime = EFalse;

        aData->iFirstUpdateTime.UniversalTime();

        aData->iUniversalTime = aData->iFirstUpdateTime;

        aData->iRealUniversalTime = aData->iUniversalTime;

        return;

        }

    TTime now;

    now.UniversalTime();

    // Advance the toolkit's internal clock, applying the time factor.

    if(!aData->iTimePaused)

        {

        aData->iInternalElapsed = now.MicroSecondsFrom(aData->iRealUniversalTime).Int64();

        aData->iInternalElapsed = (TInt64)((TReal32)aData->iInternalElapsed * aData->iTimeFactor);

        aData->iUniversalTime += TTimeIntervalMicroSeconds(aData->iInternalElapsed);

        }

    else

        {

        aData->iInternalElapsed = aData->iInternalElapsedBeforePausing;

        aData->iInternalElapsedBeforePausing = 0;        

        }

    aData->iRealUniversalTime = now;      

    }

TUint32 CHuiStatic::MilliSecondsSinceUpdateTime()

    {

    TTlsData* data = Data();

    TTime now;

    now.UniversalTime();

    return now.MicroSecondsFrom(data->iRealUniversalTime).Int64() / 1000;

    }

EXPORT_C CHuiEnv& CHuiStatic::Env()

    {

    if(!Data())

        {

        THuiPanic::Panic(THuiPanic::EStaticDataNotCreated);

        }

    return *Data()->iPrimaryEnv;

    }

EXPORT_C CHuiRenderPlugin& CHuiStatic::Renderer()

    {

    if(!Data() || !Data()->iRenderer)

        {

           HUI_DEBUG(_L("CHuiStatic::Renderer() - Static data or renderer not specified."));

        THuiPanic::Panic(THuiPanic::EStaticInvalidRenderer);

        }

    return *Data()->iRenderer;

    }

void CHuiStatic::SetRenderer(CHuiRenderPlugin& aRenderer)

    {

    if(!Data())

        {

        THuiPanic::Panic(THuiPanic::EStaticDataNotCreated);

        }

    Data()->iRenderer = &aRenderer;

    }

// @TODO SHOULD THIS BE MODIFIED SOMEHOW, OR IS THIS EXPORT OK???

EXPORT_C CHuiBitgdiRenderPlugin& CHuiStatic::BitgdiRenderer()

    {

    CHuiRenderPlugin* renderer = &Renderer();

    if(renderer->Id() != EHuiRenderPluginBitgdi)

        {

        HUI_DEBUG(_L("CHuiStatic::BitgdiRenderer() - Renderer cannot be used as Bitgdi renderer."));

        THuiPanic::Panic(THuiPanic::EStaticInvalidRenderer);

        }

    return *reinterpret_cast< CHuiBitgdiRenderPlugin* >(renderer);

    }

EXPORT_C CHuiVg10RenderPlugin& CHuiStatic::Vg10Renderer()

    {

    CHuiRenderPlugin* renderer = &Renderer();

    if(renderer->Id() != EHuiRenderPluginVg10)

        {

        HUI_DEBUG(_L("CHuiStatic::Vg10Renderer() - Renderer cannot be used as Vg10 renderer."));

        THuiPanic::Panic(THuiPanic::EStaticInvalidRenderer);

        }

    return *reinterpret_cast< CHuiVg10RenderPlugin* >(renderer);

    }

EXPORT_C CHuiGles10RenderPlugin& CHuiStatic::Gles10Renderer()

    {

    CHuiRenderPlugin* renderer = &Renderer();

    if(renderer->Id() != EHuiRenderPluginGles10 &&

       renderer->Id() != EHuiRenderPluginGles11) // compatible

        {

        HUI_DEBUG(_L("CHuiStatic::Gles10Renderer() - Renderer cannot be used as Gles10 renderer."));

        THuiPanic::Panic(THuiPanic::EStaticInvalidRenderer);

        }

    return *reinterpret_cast< CHuiGles10RenderPlugin* >(renderer);

    }

EXPORT_C CHuiGles11RenderPlugin& CHuiStatic::Gles11Renderer()

    {

    CHuiRenderPlugin* renderer = &Renderer();

    if(renderer->Id() != EHuiRenderPluginGles11)

        {

        HUI_DEBUG(_L("CHuiStatic::Gles11Renderer() - Renderer cannot be used as Gles11 renderer."));

        THuiPanic::Panic(THuiPanic::EStaticInvalidRenderer);

        }

    return *reinterpret_cast< CHuiGles11RenderPlugin* >(renderer);

    }

EXPORT_C CHuiGles20RenderPlugin& CHuiStatic::Gles20Renderer()

    {

    CHuiRenderPlugin* renderer = &Renderer();

    if(renderer->Id() != EHuiRenderPluginGles20)

        {

        HUI_DEBUG(_L("CHuiStatic::Gles20Renderer() - Renderer cannot be used as Gles20 renderer."));

        THuiPanic::Panic(THuiPanic::EStaticInvalidRenderer);

        }

    return *reinterpret_cast< CHuiGles20RenderPlugin* >(renderer);

    }

EXPORT_C MHuiRenderSurface* CHuiStatic::CurrentRenderSurface()

    {

    if(!Data())

        {

        HUI_DEBUG(_L("CHuiStatic::CurrentRenderSurface() - Static data or current render surface not specified. Panicking."));

        THuiPanic::Panic(THuiPanic::EStaticCurrentRenderSurfaceNotSpecified);

        }

    return Data()->iCurrentRenderSurface;

    }

EXPORT_C void CHuiStatic::SetCurrentRenderSurface(MHuiRenderSurface* aSurface)

    {

    Data()->iCurrentRenderSurface = aSurface;

    }

EXPORT_C void CHuiStatic::EnableLogging(TBool aEnable)

    {

    TTlsData* data = Data();

    if(aEnable && !data->iLogEnabled)

        {

        data->iLogEnabled = ETrue;

		// debug code only 

        TFileName filename;

        filename.Append('e');

        filename.Append(':');