/*

* Copyright (c) 2006 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:  Command manager class.

*

*/

#include <cvtlogger.h>

#include "cvtuicmdbase.h"

#include "cvtuicommandmanager.h"

#include "cvtuicommandpolicymanager.h"

#include "cvtuiprimarycmdpolicy.h"

#include "cvtuiexecutioncontext.h"

#include "cvtuimenuitemdimmeraction.h"

#include "tvtuistates.h"

#include "mvtuicommandui.h"

#include "cvtuicommandmodifybase.h"

#include "cvtuicmdstatecheckaction.h"

// Default array granularity.

static const TInt KVtUiArrayGranularity = 1;

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

// CVtUiCommandManager::NewL

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

//

CVtUiCommandManager* CVtUiCommandManager::NewL( const TVtUiStates& aUiStates,

    CVtUiAppUi& aAppUi )

    {

    __VTPRINTENTER( "CmdMgr.NewL" )

    CVtUiCommandManager* self = new ( ELeave ) CVtUiCommandManager( aUiStates,

        aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

    __VTPRINTEXIT( "CmdMgr.NewL" )

    return self;

    }

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

// CVtUiCommandManager::~CVtUiCommandManager

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

//

CVtUiCommandManager::~CVtUiCommandManager()

    {

    __VTPRINTENTER( "CmdMgr.~" )

    iCommands.Reset();

    iCommandUis.Reset();

    iCommandModifiers.Reset();

    delete iExecutionContext;

    delete iCmdStateCheckAction;

    delete iCmdPolicyMgr;

    __VTPRINTEXIT( "CmdMgr.~" )

    }

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

// CVtUiCommandManager::UiStates

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

//

const TVtUiStates& CVtUiCommandManager::UiStates() const

    {

    return iUiStates;

    }

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

// CVtUiCommandManager::AppUi

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

//

const CVtUiAppUi& CVtUiCommandManager::AppUi() const

    {

    return iAppUi;

    }

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

// CVtUiCommandManager::VideoTelephonyVariation

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

//

const TVtUiVideoTelephonyVariation&

CVtUiCommandManager::VideoTelephonyVariation() const

    {

    return iVtVariation;

    }

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

// CVtUiCommandManager::HandleCommandL

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

//

void CVtUiCommandManager::HandleCommandL( TInt aCommandId )

    {

    TInt index( iCommands.FindInOrder( aCommandId, CVtUiCmdBase::KeyOrder() ) );

    if ( index != KErrNotFound )

        {

        iCommands[ index ]->HandleL();

        }

    /*

    This was commented out, because current CVtUiAppUi silently ignores

    commands that are not handled, changed this to emulate same kind of

    behaviour.

    else

        {

        User::Leave( KErrNotFound );

        }

    */

    }

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

// CVtUiCommandManager::AddCommandUi

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

//

TInt CVtUiCommandManager::AddCommandUi( MVtUiCommandUi& aCommandUi )

    {

    __VTPRINTENTER( "CmdMgr.AddCommandUi" )

    TInt result( KErrAlreadyExists );

    TInt idx( iCommandUis.Find( &aCommandUi ) );

    if ( idx == KErrNotFound )

        {

        result = iCommandUis.Append( &aCommandUi );

        if ( result == KErrNone )

            {

            result = CommandUiAdded( aCommandUi );

            }

        }

    __VTPRINTEXITR( "CmdMgr.AddCommandUi %d", result )

    return result;

    }

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

// CVtUiCommandManager::RemoveCommandUi

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

//

void CVtUiCommandManager::RemoveCommandUi( MVtUiCommandUi& aCommandUi )

    {

    __VTPRINTENTER( "CmdMgr.RemoveCommandUi" )

    TInt idx( iCommandUis.Find( &aCommandUi ) );

    if ( idx != KErrNotFound )

        {

        iCommandUis.Remove( idx );

        CommandUiRemoved( aCommandUi );

        }

    __VTPRINTEXIT( "CmdMgr.RemoveCommandUi" )

    }

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

// CVtUiCommandManager::ValidateMenuItemsL

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

//

void CVtUiCommandManager::ValidateMenuItemsL(

    CVtUiCmdValidationActionBase& aAction )

    {

    __VTPRINTENTER( "CmdMgr.ValidateMenuItemsL" )

    iCmdPolicyMgr->ValidateMenuItemsL( aAction );

    __VTPRINTEXIT( "CmdMgr.ValidateMenuItemsL" )

    }

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

// CVtUiCommandManager::ValidateSoftkeyItemsL

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

//

void CVtUiCommandManager::ValidateSoftkeyItemsL(

    CVtUiCmdValidationActionBase& aAction )

    {

    __VTPRINTENTER( "CmdMgr.ValidateSoftkeyItemsL" )

    iCmdPolicyMgr->ValidateSoftkeyItemsL( aAction );

    __VTPRINTEXIT( "CmdMgr.ValidateSoftkeyItemsL" )

    }

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

// CVtUiCommandManager::ValidateToolbarItemsL

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

//

void CVtUiCommandManager::ValidateToolbarItemsL(

    CVtUiCmdValidationActionBase& aAction )

    {

    __VTPRINTENTER( "CmdMgr.ValidateToolbarItemsL" )

    iCmdPolicyMgr->ValidateToolbarItemsL( aAction );

    __VTPRINTEXIT( "CmdMgr.ValidateToolbarItemsL" )

    }

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

// CVtUiCommandManager::IsCommandAllowedL

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

//

TBool CVtUiCommandManager::IsCommandAllowedL( TInt aCommandId )

    {

    __VTPRINTENTER( "CmdMgr.IsCommandAllowedL" )

    TInt index( iCommands.FindInOrder( aCommandId, CVtUiCmdBase::KeyOrder() ) );

    if ( index == KErrNotFound )

        {

        iCmdStateCheckAction->SetCommand( aCommandId );

        iCmdPolicyMgr->CustomValidateL( *iCmdStateCheckAction );

        }

    else

        {

        return iCommands[ index ]->IsEnabled();

        }

    __VTPRINTEXIT( "CmdMgr.IsCommandAllowedL" )

    return iCmdStateCheckAction->IsCommandAllowed();

    }

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

// CVtUiCommandManager::RegisterCommandContext

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

//

TInt CVtUiCommandManager::RegisterCommandContext( CVtUiCmdContext& aContext )

    {

    __VTPRINTENTER( "CmdMgr.RegisterCommandContext" )

    TInt result( iCmdPolicyMgr->RegisterCommandContext( aContext ) );

    __VTPRINTEXITR( "CmdMgr.RegisterCommandContext %d", result )

    return result;

    }

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

// CVtUiCommandManager::UnregisterCommandContext

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

//

void CVtUiCommandManager::UnregisterCommandContext( CVtUiCmdContext& aContext )

    {

    __VTPRINTENTER( "CmdMgr.UnregisterCommandContext" )

    iCmdPolicyMgr->UnregisterCommandContext( aContext );

    __VTPRINTEXIT( "CmdMgr.UnregisterCommandContext" )

    }

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

// CVtUiCommandManager::AddValidator

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

//

TInt CVtUiCommandManager::AddValidator( CVtUiCmdValidatorBase& aValidator )

    {

    __VTPRINTENTER( "CmdMgr.AddValidator" )

    TInt result( iCmdPolicyMgr->AddValidator( aValidator ) );

    __VTPRINTEXITR( "CmdMgr.AddValidator %d", result )

    return result;

    }

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

// CVtUiCommandManager::RemoveValidator

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

//

void CVtUiCommandManager::RemoveValidator(

    CVtUiCmdValidatorBase& aValidator )

    {

    __VTPRINTENTER( "CmdMgr.RemoveValidator" )

    iCmdPolicyMgr->RemoveValidator( aValidator );

    __VTPRINTEXIT( "CmdMgr.RemoveValidator" )

    }

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

// CVtUiCommandManager::RefreshL

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

//

void CVtUiCommandManager::RefreshL()

    {

    __VTPRINTENTER( "CmdMgr.RefreshL" )

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

        {

        iCommandUis[ i ]->RefreshL();

        }

    __VTPRINTEXIT( "CmdMgr.RefreshL" )

    }

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

// CVtUiCommandManager::AddCommandModifier

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

//

TInt CVtUiCommandManager::AddCommandModifier(

    CVtUiCommandModifyBase& aModifier )

    {

    __VTPRINTENTER( "CmdMgr.AddCommandModifier" )

    TInt result(

        iCommandModifiers.InsertInOrder( &aModifier,

            CVtUiCommandModifyBase::PriorityOrder() ) );

    if ( result == KErrNone )

        {

        result = CommandModifierAdded( aModifier );

        }

    __VTPRINTEXITR( "CmdMgr.AddCommandModifier %d", result )

    return result;

    }

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

// CVtUiCommandManager::RemoveCommandModifier

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

//

void CVtUiCommandManager::RemoveCommandModifier(

    CVtUiCommandModifyBase& aModifier )

    {

    __VTPRINTENTER( "CmdMgr.RemoveCommandModifier" )

    TInt idx( iCommandModifiers.FindInOrder( &aModifier,

        CVtUiCommandModifyBase::PriorityOrder() ) );

    if ( idx != KErrNotFound )

        {

        iCommandModifiers.Remove( idx );

        CommandModifierRemoved( aModifier );

        }

    __VTPRINTEXIT( "CmdMgr.RemoveCommandModifier" )

    }

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

// CVtUiCommandManager::RegisterCommandL

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

//

void CVtUiCommandManager::RegisterCommandL( CVtUiCmdBase& aCommand )

    {

    __VTPRINTENTER( "CmdMgr.RegisterCommandL" )

    iCommands.InsertInOrderL( &aCommand, CVtUiCmdBase::LinearOrder() );

    __VTPRINTEXIT( "CmdMgr.RegisterCommandL" )

    }

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

// CVtUiCommandManager::UnregisterCommand

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

//

void CVtUiCommandManager::UnregisterCommand( const CVtUiCmdBase& aCommand )

    {

    __VTPRINTENTER( "CmdMgr.UnregisterCommand" )

    TInt index( iCommands.FindInOrder( &aCommand,

        CVtUiCmdBase::LinearOrder() ) );

    if ( index != KErrNotFound )

        {

        iCommands.Remove( index );

        }

    __VTPRINTEXIT( "CmdMgr.UnregisterCommand" )

    }

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

// CVtUiCommandManager::CVtUiCommandManager

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

//

CVtUiCommandManager::CVtUiCommandManager( const TVtUiStates& aUiStates, 

    CVtUiAppUi& aAppUi )

: iCommandUis( KVtUiArrayGranularity ),

  iCommandModifiers( KVtUiArrayGranularity ),

  iCommands( KVtUiArrayGranularity ),

  iUiStates( aUiStates ),

  iAppUi( aAppUi )

    {

    __VTPRINTENTER( "CmdMgr.ctor" )

    __VTPRINTEXIT( "CmdMgr.ctor" )

    }

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

// CVtUiCommandManager::ConstructL

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

//

void CVtUiCommandManager::ConstructL()

    {

    __VTPRINTENTER( "CmdMgr.ConstructL" )

    iVtVariation.ReadL();

    iCmdPolicyMgr = CVtUiCommandPolicyManager::NewL( *this );

    iCmdStateCheckAction = CVtUiCmdStateCheckAction::NewL();

    iExecutionContext = CVtUiExecutionContext::NewL( *this );

    __VTPRINTEXIT( "CmdMgr.ConstructL" )

    }

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

// CVtUiCommandManager::CommandModifierAdded

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

//

TInt CVtUiCommandManager::CommandModifierAdded(

    CVtUiCommandModifyBase& aModifier )

    {

    TInt error( KErrNone );

    for ( TInt i = iCommandUis.Count() - 1; !error && i >= 0; i-- )

        {

        error = iCommandUis[ i ]->AddCommandModifier( aModifier );

        }

    return error;

    }

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

// CVtUiCommandManager::CommandModifierRemoved

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

//

void CVtUiCommandManager::CommandModifierRemoved(

    CVtUiCommandModifyBase& aModifier )

    {

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

        {

        iCommandUis[ i ]->RemoveCommandModifier( aModifier );

        }

    }

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

// CVtUiCommandManager::CommandUiAdded

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

//

TInt CVtUiCommandManager::CommandUiAdded( MVtUiCommandUi& aCommandUi )

    {

    TInt error( KErrNone );

    for ( TInt i = iCommandModifiers.Count() - 1; !error && i >= 0; i-- )

        {

        error = aCommandUi.AddCommandModifier( *iCommandModifiers[ i ] );

        }

    return error;

    }

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

// CVtUiCommandManager::CommandUiRemoved

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

//

void CVtUiCommandManager::CommandUiRemoved( MVtUiCommandUi& aCommandUi )

    {

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

        {

        aCommandUi.RemoveCommandModifier( *iCommandModifiers[ i ] );

        }

    }