/*

* Copyright (c) 2002-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:  Volume editor class

*

*/

// INCLUDE FILES

#include "Aknvolumecontrol.h"

#include <gulicon.h>

#include <AknPanic.h>

#include <AknNaviObserver.h>

#include <AknUtils.h>

#include <barsread.h>

#include <AknStatuspaneUtils.h>

#include <aknnavide.h>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <aknappui.h>

#include <aknconsts.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <skinlayout.cdl.h>

#include <avkon.mbg>

#include <AknVolumePopup.h>

#include <AknTasHook.h>

#include <touchfeedback.h>

#include <aknlayoutscalable_apps.cdl.h>

// CONSTANTS

const TInt KVolumeMinValue  = 1;

const TInt KVolumeMaxValue  = 10;

const TInt KVolumeLevels    = 10;

const TInt KVolumeButtonDown        = 0x01;

const TInt KVolumeNaviPaneMuted     = 0x02;

const TInt KVolumeStepChange        = 0x04;

const TInt KVolumeLevelNotFound     = 0;

const TInt KVolumeLevelMuteTapped   = 2000;

const TInt KVolumeNaviPaneMutedValue = 0;

// Define the loaded icon types - this affects drawing.

const TInt KGfxModeNotLoaded    = 0;

const TInt KGfxModeNew          = 1;// 1 slider type icon (+mask)

const TInt KGfxModeOld          = 2;// 10 ball icons, one for each volume level (+masks)

const TInt KScrollRepeatTimeout = 250000; // 0.25 seconds

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

// Extension class

//

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

//

NONSHARABLE_CLASS(CVolumeExtension) : public CBase

    {

    public:

        CVolumeExtension();

        ~CVolumeExtension();

        // Methods for svg drawing

        static TBool UseSvgDrawing();

        void DeleteBitmaps();

        void SetIconSizes( TInt aStyle, const TRect& aParent ) const;

        void LoadBitmapsL( TInt aStyle, const TRect& aParent );

        // Sub-methods used by LoadBitmapsL

        void TryLoadBitmapsSkinnedL( MAknsSkinInstance* aSkin );

        void TryLoadBitmapsDefaultLargeL( MAknsSkinInstance* aSkin );

        void TryLoadBitmapsDefaultSmallL( MAknsSkinInstance* aSkin );

        void TryLoadBitmapsNoSkinL();

        void CalculateParentRect( TInt aStyle, const TRect& aParent );

        void DrawSvgSmallVolume( TInt aStyle, const TRect& aRect,

                                CBitmapContext& aGc, TInt aValue );

        void DrawSvgSettingsVolume( const TRect& aRect,

                                CWindowGc& aGc, TInt aValue );

        static void CreateSvgSettingsIconL( const TRect& aRect,

                                            TInt aValue, 

                                            CGulIcon* aIcon );

        static void CreateDynRangeStyleSettingsIconL( const TRect& aRect,

                                            TInt aValue, 

                                            CGulIcon* aIcon,

                                            TInt aMinimum,

                                            TInt aMaximum );                                   

        void DrawSvgSettingsIconL( const TRect& aRect,

                                    TInt aValue,

                                    CGulIcon* aIcon );

        void DrawDynRangeStyleSettingsIconL( const TRect& aRect,

                                    TInt aValue,

                                    CGulIcon* aIcon,

                                    TInt aMinimum, 

                                    TInt aMaximum );

        TInt GetVolumeLevelByPosition( const TInt& aStyle,

                                       const TPoint& aPoint,

                                       const TRect& aAreaRect ) const;

        TRect RectFromLayout( const TRect& aParent,

                              const TAknWindowComponentLayout& aComponentLayout

                            ) const;

        CFbsBitmap* iActiveIcons[KVolumeLevels];

        CFbsBitmap* iInActiveIcons[KVolumeLevels];

        CFbsBitmap* iActiveMasks[KVolumeLevels];

        CFbsBitmap* iInActiveMasks[KVolumeLevels];

        TRect iParentRect;  // Volume indicator area

        TRect iMuteRect; // Mute indicator rect for tapping 

        TRect iVolumeLevels[ KVolumeLevels ]; // Deprecated

        TInt iFlags;

        // Volume icons will be loaded the first time they are drawn,

        // not when the control is constructed.

        TBool iHasBeenDrawn;

        TFileName iBmpFilename;

        TInt iBmpId;

        TInt iBmpMask;

        CPeriodic* iTimer;

        TInt iEffectTimerCount;

        TInt iAnimatedEffectValue;

        TInt iStoredLevel;

        // For hi-res volume control implementation

        TInt iMinimumValue;

        TInt iMaximumValue;

        TInt iGfxMode; // Defines which icons are loaded when drawing

        TInt iOldScaleSettingVolume; // for 9 step setting volume

        /**

        * Flag to define whether or not this control is topmost on the navi pane's

        * control stack.

        */

        TBool iIsOnNaviStack;

        TInt iOldLevel;

        TBool iReduce;        

        TBool iNoDraw;        

        TBool iGrabPoint;

       /**

        * Extended touch area used 

        */

        TBool iUseExtendedTouchArea;

       /**

        * Touch area 

        */        

        TRect iTouchArea;

    };

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

// CAknVolumeControl::CAknVolumeControl()

// Default constructor.

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

//

EXPORT_C CAknVolumeControl::CAknVolumeControl()

    {

    AKNTASHOOK_ADD( this, "CAknVolumeControl" );

    }

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

// CAknVolumeControl::~CAknVolumeControl()

// Destructor.

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

//

EXPORT_C CAknVolumeControl::~CAknVolumeControl()

    {

    AKNTASHOOK_REMOVE();

    AknsUtils::DeregisterControlPosition( this );

    delete iBitmap;

    delete iMaskBitmap;

    delete iExtension;

    }

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

// CAknVolumeControl::SetValue(TInt aValue)

// Sets the value.

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

//

EXPORT_C void CAknVolumeControl::SetValue( TInt aValue )

    {

    // NOTE: In settings page layouts (EDynRangeSettingsVolumeControl) 

    // using dynamic min and max values defined in the resource file. The 

    // values cannot be checked in SetValue() because SetValue() is called 

    // before ConstructFromResource() which actually reads the min and max 

    // values as well as the default value even though it is also given in 

    // the settings page constructor parameter.

    //

    if ( !iExtension )

        {

        return;

        }

    TBool valueChanged( aValue != iValue );

    switch( iStyle )

        {

        case EDynRangeSettingsVolumeControl:

        case EDynRangeNaviPaneVolumeControl:

            // Do not check EDynRangeSettingsVolumeControl because it's value 

            // might be set before the actual min and max are read from the 

            // resource (settings page feature).

            // Navi pane's EDynRangeNaviPaneVolumeControl is also ignored.

            break;

        default:

            __ASSERT_DEBUG( aValue >= iExtension->iMinimumValue && 

                            aValue <= iExtension->iMaximumValue, 

                            Panic( EAknPanicOutOfRange ) );

        }

    iValue = aValue;

    if ( iExtension )

        {

        iExtension->iFlags &= ~KVolumeNaviPaneMuted;

        }

    if ( iStyle == ENaviPaneVolumeControl || 

         iStyle == EDynRangeNaviPaneVolumeControl )

        {

        TInt event = MAknNavigationObserver::ENaviEventHandleNavigation;

        if ( iValue <= iExtension->iMinimumValue )

            {

            event=MAknNavigationObserver::ENaviEventLeftMostItemReached;

            if ( iValue == iExtension->iMinimumValue )

                {

                iExtension->iFlags |= KVolumeNaviPaneMuted;

                }

            }

        else if ( iExtension->iMaximumValue == iValue )

            {

            event = MAknNavigationObserver::ENaviEventRightMostItemReached;

            }

        TRAP_IGNORE(

            ReportEventL(

                STATIC_CAST( MCoeControlObserver::TCoeEvent, event ) ) );

        if ( valueChanged )

            {

            TRAP_IGNORE(

                ReportEventL(

                    MCoeControlObserver::EEventStateChanged ) );

            }

        SetVolumeLayout( iStyle );

        if ( !iExtension->iNoDraw )

            {

            DrawNow();    

            }        

        // Volume popup is used instead of navi pane volume control,

        // pass the new value also to the popup.

        CAknVolumePopup* parent = static_cast<CAknVolumePopup*> ( Parent() );

        if ( parent && parent->ComponentControl( 5 ) == this )

            {

            if ( valueChanged )

                {

                parent->SetValue( aValue );

                }

            if ( iExtension->iIsOnNaviStack && ( valueChanged ||

                aValue == iExtension->iMinimumValue ||

                aValue == iExtension->iMaximumValue ) )

                {

                // Show the popup only if status pane is visible

                // to maintain same kind of functionality as in

                // navi pane volume control.

                CEikStatusPaneBase* sp = CEikStatusPaneBase::Current();

                if ( sp && sp->IsVisible() )

                    {

                    TRAP_IGNORE( parent->ShowVolumePopupL() );

                    }

                }

            }

        }

    }

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

// CAknVolumeControl::Value() const

// Returns the value.

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

//

EXPORT_C TInt CAknVolumeControl::Value() const

    {

    return iValue;

    }

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

// CAknVolumeControl::SetRange()

//

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

//

EXPORT_C void CAknVolumeControl::SetRange( TInt aMinimumValue, 

                                           TInt aMaximumValue )

    {

    TBool rangeChanged( aMinimumValue != iExtension->iMinimumValue ||

                        aMaximumValue != iExtension->iMaximumValue );

    __ASSERT_DEBUG( aMinimumValue < aMaximumValue, 

                     Panic( EAknPanicInvalidValue ) );

    if ( iExtension )

        {

        iExtension->iMinimumValue = aMinimumValue;

        iExtension->iMaximumValue = aMaximumValue;

        }

    // disable old volume control scaling

    if(iExtension->iOldScaleSettingVolume)

        {

        iExtension->iOldScaleSettingVolume = EFalse;

        }

    if ( iExtension->iIsOnNaviStack )

        {

        // Volume popup is used instead of navi pane volume control,

        // pass the new range also to the popup.

        CAknVolumePopup* parent = static_cast<CAknVolumePopup*> ( Parent() );

        if ( parent && parent->ComponentControl( 5 ) == this )

            {

            if ( rangeChanged )

                {

                parent->SetRange( aMinimumValue, aMaximumValue );

                }

            }

        }

    }

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

// CAknVolumeControl::GetRange()

//

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

//

EXPORT_C void CAknVolumeControl::GetRange( TInt& aMinimumValue, 

                                           TInt& aMaximumValue )

    {

    if ( iExtension )

        {

        aMinimumValue = iExtension->iMinimumValue;

        aMaximumValue = iExtension->iMaximumValue;

        }

    }

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

// CAknVolumeControl::CreateBitmapL()

//

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

//

EXPORT_C CFbsBitmap* CAknVolumeControl::CreateBitmapL(TInt aValue)

    {

    CGulIcon* icon = 

            CreateSetStyleListBoxIconL( aValue ); // now have ownership

    icon->SetBitmapsOwnedExternally( ETrue );

    CFbsBitmap* bitmap = icon->Bitmap();

    CFbsBitmap* mask = icon->Mask();

    delete icon;

    delete mask;

    return bitmap; // Ownership transferred

    }

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

// CAknVolumeControl::CreateSetStyleListBoxIconL()

// Draw volume control in setting list item

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

//

EXPORT_C CGulIcon* CAknVolumeControl::CreateSetStyleListBoxIconL( TInt aValue )

    {

    // Make the icon and put it in the array

    CGulIcon* icon = CGulIcon::NewLC();

    TRect origin;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, origin );

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect(origin,

                    AknLayoutScalable_Avkon::listscroll_gen_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::list_gen_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::list_setting_number_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::set_value_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::volume_small_pane_cp());

    TRect rect(layoutRect.Rect());

    // Move to 0,0

    rect.Move(-rect.iTl.iX,-rect.iTl.iY);

    CVolumeExtension::CreateSvgSettingsIconL( rect, aValue, icon );

    CleanupStack::Pop( icon ); // icon - not owned anymore, do not destroy

    return icon; // Ownership transferred

    }

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

// CAknVolumeControl::CreateScalableListBoxIconL()

// Draw a scalable volume control in setting list item

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

//

EXPORT_C CGulIcon* CAknVolumeControl::CreateSetDynRangeStyleListBoxIconL( 

                                                                 TInt aValue,

                                                                 TInt aMinimum,

                                                                 TInt aMaximum )

    {

    // Make the icon and put it in the array

    CGulIcon* icon = CGulIcon::NewLC();

    TRect origin;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, origin );

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect(origin,

                    AknLayoutScalable_Avkon::listscroll_gen_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::list_gen_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::list_setting_number_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::set_value_pane(0));

    layoutRect.LayoutRect(layoutRect.Rect(),

                    AknLayoutScalable_Avkon::volume_small_pane_cp());

    TRect rect(layoutRect.Rect());

    // Move to 0,0

    rect.Move(-rect.iTl.iX,-rect.iTl.iY);

    CVolumeExtension::CreateDynRangeStyleSettingsIconL( rect, aValue, icon, 

                                                        aMinimum, aMaximum );

    CleanupStack::Pop( icon ); // icon - not owned anymore, do not destroy

    return icon; // Ownership transferred

    }

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

// CAknVolumeControl::HandleNaviStackChange()

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

//    

void CAknVolumeControl::HandleNaviStackChange( TBool aIsOnNaviStack )

    {

    if ( iExtension )

        {

        iExtension->iIsOnNaviStack = aIsOnNaviStack;

        }

    }

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

// CAknVolumeControl::MinimumSize()

// Returns the size.

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

//

TSize CAknVolumeControl::MinimumSize()

    {

    TAknLayoutRect layout;

    if ( iStyle == ENaviPaneVolumeControl )

        {

        if ( AknStatuspaneUtils::SmallLayoutActive() )

            {

            layout.LayoutRect( Rect(),

                        AknLayoutScalable_Avkon::volume_small2_pane() );        

            }

        else

            {

            layout.LayoutRect( Rect(),

                        AknLayoutScalable_Avkon::volume_small_pane() );        

            }

        return layout.Rect().Size();

        }

    else // Setting Page & Popup volume control

        {

        return Rect().Size();

        }

    }

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

// CAknVolumeControl::OfferKeyEventL

// Handles the key events.

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

//

TKeyResponse CAknVolumeControl::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                TEventCode aType )

    {

    if ( aType == EEventKey )

        {

        TInt volumeValue = Value();

        switch( aKeyEvent.iCode )

            {

            case EKeyLeftArrow:

                {

                if (volumeValue > iExtension->iMinimumValue)

                    {

                    volumeValue--;

                    SetValue( volumeValue );

                    if ( iStyle != EDynRangePopupVolumeControl &&

                         !iExtension->iNoDraw )

                        {                        

                        DrawNow();

                        }

                    ReportEventL( MCoeControlObserver::EEventStateChanged );

                    }

                else

                    {

                    CAknVolumePopup* parent =

                        static_cast<CAknVolumePopup*> ( Parent() );

                    if ( iExtension &&