/*

* 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:   Implementation of CHuiEnv, a common working environment for the Toolkit.

*

*/

#include <eikenv.h>

#include <bautils.h>

#include <coemain.h>

#include <w32std.h>

#include <gdi.h>

#include <e32math.h>

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

#include <ecom/implementationinformation.h>

#include "HuiRenderPlugin.h"

#include "uiacceltk/HuiStatic.h"

#include "alf/alfconstants.h"

#include "HuiRenderSurface.h"

#include "uiacceltk/HuiDisplay.h"

#include "HuiRosterImpl.h"

#include "uiacceltk/HuiScheduler.h"

#include "uiacceltk/HuiTextureManager.h"

#include "uiacceltk/HuiControlGroup.h"

#include "HuiVisualFactory.h"

#include "uiacceltk/HuiS60Skin.h"

#include "uiacceltk/HuiEvent.h"

#include "uiacceltk/HuiRoster.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/huitextstylemanager.h"

#include "huistatictlsdata.h"

#include "uiacceltk/HuiThemeManager.h"

#include "huicanvastexturecache.h"

#include "HuiFxEngine.h"

#include "huisynchronizationobserver.h"

#define HUI_HIRES_TIMER

/* Constants */

// Until we get refresh interval issues solved (implement hi-res timer), this define keeps fps at respectable enough level

#ifdef SYMBIAN_BUILD_GCE

#define HUI_NGA_MIN_REFRESH_INTERVAL 

#endif

// This is for testing, can be used to force forced refresh

#ifdef SYMBIAN_BUILD_GCE

//#define HUI_NGA_FORCED_REFRESH 

#endif

// This is for testing, prints performance information

//#define HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

#ifdef SYMBIAN_BUILD_GCE

    #ifdef __WINSCW__

    const TInt KHuiEnvDefaultNormalRefreshIntervalMs = 40;

    const TInt KHuiEnvDefaultBusyRefreshIntervalMs = 40;

    #else

    const TInt KHuiEnvDefaultNormalRefreshIntervalMs = 15;

    const TInt KHuiEnvDefaultBusyRefreshIntervalMs = 15;

    #endif

#else

const TInt KHuiEnvDefaultNormalRefreshIntervalMs = 20;

const TInt KHuiEnvDefaultBusyRefreshIntervalMs = 2 * KHuiEnvDefaultNormalRefreshIntervalMs;

#endif

#ifndef SYMBIAN_BUILD_GCE

const TUint KHuiEnvMaxCpuTime = 100;

#endif

const TUint KRndTexMemCalcFlag = 0x800;

/* If there is idle between frames, this is how much we can use as overdrive max cpu utilisation */

const TUint KHuiEnvMaxCpuTimeOverdriveMaxValue = 100;

/* If max cpu usage has been set below this value, overdrive is not used because there is probaply a good reson 

for a low max cpu usage value */

const TUint KHuiEnvMaxCpuTimeOverdriveLowerThreshold = 50;

/** Threshold number for refreshes that don't have any effect. When exceeded,

    refresh is paused. */

const TInt KIdleRefreshCountThreshold = 3;

const THuiRefreshMode KHuiDefaultRefreshMode = EHuiRefreshModeAutomatic;

class CHighResTimer : public CTimer

	{

public:

	static CHighResTimer* NewL(TCallBack aCallBack, TInt aPriority)

		{

		CHighResTimer* self = new(ELeave) CHighResTimer(aCallBack, aPriority);

		CleanupStack::PushL(self);

		self->ConstructL();

		CleanupStack::Pop(self);

		return self;

		}

	~CHighResTimer()

		{

		Cancel();

		}

	void CallBack(const TInt aWaitInMilliSecs)

		{

		TInt wait = 1000*aWaitInMilliSecs;

		if (wait < 0)

		    {

		    wait = 15000;

		    }

		else if (wait > 60000)

		    {

		    wait = 60000;

		    }

		HighRes( TTimeIntervalMicroSeconds32( wait ) );

		}

private:

	CHighResTimer(TCallBack aCallBack, TInt aPriority) 

	: CTimer(aPriority), iCallBack(aCallBack)

		{

		CActiveScheduler::Add(this);

		}

	void RunL()

		{

		iCallBack.CallBack();

		}

	TCallBack iCallBack;

	};

EXPORT_C CHuiEnv* CHuiEnv::NewL(THuiRenderer aRenderer, MHuiEnvObserver* aObserver)

    {

    CHuiEnv* self = CHuiEnv::NewLC(aRenderer, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CHuiEnv* CHuiEnv::NewLC(THuiRenderer aRenderer, MHuiEnvObserver* aObserver)

    {

    CHuiEnv* self = new (ELeave) CHuiEnv(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aRenderer);

    return self;

    }

CHuiEnv::CHuiEnv(MHuiEnvObserver* aObserver)

        : iState(ENormal),

          iRefreshMode(KHuiDefaultRefreshMode),

          iRefreshInterval(KHuiEnvDefaultNormalRefreshIntervalMs),

          iRefreshIntervalTarget(KHuiEnvDefaultNormalRefreshIntervalMs),

          iEnvObserver(aObserver),

          iIdleThreshold(10),

          iMaxCPUUtilization(0), // disable adaptive scheduling by default

          iRefreshLoopPriority(CActive::EPriorityStandard),

          iRefreshLoopActive(EFalse)

    {

    iIdleCPUValueMonitored = CPUTimeSupported() && OpenHandleToIdleCPUValueThread();

    }

// to get around nasty ownership problem with texture manager interface

void NullTextureManagerPtr(TAny* aPtrToPtr)

    {

    if (aPtrToPtr)

        {

        CHuiTextureManager** ptr = (CHuiTextureManager**)aPtrToPtr;

        *ptr = 0;

        }

    }

void CHuiEnv::ConstructL(THuiRenderer aRenderer)

    {

    HUI_DEBUG(_L("CHuiEnv::ConstructL() - Constructing Hitchcock User Interface Toolkit (HUITK) working environment") );

    HUI_DEBUG1(_L("CHuiEnv::ConstructL() - Free memory in beginning: %i"), HuiUtil::FreeMemory());

    // Static data area.

    iStatic = CHuiStatic::NewL(this);

    HUI_DEBUG1(_L("CHuiEnv::ConstructL() - Free memory after static created: %i"), HuiUtil::FreeMemory());

    // Instantiate the right type of renderer plugin.

    // The Ecom plugin framework requires the identifier to be a descriptor.

    // Convert the identifier to descriptor, which the ecom uses to determine

    // the correct renderer.

    // -----------RnD-------------------------------------------------------------

    // Disable renderer selection for now !!

    // -----------RnD-------------------------------------------------------------

    // can't currently switch on fly and alf_config has its issues..

    aRenderer = EHuiRendererVg10; 

    TBuf<10> renderer;

    renderer.Num(aRenderer);

    // The aRenderer holds the renderer information which is usually gotten from

    // central repository key. It might not be defined though, and in that case,

    // we'll try to load from the 

    switch(aRenderer)

        {

        case EHuiRendererDefault:

            {

            const THuiRenderer rendererTable[] =

                {

                EHuiRendererVg10,

                EHuiRendererBitgdi,

                EHuiRendererGles20,

                EHuiRendererGles11,

                EHuiRendererGles10,

                };

            const TInt KRendererCount = 5;        

            for (TInt index = 0; index <  KRendererCount ; index++)

                {

                renderer.Num(rendererTable[index]);

                TRAPD(error, iRenderer = reinterpret_cast<CHuiRenderPlugin*>(CHuiRenderPluginBase::NewL( renderer )));

                if (error)

                    {

                    HUI_DEBUG1(_L("CHuiEnv::ConstructL() - Renderer construction failed, error code: %i, trying next one...."),error );

                    if (index ==  KRendererCount-1) 

                        {

                        // the last renderer in the table failed to load

                        HUI_DEBUG(_L("CHuiEnv::ConstructL() - ERROR! Failed to create any renderer.. bailing out") );

                        User::Leave(error);

                        }

                    continue;                    

                    }

                // got a renderer, use that...

                iRendererIdentifier = rendererTable[index];

                break;

                }

            break;

            }

        default:

            {

            // Load the renderer plugin with the given identifier. The Ecom framework

            // will take care searching for matching renderer. If not found, will leave with KErrNotFound

            iRenderer = reinterpret_cast<CHuiRenderPlugin*>(CHuiRenderPluginBase::NewL( renderer ));

            iRendererIdentifier = aRenderer;

            // @TODO Should we panic, if renderer wasn't found, or is the Leave

            // with KErrNotFound enough?

            //THuiPanic::Panic(THuiPanic::EStaticInvalidRenderer);

            break;

            }

        }

    iStatic->SetRenderer(*iRenderer);

    CHuiStatic::Tic(1);

    // Create the scheduler.

    iScheduler = new (ELeave) CHuiScheduler(*this);

    // Create a texture manager.

    CleanupStack::PushL(TCleanupItem(NullTextureManagerPtr,&iTextureManager));

    iTextureManager = iRenderer->CreateTextureManagerL(*this);

    // Register as a state change and texture loaded event observer

    CleanupStack::Pop(); 

    iTextureManager->iStateObservers.AppendL(*this);

    iTextureManager->iLoadObservers.AppendL(*this);

    // Create a font manager.

    iFontManager = iRenderer->CreateFontManagerL();

    // Create a text style manager.

    iTextStyleManager = CHuiTextStyleManager::NewL();

    iTextStyleManager->ConstructBuiltInStylesL();

    // Create a visual factory.

    iVisualFactory = new (ELeave) CHuiVisualFactory(*this);

    // Create an effects engine

    iEffectsEngine = iRenderer->CreateEffectsEngineL();

    // Cache the last input time.

    iLastInputTime = CHuiStatic::Time();

    // Create a shared roster. This is used by all overlaid displays.

    iSharedRoster = new (ELeave) CHuiRosterImpl(NULL);

    /** @todo Create a skin here. This must be done in a better way.

        The skin can only be created when there is a EGL context because

        the skin will attempt to create textures and load fonts. */

    if(!iSkin)

        {

        if(iEnvObserver)

            {

            iSkin = iEnvObserver->CreateSkinL(*this);

            }

        if(!iSkin)

            {

            // Create an instance of the default skin. The S60 skin uses data

            // and bitmaps from the current S60 skin.

            iSkin = new (ELeave) CHuiS60Skin(*this);

            (static_cast<CHuiS60Skin*>(iSkin))->ConstructL();

            }

        }

    // DEPRECATED: JUST A DUMMY CONSTRUCTION TO PREVENT BREAKS

    //iThemeManager = CHuiThemeManager::NewL();

    iCanvasTextureCache = CHuiCanvasTextureCache::NewL();

#ifndef SYMBIAN_BUILD_GCE

#ifndef __WINSCW__

    // for now, display fps information automatically if errrd installed

    if (eikenv)

        {

        _LIT(KRDSupport, "c:\\resource\\errrd" );

        if (eikenv->FsSession().Handle() && BaflUtils::FileExists( eikenv->FsSession(), KRDSupport ))

            {

            SetFPSCounterThreshold(700);

            }

        }

#endif

#endif //SYMBIAN_BUILD_GCE

    HUI_DEBUG(_L("CHuiEnv::ConstructL - Working environment ready."));

    }

CHuiEnv::~CHuiEnv()

    {

    iActionObservers.Close();

    // Destroy groups in reverse order so that references will be removed

    // in natural order.

    TInt i = 0;

    for(i = iLoadedGroups.Count() - 1; i >= 0; --i)

        {

        CHuiControlGroup* g = iLoadedGroups[i];

        iLoadedGroups.Remove(i);

        delete g;

        }

    iLoadedGroups.Reset();

    for(i = iDisplays.Count() - 1; i >= 0; --i)

        {

        // Deleting a display causes it to be automatically removed from the

        // displays array.

        delete iDisplays[i];

        }

    iDisplays.Reset();

    iOverlaidDisplays.Reset();

    delete iCanvasTextureCache;

    delete iSharedRoster;

    delete iSkin;

    delete iVisualFactory;

    delete iTextureManager;

    delete iEffectsEngine;

    // DEPRECATED: JUST A DUMMY DESTRUCTION

    //delete iThemeManager;	//Theme support

    delete iFontManager;

    delete iTextStyleManager;

    delete iPeriodic;

    delete iScheduler;

    iScheduler = NULL;

    delete iRenderer;

    delete iStatic;

    iEnvObserver = NULL;

    if (iIdleCPUValueMonitored)

        {

        CloseHandleToIdleCPUValueThread();            

        }

    iLowMemoryObservers.Close();

    iMemoryLevelObservers.Close();

    }

void CHuiEnv::SetTextureManager(CHuiTextureManager& aManager)

    {

    iTextureManager = &aManager;

    }

EXPORT_C THuiRenderer CHuiEnv::Renderer() const

    {

    return iRendererIdentifier;

    }

EXPORT_C void CHuiEnv::SetRefreshMode(THuiRefreshMode aMode)

    {

    switch (aMode)

        {

        case EHuiRefreshModeManual:

               //HUI_DEBUG(_L("CHuiEnv::SetRefreshMode() - Setting manual refresh mode."));

               break;

        case EHuiRefreshModeAutomatic:

               //HUI_DEBUG(_L("CHuiEnv::SetRefreshMode() - Setting automatic refresh mode."));

               break;

        case EHuiRefreshModeForced:

               //HUI_DEBUG(_L("CHuiEnv::SetRefreshMode() - Setting forced refresh mode."));

               break;

        default:

               //HUI_DEBUG(_L("CHuiEnv::SetRefreshMode() - ERROR! Tried to set unknown refresh mode! Ignoring.."));

               return;

        }

#ifdef HUI_NGA_FORCED_REFRESH

    iRefreshMode = EHuiRefreshModeForced;

#else

    iRefreshMode = aMode;

#endif

    if(aMode == EHuiRefreshModeManual)

        {

        StopRefresh();

        }

    else

        {

        StartRefresh(iRefreshIntervalTarget);

        }

    }

EXPORT_C THuiRefreshMode CHuiEnv::RefreshMode() const

    {

    return iRefreshMode;

    }

EXPORT_C void CHuiEnv::SetMaxFrameRate(TReal32 aFrameRate) __SOFTFP

    {

#ifdef HUI_NGA_MIN_REFRESH_INTERVAL

    if (aFrameRate < (1000/KHuiEnvDefaultNormalRefreshIntervalMs))

        aFrameRate = 1000/KHuiEnvDefaultNormalRefreshIntervalMs;

#endif

    TInt oldIRefreshIntervalTarget = iRefreshIntervalTarget;

    if(aFrameRate != 0.0)

        {

        iRefreshIntervalTarget = TInt(1000 / aFrameRate);

        }

    else

        {

        iRefreshIntervalTarget = KHuiEnvDefaultNormalRefreshIntervalMs;

        }

    if(iRefreshIntervalTarget < 1)

        {

        iRefreshIntervalTarget = 1;

        }

    // If the refresh timer is running, update it.

    if(!iMaxCPUUtilization &&  /* Adaptive scheduling not enabled */ 

       iPeriodic && (iPeriodic->IsActive() || iRefreshLoopActive ) && /* and heart beat already active */

       oldIRefreshIntervalTarget != iRefreshIntervalTarget ) 

        {

        StartRefresh(iRefreshIntervalTarget);

        }

    }

EXPORT_C void CHuiEnv::StartRefresh(TInt aMilliSeconds)

    {

    StartRefresh(aMilliSeconds, aMilliSeconds);

    }

void CHuiEnv::StartRefresh(TInt aIntervalInMilliSeconds, TInt aDelayInMilliseconds)

    {

    // Cancel the previous timer.

    StopRefresh();

    if(iState == EReleased)

        {

        // When environment is released no refresh is done.

        return;

        }

    if ( aIntervalInMilliSeconds < 1 )

        {

        HUI_DEBUG1(_L("CHuiEnv::StartRefresh() - Requested %i ms - too low!."), aIntervalInMilliSeconds);

        aIntervalInMilliSeconds = 1;

        }

    if (aIntervalInMilliSeconds > 1000)

        {

        HUI_DEBUG1(_L("CHuiEnv::StartRefresh() - Requested %i ms - too high!."), aIntervalInMilliSeconds);

        aIntervalInMilliSeconds = 1000;    

        }

    if ( aDelayInMilliseconds < 1 )

        {

        HUI_DEBUG1(_L("CHuiEnv::StartRefresh() - Requested %i aDelayInMilliseconds ms - too low!."), aDelayInMilliseconds);

        aDelayInMilliseconds = 1;

        }

    if (aDelayInMilliseconds > 1000)

        {

        HUI_DEBUG1(_L("CHuiEnv::StartRefresh() - Requested %i aDelayInMilliseconds ms - too high!."), aDelayInMilliseconds);

        aDelayInMilliseconds = 1000;