#include <akntranseffect.h>

#include <alf/alfcompositionutility.h>

#include <layoutmetadata.cdl.h>

#include "xnappuiadapter.h"

#include "xnbackgroundmanager.h"

#include "xnviewadapter.h"

const TInt KWaitForLayout( 1 );

const TInt KEffectStarted( 2 );

const TInt KControlEffectWaitInterval( 100000 ); // 100ms

const TInt KFullScreenEffectWaitInterval( 300000 ); // 300ms

const TInt KWaitInterval( 25000 ); // 25ms

const TInt KInterval( 500000 );

#define IS_VALID( e ) \

    ( e == KGfxContextActivateNextView || \

    e == KGfxContextActivatePrevView )

// ============================ LOCAL FUNCTIONS ================================

CXnEffectManager::CXnEffectManager( CXnAppUiAdapter& aAppUiAdapter )

    : CTimer( CActive::EPriorityIdle ), iAppUiAdapter( aAppUiAdapter ), 

      iGroupId( -1 )

    CActiveScheduler::Add( this );

    CTimer::ConstructL();

    OrientationChanged();

    iObserver = CAlfEffectObserver::NewL();

CXnEffectManager* CXnEffectManager::NewL( CXnAppUiAdapter& aAppUiAdapter )

    CXnEffectManager* self = new ( ELeave ) CXnEffectManager( aAppUiAdapter );

    Cancel();

    delete iObserver;

    iControls.Reset();

    iEffects.Reset();

    }

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

// CXnEffectManager::RunL

//

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

//

void CXnEffectManager::RunL() 

    {

    // No implementation required

    {    

    TXnEffect effect;

    effect.iId = aId;    

    effect.iNode = aView.ViewNode();

        effect.iState = KWaitForLayout;

        iEffects.AppendL( effect );               

        if ( DoBeginFullscreenEffect( effect ) )

            {

            iEffects.AppendL( effect );                               

            }

        }

    }

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

// CXnEffectManager::BeginFullscreenEffectL

//

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

//

void CXnEffectManager::BeginFullscreenEffectL( TInt aId )

    {

    TXnEffect effect;

    effect.iId = aId;

    effect.iExplicitEnd = ETrue;

    if ( DoBeginFullscreenEffect( effect ) )

        {

        iEffects.AppendL( effect );

// CXnEffectManager::EndFullscreenEffect

//

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

//

void CXnEffectManager::EndFullscreenEffect( TInt aId )

    {

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

        {

        TXnEffect& effect( iEffects[i] );

        if ( effect.iId == aId && 

            effect.iExplicitEnd && 

            effect.iState == KEffectStarted )

            {

            GfxTransEffect::EndFullScreen();

            iEffects.Remove( i );

            break;

            }

        }        

    }

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

        TXnEffect& effect( iEffects[i] );

        if ( effect.iState == KEffectStarted && !effect.iExplicitEnd )            

            iEffects.Remove( i );            

        TBool started( ETrue );

        TXnEffect& effect( iEffects[i] );

        if ( effect.iNode && effect.iState == KWaitForLayout &&             

             effect.iNode->IsLaidOut() )

            started = DoBeginFullscreenEffect( effect );                       

        if ( !started )

            iEffects.Remove( i );            

            i++;

    {   

    if ( !iAppUiAdapter.IsForeground() )          

        {

        // Not in foreground

        return EFalse;

        }

    if ( !WaitActiveEffect( KFullScreenEffectWaitInterval ) )

    const TUid targetAppUid( iAppUiAdapter.Application()->AppDllUid() );

    GfxTransEffect::BeginFullScreen( aEffect.iId , iAppUiAdapter.ClientRect(),

// CXnEffectManager::WaitActiveEffect

//

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

//

TBool CXnEffectManager::WaitActiveEffect( TInt aInterval )     

    {

    TBool retval( EFalse );

    TInt loop( aInterval / KWaitInterval );

    while ( loop >= 0 )

        {               

        TInt count( iObserver->ActiveEffectsCount() );

        if ( count == 0 )

            {

            retval = ETrue;

            break;                        

            }

        User::After( KWaitInterval );

        loop--;

        }

    return retval;    

    }

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

// CXnEffectManager::BeginActivateViewEffect

TBool CXnEffectManager::BeginActivateViewEffect( const CXnViewData& aThis, 

    const CXnViewData& aOther, TUid aEffect )

    CleanupControlEffect();

    if ( !IS_VALID( aEffect ) )

        {

        // Not a valid view switch effect uid

        return EFalse;

        }

    CXnControlAdapter* thisView( aThis.ViewNode()->Control() );                             

    CXnControlAdapter* otherView( aOther.ViewNode()->Control() ); 

    if ( thisView == otherView )

        {

        // Same controls

        return EFalse;

        }

    if ( IsActive() )

        {

        Cancel();

        After( KInterval );

        return EFalse;

        }

    if ( !WaitActiveEffect( KControlEffectWaitInterval ) )

        {               

        After( KInterval );

        return EFalse;

        }

    iControls.Append( thisView );

    iControls.Append( otherView );

    GfxTransEffect::Register( thisView, aEffect );    

    GfxTransEffect::Register( otherView, aEffect );

    iGroupId = GfxTransEffect::BeginGroup();

    CFbsBitmap* currentBg( aThis.WallpaperImage() );

    CFbsBitmap* nextBg( aOther.WallpaperImage() );

    if ( currentBg || nextBg )

        {

        CCoeControl* bg( &iAppUiAdapter.ViewAdapter().BgManager() );

        iControls.Append( bg );

        if ( !currentBg && nextBg )

            {           

            GfxTransEffect::Begin( bg, KGfxControlActionBgAnimToImgAppear );

            }

        else

            {

            GfxTransEffect::Begin( bg, KGfxControlActionBgImgToImgAppear );

            }

        iBgEffect = ETrue;

        }

    if ( iLandscape )

        {

        GfxTransEffect::Begin( thisView, KGfxControlActionDisappearLsc );

        GfxTransEffect::Begin( otherView, KGfxControlActionAppearLsc );

        }

    else

        GfxTransEffect::Begin( thisView, KGfxControlActionDisappearPrt );

        GfxTransEffect::Begin( otherView, KGfxControlActionAppearPrt );

        }    

    return ETrue;

    }

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

// CXnEffectManager::EndActivateViewEffect

//

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

//

void CXnEffectManager::EndActivateViewEffect( const CXnViewData& aThis, 

    const CXnViewData& aOther, TUid aEffect )

    {

    if ( !IS_VALID( aEffect ) || iGroupId == -1 )

        {

        // Not a valid view switch effect uid or group effect is not started

        return;

        }

    CXnControlAdapter* thisView( aThis.ViewNode()->Control() );                             

    CXnControlAdapter* otherView( aOther.ViewNode()->Control() ); 

    if ( iBgEffect )

        {    

        CCoeControl* bg( &iAppUiAdapter.ViewAdapter().BgManager() );

        GfxTransEffect::SetDemarcation( bg, bg->Position() );

        GfxTransEffect::End( bg );        

        }

    GfxTransEffect::SetDemarcation( thisView, thisView->Position() );

    GfxTransEffect::End( thisView );

    GfxTransEffect::SetDemarcation( otherView, otherView->Position() );

    GfxTransEffect::End( otherView );                     

    GfxTransEffect::EndGroup( iGroupId );

    GfxTransEffect::Deregister( thisView );

    GfxTransEffect::Deregister( otherView );    

    }

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

// CXnEffectManager::BgAppearEffect

//

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

//

void CXnEffectManager::BgAppearEffect( CCoeControl* aBg, TBool aWaitActiveEffect )

    {

    if ( aWaitActiveEffect )

        {

        WaitActiveEffect( KFullScreenEffectWaitInterval );               

    GfxTransEffect::Begin( aBg, KGfxControlActionBgImgToImgAppear );

    GfxTransEffect::SetDemarcation( aBg, aBg->Position() );

    GfxTransEffect::End( aBg );                         

    }

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

// CXnEffectManager::Cleanup

//

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

//

void CXnEffectManager::CleanupControlEffect()

    {

    iBgEffect = EFalse;

    iGroupId = -1;       

    iControls.Reset();        

    }

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

// CXnEffectManager::ControlEffectActive

//

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

//

TBool CXnEffectManager::ControlEffectActive( const CCoeControl* aControl ) const

    {

    TInt index( iControls.Find( aControl ) );

    return index != KErrNotFound;

    }

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

// CXnEffectManager::OrientationChanged

//

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

//

void CXnEffectManager::OrientationChanged()

    {

    iLandscape = Layout_Meta_Data::IsLandscapeOrientation();