/*

* Copyright (c) 2009 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:  Component manager implementation.

*

*/

#include <cvtlogger.h>

#include "cvtuicomponentmanager.h"

#include "mvtuiwindowservereventobserver.h"

#include "mvtuiresourcechangeobserver.h"

#include "mvtuikeyeventobserver.h"

#include "mvtuilayoutchangeobserver.h"

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

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

// CmpByPtr

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

//

template < class T >

TInt CmpByPtr( const T& aObj1, const T& aObj2 )

    {

    return reinterpret_cast< TInt >( &aObj1 ) -

        reinterpret_cast< TInt >( &aObj2 );

    }

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

// FindByPtr

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

//

template < class T >

TInt FindByPtr( const TInt* aPtr, const T& aObj )

    {

    return *aPtr - reinterpret_cast< TInt >( &aObj );

    }

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

// CmpMVtUiComponent

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

//

TInt CmpMVtUiComponent( const MVtUiComponent& aC1, const MVtUiComponent& aC2 )

    {

    return ( aC1.ComponentId() - aC2.ComponentId() );

    }

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

// CmpTVtUiComponentState

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

//

TInt CmpTVtUiComponentState( const TVtUiComponentState& aC1,

    const TVtUiComponentState& aC2 )

    {

    return ( aC1.Component().ComponentId() - aC2.Component().ComponentId() );

    }

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

// CmpTVtUiComponentStateByKey

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

//

TInt CmpTVtUiComponentStateByKey( const MVtUiComponent::TComponentId* aKey,

    const TVtUiComponentState& aC )

    {

    return ( *aKey - aC.Component().ComponentId() );

    }

// ======== MEMBER FUNCTIONS ========

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

// CVtUiComponentManager::NewL

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

//

CVtUiComponentManager* CVtUiComponentManager::NewL()

    {

    __VTPRINTENTER( "CompMgr.NewL" )

    CVtUiComponentManager* self = new ( ELeave ) CVtUiComponentManager();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

    __VTPRINTEXIT( "CompMgr.NewL" )

    return self;

    }

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

// CVtUiComponentManager::~CVtUiComponentManager

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

//

CVtUiComponentManager::~CVtUiComponentManager()

    {

    __VTPRINTENTER( "CompMgr.~" )

    iWsEventObservers.Close();

    iResourceChangeObservers.Close();

    iKeyEventObservers.Close();

    iLayoutChangeObservers.Close();

    iComponents.Close();

    __VTPRINTEXIT( "CompMgr.~" )

    }

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

// CVtUiComponentManager::HandleWsEventL

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

//

void CVtUiComponentManager::HandleWsEventL( const TWsEvent& aEvent,

    CCoeControl* aDestination )

    {

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

        {

        iWsEventObservers[ i ]->HandleWsEventL( aEvent, aDestination );

        }

    }

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

// CVtUiComponentManager::HandleResourceChangeL

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

//

void CVtUiComponentManager::HandleResourceChangeL( TInt aType )

    {

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

        {

        iResourceChangeObservers[ i ]->HandleResourceChangeL( aType );

        }

    }

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

// CVtUiComponentManager:OfferKeyEventL

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

//

TKeyResponse CVtUiComponentManager::OfferKeyEventL(

    const TKeyEvent& aEvent, TEventCode aCode )

    {

    TKeyResponse response( EKeyWasNotConsumed );

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

        {

        response = iKeyEventObservers[ i ]->OfferKeyEventL( aEvent, aCode );

        if ( response == EKeyWasConsumed )

            {

            break;

            }

        }

    return response;

    }

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

// CVtUiComponentManager::HandleLayoutChangeL

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

//

void CVtUiComponentManager::HandleLayoutChangeL()

    {

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

        {

        iLayoutChangeObservers[ i ]->HandleLayoutChangeL();

        }    

    }

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

// CVtUiComponentManager::ChangeWsEventRegistration

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

//

TInt CVtUiComponentManager::ChangeWsEventRegistration(

    MVtUiWindowServerEventObserver& aObserver, TAction aAction )

    {

    return AddOrRemoveComponent( iWsEventObservers, &aObserver, aAction );

    }

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

// CVtUiComponentManager::ChangeResourceChangeRegistration

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

//

TInt CVtUiComponentManager::ChangeResourceChangeRegistration(

    MVtUiResourceChangeObserver& aObserver, TAction aAction )

    {

    return AddOrRemoveComponent( iResourceChangeObservers, &aObserver,

        aAction );

    }

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

// CVtUiComponentManager::ChangeKeyEventRegistration

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

//

TInt CVtUiComponentManager::ChangeKeyEventRegistration(

    MVtUiKeyEventObserver& aObserver, TAction aAction )

    {

    return AddOrRemoveComponent( iKeyEventObservers, &aObserver, aAction );

    }

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

// CVtUiComponentManager::ChangeLayoutChangeRegistration

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

//

TInt CVtUiComponentManager::ChangeLayoutChangeRegistration(

    MVtUiLayoutChangeObserver& aObserver, TAction aAction )

    {

    return AddOrRemoveComponent( iLayoutChangeObservers, &aObserver, aAction );

    }

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

// CVtUiComponentManager::ChangeComponentRegistration

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

//

TInt CVtUiComponentManager::ChangeComponentRegistration(

    TVtUiComponentState& aComponentState, TAction aAction )

    {

    __VTPRINTENTER( "CompMgr.ChangeComponentRegistrationL" )

    TInt result( KErrNone );

    if ( aAction == ERegister )

        {

        result =

            iComponents.InsertInOrder( &aComponentState,

                ComponentStateOrder() );

        }

    else

        {

        TInt index( iComponents.FindInOrder(

            &aComponentState, ComponentStateOrder() ) );

        if ( index != KErrNotFound )

            {

            iComponents.Remove( index );

            }

        }

    __VTPRINTEXITR( "CompMgr.ChangeComponentRegistrationL %d", result )

    return result;

    }

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

// CVtUiComponentManager::RequestActivationL

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

//

void CVtUiComponentManager::RequestActivationL(

    MVtUiComponent::TComponentId aId )

    {

    __VTPRINTENTER( "CompMgr.RequestActivationL" )

    TInt index( iComponents.FindInOrder( aId, ::CmpTVtUiComponentStateByKey ) );

    if ( index == KErrNotFound )

        {

        User::Leave( index );

        }

    else

        {

        TVtUiComponentState& state( *iComponents[ index ] );

        if ( state.State() == TVtUiComponentState::EActive )

            {

            User::Leave( KErrNotReady );

            }

        else

            {

            DoActivationL( state, TVtUiComponentState::EActive );

            }

        }

    __VTPRINTEXIT( "CompMgr.RequestActivationL" )

    }

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

// CVtUiComponentManager::DeActivateComponentL

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

//

void CVtUiComponentManager::DeActivateComponentL(

    MVtUiComponent::TComponentId aId )

    {

    __VTPRINTENTER( "CompMgr.DeActivateComponentL" )

    TInt index( iComponents.FindInOrder( aId, ::CmpTVtUiComponentStateByKey ) );

    if ( index == KErrNotFound )

        {

        User::Leave( index );

        }

    else

        {

        TVtUiComponentState& state( *iComponents[ index ] );

        if ( state.State() == TVtUiComponentState::EInactive )

            {

            User::Leave( KErrNotReady );

            }

        else

            {

            DoDeactivationL( state, TVtUiComponentState::EInactive );

            }

        }

    __VTPRINTEXIT( "CompMgr.DeActivateComponentL" )

    }

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

// CVtUiComponentManager::DoActivationL

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

//

void CVtUiComponentManager::DoActivationL(

	TVtUiComponentState& aComponentState,

	TVtUiComponentState::TState aNewState )

    {

    __VTPRINTENTER( "CompMgr.DoActivationL" )

    TStateList stateList;

    ConstructStateListL( stateList );

    TInt index( stateList.FindItem(

    	aComponentState.Component().ComponentId() ) );

    if ( index != KErrNotFound )

        {

        TStateListItem& sli( stateList.At( index ) );

        TVtUiBlockListBitField exclList;

        for ( TInt i = stateList.ItemCount() - 1; i >= 0; i-- )

        	{

        	TStateListItem& sli2( stateList.At( i ) );

        	if ( sli2.ComponentId() != sli.ComponentId() )

        		{

        		if ( sli2.State() == TVtUiComponentState::EActive &&

        			 !sli.BlockList().Contains( sli2.ComponentId() ) )

        			{

        			exclList.Union( sli2.BlockList() );

        			}

        		}

        	}

       	sli.SetRoot();

        sli.SetState( aNewState );

        CalculateActivationL( sli.BlockList(), exclList, stateList, EHide );

        }

    CommitStateListL( stateList );

    __VTPRINTEXIT( "CompMgr.DoActivationL" )

    }

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

// CVtUiComponentManager::DoDeactivationL

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

//

void CVtUiComponentManager::DoDeactivationL(

    TVtUiComponentState& aComponentState,

    TVtUiComponentState::TState aNewState )

    {

    __VTPRINTENTER( "CompMgr.DoDeactivationL" )

    TStateList stateList;

    ConstructStateListL( stateList );

    TInt index( stateList.FindItem(

        aComponentState.Component().ComponentId() ) );

    if ( index != KErrNotFound )

        {

        TStateListItem& sli( stateList.At( index ) );

        TVtUiBlockListBitField exclList;

        if ( sli.State() == TVtUiComponentState::EActive )

        	{

	        for ( TInt i = stateList.ItemCount() - 1; i >= 0; i-- )

	        	{

	        	TStateListItem& sli2( stateList.At( i ) );

	        	if ( sli2.ComponentId() != sli.ComponentId() )

	        		{

	        		if ( sli2.State() == TVtUiComponentState::EActive )

	        			{

	        			exclList.Union( sli2.BlockList() );

	        			}

	        		}

	        	}

        	}

        sli.SetRoot();

        sli.SetState( aNewState );

        CalculateActivationL( sli.BlockList(), exclList, stateList, EShow );

        }

    CommitStateListL( stateList );

    __VTPRINTEXIT( "CompMgr.DoDeactivationL" )

    }

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

// CVtUiComponentManager::CommitStateListL

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

//

void CVtUiComponentManager::CommitStateListL( TStateList& aList )

    {

    __VTPRINTENTER( "CompMgr.CommitStateListL" )

    // Sort list by component state. Components will first deactivated, then

    // blocked and finally activated.

    aList.Sort( TStateListItem::StateOrder() );

    for ( TInt i = 0; i < aList.ItemCount(); i++ )

        {

        const TStateListItem& sli( aList.At( i ) );

        TInt index( iComponents.FindInOrder( sli.ComponentId(),

            ::CmpTVtUiComponentStateByKey ) );

        if ( index != KErrNotFound )

            {

            TVtUiComponentState& cs( *iComponents[ index ] );

            if ( cs.State() != sli.State() )

                {

                switch ( sli.State() )

                    {

                case TVtUiComponentState::EInactive:

                    cs.DeActivateComponentL();

                    break;

                case TVtUiComponentState::EActive:

                    cs.ActivateComponentL();

                    break;

                case TVtUiComponentState::EWaiting:

                    cs.BlockComponentL();

                    break;

                default:

                    User::Leave( KErrArgument );

                    break;

                    }

                }

            }

        }

    __VTPRINTEXIT( "CompMgr.CommitStateListL" )

    }

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

// CVtUiComponentManager::CalculateActivationL

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

//

void CVtUiComponentManager::CalculateActivationL(

    const TVtUiBlockList& aBlockList,

    const TVtUiBlockList& aExclList,

    TStateList& aStateList, TActivationAction aAction )

    {

    __VTPRINTENTER( "CompMgr.CalculateActivationL" )

    __VTPRINT2( DEBUG_GEN, "aAction = %d", (TInt)aAction )

    TVtUiBlockListBitField blockList;

    CVtUiBlockListIterator* iterator = aBlockList.IteratorLC();

    while ( iterator->HasNext() )

        {

        MVtUiComponent::TComponentId cid( iterator->Next() );

		if ( aExclList.Contains( cid ) )

			{

			continue;

			}

        TInt index( aStateList.FindItem( cid ) );

        if ( index != KErrNotFound )

            {

            TStateListItem& sli( aStateList.At( index ) );

            __VTPRINT3( DEBUG_GEN, "@1, Id = %d, state = %d", (TInt)sli.ComponentId(), (TInt)sli.State() )

            if ( !sli.IsRoot() )

                {

                if ( aAction == EShow )

                    {

                    // if action == EShow and component is being blocked,

                    // then activate component

                    if ( sli.State() == TVtUiComponentState::EWaiting )

                        {

                        sli.SetState( TVtUiComponentState::EActive );

                        if ( !sli.IsVisited() )

                            {

                            blockList.Union( sli.BlockList() );

                            }

                        sli.SetVisited();

                        }

                    }

                else // aAction == EHide

                    {

                    // if action == EHide and component is active, then

                    // block component

                    if ( sli.State() == TVtUiComponentState::EActive )

                        {

                        sli.SetState( TVtUiComponentState::EWaiting );

                        if ( !sli.IsVisited() )

                            {

                            blockList.Union( sli.BlockList() );

                            }

                        sli.SetVisited();

                        }

                    }

                }

			__VTPRINT3( DEBUG_GEN, "@2, Id = %d, state = %d", (TInt)sli.ComponentId(), (TInt)sli.State() )

            }

        }

    CleanupStack::PopAndDestroy(); // iterator

    if ( !blockList.IsEmpty() )

        {

        CalculateActivationL( blockList, aExclList, aStateList,

            ( aAction == EShow ) ? EHide : EShow );

        }

    __VTPRINTEXIT( "CompMgr.CalculateActivationL" )

    }

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

// CVtUiComponentManager::ConstructStateListL

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

//

void CVtUiComponentManager::ConstructStateListL( TStateList& aList )

    {

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

        {

        TStateListItem sli( *iComponents[ i ] );

        aList.AddItemL( sli );

        }

    }

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

// CVtUiComponentManager::CVtUiComponentManager

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

//

CVtUiComponentManager::CVtUiComponentManager()

    : iWsEventObservers( 1 ), iResourceChangeObservers( 1 ),

      iKeyEventObservers( 1 ),iLayoutChangeObservers( 1 ), iComponents( 1 )

    {

    }

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

// CVtUiComponentManager::ConstructL

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

//

void CVtUiComponentManager::ConstructL()

    {

    }

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

// CVtUiComponentManager::AddOrRemoveComponent

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

//

template < class T >

TInt CVtUiComponentManager::AddOrRemoveComponent( RPointerArray< T >& aArray,

    T* aComponent, TAction aAction )

    {

    __VTPRINTENTER( "CompMgr.AddOrRemoveComponent" )

    TInt result( KErrNone );

    if ( aAction == ERegister )

        {

        result = aArray.InsertInOrder( aComponent, ::CmpByPtr );

        }

    else

        {

        TInt index( aArray.FindInOrder( aComponent, ::CmpByPtr ) );

        if ( index != KErrNotFound )