/*

* Copyright (c) 2004, 2005 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:  Implementation of the CVtUiZoomControl control class.

*

*/

// INCLUDE FILES

#include    "CVtUiZoomControl.h"

#include    "VtUiLayout.h"

#include    <AknsUtils.h>

#include    <AknsDrawUtils.h>

#include    "videotelui.hrh"

#include    <cvtlogger.h>

// CONSTANTS

// Maximum amount of steps.

const TInt KVtUiZoomControlMaxSteps = 11;

// Minimum amount of steps.

const TInt KVtUiZoomControlMinSteps = 1;

// Fixed point position.

const TInt KVtUiZoomControlFixed = 16;

// Fixed point number, corresponds to one.

const TInt KVtUiZoomControlOne = ( 1 << KVtUiZoomControlFixed );

// Amount of partial bits. It is expected that 

// KVtUiZoomControlFixed >= KVtUiZoomControlPartial.

const TInt KVtUiZoomControlPartial = 8;

// Maximum duration of zooming from minimum to maximum, in microseconds.

const TInt KVtUiZoomDurationMax = 2000000;

// Maximum duration to increase zoom step by one, in microseconds.

const TInt KVtUiZoomStepDurationMax = 200000;

// Index of transparent color.

const TInt KVtUiZoomTransparent = 0;

// MODULE DATA STRUCTURES

/**

* Inner class to hold everything related to one bitmap.

* @since Series 60 2.6

*/

class CVtUiZoomControl::CBitmap

    : public CBase

    {

    public: // Constructors and destructors.

        /**

        * Constructor.

        */

        CBitmap();

        /**

        * Symbian OS constructor.

        * @param aSize size of the bitmap.

        * @param aMode display mode of the bitmap.

        */

        void ConstructL( 

            const TSize& aSize,

            const TDisplayMode aMode );

        /**

        * Destructor.

        */

        ~CBitmap();

    public:

        /**

        * Returns bitmap.

        * @return bitmap, ownership not passed.

        */

        inline CFbsBitmap* Bitmap() const;

        /**

        * Returns bitmap context.

        * @return bitmap context, ownership not passed.

        */

        inline CFbsBitGc* Context() const;

    private:

        // Owned bitmap.

        CFbsBitmap* iBitmap;

        // Owned device.

        CFbsBitmapDevice* iDevice;

        // Owned context.

        CFbsBitGc* iContext;

    };

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

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

// CVtUiZoomControl::CVtUiZoomControl

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

// might leave.

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

//

CVtUiZoomControl::CVtUiZoomControl( CVtUiBitmapManager& aBitmapManager )

    : iBitmapManager( aBitmapManager )

    {

    }

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

// CVtUiZoomControl::ConstructL

// Symbian 2nd phase constructor.

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

//

void CVtUiZoomControl::ConstructL()

    {

    iZoomDirId = 

        iBitmapManager.AddBitmapsL( 

            EVtUiBitmap_qgn_indi_zoom_dir, 

            EVtUiBitmap_qgn_indi_zoom_dir_mask,

            ETrue );

    iZoomAreaId =

        iBitmapManager.AddBitmapL( EVtUiBitmap_qgn_graf_zoom_area, EFalse );

    iBitmapManager.SetAspectRatio( iZoomAreaId, EFalse );

    iZoomMinId =

        iBitmapManager.AddBitmapL( EVtUiBitmap_qgn_indi_zoom_min, EFalse );

    iBitmapManager.SetAspectRatio( iZoomMinId, EFalse );

    iZoomMaxId =

        iBitmapManager.AddBitmapL( EVtUiBitmap_qgn_indi_zoom_max, EFalse );

    iBitmapManager.SetAspectRatio( iZoomMaxId, EFalse );

    }

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

// CVtUiZoomControl::~CVtUiZoomControl

// Destructor.

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

//

CVtUiZoomControl::~CVtUiZoomControl()

    {

    AknsUtils::DeregisterControlPosition( this );

    iBitmapManager.RemoveBitmap( iZoomDirId );

    iBitmapManager.RemoveBitmap( iZoomAreaId );

    iBitmapManager.RemoveBitmap( iZoomMinId );

    iBitmapManager.RemoveBitmap( iZoomMaxId );

    delete iZoomPartialMask;

    delete iZoomPartialShade;

    delete iZoomPartialShadeMask;

    }

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

// CVtUiZoomControl::SetZoomParams

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

//

void CVtUiZoomControl::SetZoomParams( 

        const TInt aStepCount, 

        const TInt aCurrentStep )

    {

    iCurrentZoomStep = aCurrentStep;

    iMaxZoomStep = aStepCount;

    if ( iMaxZoomStep < 0 )

        {

        iMaxZoomStep = 0;

        }

    iCurrentZoomStep = Max( Min( iCurrentZoomStep, iMaxZoomStep ), 0 );

    }

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

// CVtUiZoomControl::CommitL

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

//

void CVtUiZoomControl::CommitL()

    {

    ReportEventL( MCoeControlObserver::EEventStateChanged );

    }

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

// CVtUiZoomControl::IsZoomEnabled

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

//

TBool CVtUiZoomControl::IsZoomEnabled() const

    {

    return ( iMaxZoomStep > 0 );

    }

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

// CVtUiZoomControl::GetZoomParams

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

//

void CVtUiZoomControl::GetZoomParams(

        TInt& aStepCount,

        TInt& aCurrentStep ) const

    {

    aStepCount = iMaxZoomStep;

    aCurrentStep = iCurrentZoomStep;

    }

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

// CVtUiZoomControl::UpdateZoomL

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

//

TBool CVtUiZoomControl::UpdateZoomL()

    {

    const TInt oldZoomStep = iCurrentZoomStep;

    if ( iZoomDirection )

        {

        __VTPRINT( DEBUG_GEN, "VtUiZmCtl.UpdZoom" )

        TTime timeNow;

        timeNow.UniversalTime();

        const TTimeIntervalMicroSeconds duration = 

            timeNow.MicroSecondsFrom( iZoomStartTime );

        if ( duration >= TInt64( KVtUiZoomDurationMax ) )

            {

            // Duration is over maximum, so we can stop zooming.

            if ( iZoomDirection > 0 )

                {

                iCurrentZoomStep = iMaxZoomStep;

                }

            else

                {

                iCurrentZoomStep = 0;

                }

            iZoomDirection = 0;

            }

        else if ( duration < TInt64( 0 ) )

            {

            // Clock has been changed. Stop zooming.

            iZoomDirection = 0;

            }

        else

            {

            // Zoom is increased at least by one step per 0.2 seconds.

            TInt64 minimum( duration.Int64() );

            minimum /= KVtUiZoomStepDurationMax;

            // Zoom is increased from minimum to maximum in 2 seconds.

            TInt64 maximum( duration.Int64() );

            maximum *= iMaxZoomStep;

            maximum /= KVtUiZoomDurationMax;

            // Select maximum.

            TInt zoomStepDelta = 

                iZoomDirection * Max( I64INT( minimum ), I64INT( maximum ) );

            TInt zoomStep = iZoomStepStart + zoomStepDelta;

            // If minimum has been reached, zooming can be stopped.

            if ( zoomStep < 0 )

                {

                zoomStep = 0;

                iZoomDirection = 0;

                }

            // If maximum has been reached, zooming can be stopped.

            if ( zoomStep > iMaxZoomStep )

                {

                zoomStep = iMaxZoomStep;

                iZoomDirection = 0;

                }

            iCurrentZoomStep = zoomStep;

            }

        __VTPRINT( DEBUG_GEN, "VtUiZmCtl.chk" )

        }

    const TBool updateNeeded = ( oldZoomStep != iCurrentZoomStep );

    if ( updateNeeded )

        {

        __VTPRINT( DEBUG_GEN, "VtUiZmCtl.upd" )

        ReportEventL( MCoeControlObserver::EEventStateChanged );

        }

    return updateNeeded;

    }

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

// CVtUiZoomControl::StopZoom

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

//

void CVtUiZoomControl::StopZoom()

    {

    iZoomDirection = 0;

    }

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

// CVtUiZoomControl::OfferKeyEventL

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

//

TKeyResponse CVtUiZoomControl::OfferKeyEventL(

        const TKeyEvent& aKeyEvent,

        TEventCode aType )

    {

    TKeyResponse response = EKeyWasNotConsumed;

    if ( aKeyEvent.iScanCode == EStdKeyUpArrow ||

         aKeyEvent.iScanCode == EStdKeyDownArrow ||

         aKeyEvent.iCode == EKeyZoomIn ||

         aKeyEvent.iCode == EKeyZoomOut )

        {

        switch ( aType )

            {

            case EEventKey:

                {

                TInt direction = +1;

                if ( aKeyEvent.iScanCode == EStdKeyDownArrow ||

                    aKeyEvent.iCode == EKeyZoomOut )

                    {

                    direction = -1;

                    }

                if ( !aKeyEvent.iRepeats )

                    {

                    // Update start parameters.

                    iZoomDirection = direction;

                    iZoomStepStart = iCurrentZoomStep + direction;

                    iZoomStepStart = Min( iZoomStepStart, iMaxZoomStep );

                    iZoomStepStart = Max( iZoomStepStart, 0 );

                    iZoomStartTime.UniversalTime();

                    }

                (void)UpdateZoomL();

                }

                break;

            case EEventKeyUp:

                // Stop zooming.

                iZoomDirection = 0;

                break;

            default:

                // Do nothing.

                break;

            }

        response = EKeyWasConsumed;

        }

    return response;

    }

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

// CVtUiZoomControl::HandleResourceChange

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

//

void CVtUiZoomControl::HandleResourceChange(

        TInt aType )

    {

    if ( aType == KAknsMessageSkinChange ) 

        {

        // We must refresh partial bitmap upon next redraw.

        iZoomMaskPartial = KErrNotFound;

        iZoomMaskRow = KErrNotFound;

        }

    CCoeControl::HandleResourceChange( aType );

    }

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

// CVtUiZoomControl::Draw

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

//

void CVtUiZoomControl::Draw( const TRect& /*aRect*/ ) const

    {   

    __VTPRINT( DEBUG_GEN, "VtUiZmCtl.Draw" )   

    iBitmapManager.SetSizeAndColor( 

        iZoomDirId, 

        iZoomDirLayout.Rect().Size(),

        iZoomDirLayout.Color() );

    iBitmapManager.SetSize( 

        iZoomAreaId, 

        iZoomAreaLayout.Rect().Size() );

    iBitmapManager.SetSize( 

        iZoomMinId, 

        iZoomAreaLayout.Rect().Size() );

    iBitmapManager.SetSize( 

        iZoomMaxId, 

        iZoomAreaLayout.Rect().Size() );

    CFbsBitmap* maxBitmap = NULL;

    CFbsBitmap* minBitmap = NULL;

    CFbsBitmap* areaBitmap = NULL;

    iBitmapManager.GetBitmap( iZoomMaxId, maxBitmap );

    iBitmapManager.GetBitmap( iZoomMinId, minBitmap );

    iBitmapManager.GetBitmap( iZoomAreaId, areaBitmap );

    TInt full;

    TInt partial;

    TRect drawRect;

    TPoint drawPos;

    DetermineSteps( full, partial );

    if ( areaBitmap && partial && ( full < KVtUiZoomControlMaxSteps ) )

        {

        // First generate bitmaps, so that drawing can be done 

        // quickly in sequence.

        GetPositionAndRect( 

            drawPos,

            drawRect,

            full + 1 );

        if ( !GenerateZoomMaskBitmap( 

                areaBitmap, 

                partial, 

                drawRect.iTl.iY,

                drawRect.Size() ) )

            {

            // If zoom mask generation fails, then we have no choice

            // than not to draw.

            partial = 0; 

            }

        }

    CWindowGc& gc = SystemGc();

    gc.SetBrushStyle( CGraphicsContext::ENullBrush );

    // Draw zoom direction indicator:

    CFbsBitmap* zoomDirBitmap = NULL;

    CFbsBitmap* zoomDirMask = NULL;

    iBitmapManager.GetBitmaps( iZoomDirId, zoomDirBitmap, zoomDirMask );

    if ( zoomDirBitmap && zoomDirMask )

        {

        iZoomDirLayout.DrawImage( gc, zoomDirBitmap, zoomDirMask );

        }

    // Draw zoom indicator:

    if ( !areaBitmap )

        {

        // If area bitmap is invalid, then we have to return.

        return;

        }

    if ( maxBitmap )

        {

        // First, draw maximum area.

        for ( TInt index = KVtUiZoomControlMinSteps; 

              index <= full; 

              index++ )

            {

            GetPositionAndRect( 

                drawPos, 

                drawRect, 

                index );

            gc.BitBltMasked( 

                drawPos,

                maxBitmap, 

                drawRect, 

                areaBitmap, 

                ETrue );

            }

        }

    if ( minBitmap && ( full < KVtUiZoomControlMaxSteps ) )

        {

        // Then draw minimum area.

        for ( TInt index = full + 1; 

              index <= KVtUiZoomControlMaxSteps; 

              index++ )

            {

            GetPositionAndRect( 

                drawPos, 

                drawRect, 

                index );

            gc.BitBltMasked( 

                drawPos, 

                minBitmap, 

                drawRect, 

                areaBitmap, 

                ETrue );

            }

        if ( maxBitmap && partial && iZoomPartialMask )

            {

            // Finally draw partial area.

            GetPositionAndRect( 

                drawPos,

                drawRect,

                full + 1 );

            gc.BitBltMasked( 

                drawPos,

                maxBitmap,

                drawRect, 

                iZoomPartialMask->Bitmap(),

                ETrue );

            }

        }

    __VTPRINT( DEBUG_GEN, "VtUiZmCtl.Draw.ok" )

    }

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

// CVtUiZoomControl::SizeChanged

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

//

void CVtUiZoomControl::SizeChanged()

    {

    AknsUtils::RegisterControlPosition( this );

    TRect parent( Rect() );

    TAknWindowLineLayout rect;

    if ( parent.IsEmpty() )

        {

        return;

        }

        {

        TAknLayoutRect& tmpRect = iZoomDirLayout; 

        VtUiLayout::GetZoomPaneLayout( rect );

        tmpRect.LayoutRect( parent, rect );