/*
* Copyright (c) 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:  Utility class for passing data between controls.
*
*/


#include "gfxtransextension.h"

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CGfxTransExtension::TDataEntry::TDataEntry( const TInt aKey, 
                                            const TDesC8* aData ) :
        iKey( aKey ), iData( aData )
    {
    }
        
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CGfxTransExtension::TDataEntry::SameKey( const TDataEntry& aEntry1, 
                                               const TDataEntry& aEntry2 )
    {
    return aEntry1.iKey == aEntry2.iKey;
    }
    

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CGfxTransExtension::TTransitionObserver::TTransitionObserver( 
            const TInt aKey, const TInt aEventType, 
            MAknTransitionUtilsObserver* aObserver ) :
        iKey( aKey ), iObserver( aObserver ), iEventType( ( TEvents )aEventType )
    {
    }
 
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CGfxTransExtension::TTransitionObserver::SameKey( 
        const TTransitionObserver& aObserver1,
        const TTransitionObserver& aObserver2 )
    {
    return aObserver1.iKey == aObserver2.iKey;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CGfxTransExtension::TTransitionObserver::Equal( 
        const TTransitionObserver& aObserver1,
        const TTransitionObserver& aObserver2 )
    {
    return ( aObserver1.iObserver == aObserver2.iObserver ) &&
           ( aObserver1.iEventType == aObserver2.iEventType );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CGfxTransExtension::~CGfxTransExtension() 
    {
    TInt count = iUserData.Count();
        
    for ( TInt i = 0; i < count; i++ )
        {
        delete iUserData[i].iData;
        }
            
    iUserData.Reset();
    iObservers.Reset();
    };

/*
    static TInt GetState(TInt aEvent, TInt* aState, TDes8* aParams = NULL);

    // FIXME: TDes8 instead of TAny
    static TInt SetData( const TInt aKey, TAny* aData );
    static TAny* GetData( const TInt aKey );
    static void RemoveData( const TInt aKey );
*/

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CGfxTransExtension::AddObserver( MAknTransitionUtilsObserver* aObserver,
                                      TInt aEvent,
                                      const TDesC8* aParams )
    {
    CGfxTransExtension* singleton = 
        reinterpret_cast<CGfxTransExtension*>(CCoeEnv::Static( KGfxTransExtensionUid ) );
    if ( !singleton )
        {
        return KErrNoMemory;
        }
    
    TInt key = ( TInt )aParams;
    TInt count = singleton->iObservers.Count();
    TBool exists = EFalse;
    for ( TInt i = 0; i < count; i++ )
        {
        TTransitionObserver o = singleton->iObservers[i];
        if ( ( o.iEventType == aEvent ) && ( o.iObserver == aObserver ) )
            {
            exists = ETrue;
            break;
            }
        }
        
    if ( !exists )
        {
        TTransitionObserver observer( key, aEvent, aObserver );
        singleton->iObservers.Append( observer );
        }

    if ( aEvent == EEventControlTransitionFinished )
        {
        GfxTransEffect::SetTransitionObserver( singleton );
        singleton->iNumControlTransitionObservers++;
        }
        
    return KErrNone;
    }
  
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CGfxTransExtension::RemoveObserver( 
        MAknTransitionUtilsObserver* aObserver, TInt aEvent )
    {
    CGfxTransExtension* singleton = CGfxTransExtension::Static();
    if ( !singleton )
        {
        return KErrNotFound;
        }

    TIdentityRelation<TTransitionObserver> identity( TTransitionObserver::Equal );
    TTransitionObserver tmp( 0, aEvent, aObserver );
    TInt index = singleton->iObservers.Find( tmp, identity );
    if ( index != KErrNotFound )
        {
        singleton->iObservers.Remove( index );
        if ( aEvent == EEventControlTransitionFinished )
            {
            singleton->iNumControlTransitionObservers--;
            }
        
        if ( singleton->iNumControlTransitionObservers == 0 )
            {
            GfxTransEffect::SetTransitionObserver( NULL );
            }
            
        return KErrNone;
        }
        
    return KErrNotFound;
    }
    
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CGfxTransExtension::GetState(TInt /*aEvent*/, TInt* /*aState*/, TDes8* /*aParams*/ )
    {
    return 0;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CGfxTransExtension::TransitionFinished( const CCoeControl* aControl, 
                                             TUint /* aAction */ )
    {
    CGfxTransExtension* singleton = 
        reinterpret_cast<CGfxTransExtension*>(CCoeEnv::Static( KGfxTransExtensionUid ) );
    if ( !singleton )
        {
        return;
        }

    TInt key = ( TInt )aControl;

    TInt count = singleton->iObservers.Count();
    for ( TInt i = 0; i < count; i++ )
        {
        if ( singleton->iObservers[i].iKey == key )
            {
            singleton->iObservers[i].iObserver->AknTransitionCallback(
                EEventControlTransitionFinished, 0, ( const TDesC8* )aControl );
            }
        }
    }
    
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CGfxTransExtension::RemoveData( const TInt aKey )
    {
    CGfxTransExtension* singleton = CGfxTransExtension::Static();
    if ( !singleton )
        {
        return;
        }

    // Find the data
    TIdentityRelation<TDataEntry> identity( TDataEntry::SameKey );
    TDataEntry tmp( aKey, NULL );
    TInt index = singleton->iUserData.Find( tmp, identity );
    if ( index != KErrNotFound )
        {
        delete singleton->iUserData[index].iData;
        singleton->iUserData.Remove( index );
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CGfxTransExtension::SetData( const TInt aKey, const TDesC8* aData )
    {
    CGfxTransExtension* singleton = CGfxTransExtension::Static();
    if ( !singleton )
        {
        return KErrNoMemory;
        }
        
    TIdentityRelation<TDataEntry> identity( TDataEntry::SameKey );
    TDataEntry tmp( aKey, aData );
    TInt index = singleton->iUserData.Find( tmp, identity );
    if ( index != KErrNotFound )
        {
        delete singleton->iUserData[index].iData;
        singleton->iUserData[index].iData = aData;
        }
    else
        {
        singleton->iUserData.Append( tmp );
        }

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
const TDesC8* CGfxTransExtension::GetData( const TInt aKey )
    {
    CGfxTransExtension* singleton = CGfxTransExtension::Static();
    if ( !singleton )
        {
        return NULL;
        }
        
    TIdentityRelation<TDataEntry> identity( TDataEntry::SameKey );
    TDataEntry tmp( aKey, NULL );
    TInt index = singleton->iUserData.Find( tmp, identity );
    if ( index != KErrNotFound )
        {
        return singleton->iUserData[index].iData;
        }
    else
        {
        return NULL;
        }
    }
        
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CGfxTransExtension::CGfxTransExtension() :
        CCoeStatic( KGfxTransExtensionUid, -1, CCoeStatic::EThread ),
        iNumControlTransitionObservers( 0 )
    {
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CGfxTransExtension* CGfxTransExtension::Static()
    {
    CGfxTransExtension* singleton = 
        reinterpret_cast<CGfxTransExtension*>(CCoeEnv::Static( KGfxTransExtensionUid ) );
    if ( !singleton )
        {
        singleton = new CGfxTransExtension();
        }
        
    return singleton;
    }