/*
* Copyright (c) 2006 - 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:  Color tone UI feature implementation.
*
*/


#include    <mvtengmedia.h>
#include    <cvtengmodel.h>
#include    <mvtengcamerapreferences.h>
#include    <cvtlogger.h>
#include    "cvtuicolortone.h"
#include    "tvtuifeatureids.h"
#include    <videotelui.rsg>
#include    "mvtuicomponentmanager.h"
#include    "cvtuifeaturemanager.h"
#include    "CVtUiAppUi.h"
#include	"tvtuilocalvariation.h"
#include    "cvtuifeaturemanager.h"
#include    "tvtuistates.h"
#include    "cvtuicommandmanager.h"

// Implementation of TVtUiColorToneComponentState

// ---------------------------------------------------------------------------
// TVtUiColorToneComponentState::TVtUiColorToneComponentState
// ---------------------------------------------------------------------------
//
TVtUiColorToneComponentState::TVtUiColorToneComponentState(
    MVtUiComponent& aComponent ) :
    TVtUiComponentState( aComponent,
        TVtUiBlockListBitField(
            MVtUiComponent::EComponentIdDialer |
            MVtUiComponent::EComponentIdToolbar |
            MVtUiComponent::EComponentIdNumberEntry ) )
    {
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::NewL
// ---------------------------------------------------------------------------
//
CVtUiColorTone* CVtUiColorTone::NewL( CVtUiFeatureManager&
    aFeatureManager )
    {
    __VTPRINTENTER( "UiColorTone.NewL" )
    CVtUiColorTone* self =
        new ( ELeave ) CVtUiColorTone( aFeatureManager );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    __VTPRINTEXIT( "UiColorTone.NewL" )
    return self;
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::~CVtUiColorTone
// ---------------------------------------------------------------------------
//
CVtUiColorTone::~CVtUiColorTone()
    {
    __VTPRINTENTER( "UiColorTone.~" )
    // unregister layout change
    iFeatureManager.ComponentManager().ChangeLayoutChangeRegistration(
        *this, MVtUiComponentManager::EUnregister );
     // unregister component
    iFeatureManager.ComponentManager().ChangeComponentRegistration(
        iComponentState, MVtUiComponentManager::EUnregister );
    __VTPRINTEXIT( "UiColorTone.~" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::StartL
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::StartL()
    {
    __VTPRINTENTER( "UiColorTone.StartL" )
    if ( iFeatureState  == MVtUiFeature::EReady )
        {
        iFeatureManager.AppUi().EnableCommandActivatingAndCleanupPushL();
        iFeatureManager.UiStates().SetIsFixedToolbarVisible( EFalse );        
        iFeatureManager.ComponentManager().
            RequestActivationL ( MVtUiComponent::EComponentIdColorTone );
        CleanupStack::Pop(); // EnableCommandActivatingAndCleanupPushL
        // set state
        iFeatureState  = MVtUiFeature::EActive;
        }
    __VTPRINTEXIT( "UiColorTone.StartL" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::Stop
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::Stop()
    {
    __VTPRINTENTER( "UiColorTone.Stop" )
    iAsyncCallback->Cancel();
    iAsyncCallback->Set( TCallBack( &DoStopL, this ) );
    iAsyncCallback->CallBack();
    __VTPRINTEXIT( "UiColorTone.Stop" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::InitFeatureL
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::InitFeatureL()
    {
    __VTPRINTENTER( "UiColorTone.InitFeatureL" )
    CVtUiPrefSettingListBase::InitFeatureL();
    User::LeaveIfError(
       iFeatureManager.ComponentManager().ChangeComponentRegistration(
       iComponentState, MVtUiComponentManager::ERegister ) );
    User::LeaveIfError(
       iFeatureManager.ComponentManager().ChangeLayoutChangeRegistration(
       *this, MVtUiComponentManager::ERegister ) );
    iFeatureState  = EReady;
    __VTPRINTEXIT( "UiColorTone.InitFeatureL" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::ComponentId
// ---------------------------------------------------------------------------
//
MVtUiComponent::TComponentId CVtUiColorTone::ComponentId() const
    {
    __VTPRINTENTER( "UiColorTone.ComponentId" )
    __VTPRINTEXIT( "UiColorTone.ComponentId" )
    return MVtUiComponent::EComponentIdColorTone;
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::ComponentAsControl
// ---------------------------------------------------------------------------
//
CCoeControl* CVtUiColorTone::ComponentAsControl()
    {
    __VTPRINTENTER( "UiColorTone.ComponentAsControl" )
    __VTPRINTEXIT( "UiColorTone.ComponentAsControl" )
    return NULL;
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::DoActivateL
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::DoActivateL()
    {
    __VTPRINTENTER( "UiColorTone.DoActivateL" )
    // get supported color tone modes
    iCameraPref->GetSupportedColorTones( iSupportedModes );
    __VTPRINT2( DEBUG_GEN, "UiColorTone.ConstructL=%d", iSupportedModes )
    iFeatureManager.UiStates().SetColorToneModeOn( ETrue );
    iAsyncCallback->Cancel();
    iAsyncCallback->Set( TCallBack( &DoStartL, this ) );
    iAsyncCallback->CallBack();
    __VTPRINTEXIT( "UiColorTone.DoActivateL" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::DoDeactivateL
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::DoDeactivateL()
    {
    __VTPRINTENTER( "UiColorTone.DoDeactivateL" )
    iFeatureManager.UiStates().SetColorToneModeOn( EFalse );
    CVtUiPrefSettingListBase::StopSettingPageL();
    __VTPRINTEXIT( "UiColorTone.DoDeactivateL" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::HandleLayoutChangeL
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::HandleLayoutChangeL()
    {
    __VTPRINTENTER( "UiColorTone.HandleLayoutChangeL" )
    if ( iFeatureState  == MVtUiFeature::EActive )
        {
        SizeChanged();
        }
    __VTPRINTEXIT( "UiColorTone.HandleLayoutChangeL" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::CurrentSelection
// ---------------------------------------------------------------------------
//
TInt CVtUiColorTone::CurrentSelection()
    {
    __VTPRINTENTER( "UiColorTone.CurrentSelection" )
    // ask from engine which item is currently active
    MVtEngCameraPreferences::TColorTone wb;
    if ( iCameraPref->GetColorTone( wb ) )
        {
        __VTPRINTEXIT( "UiColorTone.CurrentSelectionERR" )
        // if error occured return 0 i.e. first list item
        return 0;
        }
    __VTPRINTEXIT( "UiColorTone.CurrentSelection" )
    return MapCTEnumToArrayIndex( wb );
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::SetItemsL
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::SetItemsL( CDesCArray& aArray )
    {
    __VTPRINTENTER( "UiColorTone.SetItemsL<" )
    __VTPRINT2( DEBUG_GEN, "UiColorTone.SetItemsL=%d", iSupportedModes )
    // Normal mode allways supported
    ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_CT_NORMAL_OPTION );
    iActiveItems.Append( MVtEngCameraPreferences::ENormal );

    if( iSupportedModes & MVtEngCameraPreferences::ESepia )
        {
        ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_SEPIA_OPTION );
        iActiveItems.Append( MVtEngCameraPreferences::ESepia );
        }
    if( iSupportedModes & MVtEngCameraPreferences::EGrayscale )
        {
        ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_B_AND_W_OPTION );
        iActiveItems.Append( MVtEngCameraPreferences::EGrayscale );
        }
    if( iSupportedModes & MVtEngCameraPreferences::ENegative )
        {
        ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_NEGATIVE_OPTION );
        iActiveItems.Append( MVtEngCameraPreferences::ENegative );
        }
    __VTPRINTEXIT( "UiColorTone.SetItemsL" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::SettingPageResId
// ---------------------------------------------------------------------------
//
TInt CVtUiColorTone::SettingPageResId() const
    {
    __VTPRINTENTER( "UiColorTone.SettingPageResId" )
    __VTPRINTEXIT( "UiColorTone.SettingPageResId" )
    return R_VIDEOTELUI_COLOR_TONE_SETTING_PAGE;
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::SettingPageItemChanged
// ---------------------------------------------------------------------------
//
void CVtUiColorTone::SettingPageItemChangedL( TInt aIndex )
    {
    __VTPRINTENTER( "CVtUiColorTone.SettingPageItemChangedL" )
    __VTPRINT2( DEBUG_GEN, "CVtUiColorTone.index=%d", aIndex )
    if ( iFeatureManager.UiStates().ExecState() == TVtUiStates::EExecStateResetting )
        {
    __VTPRINTEXIT( "CVtUiColorTone.SettingPageItemChangedL" )
        return;
        }
    // Map index to right color tone value
    MVtEngCameraPreferences::TColorTone ct = MapArrayIndexToCTEnum( aIndex );

    // cast the parameter
    TPtrC8 params( reinterpret_cast< TUint8* >( &ct ),
        sizeof( MVtEngCameraPreferences::TColorTone ) );

    // Adjust color tone
  MVtEngMedia::TCameraId currentCamId;
    iFeatureManager.AppUi().Model().Media().GetCurrentCameraId( currentCamId );
    if( currentCamId == MVtEngMedia::ESecondaryCamera  )
        {
        iFeatureManager.AppUi().DoExecuteCmdL( KVtEngSetColorTone, &params );
        iPendingSettingChangeCmd = EFalse;
        }
    else
        iPendingSettingChangeCmd = ETrue;
    __VTPRINTEXIT( "CVtUiColorTone.SettingPageItemChangedL" )
    }


// ---------------------------------------------------------------------------
// CVtUiColorTone::CVtUiColorTone
// ---------------------------------------------------------------------------
//
CVtUiColorTone::CVtUiColorTone( CVtUiFeatureManager& aFeatureManager )
    : CVtUiPrefSettingListBase( aFeatureManager, EVtUiFeatureIdColourTone ),
    iComponentState( *this )
    {
    __VTPRINTENTER( "UiColorTone.UiColorTone" )
    __VTPRINTEXIT( "UiColorTone.UiColorTone" )
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::MapCTEnumToArrayIndex
// ---------------------------------------------------------------------------
//
TInt CVtUiColorTone::MapCTEnumToArrayIndex( MVtEngCameraPreferences::
    TColorTone& aColorTone ) const
    {
    __VTPRINTENTER( "CVtUiColorTone.MapCTEnumToArrayIndex" )
    __VTPRINT2( DEBUG_GEN, "CVtUiColorTone.cpunt=%d", iActiveItems.Count() )
    for ( TInt i = 0; i < iActiveItems.Count(); ++i )
         {
         if ( iActiveItems [ i ] ==  aColorTone  )
             {
             __VTPRINT2( DEBUG_GEN, "CVtUiColorTone.index=%d", i )
             __VTPRINTEXIT( "CVtUiColorTone.MapCTEnumToArrayIndex" )
             return i;
             }
         }
     __VTPRINTEXIT( "CVtUiColorTone.MapCTEnumToArrayIndex" )
     // not found
     return KErrNotFound;
    }
// ---------------------------------------------------------------------------
// CVtUiColorTone::MapArrayIndexToCTEnum
// ---------------------------------------------------------------------------
//
MVtEngCameraPreferences::TColorTone CVtUiColorTone::MapArrayIndexToCTEnum(
    TInt aIndex) const
    {
    __VTPRINTENTER( "TColorTone.MapArrayIndexToCTEnum" )
    __VTPRINT2( DEBUG_GEN, "TColorTone.index=%d", aIndex )
    __VTPRINT2( DEBUG_GEN, "TColorTone.count=%d", iActiveItems.Count() )
    const TInt count = iActiveItems.Count();
    if ( count > 0 && aIndex < count && aIndex >= 0 )
        {
        __VTPRINTEXIT( "TColorTone.MapArrayIndexToCTEnum" )
        return static_cast< MVtEngCameraPreferences::TColorTone >
            ( iActiveItems[ aIndex ] );
        }
    else // not valid index return first item in the list
        {
        __VTPRINTEXIT( "TColorTone.MapArrayIndexToCTEnum_ERROR_INDEX" )
        return static_cast< MVtEngCameraPreferences::TColorTone >
            ( iActiveItems[ 0 ] );
        }
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::DoStop
// ---------------------------------------------------------------------------
//
TInt CVtUiColorTone::DoStopL( TAny* aAny )
    {
    __VTPRINTENTER( "CVtUiColorTone.DoStopL" )
    CVtUiColorTone* self = static_cast< CVtUiColorTone* >( aAny );
    if ( self->iFeatureState  == MVtUiFeature::EActive )
        {
        self->iFeatureManager.ComponentManager().
            DeActivateComponentL ( MVtUiComponent::EComponentIdColorTone );
        // set state
        self->iFeatureState = MVtUiFeature::EReady;
        }
    __VTPRINTEXIT( "CVtUiColorTone.DoStopL" )
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CVtUiColorTone::DoStart
// ---------------------------------------------------------------------------
//
TInt CVtUiColorTone::DoStartL( TAny* aAny )
    {
    __VTPRINTENTER( "CVtUiColorTone.DoStart" )
    CVtUiColorTone* self = static_cast< CVtUiColorTone* >( aAny );
    self->CVtUiPrefSettingListBase::StartSettingPageL();
    self->iFeatureManager.UiStates().SetIsCommandActivating( EFalse );
    __VTPRINTEXIT( "CVtUiColorTone.DoStart" )
    return KErrNone;
    }