/*

* 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:   AppUi class

*

*/

#include <apgtask.h>

#include <AknDoc.h>

#include "alf/alfappui.h"

#include "alf/alfappserver.h"

#include <uiacceltk/HuiEnv.h>

#include <aknenv.h>

#include <AknsConstants.h>

#include <s32mem.h>

#include <uiacceltk/HuiSkin.h>

#include <uiacceltk/HuiDisplay.h>

#include <uiacceltk/HuiControl.h>

#include <uiacceltk/HuiControlGroup.h>

#include <uiacceltk/HuiEvent.h>

#include <uiacceltk/HuiDeckLayout.h>

#include <uiacceltk/HuiImageVisual.h>

#include <uiacceltk/HuiTransformation.h>

#include <uiacceltk/HuiBorderBrush.h>

#include <uiacceltk/HuiUtil.h>

#include <uiacceltk/HuiTextVisual.h>

#include <uiacceltk/HuiGradientBrush.h>

#include <uiacceltk/HuiImageBrush.h>

#include <uiacceltk/HuiRoster.h>

#ifdef ALF_USE_CANVAS

#include <uiacceltk/HuiCanvasVisual.h>

#endif

#include "alflogger.h"

#include "alf/alfappsrvsessionbase.h"

#include "alfsrvresourcemanager.h"

#include "alfsrvsettingshandler.h"

#include <uiacceltk/HuiTextureManager.h>

#include "alfsrvtexturemanager.h"

#include "alfstreamerserver.h"

#include "alfshareddisplaycoecontrol.h"

#include "alfbridge.h"

#include "alfstreamerconsts.h"

#include "alfscreen.h"

#include <akntranseffect.h>

#include "alfwindowmanager.h"

#include "alfwindowstructs.h"

#include <e32property.h>

#include "HuiFxEffect.h"

#include <akntransitionutils.h>

#include <alf/AlfTransEffectPlugin.h>

#include "alfwindowdata.h"

#include "huieffectable.h"

#include <akntranseffect.h>

#include "HuiRenderPlugin.h"

#include "huicanvasgc.h"

#include "huicanvasrenderbuffer.h"

#ifdef HUI_DEBUG_TRACK_DRAWING

#include <alfcommanddebug.h>

#endif

#ifdef _ALF_FXLOGGING

#include <alfcommanddebug.h>

#endif

#ifdef SYMBIAN_BUILD_GCE

#include <bautils.h>

#endif

const TInt KVisualTransformationStepRotate    = 0;

const TReal32 KAlfVisualDefaultOpacity = 1.0f;

//const TReal32 KAlfVisualDefaultOpacity = 0.5f;

_LIT8(KAlfWindowGroupContainerControlTag, "WGROUP");

// This debug option prints window group order with __ALFLOGSTRING

//#define ALF_DEBUG_PRINT_WINDOWGROUP_ORDER

// This debug option shows window groups in a grid

//#define ALF_DEBUG_VISUALIZE_WINDOWGROUP_ORDER

const TInt KFadeAction = 6000;

const TInt KRosterFreezeEndTimeoutInMs = 400;

// Timer to send finish full screen effect

// ---------------------------------------------------------

// CAlfFinishTimer

// ---------------------------------------------------------

//

NONSHARABLE_CLASS( CAlfRosterFreezeEndTimer ):public CTimer

    {

    public:  // Constructors and destructor

        static CAlfRosterFreezeEndTimer* NewL( CAlfBridge& aBridge );

        virtual ~CAlfRosterFreezeEndTimer();

    public: // New functions

        void Start( TTimeIntervalMicroSeconds32 aPeriod );

    protected:  // Functions from base classes

        void DoCancel();

    private:

        CAlfRosterFreezeEndTimer( CAlfBridge& aBridge );

        void ConstructL();

        void RunL();

    private:    // Data

        CAlfBridge& iBridge;

    };

// ---------------------------------------------------------

// CAlfRosterFreezeEndTimer

// ---------------------------------------------------------

//

CAlfRosterFreezeEndTimer::CAlfRosterFreezeEndTimer( CAlfBridge& aBridge )

    :CTimer ( EPriorityStandard ),

    iBridge( aBridge )

    {   

    }

void CAlfRosterFreezeEndTimer::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    }

CAlfRosterFreezeEndTimer* CAlfRosterFreezeEndTimer::NewL( CAlfBridge& aBridge )

    {

    CAlfRosterFreezeEndTimer* self = new ( ELeave ) CAlfRosterFreezeEndTimer( aBridge );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAlfRosterFreezeEndTimer::~CAlfRosterFreezeEndTimer()

    {

    Cancel();        

    }

void CAlfRosterFreezeEndTimer::Start( TTimeIntervalMicroSeconds32 aPeriod )

    {

    if (!IsActive())

        {

        After( aPeriod );

        }

    }

void CAlfRosterFreezeEndTimer::RunL()

    {

    iBridge.iHuiEnv->Display(0).SetDirty();

    TRAP_IGNORE(iBridge.iHuiEnv->Display(0).Roster().FreezeVisibleContentL(EFalse));

    iBridge.SetVisualTreeVisibilityChanged(ETrue);    

    }

void CAlfRosterFreezeEndTimer::DoCancel()

    {

    CTimer::DoCancel();

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectcoordinator

// ---------------------------------------------------------

//

NONSHARABLE_CLASS( CAlfLayoutSwitchEffectCoordinator ) : public CBase, public MAlfGfxEffectObserver

    {

    public:  // Constructors and destructor

        CAlfLayoutSwitchEffectCoordinator( CAlfBridge& aBridge );

        virtual ~CAlfLayoutSwitchEffectCoordinator();

    public: // MAlfGfxEffectObserver           

        void AlfGfxEffectEndCallBack( TInt aHandle );

    public:

        void BeginLayoutSwitch();

        void Cancel();

    private:

        AknTransEffect::TContext NextLayoutSwitchContext();

        void SetLayoutSwitchEffect(AknTransEffect::TContext aContext);

        TBool LayoutSwitchEffectsExist();

    private: // Data

        CAlfBridge& iBridge;

        AknTransEffect::TContext iLayoutSwitchEffectContext;

        TThreadPriority iOriginalPriority;

        CAlfRosterFreezeEndTimer* iRosterFreezeEndTimer;

    };

CAlfLayoutSwitchEffectCoordinator::CAlfLayoutSwitchEffectCoordinator( CAlfBridge& aBridge ) :

    iBridge( aBridge ),

    iLayoutSwitchEffectContext(AknTransEffect::ENone)    

    {

    RThread me = RThread();

    iOriginalPriority = me.Priority();    

    me.Close();

    }

CAlfLayoutSwitchEffectCoordinator::~CAlfLayoutSwitchEffectCoordinator()

    {   

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::AlfGfxEffectEndCallBack

//

// This method is callback which gets called when layout 

// switch effect has ended.

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::AlfGfxEffectEndCallBack( TInt aHandle )

    {

    //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::AlfGfxEffectEndCallBack"));

    if (iLayoutSwitchEffectContext == aHandle)

        {

        AknTransEffect::TContext nextContext = NextLayoutSwitchContext();

        // Unfreeze visible content. This reveals real roster content (in new orientation).

        if (nextContext == AknTransEffect::ELayoutSwitchExit)

            {

            #ifdef HUI_DEBUG_TRACK_DRAWING

            RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::AlfGfxEffectEndCallBack unfreezing roster content"));

            #endif

            iBridge.iHuiEnv->Display(0).SetDirty();

            TRAP_IGNORE(iBridge.iHuiEnv->Display(0).Roster().FreezeVisibleContentL(EFalse));

            iBridge.SetVisualTreeVisibilityChanged(ETrue);

            }

        // Set next effect

        SetLayoutSwitchEffect(nextContext);

        if (nextContext == AknTransEffect::ENone)

            {

            // Restore normal priority

            RThread me = RThread();

            me.SetPriority(iOriginalPriority);    

            me.Close();

            // Just in case refresh everything

            iBridge.iHuiEnv->Display(0).SetDirty();

            }        

        }

    else

        {

        //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::AlfGfxEffectEndCallBack - got different handle (normal, dont worry...) - %i"), aHandle);        

        }

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::Cancel

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::Cancel()

    {

    // Disable effect

    SetLayoutSwitchEffect( AknTransEffect::ENone );

    // Unfreeze visible content

    if ( iRosterFreezeEndTimer )

        {

		iRosterFreezeEndTimer->Cancel();

    	}

    iBridge.iHuiEnv->Display(0).SetDirty();

    TRAP_IGNORE(iBridge.iHuiEnv->Display(0).Roster().FreezeVisibleContentL(EFalse));

    iBridge.SetVisualTreeVisibilityChanged(ETrue);

    // Restore normal priority

    RThread me = RThread();

    me.SetPriority(iOriginalPriority);    

    me.Close();

	}

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch

//

// This method starts the layout switch effect procedure.

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch()

    {

    // Hm. what to do if earlier is already in progress ?

    //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch"));

    if ( iBridge.iHuiEnv->MemoryLevel() <= EHuiMemoryLevelLowest )

        {

        // No effects in low memory mode

        return;

        }

    if (!iLayoutSwitchEffectContext)

        {

        TBool tfxOn = CAknTransitionUtils::TransitionsEnabled(AknTransEffect::ELayoutswitchTransitionsOff );

        TBool tfxExists = LayoutSwitchEffectsExist();

        if (tfxOn && tfxExists)

            {

            // Boost priority so that we are able to draw more frames for the effect

            RThread me = RThread();

            me.SetPriority(EPriorityAbsoluteHigh);    

            me.Close();

            // Freeze visual content

            //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch freezing roster content"));

            iBridge.iHuiEnv->Display(0).SetDirty();

            TRAP_IGNORE(iBridge.iHuiEnv->Display(0).Roster().FreezeVisibleContentL(ETrue));

            // Remove all other effects

            iBridge.HandleGfxStopEvent( EFalse );

            iBridge.RemoveAllTemporaryPresenterVisuals();

            // Set first layout switch effect 

            SetLayoutSwitchEffect(AknTransEffect::ELayoutSwitchStart);

            }

        else

            {

            if (!iRosterFreezeEndTimer)

                {

                TRAP_IGNORE(iRosterFreezeEndTimer = CAlfRosterFreezeEndTimer::NewL(iBridge));

                }

            if (iRosterFreezeEndTimer)

                {

                iBridge.iHuiEnv->Display(0).SetDirty();

                TRAP_IGNORE(iBridge.iHuiEnv->Display(0).Roster().FreezeVisibleContentL(ETrue));

                // Remove all other effects

                iBridge.HandleGfxStopEvent( EFalse );

                iBridge.RemoveAllTemporaryPresenterVisuals();

                // Set remove freeze timer

                iRosterFreezeEndTimer->Start(KRosterFreezeEndTimeoutInMs*1000); 

                }            

            //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch - tfx are set OFF -> I am not starting effect."));                        

            }

        }

    else

        {

        //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch - old effect exists - %i"), iLayoutSwitchEffectContext);

        }

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::NextLayoutSwitchContext

//

// This method automatically selects the next context in the 

// layout switch procedure.

//

// Contextes change in the following order during layout switch:

//

// 1. AknTransEffect::ENone

// 2. AknTransEffect::ELayoutSwitchStart

// 3. AknTransEffect::ELayoutSwitchExit

// 4. AknTransEffect::ENone

//

// After new context is selected, appropriate effect is set 

// (and/or removed) from the roster.

//

// ---------------------------------------------------------

//

AknTransEffect::TContext CAlfLayoutSwitchEffectCoordinator::NextLayoutSwitchContext()

    {

    // Resolve next context based on current context

    AknTransEffect::TContext newContext = AknTransEffect::ENone;    

    switch (iLayoutSwitchEffectContext)

        {

        case AknTransEffect::ENone:

            {

            newContext = AknTransEffect::ELayoutSwitchStart;            

            break;

            }

        case AknTransEffect::ELayoutSwitchStart:

            {

            newContext = AknTransEffect::ELayoutSwitchExit;                    

            break;

            }

        case AknTransEffect::ELayoutSwitchExit: // fallthrough

        default:

            {

            newContext = AknTransEffect::ENone;            

            break;

            }              

        }

    //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::NextLayoutSwitchEffectL old ctx = %i, new ctx = %i"), iLayoutSwitchEffectContext, newContext);

    return newContext;

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::SetLayoutSwitchEffectL

//

// This method sets correct effect based on the given 

// layout switch context.

//

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::SetLayoutSwitchEffect(AknTransEffect::TContext aContext)

    {

    MHuiEffectable* effectable = iBridge.iHuiEnv->Display(0).Roster().Effectable();

    CHuiFxEffect* effect = NULL;

    CHuiFxEngine* engine = iBridge.iHuiEnv->EffectsEngine();

    if (!effectable || !engine)

        {

        return;

        }    

    // Update current context

    iLayoutSwitchEffectContext = aContext;           

    if (aContext == AknTransEffect::ENone)

        {

        // Just remove effect

        //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::NextLayoutSwitchEffectL - removing effect"));

        effectable->EffectSetEffect(NULL); // This calls AlfGfxEffectEndCallBack         

        }

    else

        {    

        // Load correct effect

        for ( TInt i = 0; i<iBridge.iAlfRegisteredEffects.Count(); i++ )

            {             

            if ( iBridge.iAlfRegisteredEffects[i].iAction == aContext)

                {

                //RDebug::Print(_L("CAlfLayoutSwitchEffectCoordinator::SetLayoutSwitchEffectL - loading effect"));

                TRAP_IGNORE(engine->LoadEffectL(*iBridge.iAlfRegisteredEffects[i].iEffectFile, effect, effectable, NULL, this, iLayoutSwitchEffectContext, 0 ) );                    

                break;

                }

            }

        }    

    }

TBool CAlfLayoutSwitchEffectCoordinator::LayoutSwitchEffectsExist()

    {

    TBool appearExists = EFalse;

    TBool disAppearExists = EFalse;

    for ( TInt i = 0; i<iBridge.iAlfRegisteredEffects.Count(); i++ )

        {             

        if ( iBridge.iAlfRegisteredEffects[i].iAction == AknTransEffect::ELayoutSwitchStart)

            {

            disAppearExists = ETrue;

            break;

            }

        else if ( iBridge.iAlfRegisteredEffects[i].iAction == AknTransEffect::ELayoutSwitchExit)

            {

            appearExists = ETrue;

            break;

            }

        }

    return (appearExists || disAppearExists);    

    }

// Timer to send finish full screen effect

// ---------------------------------------------------------

// CAlfFinishTimer

// ---------------------------------------------------------

//

NONSHARABLE_CLASS( CAlfEffectEndTimer ):public CTimer

    {

    public:  // Constructors and destructor

        static CAlfEffectEndTimer* NewL( CAlfBridge& aBridge );

        virtual ~CAlfEffectEndTimer();

    public: // New functions

        void Start( TTimeIntervalMicroSeconds32 aPeriod, TInt aHandle );

    protected:  // Functions from base classes

        void DoCancel();

    private:

        CAlfEffectEndTimer( CAlfBridge& aBridge );

        void ConstructL();

        void RunL();

    private:    // Data

        CAlfBridge& iBridge;

        TInt iHandle;

    };

// ---------------------------------------------------------

// CAlfFinishTimer

// ---------------------------------------------------------

//

CAlfEffectEndTimer::CAlfEffectEndTimer( CAlfBridge& aBridge )

    :CTimer(EPriorityHigh), 

	iBridge(aBridge)

    {   

    }

void CAlfEffectEndTimer::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    }

CAlfEffectEndTimer* CAlfEffectEndTimer::NewL( CAlfBridge& aBridge )

    {

    CAlfEffectEndTimer* self = new ( ELeave ) CAlfEffectEndTimer( aBridge );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAlfEffectEndTimer::~CAlfEffectEndTimer()