/*
* Copyright (c) 2007 - 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:  White balance UI feature implementation.
*
*/


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

// Implementation of TVtUiWhiteBalanceComponentState

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

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

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

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

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

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

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::ComponentId
// ---------------------------------------------------------------------------
//
MVtUiComponent::TComponentId CVtUiWhiteBalance::ComponentId() const
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.ComponentId" )
    __VTPRINTEXIT( "CVtUiWhiteBalance.ComponentId" )
    return MVtUiComponent::EComponentIdWhiteBalance;
    }

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

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::DoActivateL
// ---------------------------------------------------------------------------
//
void CVtUiWhiteBalance::DoActivateL()
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.DoActivateL" )
    // get supported white balance modes
    iCameraPref->GetSupportedWhiteBalanceModes( iSupportedModes );
    __VTPRINT2( DEBUG_GEN,"CVtUiWhiteBalance.DoActivateL=%d", iSupportedModes )
    iFeatureManager.UiStates().SetWhiteBalanceModeOn( ETrue );
    iAsyncCallback->Cancel();
    iAsyncCallback->Set( TCallBack( &DoStartL, this ) );
    iAsyncCallback->CallBack();
    __VTPRINTEXIT( "CVtUiWhiteBalance.DoActivateL" )
    }

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::DoDeactivateL
// ---------------------------------------------------------------------------
//
void CVtUiWhiteBalance::DoDeactivateL()
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.DoDeactivateL" )
    iFeatureManager.UiStates().SetWhiteBalanceModeOn( EFalse );
    CVtUiPrefSettingListBase::StopSettingPageL();
    __VTPRINTEXIT( "CVtUiWhiteBalance.DoDeactivateL" )
    }

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

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::CurrentSelection
// ---------------------------------------------------------------------------
//
TInt CVtUiWhiteBalance::CurrentSelection()
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.CurrentSelection" )
    // ask from engine which item is currently active
    MVtEngCameraPreferences::TWhiteBalance wb;
    if ( iCameraPref->GetWhiteBalance( wb ) )
        {
        __VTPRINT( DEBUG_GEN, "CurrentSelection::error" );
        __VTPRINTEXIT( "CVtUiWhiteBalance.CurrentSelection" )
        // if error occured return 0 i.e. first list item
        return 0;
        }
    __VTPRINTEXIT( "CVtUiWhiteBalance.CurrentSelection" )
    return MapWBEnumToArrayIndex( wb );
    }

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::SetItemsL
// ---------------------------------------------------------------------------
//
void CVtUiWhiteBalance::SetItemsL( CDesCArray& aArray )
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.SetItemsL" )
    __VTPRINT2( DEBUG_GEN, "CVtUiWhiteBalance.SetItemsL=%d", iSupportedModes )
    // Auto mode allways supported
    ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_AUTOMATIC_OPTION );
    iActiveItems.Append( MVtEngCameraPreferences::EAuto );

    if( iSupportedModes & MVtEngCameraPreferences::EDaylight )
        {
        ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_SUNNY_OPTION );
        iActiveItems.Append( MVtEngCameraPreferences::EDaylight );
        }
    if( iSupportedModes & MVtEngCameraPreferences::ECloudy )
        {
        ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_CLOUDY_OPTION );
        iActiveItems.Append( MVtEngCameraPreferences::ECloudy );
        }
    if( iSupportedModes & MVtEngCameraPreferences::ETungsten )
        {
        ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_INCANDESCENT_OPTION );
        iActiveItems.Append( MVtEngCameraPreferences::ETungsten );
        }
    if( iSupportedModes & MVtEngCameraPreferences::EFluorescent )
        {
        ReadAndAppendItemL( aArray, R_VIDEOTELUI_QTN_INCAL_FLUORESCENT_OPTION );
        iActiveItems.Append( MVtEngCameraPreferences::EFluorescent );
        }
    __VTPRINTEXIT( "CVtUiWhiteBalance.SetItemsL" )
    }

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::SettingPageResId
// ---------------------------------------------------------------------------
//
TInt CVtUiWhiteBalance::SettingPageResId() const
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.SettingPageResId" )
    __VTPRINTEXIT( "CVtUiWhiteBalance.SettingPageResId" )
    return R_VIDEOTELUI_WHITE_BALANCE_SETTING_PAGE;
    }

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::SettingPageItemChangedL
// ---------------------------------------------------------------------------
//
void CVtUiWhiteBalance::SettingPageItemChangedL( TInt aIndex )
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.SettingPageItemChangedL" )
    __VTPRINT2( DEBUG_GEN, "CVtUiWhiteBalance.index=%d", aIndex )
    if ( iFeatureManager.UiStates().ExecState() == TVtUiStates::EExecStateResetting )
        {
        __VTPRINTEXIT( "CVtUiWhiteBalance.SettingPageItemChangedL" )
        return;
        }
    // Map index to right white balance value
    MVtEngCameraPreferences::TWhiteBalance wb = MapArrayIndexToWBEnum( aIndex );

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

    // Adjust white balance
    MVtEngMedia::TCameraId camId;
    iFeatureManager.AppUi().Model().Media().GetCurrentCameraId(camId);

    if( camId == MVtEngMedia::ESecondaryCamera  )
        {            
         iFeatureManager.AppUi().DoExecuteCmdL( KVtEngSetWhiteBalance, &params );        
         iPendingSettingChangeCmd = EFalse;
         }
    else
        iPendingSettingChangeCmd = ETrue;
    __VTPRINTEXIT( "CVtUiWhiteBalance.SettingPageItemChangedL" )
    }

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::CVtUiWhiteBalance
// ---------------------------------------------------------------------------
//
CVtUiWhiteBalance::CVtUiWhiteBalance( CVtUiFeatureManager& aFeatureManager )
    : CVtUiPrefSettingListBase( aFeatureManager, EVtUiFeatureIdWhiteBalance ),
    iComponentState( *this )
    {
    __VTPRINTENTER( "CVtUiWhiteBalance.CVtUiWhiteBalance" )
    __VTPRINTEXIT( "CVtUiWhiteBalance.CVtUiWhiteBalance" )
    }

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::MapWBEnumToArrayIndex
// ---------------------------------------------------------------------------
//
TInt CVtUiWhiteBalance::MapWBEnumToArrayIndex( MVtEngCameraPreferences::
    TWhiteBalance& aWhiteBalance ) const
    {
     __VTPRINTENTER( "CVtUiWhiteBalance.MapWBEnumToArrayIndex" )
    __VTPRINT2( DEBUG_GEN, "CVtUiWhiteBalance.cpunt=%d", iActiveItems.Count() )
    for ( TInt i = 0; i < iActiveItems.Count(); ++i )
         {
         if ( iActiveItems [ i ] ==  aWhiteBalance  )
             {
             __VTPRINT2( DEBUG_GEN, "CVtUiWhiteBalance.index=%d", i )
             __VTPRINTEXIT( "CVtUiWhiteBalance.MapWBEnumToArrayIndex" )
             return i;
             }
         }
     // not found
     __VTPRINTEXIT( "CVtUiWhiteBalance.MapWBEnumToArrayIndexNF" )
     return KErrNotFound;
    }

// ---------------------------------------------------------------------------
// CVtUiWhiteBalance::MapArrayIndexToWBEnum
// ---------------------------------------------------------------------------
//
MVtEngCameraPreferences::TWhiteBalance CVtUiWhiteBalance::
    MapArrayIndexToWBEnum( TInt aIndex) const
    {
     __VTPRINTENTER( "CVtUiWhiteBalance.MapArrayIndexToWBEnum" )
     __VTPRINT2( DEBUG_GEN, "CVtUiWhiteBalance.index=%d", aIndex )
    __VTPRINT2( DEBUG_GEN, "CVtUiWhiteBalance.count=%d", iActiveItems.Count() )
    const TInt count = iActiveItems.Count();
    if ( count > 0 && aIndex < count && aIndex >= 0 )
        {
        __VTPRINTEXIT( "CVtUiWhiteBalance.MapArrayIndexToWBEnum" )
        return static_cast< MVtEngCameraPreferences::TWhiteBalance >
            ( iActiveItems[ aIndex ] );
        }
    else // not valid index return first item in the list
        {
        __VTPRINTEXIT( "CVtUiWhiteBalance.MapArrayIndexToWBEnum_ERROR_INDEX" )
        return static_cast< MVtEngCameraPreferences::TWhiteBalance >
            ( iActiveItems[ 0 ] );
        }
    }

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

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