/*
* 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:  Zoom popup implementation.
*
*/


#include    <AknVolumePopup.h>
#include    <cvtlogger.h>
#include    "cvtuizoompopup.h"
#include    "cvtuifeaturemanager.h"
#include	"tVtuifeaturevariation.h"
#include    "CVtUiAppUi.h"
#include    "cvtengmodel.h"

// Number of zoom steps
static const TInt KZoomStepCount = 10;

// Minimum zoom factor value
static const TInt KMinZoomFactor = 0;

// default time out time for zoom popup
const TInt KDefaultZoomTimeOutTime = 5;  

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

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::~CVtUiZoomPopup
// ---------------------------------------------------------------------------
//
CVtUiZoomPopup::~CVtUiZoomPopup()
    {
    __VTPRINTENTER( "CVtUiZoomPopup.~" )
    __VTPRINTEXIT( "CVtUiZoomPopup.~" )
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::RefreshL
// ---------------------------------------------------------------------------
//
void CVtUiZoomPopup::RefreshL()
    {
    __VTPRINTENTER( "CVtUiZoomPopup.RefreshL" )
    
    UpdateAdjustRangeL();
    
    iCurrent = CurrentZoomStep();
    if ( iCurrent < KMinZoomFactor )
        {
        User::Leave( KErrArgument );
        }
    SetValue( iCurrent );
    ShowPopupL();
    __VTPRINTEXIT( "CVtUiZoomPopup.RefreshL" )
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::DoActivateL()
// ---------------------------------------------------------------------------
//
void CVtUiZoomPopup::DoActivateL()
    {
    __VTPRINTENTER( "CVtUiZoomPopup.DoActivateL" )
    UpdateAdjustRangeL();
    CVtUiPopupBase::DoActivateL();
    // In order to refresh softkey.
    iFeatureManager.AppUi().RefreshSoftkeysL();
    __VTPRINTEXIT( "CVtUiZoomPopup.DoActivateL" )
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::OfferKeyEventL()
// ---------------------------------------------------------------------------
//
TKeyResponse CVtUiZoomPopup::OfferKeyEventL( const TKeyEvent& aEvent,
    TEventCode aCode )
    {
    __VTPRINTENTER( "CVtUiZoomPopup.OfferKeyEventL" )
    TKeyResponse response( EKeyWasNotConsumed );
    // Don't  handle other types here
    if ( aCode != EEventKey )
        {
        return response;
        }
        
    if ( aEvent.iScanCode == EStdKeyUpArrow ||
         aEvent.iScanCode == EStdKeyDownArrow ||
         aEvent.iCode == EKeyZoomIn ||
         aEvent.iCode == EKeyZoomOut )
        {
        __VTPRINT( DEBUG_GEN, "CVtUiZoomPopup.OfferKeyEventL zoom key" )
        TInt step( 1 );
        if ( aEvent.iScanCode == EStdKeyDownArrow ||
             aEvent.iCode == EKeyZoomOut )
            {
            step = -step;
            }
        const TInt current( Value() );
        TInt value( current + step );
        value = Max( KMinZoomFactor, Min( value, KZoomStepCount ) );
        if ( value != current )
            {
            __VTPRINT2( DEBUG_GEN, "CVtUiZoomPopup.OfferKeyEventL zoom = %d",
                value )
            SetValue( value );
            iFeatureManager.AppUi().SetZoomFactorL( ScaledValue() );
            response = EKeyWasConsumed;
            }
        ShowPopupL();
        }
    __VTPRINTEXITR( "CVtUiZoomPopup.OfferKeyEventL %d", response )
    return response;
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::HandleControlEventL
// ---------------------------------------------------------------------------
//
void CVtUiZoomPopup::HandleControlEventL( CCoeControl* aControl,
    TCoeEvent aEventType )
    {
    __VTPRINTENTER( "CVtUiZoomPopup.HandleControlEventL" )
    CVtUiPopupBase::HandleControlEventL( aControl, aEventType );
    
    if ( aEventType == EEventStateChanged )
        {
        __VTPRINT2( DEBUG_GEN, "CVtUiZoomPopup.HandleControlEventL zoom = %d", ScaledValue() )
        
        if ( CurrentZoomStep() != Value() )
            {
            iFeatureManager.AppUi().SetZoomFactorL( ScaledValue() );
            }
        }
        
    __VTPRINTEXIT( "CVtUiZoomPopup.HandleControlEventL" )
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::CVtUiZoomPopup
// ---------------------------------------------------------------------------
//
CVtUiZoomPopup::CVtUiZoomPopup( CVtUiFeatureManager& aFeatureManager )
    : CVtUiPopupBase( aFeatureManager.ComponentManager(),
      TVtUiBlockListBitField(
        MVtUiComponent::EComponentIdDialer |
        MVtUiComponent::EComponentIdToolbar |
        MVtUiComponent::EComponentIdNumberEntry |
        MVtUiComponent::EComponentIdVolume  |
        MVtUiComponent::EVComponentIdBrightness |
        MVtUiComponent::EVComponentIdContrast
        ),
      EComponentIdZoom ),
      iFeatureManager( aFeatureManager ),
      iMedia( aFeatureManager.AppUi().Model().Media() ),
      iCurrent( KErrNotReady )
    {
    __VTPRINTENTER( "CVtUiZoomPopup.CVtUiZoomPopup" )
    __VTPRINTEXIT( "CVtUiZoomPopup.CVtUiZoomPopup" )
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::ConstructL
// ---------------------------------------------------------------------------
//
void CVtUiZoomPopup::ConstructL()
    {
    __VTPRINTENTER( "CVtUiZoomPopup.ConstructL" )
    BaseConstructL();
    // Set slider type to percentage
    SetValueType( EAknSliderValuePercentage );
    
    // Set timeout
    SetTimeOut( KDefaultZoomTimeOutTime );
    __VTPRINTEXIT( "CVtUiZoomPopup.ConstructL" )
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::UpdateAdjustRangeL
// ---------------------------------------------------------------------------
//
void CVtUiZoomPopup::UpdateAdjustRangeL()
    {
    __VTPRINTENTER( "CVtUiZoomPopup.UpdateAdjustRangeL" )
    // Get max zoom step from engine
    iMax = MaxZoomStep();
    // Set value range to visible slider control
    // range 0-10 or 0-iMax if max < 0
    // stepcount = 10 or iMax if max < 10
    SetAdjustRange( KMinZoomFactor, Min( KZoomStepCount, iMax ), Min( KZoomStepCount, iMax ) );
   
    // Set value range to baseclass
    // range on e.g. 0-20
    SetMinAndMaxValues( KMinZoomFactor, iMax );    
    
    // Get current zoom step
    iCurrent = CurrentZoomStep();    
    
    if ( iCurrent == KErrNotFound || iMax == KErrNotFound || iCurrent > iMax )
        {
        User::Leave( KErrNotFound );
        }
    // Set new value
    SetValue( iCurrent );
    __VTPRINTEXIT( "CVtUiZoomPopup.UpdateAdjustRangeL" )
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::CurrentZoomStep
// ---------------------------------------------------------------------------
//
TInt CVtUiZoomPopup::CurrentZoomStep() const
    {
    __VTPRINTENTER( "CVtUiZoomPopup.CurrentZoomStep" )
    TInt current( KMinZoomFactor );
    const TInt error( iMedia.GetCurrentZoomStep( current ) );
    current = ( error ? KErrNotFound : current );
    
    // Value asked from the engine must be scaled.
    // If the current asked  value is 1 then the scaling formula in the 
    // popupbase doesn't round the value to 1 there fore value is 
    // initalized to 1.
    TInt  val = 1; 
    if ( current != 1 )
        {
        val =  SliderValueWithScaling( current );
        }
    __VTPRINTEXITR( "CVtUiZoomPopup.CurrentZoomStep %d", val )
    return val;
    }

// ---------------------------------------------------------------------------
// CVtUiZoomPopup::MaxZoomStep
// ---------------------------------------------------------------------------
//
TInt CVtUiZoomPopup::MaxZoomStep() const
    {
    __VTPRINTENTER( "CVtUiZoomPopup.MaxZoomStep" )
    TInt max( KMinZoomFactor );
    const TInt error( iMedia.GetMaxZoomStep( max ) );
    max = ( error ? KErrNotFound : max );
    __VTPRINTEXITR( "CVtUiZoomPopup.MaxZoomStep %d", max )
    return max;
    }
    
// ---------------------------------------------------------------------------
// CVtUiZoomPopup::ScaleAndSetZoomFactorL
// ---------------------------------------------------------------------------
//
void CVtUiZoomPopup::ScaleAndSetZoomFactorL( TInt aValue )
    {
       __VTPRINTENTER( "CVtUiZoomPopup.ScaleAndSetZoomFactorL" )
    const TInt value = aValue * MaxZoomStep() / 10; // 10 vakioksi count + 1 ei yhtä
    iFeatureManager.AppUi().SetZoomFactorL( value );  
     __VTPRINTEXITR( "CVtUiZoomPopup.ScaleAndSetZoomFactorL %d", value )
    }