/*

* Copyright (c) 2008 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:  Base class for toolbar.

*

*/

// INCLUDE FILES

#include    <centralrepository.h>

#include    <cvtlogger.h>

#include    <akntoolbar.h>

#include    <featmgr.h>

#include    <StringLoader.h>

#include    <videotelui.rsg>

#include    "videotelui.hrh"

#include    "cvtuitoolbarbase.h"

#include    "mvtuifeature.h"

#include    "tvtuistates.h"

#include    "cvtuitoolbarcontext.h"

#include    "cvtuitoolbarcmdpolicy.h"

#include    "cvtuicommandpolicymanager.h"

#include    "cvtuihidetoolbaritemaction.h"

#include    "cvtuifeaturemanager.h"

#include    "CVtUiAppUi.h"

#include    "mvtuicommandui.h"

#include    "cvtuitoolbarskmodifier.h"

#include    "mvtuicommandmanager.h"

#include    "mvtuicomponentmanager.h"

#include    "cvtuitoolbarbutton.h"

#include    "VideoTelephonyInternalCRKeys.h"

#include 	"tVtuifeaturevariation.h"

#include 	"cvtuitoolbarbutton.h"

#include    <layoutmetadata.cdl.h>

// Implementation of TVtUiToolbarComponentState

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

// TVtUiToolbarComponentState::TVtUiToolbarComponentState

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

//

TVtUiToolbarComponentState::TVtUiToolbarComponentState(

    MVtUiComponent& aComponent ) :

    TVtUiComponentState( aComponent,

        TVtUiBlockListBitField(

            MVtUiComponent::EComponentIdNull ) )

    {

    }

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

// Used in FindToolbaItemByCommandId method to search toolbar item by cmd id.

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

//

TInt ToolbarItemIdCmpFunc( const TInt* aId,

    const CVtUiToolbarButton& aToolbarItem )

    {

    return ( *aId - aToolbarItem.CmdId() );

    }

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

// Used in CreateToolbarItemL method to search feature by cmd id.

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

//

TInt ToolbarCmpFunc( const CVtUiToolbarButton& aV1, const CVtUiToolbarButton& aV2 )

    {

    return ( aV1.CmdId() - aV2.CmdId() );

    }

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

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

// CVtUiToolbarBase::CVtUiToolbarBase

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CVtUiToolbarBase::CVtUiToolbarBase( CVtUiFeatureManager& aFeatureManager )

    : CVtUiFeatureBase( EVtUiFeatureIdToolbar, aFeatureManager ),

      iComponentState( *this )

    {

    __VTPRINTENTER( "Toolbar.CVtUiToolbarBase" )

    // Get number of supported buttons.

    // Six is the default value for floating toolbar

    // and three buttons for fixed toolbar

    TVtUiToolbarVariation toolbar;

    iNumberOfToolbarButtons = toolbar.NumberOfButtons();

    iCmdFocus = KErrNotFound;

    __VTPRINTEXITR( "Toolbar.CVtUiToolbarBase %d", iNumberOfToolbarButtons )

    }

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

// CVtUiToolbarBase::BaseConstructL

// Symbian 2nd phase constructor.

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

//

void CVtUiToolbarBase::BaseConstructL()

    {

    __VTPRINTENTER( "Toolbar.ConstructL" )

    CVtUiFeatureBase::BaseConstructL();

    iFeatureManager.UiStates().SetIsToolbarAvailable( ETrue );

    __VTPRINTEXIT( "Toolbar.ConstructL" )

    }

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

// CVtUiToolbarBase::~CVtUiToolbarBase

// Destructor.

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

//

CVtUiToolbarBase::~CVtUiToolbarBase()

    {

    __VTPRINTENTER( "Toolbar.~" )

    // Stop();

    // Stop can not be called here if toolbar is asked from ui fw = fixed toolbar.

    // If stop is called a crash occurs, whose root cause can not be solved.

    // It is related somehow with focus lost in ui fw.

    Clean();

    // unregister layout change

    iFeatureManager.ComponentManager().ChangeLayoutChangeRegistration(

        *this, MVtUiComponentManager::EUnregister );   

    // no need tot call resetanddestroy because buttons ownership is

    // transferred to akntoolbar.

    iToolBarControls.Reset();

    delete iToolbarCtx;

    delete iToolbarCmdPolicy;

    delete iHideToolbarItemAction;

    delete iToolbarSKModifier;

    iCmdIds.Close();

    iCmdStates.Close();

    __VTPRINTEXIT( "Toolbar.~" )

    }

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

// CVtUiToolbarBase::DynInitToolbarL

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

//

void CVtUiToolbarBase::DynInitToolbarL( TInt /*aResourceId*/,

    CAknToolbar* /*aToolbar*/ )

    {

    __VTPRINTENTER( "Toolbar.DynInitToolbarL" )

    __VTPRINTEXIT( "Toolbar.DynInitToolbarL" )

    }

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

// CVtUiToolbarBase::OfferToolbarEventL

// Destructor.

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

//

void CVtUiToolbarBase::OfferToolbarEventL( TInt aCommand )

    {

    __VTPRINTENTER( "Toolbar.OfferToolbarEventL" )

    __VTPRINT2( DEBUG_GEN, "Toolbar.OfferToolbarEventL.aCommand=%d", aCommand )

    // if capture mode is on all msk events must be converted to capture command

    if ( iFeatureManager.UiStates().IsCaptureModeOn() )

        {

        iFeatureManager.AppUi().HandleCommandL( EVtUiCmdCapture );

        return;

        }

        TInt command = MapCmdIdToChilId( aCommand );

        if ( EVtUiCmdSwapImagesPlaces == command )

            {

            if ( !( iFeatureManager.AppUi().CanSwapImagePlaces() ) )

                {

                return;

                }

            }

        iFeatureManager.AppUi().HandleCommandL( command );

    __VTPRINTEXITR( "Toolbar.OfferToolbarEventL.cmd %d", aCommand )

    }

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

// CVtUiToolbarBase::StartL

// Destructor.

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

//

void CVtUiToolbarBase::StartL()

    {

    CVtUiFeatureBase::StartL();

    __VTPRINTENTER( "Toolbar.StartL" )

    TInt error;

    if ( iFeatureState == MVtUiFeature::EReady )

        { 

        TRAP( error, iFeatureManager.ComponentManager().

            RequestActivationL( MVtUiComponent::EComponentIdToolbar ) );

        // set state

        iFeatureState = MVtUiFeature::EActive;

        }

    __VTPRINTEXITR( "Toolbar.StartL error = %d", error )

    }

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

// CVtUiToolbarBase::Stop

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

//

void CVtUiToolbarBase::Stop()

    {

    __VTPRINTENTER( "Toolbar.Stop" )

    TInt error;

    if ( iFeatureState == MVtUiFeature::EActive )

        {

        TRAP( error, iFeatureManager.ComponentManager().

            DeActivateComponentL ( MVtUiComponent::EComponentIdToolbar ) );

        // set state

        iFeatureState = MVtUiFeature::EReady;

        }

    __VTPRINTEXITR( "Toolbar.Stop error = %d", error )

    }

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

// CVtUiToolbarBase::InitFeature

// Delayed initialization of the feature

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

//

void CVtUiToolbarBase::InitFeatureL()

    {

    __VTPRINTENTER( "Toolbar.InitFeatureL" )

    iFeatureState = EPreparing;

    iToolBarControls.ReserveL( iNumberOfToolbarButtons );

    //create toolbar

    //iToolbar = CAknToolbar::NewL( R_VIDEOTELUI_TOOLBAR );

    iToolbar->SetToolbarObserver( this );

    // Prohibit toolbar sliding on UI.    

    iToolbar->SetWithSliding( EFalse );

    // create toolbar context and policy

    iToolbarCtx =

         CVtUiToolbarContext::NewL( iFeatureManager.CommandManager() );

    iToolbarCmdPolicy = CVtUiToolbarCmdPolicy::NewL( *this );

    // create toolbaraction

    iHideToolbarItemAction = CVtUiHideToolbarItemAction::NewL( this,

        iFeatureManager.UiStates() );

    // create sofkey modifier

    iToolbarSKModifier = CVtUiToolbarSKModifier::

        NewL( iFeatureManager.AppUi(), iFeatureManager.UiStates() );

    // set supported commands

    PopulateCmdsIdsL();

    User::LeaveIfError(

       iFeatureManager.ComponentManager().ChangeComponentRegistration(

       iComponentState, MVtUiComponentManager::ERegister ) );

    User::LeaveIfError(

       iFeatureManager.ComponentManager().ChangeLayoutChangeRegistration(

       *this, MVtUiComponentManager::ERegister ) );

    iFeatureState = EReady;

    __VTPRINTEXIT( "Toolbar.InitFeatureL" )

    }

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

// CVtUiToolbarBase::MapCmdIdToChilId

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

//

TInt CVtUiToolbarBase::MapCmdIdToChilId( TInt aCmdId )

    {

    __VTPRINTENTER( "Toolbar.MapCmdIdToChilId" )

     __VTPRINT2( DEBUG_GEN, "Toolbar.MapCmdIdToChilId.aCmdId=%d", aCmdId )

    TInt result = aCmdId;

    CVtUiToolbarButton* tbButton = FindToolbarItemByCommandId( aCmdId );

    const TInt stateIndexValue( tbButton->StateIndex() );

    __VTPRINT2( DEBUG_GEN, "Toolbar.MapCmdIdToChilId.idx=%d", stateIndexValue )

    switch( aCmdId )

        {

        case EVtUiCmdToolbarToggleVideo:

            { 

            switch ( stateIndexValue )

                {

            case 0:  

            case 1:

                result = EVtUiCmdDisableVideo;

                break;

            case 2:

            case 3:

                result = EVtUiCmdEnableVideo;

                break;

                }    

            }

            break;

        case EVtUiCmdToolbarToggleMicrophone:

            { 

            switch ( stateIndexValue )

                {

            case 0:    

            case 1:

                result = EVtUiCmdDisableAudio;

                break;

            case 2:

            case 3:

                result = EVtUiCmdEnableAudio;

                break;

                }    

            }

            break;            

        case EVtUiCmdToolbarAudioRouting:

            {

            switch ( stateIndexValue )

                {

            case 0:

            case 1:

                result = EVtUiCmdDeactivateLoudspeaker;

                break;

            case 2:

            case 3:

                result = EVtUiCmdSwitchFromBTToIHF;

                break;

            case 4:

            case 5:

                result = EVtUiCmdActivateLoudspeaker;

                break;

            case 6:

            case 7:

                result = EVtUiCmdActivateBT;

                break;

            default:

                break;

                };

            }

            break;

        case EVtUiCmdToolbarToggleCamera:

            {

            switch ( stateIndexValue )

                {

            case 0:   

            case 1:

                result = EVtUiCmdUsePrimaryCamera;

                break;

            case 2:

            case 3:

                result = EVtUiCmdUseSecondaryCamera;

                break;

                }    

            }

            break;  

        default:

            break;

        }

    if ( aCmdId == result )

        {

        TInt index( stateIndexValue - 1 );

        if ( index < 0 )

            {

            index = tbButton->StatesCount() - 1;

            }

        tbButton->SetCurrentState( index, EFalse );

        }

    __VTPRINTEXITR( "Toolbar.MapCmdIdToChilId.result %d", (TInt)result )

    return result;

    }

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

// CVtUiToolbarBase::MapCmdIdToParentId

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

//

TInt CVtUiToolbarBase::MapCmdIdToParentId( TInt aCmdId )

    {

    __VTPRINTENTER( "Toolbar.MapCmdIdToParentId" )

    TInt result = aCmdId;

        switch( aCmdId )

            {

            case EVtUiCmdDisableVideo:

            case EVtUiCmdEnableVideo:

                result = EVtUiCmdToolbarToggleVideo;

                break;

            case EVtUiCmdDisableAudio:

            case EVtUiCmdEnableAudio:

                result = EVtUiCmdToolbarToggleMicrophone;

                break;

            case EVtUiCmdActivateBT:

            case EVtUiCmdSwitchFromBTToIHF:

            case EVtUiCmdActivateLoudspeaker:

            case EVtUiCmdDeactivateLoudspeaker:

                result = EVtUiCmdToolbarAudioRouting;

                break;

            case EVtUiCmdUsePrimaryCamera:

            case EVtUiCmdUseSecondaryCamera:

                result = EVtUiCmdToolbarToggleCamera;

                break;

            default:

                break;

            }

    __VTPRINTEXITR( "Toolbar.MapCmdIdToParentId.result %d", (TInt)result )

    return result;

    }

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

// CVtUiToolbarBase::IsCmdIdVisibleInToggleButton

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

//

TBool CVtUiToolbarBase::IsCmdIdVisibleInToggleButton( TInt aCmdId )

    {

    __VTPRINTENTER( "Toolbar.IsCMdIdVisibleInTogB" )

    TBool result( ETrue );

    TInt cmdId( MapCmdIdToParentId( aCmdId ) );

    TInt targetStateIndex( KErrNotFound );

    switch( aCmdId )

        {

        case EVtUiCmdActivateBT:

            targetStateIndex = 6;

            break;

        case EVtUiCmdActivateLoudspeaker:

            targetStateIndex = 4;

            break;

        case EVtUiCmdSwitchFromBTToIHF:

        case EVtUiCmdEnableVideo:

        case EVtUiCmdEnableAudio:

        case EVtUiCmdUseSecondaryCamera:

            targetStateIndex = 2;

            break;

        case EVtUiCmdDisableVideo:

        case EVtUiCmdDisableAudio:

        case EVtUiCmdUsePrimaryCamera:

        case EVtUiCmdDeactivateLoudspeaker:

            targetStateIndex = 0;

            break;

        default:

            break;

        }

    if ( targetStateIndex != KErrNotFound )

        {

        result = ( FindToolbarItemByCommandId( cmdId )

            ->StateIndex() == targetStateIndex );

        }

    __VTPRINTEXITR( "Toolbar.IsCMdIdVisibleInTogB.result %d", (TInt)result )

    return result;

    }

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

// CVtUiToolbarBase::PopulateCmdsIdsL

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

//

void CVtUiToolbarBase::PopulateCmdsIdsL()

    {

    __VTPRINTENTER( "Toolbar.PopulateCmdsIdsL" )

    CVtUiAppUi& appUi = iFeatureManager.AppUi();

    // default commands

    iCmdIds.AppendL( EVtUiCmdDisableVideo );

    iCmdIds.AppendL( EVtUiCmdEnableVideo );

    iCmdIds.AppendL( EVtUiCmdDisableAudio );

    iCmdIds.AppendL( EVtUiCmdEnableAudio );

    __VTPRINTEXIT( "Toolbar.PopulateCmdsIdsL" )

    }

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

// CVtUiToolbarBase::SetToolbarVisibilityAfterLayoutChangeL

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

//

void CVtUiToolbarBase::SetToolbarVisibilityAfterLayoutChangeL( TBool /*aVisible*/ )

    {

    __VTPRINTENTER( "Toolbar.SetToolbarVisibilityAfterLayoutChangeL" )

    __VTPRINTEXIT( "Toolbar.SetToolbarVisibilityAfterLayoutChangeL" )

    }

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

// CVtUiToolbarBase::IsToggleButtonHidden

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

//

TBool CVtUiToolbarBase::IsToggleButtonHidden(TInt aFirstCmdId, TInt aSecondCmdId )

    {

    __VTPRINTENTER( "Toolbar.IsToggleButtonHidden" )

    TInt count = 0;

    TBool result = EFalse;

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

        {

        if ( iCmdStates[ i ].iCmdId == aFirstCmdId ||

            iCmdStates[ i ].iCmdId == aSecondCmdId )

            {

            if ( iCmdStates[ i ].iNewState == EHidden )

                {

                count++;

                }

            }

        }

    if ( count > 1 )

        {

        __VTPRINT(DEBUG_GEN, "IsToggleButtonHidden.Count>1" )

        result = ETrue;

        }

   __VTPRINTEXITR( "Toolbar.IsToggleButtonHidden.result%d", result )

    return result;

    }