/*
* 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 policy manager class.
*
*/


#include <cvtlogger.h>

#include "cvtuicommandpolicymanager.h"
#include "cvtuicmdcontext.h"
#include "cvtuicmdvalidatorbase.h"
#include "cvtuicmdvalidationactionbase.h"
#include "cvtuicmdcustomvalidationactionbase.h"
#include "cvtuiprimarycmdpolicy.h"
#include "cvtuicommandmanager.h"

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

// ---------------------------------------------------------------------------
// Used in InsertInOrder() method to compare two instances of CVtUiCmdContext.
// ---------------------------------------------------------------------------
//
TInt ContextTypeCmpFunc( const CVtUiCmdContext& aV1,
    const CVtUiCmdContext& aV2 )
    {
    return static_cast< TInt >( aV1.ContextType() ) -
        static_cast< TInt >( aV2.ContextType() );
    }

// ---------------------------------------------------------------------------
// Used in FindInOrder() method to compare instances of CVtUiCmdContext versus
// given key value.
// ---------------------------------------------------------------------------
//
TInt ContextTypeCmpFuncVsKey( const TVtUiCmdContextType* aKey,
    const CVtUiCmdContext& aValue )
    {
    return static_cast< TInt > ( *aKey ) -
        static_cast< TInt >( aValue.ContextType() );
    }

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

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::NewL
// ---------------------------------------------------------------------------
//
CVtUiCommandPolicyManager*
CVtUiCommandPolicyManager::NewL( const CVtUiCommandManager& aCmdManager )
    {
    CVtUiCommandPolicyManager* self =
        new ( ELeave ) CVtUiCommandPolicyManager( aCmdManager );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop(); // self
    return self;
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::~CVtUiCommandPolicyManager
// ---------------------------------------------------------------------------
//
CVtUiCommandPolicyManager::~CVtUiCommandPolicyManager()
    {
    __VTPRINTENTER( "CmdPolicyMgr.~" )
    iContexts.Reset();
    iValidators.Reset();
    delete iPrimaryCommandPolicy;
    __VTPRINTEXIT( "CmdPolicyMgr.~" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::RegisterCommandContext
// ---------------------------------------------------------------------------
//
TInt CVtUiCommandPolicyManager::RegisterCommandContext(
    CVtUiCmdContext& aContext )
    {
    __VTPRINTENTER( "CmdPolicyMgr.RegisterCommandContext" )
    TLinearOrder< CVtUiCmdContext > cmpFunc( ::ContextTypeCmpFunc );
    TInt result( KErrNone );
    TInt index( iContexts.FindInOrder( &aContext, cmpFunc ) );
    if ( index == KErrNotFound )
        {
        TInt error( iContexts.InsertInOrder( &aContext, cmpFunc ) );
        if ( !error )
            {
            CommandContextRegistered( aContext );
            }
        result = error;
        }
    else
        {
        result = KErrAlreadyExists;
        }
    __VTPRINTEXITR( "CmdPolicyMgr.RegisterCommandContext %d", result )
    return result;
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::UnregisterCommandContext
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::UnregisterCommandContext(
    CVtUiCmdContext& aContext )
    {
    __VTPRINTENTER( "CmdPolicyMgr.UnregisterCommandContext" )
    TLinearOrder< CVtUiCmdContext > cmpFunc( ::ContextTypeCmpFunc );
    TInt index( iContexts.FindInOrder( &aContext, cmpFunc ) );
    if ( index != KErrNotFound )
        {
        iContexts.Remove( index );
        CommandContextUnregistered( aContext );
        }
    __VTPRINTEXIT( "CmdPolicyMgr.UnregisterCommandContext" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::AddValidator
// ---------------------------------------------------------------------------
//
TInt CVtUiCommandPolicyManager::AddValidator(
    CVtUiCmdValidatorBase& aValidator )
    {
    __VTPRINTENTER( "CmdPolicyMgr.AddValidator" )
    TInt error( iValidators.Append( &aValidator ) );
    if ( !error )
        {
        ValidatorAdded( aValidator );
        }
    __VTPRINTEXITR( "CmdPolicyMgr.AddValidator %d", error )
    return error;
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::RemoveValidator
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::RemoveValidator(
    CVtUiCmdValidatorBase& aValidator )
    {
    __VTPRINTENTER( "CmdPolicyMgr.RemoveValidator" )
    TInt index( iValidators.Find( &aValidator ) );
    if ( index != KErrNotFound )
        {
        iValidators.Remove( index );
        ValidatorRemoved( aValidator );
        }
    __VTPRINTEXIT( "CmdPolicyMgr.RemoveValidator" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::ValidateMenuItemsL
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::ValidateMenuItemsL(
    CVtUiCmdValidationActionBase& aAction )
    {
    __VTPRINTENTER( "CmdPolicyMgr.ValidateMenuItemsL" )
    ValidateL( EVtUiCmdContextTypeMenu, aAction );
    __VTPRINTEXIT( "CmdPolicyMgr.ValidateMenuItemsL" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::ValidateSoftkeyItemsL
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::ValidateSoftkeyItemsL(
    CVtUiCmdValidationActionBase& aAction )
    {
    __VTPRINTENTER( "CmdPolicyMgr.ValidateSoftkeyItemsL" )
    ValidateL( EVtUiCmdContextTypeSoftkey, aAction );
    __VTPRINTEXIT( "CmdPolicyMgr.ValidateSoftkeyItemsL" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::ValidateToolbarItemsL
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::ValidateToolbarItemsL(
    CVtUiCmdValidationActionBase& aAction )
    {
    __VTPRINTENTER( "CmdPolicyMgr.ValidateToolbarItemsL" )
    ValidateL( EVtUiCmdContextTypeToolbar, aAction );
    __VTPRINTEXIT( "CmdPolicyMgr.ValidateToolbarItemsL" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::CustomValidateL
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::CustomValidateL(
    CVtUiCmdCustomValidationActionBase& aAction )
    {
    __VTPRINTENTER( "CmdPolicyMgr.CustomValidateL" )
    ValidateL( EVtUiCmdContextTypeExecution, aAction );
    __VTPRINTEXIT( "CmdPolicyMgr.CustomValidateL" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::CVtUiCommandPolicyManager
// ---------------------------------------------------------------------------
//
CVtUiCommandPolicyManager::CVtUiCommandPolicyManager(
    const CVtUiCommandManager& aCmdManager ) : iCommandManager( aCmdManager )
    {
    __VTPRINTENTER( "CmdPolicyMgr.ctor" )
    __VTPRINTEXIT( "CmdPolicyMgr.ctor" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::ConstructL
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::ConstructL()
    {
    __VTPRINTENTER( "CmdPolicyMgr.ConstructL" )
    iPrimaryCommandPolicy =
        CVtUiPrimaryCmdPolicy::NewL( iCommandManager.UiStates(),
        iCommandManager.AppUi() );
    User::LeaveIfError( AddValidator( *iPrimaryCommandPolicy ) );
    __VTPRINTEXIT( "CmdPolicyMgr.ConstructL" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::CommandContextRegistered
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::CommandContextRegistered(
    CVtUiCmdContext& aContext )
    {
    __VTPRINTENTER( "CmdPolicyMgr.CommandContextRegistered" )
    for ( TInt i = iValidators.Count() - 1 ; i >= 0; i-- )
        {
        aContext.AddValidator( *iValidators[ i ] );
        }
    __VTPRINTEXIT( "CmdPolicyMgr.CommandContextRegistered" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::CommandContextUnregistered
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::CommandContextUnregistered(
    CVtUiCmdContext& aContext )
    {
    __VTPRINTENTER( "CmdPolicyMgr.CommandContextUnregistered" )
    for ( TInt i = iValidators.Count() - 1 ; i >= 0; i-- )
        {
        aContext.RemoveValidator( *iValidators[ i ] );
        }
    __VTPRINTEXIT( "CmdPolicyMgr.CommandContextUnregistered" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::ValidatorAdded
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::ValidatorAdded(
    CVtUiCmdValidatorBase& aValidator )
    {
    __VTPRINTENTER( "CmdPolicyMgr.ValidatorAdded" )
    for ( TInt i = iContexts.Count() - 1 ; i >= 0; i-- )
        {
        iContexts[ i ]->AddValidator( aValidator );
        }
    __VTPRINTEXIT( "CmdPolicyMgr.ValidatorAdded" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::ValidatorRemoved
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::ValidatorRemoved(
    CVtUiCmdValidatorBase& aValidator )
    {
    __VTPRINTENTER( "CmdPolicyMgr.ValidatorRemoved" )
    for ( TInt i = iContexts.Count() - 1 ; i >= 0; i-- )
        {
        iContexts[ i ]->RemoveValidator( aValidator );
        }
    __VTPRINTEXIT( "CmdPolicyMgr.ValidatorRemoved" )
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::FindCommandContextByType
// ---------------------------------------------------------------------------
//
CVtUiCmdContext* CVtUiCommandPolicyManager::FindCommandContextByType(
        TVtUiCmdContextType aContextType )
    {
    __VTPRINTENTER( "CmdPolicyMgr.FindCommandContextByType" )
    CVtUiCmdContext* result = NULL;
    TInt index( iContexts.FindInOrder( aContextType,
        ::ContextTypeCmpFuncVsKey ) );
    if ( index != KErrNotFound )
        {
        result = iContexts[ index ];
        }
    __VTPRINTEXIT( "CmdPolicyMgr.FindCommandContextByType" )
    return result;
    }

// ---------------------------------------------------------------------------
// CVtUiCommandPolicyManager::ValidateL
// ---------------------------------------------------------------------------
//
void CVtUiCommandPolicyManager::ValidateL( TVtUiCmdContextType aContextType,
    CVtUiCmdValidationActionBase& aAction )
    {
    __VTPRINTENTER( "CmdPolicyMgr.ValidateL" )
    CVtUiCmdContext* context =
        FindCommandContextByType( aContextType );
    if ( context )
        {
        aAction.BeginProcess();
        context->ValidateL( aAction );
        aAction.EndProcess();
        }
    __VTPRINTEXIT( "CmdPolicyMgr.ValidateL" )
    }