/*

* Copyright (c) 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:   

*

*/

#ifndef HUIFXENGINE_H_

#define HUIFXENGINE_H_

#include "HuiFxConstants.h"

#include "HuiFxParameter.h"

#include "huieffectable.h"

#include <uiacceltk/huilowmemoryobserver.h>

#include <e32std.h>

#define HUIFX_RBCACHE_ENABLED

#define HUIFX_EFFECTCACHE_ENABLED

//FORWARD DECLARATIONS

class CHuiFxRenderbuffer;

class CHuiFxFilter;

class CHuiFxEffect;

class CHuiVisual;

class CHuiFxEffectCache;

class MAlfGfxEffectObserver;

class CHuiGc;

class MHuiEffectObserver

    {

    public:

    virtual void EffectAdded(CHuiFxEffect* aEffect) = 0;

    virtual void EffectComplete(CHuiFxEffect* aEffect) = 0;

    };

class CHuiFxEngine : public CBase, public MHuiLowMemoryObserver, public MHuiMemoryLevelObserver

    {

    // important constant! Affects memory fragmentation in backend too small 

    // number forces lots of acquires/releases resulting in fragmented memory 

    // and finally panic.

    // CACHE_SIZE set to 20 to avoid buffer creation at worst case scenario (fading).

    // Emulator cannot currently handle that much (out of memory) 

#ifdef __WINS__ 

    static const TInt CACHE_SIZE = 1;

#else

    static const TInt CACHE_SIZE = 20;

#endif    

    friend class CHuiFxEffect;

protected:

    IMPORT_C void ConstructL(THuiFxEngineType aEngineType);

public:

    IMPORT_C virtual ~CHuiFxEngine();

    // Engine management

    IMPORT_C virtual void Release();

    IMPORT_C virtual void RestoreL();

    // Render buffer management

    IMPORT_C virtual CHuiFxRenderbuffer* AcquireRenderbuffer(const TSize& aDesiredSize);

    CHuiFxRenderbuffer* AcquireRenderbuffer(const TSize& aDesiredSize, TBool aAlllowLarger);

    IMPORT_C virtual void ReleaseRenderbuffer(CHuiFxRenderbuffer* aBuffer);

    virtual CHuiFxRenderbuffer* DefaultRenderbuffer() = 0;

    // Filter construction

    virtual CHuiFxFilter* CreateFilterL(THuiFxFilterType aType) = 0;

    // Composition

    // TODO: Coordinates

    virtual void Composite(CHuiFxRenderbuffer& aTarget, CHuiFxRenderbuffer& aSource,

                                    const TRect& aTargetRect, const TRect& aSourceRect,

                                    THuiFxBlendingMode aMode, TInt aAlpha) = 0;

    // Composition variant to compose directly to the screen. Uses always over blending with constant alpha.

    IMPORT_C virtual void Composite(CHuiGc& aGc, CHuiFxRenderbuffer& aSource, const TPoint& aTargetPoint, TBool aOpaque, TInt aAlpha);

    // Effect construction

    // TODO: Other needed effect parameters?

    // Demarcation rectangele added.

    // Effect end observer and handle added

    IMPORT_C void RegisterEffectL(const TDesC &aFileName);

    IMPORT_C void UnRegisterEffectL(const TDesC &aFileName);

    IMPORT_C void LoadEffectL(

        const TDesC& aFileName,

        CHuiFxEffect*& aEffect,

        MHuiEffectable* aVisual = 0,

        TRect* extRect = 0,

        MAlfGfxEffectObserver* aEffectEndObserver = 0,

        TInt aHandle = 0, 

        TInt aFlags = 0 );

    IMPORT_C void LoadGroupEffectL(

            const TDesC& aFileName,

            CHuiFxEffect*& aEffect,

            MHuiEffectable* aVisual = 0,

            TInt aGroupHandle = 0,

            TRect* extRect = 0,

            MAlfGfxEffectObserver* aEffectEndObserver = 0,

            TInt aHandle = 0,

            TInt aFlags = 0 );

    IMPORT_C TBool FxmlUsesInput1(const TDesC &aFileName);

    IMPORT_C void AdvanceTime(TReal32 aElapsedTime);

    IMPORT_C TReal32 GetReferenceValue(THuiFxReferencePoint aPoint);

    IMPORT_C THuiFxEngineType EngineType();

    //from MHuiLowMemoryObserver

    // deprecated

    IMPORT_C void EnableLowMemoryState(TBool aEnable);

    /*

	 * BeginGroupEffect

	 *

	 * Begins new group. start collecting effects, that should be set to motion at the same 

	 * time.

	 */

	IMPORT_C void BeginGroupEffect(TInt aGroup);

    IMPORT_C TInt ActiveGroupEffect();

    IMPORT_C TBool AddEffectToGroup(TInt aGroup);

    /*

	 * StartGroupEffect

	 *

	 * Starts syncronously group of effects that have the same aGroup id. 

	 */

    IMPORT_C void StartGroupEffect(TInt aGroup);

    TInt LowMemoryState();

    TBool HasActiveEffects() const;

    TBool HasActiveFadeEffect() const;

    void ClearCache();

    void NotifyEffectEndObservers();

    IMPORT_C void SetMemoryLevel(THuiMemoryLevel aLevel);

    void SetObserver(MHuiEffectObserver* aObserver)

        {

        iEffectObserver = aObserver;    

        }

	/**

	 * Group effects wait until each effect has been drawn once. 

	 *

	 * Group effects are set into motion by NotifyEffectReady, when all effects in

	 * the group have been drawn at least once.

	 */

    void NotifyEffectReady(TInt aGroupId);

protected:

    IMPORT_C void AddEffectL(CHuiFxEffect* aEffect);

    IMPORT_C void RemoveEffect(CHuiFxEffect* aEffect);

    TRequestStatus   iParserStatus;

    TInt             iBuffersInUse;

private:

    TBool FxmlUsesInput1(CHuiFxEffect& aEffect);

    TInt FindEffectGroup(TInt aGroup);

private:

    // Render buffer management --- native implementations

    virtual CHuiFxRenderbuffer* AcquireNativeRenderbuffer(const TSize& aDesiredSize) = 0;

    virtual void ReleaseNativeRenderbuffer(CHuiFxRenderbuffer* aBuffer) = 0;

    // Render buffer cache

#ifdef HUIFX_RBCACHE_ENABLED

    CHuiFxRenderbuffer* LookupFreeRenderbuffer(const TSize& aDesiredSize, TBool aAlllowLarger);

    void InsertFreeRenderbuffer(CHuiFxRenderbuffer *aBuffer);

    inline TBool IsCacheEmpty() const;

    inline TBool IsCacheFull() const;

    // simple general renderbuffer cache

    TInt                iBuffersInCache;

    CHuiFxRenderbuffer* iBufferCache[CACHE_SIZE];

#endif

#ifdef HUIFX_PERF_COUNTERS

    // TODO! counters for performance evaluation?!

    TInt iMaxAcquiredBuffers;

    TInt iMaxFreeBuffers;

    TSize iMaxBufferSize;

    TInt iHit;

    TInt iMiss;

#endif

    RPointerArray<CHuiFxEffect>  iActiveEffects;

    THuiFxEngineType             iType;

    TRect                        iExtRect;

    CHuiFxEffectCache *iCache;

    TInt iLowGraphicsMemoryMode;

    NONSHARABLE_STRUCT(TEffectGroupStruct)

        {

    public:

        TEffectGroupStruct(TInt aGroup) : iGroup(aGroup), iWaiting(0), iEndCalled(EFalse){};

        TInt iGroup;

        TInt iWaiting;

        TBool iEndCalled;

        };

	/**

	 * Only one simultanious effect group is supported

	 */

    RArray<TEffectGroupStruct> iActiveEffectGroups;

    MHuiEffectObserver* iEffectObserver;

    };

#endif /*HUIFXENGINE_H_*/