/*

* Copyright (c) 2007-2009 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:  Camera Zoom Pane; shows the zoom level graphically*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32std.h>

#include <coemain.h>

#include <eikenv.h>

#include <cameraapp.mbg>

#include <eikappui.h>    // For CCoeAppUiBase

#include <eikapp.h>      // For CEikApplication

#include <barsread.h>    // resource reader

#include <AknIconUtils.h>

#include <centralrepository.h>

#include <layoutmetadata.cdl.h>         

#include <aknlayoutscalable_apps.cdl.h> 

#include <touchfeedback.h> 

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CameraUiConfigManager.h"

#include "CamPanic.h"    // Panic codes

#include "CamUtility.h"

#include "CamZoomPane.h"

#include "CamZoomModel.h"

#include "CamAppUi.h"

#include "CamBmpRotatorAo.h"

#include "CameraappPrivateCRKeys.h"

#include "CamTimer.h"

// CONSTANTS

const TInt KDivisorFactor = 10000;    // integer scaling factor to avoid the 

                                     // use of floating point arithmetic

const TInt KTouchAreaExpansion = 35; // Pixels to grow touchable area                                    

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

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

// CCamZoomPane::CCamZoomPane

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

// might leave.

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

//

CCamZoomPane::CCamZoomPane( CCamAppController& aController, TBool aOverlayViewFinder )

    : iController( aController ),

      iOverlayViewFinder( aOverlayViewFinder )

    {

    }

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

// CCamZoomPane::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCamZoomPane::ConstructL()

    {

    PRINT( _L( "Camera => CCamZoomPane::ConstructL " ) );

    // Load the zoom pane orientation value from the Central Repository

 	CRepository* repository = CRepository::NewL( KCRUidCameraappSettings );        

 	TInt val = 0;

    TInt err = repository->Get( KCamCrZoomPaneOrientation, val );

    // If there is an error then assume standard (vertical) orientation

    if ( err != KErrNone )

        {

        iOrientation = EZPOrientationVertical;

        }

    else 

        {

        iOrientation = static_cast<TZPOrientation>( val );

        }

#if !( defined(__WINS__) || defined(__WINSCW__) )

    // Get Central Repository key indicating if product uses volume keys for zoom

    err = repository->Get( KCamCrZoomUsingVolumeKeys, val );

    // If there is an error then assume volume keys not used

    if ( err != KErrNone )

        {

        iZoomUsingVolumeKeys = EFalse;

        }

    else 

        {

        iZoomUsingVolumeKeys = val;

        }

        iZoomUsingVolumeKeys = EFalse;

    // Get Central Repository key indicating if product uses navi-keys for zoom

    err = repository->Get( KCamCrZoomUsingNaviKeys, val );

    // If there is an error then assume navi-keys not used

    if ( err != KErrNone )

        {

        iZoomUsingNaviKeys = EFalse;

        }

    else 

        {

        iZoomUsingNaviKeys = val;

        }

#else

    iZoomUsingVolumeKeys = EFalse;   

    iZoomUsingNaviKeys = ETrue;  

#endif // !( defined(__WINS__) || defined(__WINSCW__) )       

    delete repository;

    repository = NULL;

    // Find the name and path of the MBM file for zoom pane bitmaps

    TFileName resFileName;

    CamUtility::ResourceFileName( resFileName );

    TPtrC resname = resFileName;

    // Create component bitmaps 

    AknIconUtils::CreateIconL( iIconZoomTop[0], 

                               iIconZoomTop[1], 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_zoom_top, 

                               EMbmCameraappQgn_indi_cam4_zoom_top_mask );

    AknIconUtils::CreateIconL( iIconZoomMiddle[0], 

                               iIconZoomMiddle[1], 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_zoom_middle, 

                               EMbmCameraappQgn_indi_cam4_zoom_middle_mask );

    AknIconUtils::CreateIconL( iIconZoomBottom[0], 

                               iIconZoomBottom[1], 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_zoom_bottom, 

                               EMbmCameraappQgn_indi_cam4_zoom_bottom_mask );   

    AknIconUtils::CreateIconL( iIconZoomMarker[0], 

                               iIconZoomMarker[1], 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_zoom_marker, 

                               EMbmCameraappQgn_indi_cam4_zoom_marker_mask );

    AknIconUtils::CreateIconL( iIconZoomMarkerGray[0], 

                               iIconZoomMarkerGray[1], 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_zoom_marker_selected, 

                               EMbmCameraappQgn_indi_cam4_zoom_marker_selected_mask );

    AknIconUtils::CreateIconL( iIconZoomMin[0], 

                               iIconZoomMin[1], 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_zoom_min, 

                               EMbmCameraappQgn_indi_cam4_zoom_min_mask );

    AknIconUtils::CreateIconL( iIconZoomMax[0], 

                               iIconZoomMax[1], 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_zoom_max, 

                               EMbmCameraappQgn_indi_cam4_zoom_max_mask );   

    SizeChanged(); // Initialize layouts and set sizes   

    CamUtility::SetAlphaL( iIconZoomTop[0], iIconZoomTop[1] ); 

    CamUtility::SetAlphaL( iIconZoomMiddle[0], iIconZoomMiddle[1] ); 

    CamUtility::SetAlphaL( iIconZoomBottom[0], iIconZoomBottom[1] );  

    CamUtility::SetAlphaL( iIconZoomMarker[0], iIconZoomMarker[1] );  

    CamUtility::SetAlphaL( iIconZoomMarkerGray[0], iIconZoomMarkerGray[1] ); 

    CamUtility::SetAlphaL( iIconZoomMin[0], iIconZoomMin[1] ); 

    CamUtility::SetAlphaL( iIconZoomMax[0], iIconZoomMax[1] );  

    iIconZoomMarkerCurrent = iIconZoomMarker[0]; 

    // Retrieve product-specific information about zoom support

    CamUtility::GetPsiInt( ECamPsiVideoZoomSupport, iZoomSupport );

    // Retrieve the timing and step values for each of the zoom bar 

    // segments/modes eg Optical/Digital/Extended    

    TPckgBuf <TCamZoomLAF> pckg;

    CamUtility::GetPsiAnyL( ECamPsiZoomBarLAF, &pckg);

    iZoomLAF = pckg();

    // Register for notification of controller events

    iController.AddControllerObserverL( this );    

    iModel = CCamZoomModel::NewL( iController, this );

    iFeedback = MTouchFeedback::Instance();   

    PRINT( _L( "Camera <= CCamZoomPane::ConstructL " ) );

    }

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

// CCamZoomPane::LoadResourceDataL()

// Reads in all information needed from resources

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

//

void CCamZoomPane::LoadResourceDataL()

    {

    PRINT( _L( "Camera => CCamZoomPane::LoadResourceDataL " ) );

    ReadLayoutL();

    PRINT( _L( "Camera <= CCamZoomPane::LoadResourceDataL " ) );

    }

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

// CCamZoomPane::UnloadResourceData()

// Frees all dynamic resources allocated in LoadResourceDataL

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

//

void CCamZoomPane::UnloadResourceData()

    {

    PRINT( _L( "Camera => CCamZoomPane::UnloadResourceData " ) );

    PRINT( _L( "Camera <= CCamZoomPane::UnloadResourceData " ) );

    }

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

// CCamZoomPane::ReloadResourceDataL()

// Refreshes all resource-based information stored in the class

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

//

void CCamZoomPane::ReloadResourceDataL()

    {

    PRINT( _L( "Camera => CCamZoomPane::ReloadResourceDataL " ) );

    UnloadResourceData();

    LoadResourceDataL();

    PRINT( _L( "Camera <= CCamZoomPane::ReloadResourceDataL " ) );

    }

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

// CCamZoomPane::NewL

// Two-phased constructor.

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

//

CCamZoomPane* CCamZoomPane::NewL( CCamAppController& aController,

                                  TBool aOverlayViewFinder )

    {

    PRINT( _L( "Camera => CCamZoomPane::NewL " ) );

    CCamZoomPane* self = new( ELeave ) CCamZoomPane ( aController, aOverlayViewFinder );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    PRINT( _L( "Camera <= CCamZoomPane::NewL " ) );

    return self;

    }

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

// CCamZoomPane::~CCamZoomPane

// Destructor.

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

//

CCamZoomPane::~CCamZoomPane()

    {

    PRINT( _L("Camera => ~CCamZoomPane" ))  

    iController.RemoveControllerObserver( this );

    delete iIconZoomTop[0];  

    delete iIconZoomMiddle[0];

    delete iIconZoomBottom[0];

    delete iIconZoomMarker[0];

    delete iIconZoomMarkerGray[0]; 

    delete iIconZoomMin[0];

    delete iIconZoomMax[0];

    delete iIconZoomTop[1];  

    delete iIconZoomMiddle[1];

    delete iIconZoomBottom[1];

    delete iIconZoomMarker[1];

    delete iIconZoomMarkerGray[1]; 

    delete iIconZoomMin[1];

    delete iIconZoomMax[1];

    delete iModel;

    if ( iRotatorAo &&

         iRotatorAo->IsActive() )

        {

        iRotatorAo->Cancel();

        }

    delete iRotatorAo;

    iZoomInKeys.Close();

    iZoomOutKeys.Close();

    PRINT( _L("Camera <= ~CCamZoomPane" ))  

    }

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

// CCamZoomPane::Draw

// Draws the zoom pane

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

//

void CCamZoomPane::Draw( CBitmapContext& aGc ) const

    {

    PRINT( _L( "Camera => CCamZoomPane::Draw " ) );

    if ( !iMaxZoom )

        {        

        PRINT( _L( "Camera <= CCamZoomPane::Draw not set up yet" ) );

        return; // Not set up yet

        }

    if ( !iOverlayViewFinder )

        {

        aGc.Clear( iZoomPaneRect );

        }

    DrawPlusMinus( aGc );

    DrawShaft( aGc );

    DrawThumb( aGc );    

    PRINT( _L( "Camera <= CCamZoomPane::Draw " ) );

    }

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

// CCamZoomPane::DrawPlusMinus

// Draws the plus and minus icons

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

//    

void CCamZoomPane::DrawPlusMinus( CBitmapContext& aGc ) const

    {    

    PRINT( _L( "Camera => CCamZoomPane::DrawPlusMinus " ) );

    aGc.BitBlt( iPlusPoint,  iIconZoomMax[0] );    

    aGc.BitBlt( iMinusPoint, iIconZoomMin[0] );   

    PRINT( _L( "Camera <= CCamZoomPane::DrawPlusMinus " ) );                 

    }

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

// CCamZoomPane::DrawShaft

// Draws the shaft of the zoom pane

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

//    

void CCamZoomPane::DrawShaft( CBitmapContext& aGc ) const  

    {

    PRINT( _L( "Camera => CCamZoomPane::DrawShaft " ) );

    aGc.BitBlt( iTopPoint,    iIconZoomTop[0] );

    aGc.BitBlt( iMiddlePoint, iIconZoomMiddle[0] );

    aGc.BitBlt( iBottomPoint, iIconZoomBottom[0] );

    PRINT( _L( "Camera <= CCamZoomPane::DrawShaft " ) );

    }

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

// CCamZoomPane::SetPoint

// Sets the value of a point based on another point and an (optional) modifier value.

// This was added to simplify the bar drawing code, so the changes based on orientation 

// are (as much as possible) contained in this function

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

//    

void 

CCamZoomPane::SetPoint(       TPoint& aPoint, 

                        const TPoint& aOffset, 

                              TInt    aAdditional ) const

    {

    PRINT( _L( "Camera => CCamZoomPane::SetPoint " ) );

    if ( PaneOrientation() == EZPOrientationVertical )

        {

        aPoint.iY = aOffset.iY + aAdditional;

        }

    else

        {

        aPoint.iX = aOffset.iX - aAdditional;

        }

    PRINT( _L( "Camera <= CCamZoomPane::SetPoint " ) );

    }

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

// CCamZoomPane::PaneOrientation

// Returns the current zoom pane orientation (taking into account whether this

// should be forced or not if on secondary camera)

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

//        

CCamZoomPane::TZPOrientation CCamZoomPane::PaneOrientation() const

    {

    PRINT( _L( "Camera => CCamZoomPane::PaneOrientation " ) );

    if ( iController.ActiveCamera() == ECamActiveCameraSecondary )

        {

        PRINT( _L( "Camera <= CCamZoomPane::PaneOrientation EZPOrientationVertical" ) );

        return EZPOrientationVertical;

        }

    else 

        {

        PRINT( _L( "Camera <= CCamZoomPane::PaneOrientation iOrientation" ) );

        return iOrientation;

        }

    }

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

// CCamZoomPane::DrawThumb

// Draws the thumb of the zoom pane

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

//       

void CCamZoomPane::DrawThumb( CBitmapContext& aGc ) const

    {   

    PRINT( _L( "Camera => CCamZoomPane::DrawThumb " ) );

    TPoint newThumbPos;                            

    // Knob bitmap has an empty area on the edge, thus it starts upper than top

    // of zoom slider 

    // topPointY is iTl.iY of knob bitmap when maximum zoom is used. 

    newThumbPos.iX = iZoomPaneRect.iTl.iX;        

    TInt pixelsPerStep = ( iMaxOffset * KDivisorFactor ) / (iMaxZoom+1);

    TInt pixelsFromBase;

    pixelsFromBase = ( iTrgZoom * pixelsPerStep );

    newThumbPos.iY = iTopPoint.iY + iMaxOffset -

             (pixelsFromBase + pixelsPerStep/2 +

              iIconZoomMarker[0]->SizeInPixels().iHeight * 

              KDivisorFactor / 2) / KDivisorFactor;                                                        

    aGc.BitBlt( newThumbPos, iIconZoomMarkerCurrent ); 

    PRINT( _L( "Camera <= CCamZoomPane::DrawThumb " ) );                   

    }

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

// CCamZoomPane::SetRect

// Sets the rect that zoom pane is drawn into

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

//

void CCamZoomPane::SetRect( TRect aRect )

    {

    PRINT( _L( "Camera => CCamZoomPane::SetRect " ) );

    iZoomPaneRect = aRect;

    PRINT( _L( "Camera <= CCamZoomPane::SetRect " ) );

    }

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

// CCamZoomPane::SetZoomRange

// Specifies the range of values zoom supports

// aMax should always be more than aMin. 

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

//

TInt CCamZoomPane::SetZoomRange( TInt aMin, TInt aMax )

    {        

    PRINT( _L( "Camera => CCamZoomPane::SetZoomRange " ) );

    // The minimum value should always be less than the max.

    if ( aMin >= aMax ||

         aMin < 0 )

        {    

        PRINT( _L( "Camera <= CCamZoomPane::SetZoomRange KErrArgument" ) );

        return KErrArgument;

        }

    iMinZoom = aMin;

    iMaxZoom = aMax;

    PRINT( _L( "Camera <= CCamZoomPane::SetZoomRange " ) );

    return KErrNone;

    } 

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

// CCamZoomPane::SetZoomSteps

// Sets the number of steps allowed in each category

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

//

void CCamZoomPane::SetZoomSteps( TInt aOptSteps, TInt aStdSteps, TInt aExtSteps )

    {  

    PRINT( _L( "Camera => CCamZoomPane::SetZoomSteps " ) );      

    ASSERT( aOptSteps >= 0 && aStdSteps >= 0 && aExtSteps >= 0 );

    iOptSteps = aOptSteps;

    iStdSteps = aStdSteps;    

    iExtSteps = aExtSteps;

    PRINT( _L( "Camera <= CCamZoomPane::SetZoomSteps " ) );        

    }

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

// CCamZoomPane::SetZoomValue

// Specifies the current level of Zoom.

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

//

TInt CCamZoomPane::SetZoomValue( TInt aZoom )

    { 

    PRINT1( _L( "Camera => CCamZoomPane::SetZoomValue aZoom=%d" ), aZoom );

    if ( iController.UiConfigManagerPtr()->IsExtendedDigitalZoomSupported() )

        {

        // this may happen if in the extended zoom range

        // and we switch the extended range off - the

        // zoom value in the engine will be greater than

        // the max value allowed

        if ( aZoom > iMaxZoom )

            {

            aZoom = iMaxZoom;

            }        

        }

    // Check supplied value is within valid range

    if ( aZoom < iMinZoom || aZoom > iMaxZoom )

        {

        PRINT( _L( "Camera <= CCamZoomPane::SetZoomValue KErrArgument" ) );

        return KErrArgument;

        }

    iCurZoom = aZoom;

    iTrgZoom = aZoom;

    if ( iVisible )

        {

        // force redraw of zoom pane

        MakeVisible( ETrue, ETrue );

        }

    PRINT( _L( "Camera <= CCamZoomPane::SetZoomValue " ) );

    return KErrNone;

    }

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

// CCamZoomPane::ZoomValue

// Returns the current zoom value (as the ZoomPane knows it)

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

//

TInt CCamZoomPane::ZoomValue() const

    {   

    PRINT( _L( "Camera => CCamZoomPane::ZoomValue " ) );

    PRINT1( _L( "Camera <= CCamZoomPane::ZoomValue iCurZoom=%d" ), iCurZoom );

    return iCurZoom;

    }

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

// CCamZoomPane::IsZoomAtMinimum

// Returns whether the current zoom value is the minimum zoom

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

//

TBool CCamZoomPane::IsZoomAtMinimum() const

    {

    PRINT2(_L("Camera =><= CCamZoomPane::IsZoomAtMinimum iCurZoom = %d, iMinZoom = %d"), iCurZoom, iMinZoom);

    return iCurZoom == iMinZoom;

    }