/*

* 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:  Class for showing quality slider*

*/

// 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 <AknsDrawUtils.h>

#include <gscamerapluginrsc.rsg>

#include <aknlayoutscalable_apps.cdl.h>

#include "GSCamQualitySettingSlider.h"

#include "CamPanic.h"    // Panic codes

#include "CamUtility.h"

#include "CamPSI.h"

#include "camconfiguration.h"

// CONSTANTS

const TInt KDivisorFactor = 1024; // Avoids using TReal maths, use factor of 2

const TInt KMinQuality                = 0;

const TInt KMaxBackCameraPhotoQuality = 4;  // Can be 3 or 5 steps => 2 or 4

const TInt KMaxBackCameraVideoQuality = 4;

// Image quality value indexes

const TInt KImageQualityHigh   = 0;

const TInt KImageQualityMedium = 1;

const TInt KImageQualityLow    = 2;

const TInt KImageQualityLower  = 3;

const TInt KImageQualityLowest = 4;

// Video quality value indexes

const TInt KVideoQualityTVHigh          = 0;

const TInt KVideoQualityWide            = 1;

const TInt KVideoQualityEmailHigh       = 2;

const TInt KVideoQualityEmailNormal     = 3;

const TInt KVideoQualitySharing         = 4;

// Video quality type indexes

const TInt KVideoQualityTVHighType      = 5;

const TInt KVideoQualityWideType        = 6;

const TInt KVideoQualityEmailHighType   = 7;

const TInt KVideoQualityEmailNormalType = 8;

const TInt KVideoQualitySharingType     = 9;

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

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

// CCamSliderLegend::~CCamSliderLegend

// destructor 

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

//

CCamSliderLegend::~CCamSliderLegend()

  {

  delete iText;

  delete iBitmap;

  delete iMask;

  }

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

// CCamSliderLegend::Draw

// Draws the legend 

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

//

void CCamSliderLegend::Draw( CWindowGc& aGc ) const

    {

    if ( iItem == ECamSliderLegendItemText )

        {

        TRgb color;

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnTextColors,

                                                EAknsCIQsnTextColorsCG6 );

        iPosition.DrawText( aGc, iText->Des(), ETrue, color );

        }

    else

        {

        iIconRect.DrawImage( aGc, iBitmap, iMask );

        }

    }

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

// CCamSliderLegend::Rect

// Returns the legend rect 

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

//

TRect CCamSliderLegend::Rect() const

    {

    if ( iItem == ECamSliderLegendItemText )

        {

        return iPosition.TextRect();

        }

    else

        {

        return iIconRect.Rect();

        }

    }

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

// CCamSliderLegend::ConstructL

// Constructs the layout entry

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

//    

void CCamSliderLegend::ConstructL( const TAknLayoutRect& aLayoutRect, 

								   TInt aBitmap, TInt aMask )

	{

	TFileName resFileName;

    CamUtility::ResourceFileName( resFileName );

	TPtrC resname = resFileName;

	iItem = ECamSliderLegendItemIcon;

  	iIconRect = aLayoutRect;

	AknIconUtils::CreateIconL( iBitmap, iMask, resname, aBitmap, aMask );

    AknIconUtils::SetSize( iBitmap, iIconRect.Rect().Size() );

	}

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

// CGSCamQualitySettingSlider::CGSCamQualitySettingSlider

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

// might leave.

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

//

CGSCamQualitySettingSlider::CGSCamQualitySettingSlider( 

    MCamSettingValueObserver* aObserver, TCamSettingItemIds aSettingType,

    TInt aSteps, CCamConfiguration* aConfiguration ) : 

    iSettingObserver( aObserver ), iSettingType( aSettingType ), 

    iSteps( aSteps ), iConfiguration ( aConfiguration )

    {

    switch ( iSettingType )

        {

        case ECamSettingItemPhotoQuality:

            {

            if( CamUtility::GetCommonPsiInt( 

                ECamPsiNumberSupportedStillQualities, iMaxSliderValue) != 

                KErrNone )

                {

                iMaxSliderValue = KMaxBackCameraPhotoQuality;

                }

            iMinSliderValue = KMinQuality;

            iNumSliderValues = iMaxSliderValue + 1;

            }

            break;        

        case ECamSettingItemVideoQuality:

            {

            if( CamUtility::GetCommonPsiInt( 

                ECamPsiNumberSupportedVideoQualities, iMaxSliderValue) !=

                KErrNone )

                {

                iMaxSliderValue = KMaxBackCameraVideoQuality;

                }

            iMinSliderValue = KMinQuality;

            iNumSliderValues = iMaxSliderValue + 1;

            }

            break;

		default:

			{

            }

            break;

        }

    // Prefill iBitmapShafts and iBitmapShaftMasks with NULL

    for ( TInt i = 0; i <= BITMAP_SHAFT_MAX_DIVISIONS; i++)

        {

            iBitmapShafts[i] = static_cast<CFbsBitmap*>(NULL);

            iBitmapShaftsMasks[i] = static_cast<CFbsBitmap*>(NULL);

        }

    }

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

// CGSCamQualitySettingSlider::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CGSCamQualitySettingSlider::ConstructL( const CCoeControl* aParent )

    {

    __ASSERT_DEBUG( aParent!=NULL, CamPanic( ECamPanicNullPointer ) );

    iParentControl = aParent;

    SetContainerWindowL( *iParentControl );  

    TFileName resFileName;

    CamUtility::ResourceFileName( resFileName );

    TPtrC resname = resFileName;

    MAknsSkinInstance* skin = AknsUtils::SkinInstance(); 

    if ( IsThreeTicksSlider() ) 

        {

        // Create component bitmaps 

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Image1,

                             iBitmapShafts[KImageQualityHigh], 

                             iBitmapShaftsMasks[KImageQualityHigh], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_image_1,

                             EMbmCameraappQgn_graf_nslider_cam4_image_1_mask );

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Image2,

                             iBitmapShafts[KImageQualityMedium], 

                             iBitmapShaftsMasks[KImageQualityMedium], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_image_2,

                             EMbmCameraappQgn_graf_nslider_cam4_image_2_mask );

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Image3,

                             iBitmapShafts[KImageQualityLow], 

                             iBitmapShaftsMasks[KImageQualityLow], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_image_3,

                             EMbmCameraappQgn_graf_nslider_cam4_image_3_mask );

        }

    else // iSettingType == ECamSettingItemVideoQuality 

        {

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Video1,

                             iBitmapShafts[KVideoQualityTVHigh], 

                             iBitmapShaftsMasks[KVideoQualityTVHigh], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_video_1,

                             EMbmCameraappQgn_graf_nslider_cam4_video_1_mask );

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Video2, 

                             iBitmapShafts[KVideoQualityWide], 

                             iBitmapShaftsMasks[KVideoQualityWide], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_video_2,

                             EMbmCameraappQgn_graf_nslider_cam4_video_2_mask );

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Video3, 

                             iBitmapShafts[KVideoQualityEmailHigh], 

                             iBitmapShaftsMasks[KVideoQualityEmailHigh], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_video_3,

                             EMbmCameraappQgn_graf_nslider_cam4_video_3_mask );

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Video4, 

                             iBitmapShafts[KVideoQualityEmailNormal], 

                             iBitmapShaftsMasks[KVideoQualityEmailNormal], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_video_4,

                             EMbmCameraappQgn_graf_nslider_cam4_video_4_mask );

        AknsUtils::CreateIconL( skin, KAknsIIDQgnGrafNsliderCam4Video5, 

                             iBitmapShafts[KVideoQualitySharing], 

                             iBitmapShaftsMasks[KVideoQualitySharing], 

                             resname, 

                             EMbmCameraappQgn_graf_nslider_cam4_video_5,

                             EMbmCameraappQgn_graf_nslider_cam4_video_5_mask );

        }

    }

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

// CGSCamQualitySettingSlider::NewL

// Two-phased constructor.

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

//

CGSCamQualitySettingSlider* CGSCamQualitySettingSlider::NewL( 

                                           const CCoeControl* aParent, 

                                           MCamSettingValueObserver* aObserver,

                                           TCamSettingItemIds aSettingItem,

                                           TInt aSteps,

                                           CCamConfiguration* aConfiguration )

    {

    CGSCamQualitySettingSlider* self = 

        new( ELeave ) CGSCamQualitySettingSlider( aObserver, aSettingItem, 

                                                  aSteps, aConfiguration);

    CleanupStack::PushL( self );

    self->ConstructL( aParent );

    CleanupStack::Pop( self );

    self->iConfiguration = aConfiguration;    

    return self;

    }

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

// CGSCamQualitySettingSlider::~CGSCamQualitySettingSlider

// Destructor

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

//    

CGSCamQualitySettingSlider::~CGSCamQualitySettingSlider()

  {

  for ( TInt i = 0; i <= BITMAP_SHAFT_MAX_DIVISIONS; i++)

    {

        delete iBitmapShafts[i];

        delete iBitmapShaftsMasks[i];

    }

  // Destroy legend strings

  iLegendArray.ResetAndDestroy();

  }

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

// CGSCamQualitySettingSlider::InitializeL

// Sets up the slider with the initial value

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

//

void CGSCamQualitySettingSlider::InitializeL( TInt aValue, 

                                              HBufC* aTopSubtitle,

                                              HBufC* aBottomSubtitle )

    {

    // Check the initial value is valid.  If no, leave.

    if ( aValue < iMinSliderValue ||

         aValue > iMaxSliderValue )

        {

        PRINT3( _L("Camera <> CGSCamQualitySettingSlider::InitializeL - illegal value: %d (min %d, max %d)" ),

                aValue, iMinSliderValue, iMaxSliderValue );  

        User::Leave( KErrArgument );

        }

    iValue = aValue;

    iTopSubtitle = aTopSubtitle;

    iBottomSubtitle = aBottomSubtitle;

    }

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

// CGSCamQualitySettingSlider::MinValue

// Returns the minimum slider value

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

//

TInt CGSCamQualitySettingSlider::MinValue() const

    {

    return iMinSliderValue;

    }

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

// CGSCamQualitySettingSlider::MaxValue

// Returns the maximum slider value

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

//

TInt CGSCamQualitySettingSlider::MaxValue() const

    {

    return iMaxSliderValue;

    }

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

// CGSCamQualitySettingSlider::SetRange

// Sets the minimum and maximum values of the slider control

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

//

void CGSCamQualitySettingSlider::SetRange( TInt aMin, TInt aMax ) 

    {

    ASSERT( aMin < aMax );

    iMinSliderValue = aMin;

    iMaxSliderValue = aMax;    

    iNumSliderValues = iMaxSliderValue + 1;

    }

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

// CGSCamQualitySettingSlider::Draw

// Draws the slider 

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

//

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

    {

    CFbsBitmap* shaft; 

    CFbsBitmap* shaftMask;

    CWindowGc& gc = SystemGc();

    TRgb color;

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnTextColors,

                               EAknsCIQsnTextColorsCG6 );

    MAknsControlContext *cc = AknsDrawUtils::ControlContext( iParentControl ); 

    //AknsDrawUtils::Background( skin, cc, iParentControl, gc, Rect() );

    // draw top and bottom subtitles

    iLayoutSubtitleTop.DrawText( gc, iTopSubtitle->Des(), ETrue, color );

    iLayoutSubtitleBottom.DrawText( gc, iBottomSubtitle->Des(), ETrue, color );

    // Draw the legend icons

    TInt count = iLegendArray.Count();

    TInt i = 0;

    for ( i = 0; i < count; i++ )

        {

        iLegendArray[i]->Draw( gc );

        }

    // the quality slider has a different shaft icon for each slider value

    if ( iMaxSliderValue <= BITMAP_SHAFT_MAX_DIVISIONS

         && iValue <= BITMAP_SHAFT_MAX_DIVISIONS

         && iMaxSliderValue >= 0

         && iValue >= 0 )

        {

        shaft = iBitmapShafts[iValue];

        shaftMask = iBitmapShaftsMasks[iValue];

        }

    else

        {

        shaft = NULL;

        }

    // Draw the shaft bitmap    

    if ( shaft )

        {

        iShaftLayout.DrawImage( gc, shaft, shaftMask );

        }

    }

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

// CGSCamQualitySettingSlider::SizeChanged

// Calculates the new minimum size

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

//

void CGSCamQualitySettingSlider::SizeChanged()

    {        

    TRAPD( ignore, ReadLayoutL() );

    if ( ignore )

        { 

        // Do nothing ( removes build warning )

        }                 

    // Work out the minimum size

    TInt count = iLegendArray.Count();

    TRect minimumRect;

    // Start min rect as first legend text

    if ( count > 0 )

        {

        minimumRect = iLegendArray[0]->Rect();

        }

    // Take into account the other legend texts

    TInt i;

    for ( i = 1; i < count; i++ )

        {            

        minimumRect.BoundingRect( iLegendArray[i]->Rect() );

        }

    // Take into account the shaft bitmap

    minimumRect.BoundingRect( iShaftLayout.Rect() );

    iMinimumSize = minimumRect.Size();

    }   

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

// CGSCamQualitySettingSlider::OfferKeyEventL

// Allows the user to change the current EV value via key presses.

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

//

TKeyResponse CGSCamQualitySettingSlider::OfferKeyEventL( 

                                 const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    if ( aType == EEventKey )

        {

        if ( aKeyEvent.iScanCode == EStdKeyUpArrow ) 

            {

            if ( iValue <  iMaxSliderValue )

                {

                iValue ++;

                // Tell observer about change

                iSettingObserver->HandleSettingValueUpdateL( iValue );  

                DrawNow();

                }

            return EKeyWasConsumed;

            }

        else if ( aKeyEvent.iScanCode == EStdKeyDownArrow ) 

            {

            if ( iValue > iMinSliderValue )

                {

                iValue --;

                // Tell observer about change

                iSettingObserver->HandleSettingValueUpdateL( iValue );  

                DrawNow();

                }

            return EKeyWasConsumed;

            }

        else if ( aKeyEvent.iCode == EKeyOK && aKeyEvent.iRepeats == 0 )

            {

            return EKeyWasConsumed;

            }

        // No allowing left and right key events thansfer to other view.

        else if( aKeyEvent.iScanCode == EStdKeyLeftArrow

              || aKeyEvent.iScanCode == EStdKeyRightArrow )

            {

            return EKeyWasConsumed;

            }

        // otherwise, do nothing

        else

            {

            // empty statement to remove Lint error, MISRA required rule 60

            }

        }

    return EKeyWasNotConsumed;

    }

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

// CGSCamQualitySettingSlider::MinimumSize

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

//

TSize CGSCamQualitySettingSlider::MinimumSize()

    {

    TSize zerosize = TSize( 0, 0 );

    if ( iMinimumSize == zerosize )

        {

        SizeChanged();

        }

    return iMinimumSize; 

    }

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

// CGSCamQualitySettingSlider::ReadLayoutL

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

//

void CGSCamQualitySettingSlider::ReadLayoutL()