/*

* 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:

*

*/

// INCLUDE FILES

#include <AknUtils.h>

#include <barsread.h>

#include <eikenv.h>

#include <AknDef.h>

#include <AknPanic.h>

#include <avkon.hrh>

#include <avkon.mbg>

#include <e32math.h>

#include <bitstd.h>

#include <bitdev.h>

#include <aknconsts.h>

#include <StringLoader.h>

#include <AknsDrawUtils.h>

#include <centralrepository.h>

#include <AvkonInternalCRKeys.h>

#include <AknsFrameBackgroundControlContext.h>

#include <gulicon.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknIconUtils.h>

#include <AknBidiTextUtils.h>

#include <AknTasHook.h>

#include "aknslider.h"

#include <touchfeedback.h>

// Large enough for a 20 digit number or fraction with two 9 digit numbers.

// This number is not in the header as it does not need to be known by the

// client.

const TInt KAknSliderValueLabelValueMaxLength = 20;

// This value is used to account for the safety demands of StringLoader. It

// requires extra length in the target descriptor of its formatting than you

// would expect.

const TInt KAknSliderFormatKeyLength = 2;

// This value is the optimum number of repeat key events to get through the

// range of the slider.

const TInt KAknSliderFeedbackActionTime = 160 * 1000; // Interval, microseconds

// Default draw color 

const TInt KAknSliderDefaultDrawColor = 120;

const TInt KScrollRepeatTimeout = 250000; // 0.25 seconds

const TInt KStableFeedbackIntesity = 50;

const TInt KFeedbackTimeout = 100000;

const TInt KNoFeedbackTimeout = 0;

const TInt KStepThreshold = 15;

// ============================================================================

// Internal class to hold slider control data, primarily coming from resource.

NONSHARABLE_CLASS( CAknSliderData ): public CBase

    {

public:

    static CAknSliderData* NewLC( TInt aResourceId );

    static CAknSliderData* NewL( TResourceReader& aReader );

    ~CAknSliderData();

    void SetRange( TInt aMinimumValue, TInt aMaximumValue );

    inline TInt Range() const

        {

        return iMaximumValue - iMinimumValue;

        }

    void SetDecimalPlaces( TInt aDecimalPlaces );

    inline TInt DecimalPlaces() const

        {

        return iDecimalPlaces;

        }

private:

    CAknSliderData();

    void ConstructFromResourceL( TInt aResourceId );

    void ConstructFromResourceL( TResourceReader& aReader );

    // Copy constructor, declared not defined -> disabled

    CAknSliderData( const CAknSliderData& aData );

    // Assignment operator, declared not defined -> disabled

    const CAknSliderData& operator=( const CAknSliderData& aData );

public:

    TInt iMinimumValue;

    TInt iMaximumValue;

    TInt iStepSize;

    TInt iValueType;

    TInt iLayout;

    HBufC* iText; // Owned

    // Text to be used for the singular label if needed. Owned

    HBufC* iSingularText;

    HBufC* iMinimumLabelText; // Owned

    HBufC* iMaximumLabelText; // Owned

    TInt iDecoratorImageId;

    TAknFeedbackStyle iFeedbackStyle;

private:

    TInt iDecimalPlaces;

    // NOTE! This class is only for storing the data read from slider resource.

    // Do not add any unnecessary members to this class, such data and

    // functionality should go to the extension instead.

    };

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

// CAknSliderData::NewLC

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

//

CAknSliderData* CAknSliderData::NewLC( TInt aResourceId )

    {

    CAknSliderData* self = new ( ELeave ) CAknSliderData();

    CleanupStack::PushL( self );

    self->ConstructFromResourceL( aResourceId );

    return self;

    }

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

// CAknSliderData::NewL

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

//

CAknSliderData* CAknSliderData::NewL( TResourceReader& aReader )

    {

    CAknSliderData* self = new ( ELeave ) CAknSliderData();

    CleanupStack::PushL( self );

    self->ConstructFromResourceL( aReader );

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

//

CAknSliderData::CAknSliderData()

    {

    // Derived from CBase -> members zeroed

    }

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

// Destructor

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

//

CAknSliderData::~CAknSliderData()

    {

    delete iText;

    delete iSingularText;

    delete iMinimumLabelText;

    delete iMaximumLabelText;

    }

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

// CAknSliderData::ConstructFromResourceL

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

//

void CAknSliderData::ConstructFromResourceL( TInt aResourceId )

    {

    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId );

    ConstructFromResourceL( reader );

    CleanupStack::PopAndDestroy(); // reader

    }

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

// CAknSliderData::ConstructFromResource

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

//

void CAknSliderData::ConstructFromResourceL( TResourceReader& aReader )

    {

    TInt sliderType = aReader.ReadInt16();

    if ( sliderType == EAknSliderWithFeedbackStyle )

        {

        iFeedbackStyle = (TAknFeedbackStyle)aReader.ReadInt16();

        iLayout = aReader.ReadInt16();

        }

    else

        {

        // old resource struct used -> actually sliderType contains

        // layout information

        iLayout = sliderType;

        if ( iLayout > EAknSliderLayoutHorizontal )

            {

            iLayout = EAknSliderLayoutHorizontal;

            }

        }

    TInt min = aReader.ReadInt16();

    TInt max = aReader.ReadInt16();

    SetRange( min, max );

    iStepSize = aReader.ReadInt16();

    iValueType = aReader.ReadInt16();

    SetDecimalPlaces( aReader.ReadInt16() );

    iSingularText = aReader.ReadHBufCL();

    iMinimumLabelText = aReader.ReadHBufCL();

    iMaximumLabelText = aReader.ReadHBufCL();

    iText = aReader.ReadHBufCL();

    // Extension link for graphics

    iDecoratorImageId = aReader.ReadInt32();

    if ( !iDecoratorImageId )

        {

        iDecoratorImageId = R_AVKON_SLIDER_CONTRAST_GRAPHICS;

        }

    }

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

// CAknSliderData::SetRange

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

//

void CAknSliderData::SetRange( TInt aMinimumValue, TInt aMaximumValue )

    {

    __ASSERT_ALWAYS( aMaximumValue > aMinimumValue,

                     Panic( EAknPanicOutOfRange ) );

    iMaximumValue = aMaximumValue;

    iMinimumValue = aMinimumValue;

    }

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

// CAknSliderData::SetDecimalPlaces

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

//

void CAknSliderData::SetDecimalPlaces( TInt aDecimalPlaces )

    {

    __ASSERT_DEBUG( aDecimalPlaces >= 0, Panic( EAknPanicInvalidValue ) );

    __ASSERT_DEBUG( aDecimalPlaces < 10, Panic( EAknPanicInvalidValue ) );

    iDecimalPlaces = Abs( aDecimalPlaces );

    }

// ============================================================================

NONSHARABLE_STRUCT( TAknSliderGfx )

    {

    TAknSliderGfx(): iRgb( NULL ), iMask( NULL )

        {}

    CFbsBitmap* iRgb; // Referenced.

    CFbsBitmap* iMask; // Referenced.

    // customized graphics flag

    TInt iCustomizedFlag; // if use default, then value = 0, else value = 1

    };

// ============================================================================

NONSHARABLE_CLASS( CAknSliderExtension ): public CBase

    {

public:

    // Symbols for bitflags.

    enum TFlags

        {

        EFlagHorizontal,

        EFlagFillEnabled,

        EFlagMarkerEnabled,

        EFlagTickMarksEnabled,

        EFlagTickBelowOrRight,

        EFlagPointerDown,

        EFlagDraggingThumb,

        EFlagValueStepChange,

        EFlagPlayingContinuousFb,

        EFlagCount // must be the last flag

        };

private:

    CAknSliderExtension();

    // Copy constructor, declared not defined -> disabled

    CAknSliderExtension( const CAknSliderExtension& );

    // Assignment operator, declared not defined -> disabled

    const CAknSliderExtension& operator=( const CAknSliderExtension& );

    void ConstructL();

public:

    ~CAknSliderExtension();

    static CAknSliderExtension* NewL();

    void SetGraphics( TInt aElement, 

                      CFbsBitmap* aBitmap, 

                      CFbsBitmap* aMask,

                      TBool aCustomize = ETrue);

    void UseDefaultGraphics( TInt aElement );

    TBool UsesDefaultGraphics( TInt aElement ) const;

    TBool UsesDefaultGraphics() const;

    void GetGfx( TAknSliderGfx& aGfx, TInt aElement ) const;

    void DeleteBitmaps();

    void TryLoadNSliderBitmap(TBool aFromSkin, MAknsSkinInstance* aSkin );

    void TryLoadNSliderVerticalBitmap( MAknsSkinInstance* aSkin );                         

    inline void SetFlag( TInt aFlagIndex )

        {

        ASSERT( 0 <= aFlagIndex && aFlagIndex < EFlagCount );

        iFlags.Set( aFlagIndex );

        }

    inline void ClearFlag( TInt aFlagIndex )

        {

        ASSERT( 0 <= aFlagIndex && aFlagIndex < EFlagCount );

        iFlags.Clear( aFlagIndex );

        }

    inline TBool IsFlagSet( TInt aFlagIndex ) const

        {

        ASSERT( 0 <= aFlagIndex && aFlagIndex < EFlagCount );

        return iFlags.IsSet( aFlagIndex );

        }

public:

    CFbsBitmap* iLineIcon; // Owned.

    CFbsBitmap* iLineIconMask; // Owned.

    TRect iLeftCapRect; // The default value is zero -> no left line cap

    TRect iRightCapRect; // The default value is zero -> no right line cap

    TRect iTickRect;

    CPeriodic* iTimer; // Owned.

    TInt iEffectTimerCount;

    TRect iThumbRect; // Equals GetMarkerRect

    TUint iTickInterval;

    TPoint iPenInputPos;//remember pointer input position

    TBool iReportMarkerDragEvent;

    TRect iTouchDownArea;

    TRect iTouchActiveArea;

    TBool iNoDraw;

private:

    // If EFlagHorizontal is not set, the orientation is vertical.

    TBitFlags32 iFlags;

    // Stores the element graphics (rgb icon and mask icon) as bitmaps. Bitmaps

    // are owned.

    TAknSliderGfx iGfx[CAknSlider::EElemMarkerSelected + 1];

    };

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

// CAknSliderExtension::CAknSliderExtension

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

//

CAknSliderExtension::CAknSliderExtension()

    {

    // slider is derived from CBase -> members zeroed

    SetFlag( EFlagMarkerEnabled );//default is marker enable

    SetFlag( EFlagHorizontal ); //default is horizontal enable

    SetFlag( EFlagValueStepChange); //default is step change enable

    // Don't report drag event as default setting

    iReportMarkerDragEvent = EFalse;

    }

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

// Destructor

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

//

CAknSliderExtension::~CAknSliderExtension()

    {

    if( iTimer )

        {

        iTimer->Cancel();

        }

    delete iTimer;

    delete iLineIcon;

    delete iLineIconMask;

    DeleteBitmaps();

    }

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

// CAknSliderExtension::ConstructL

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

//

void CAknSliderExtension::ConstructL()

    {

    // Create icon for line

    AknsUtils::CreateIconL( AknsUtils::SkinInstance(),

        KAknsIIDQgnGrafLinePrimaryHorizontal, iLineIcon, iLineIconMask,

        KAvkonBitmapFile, EMbmAvkonQgn_graf_line_primary_horizontal,

        EMbmAvkonQgn_graf_line_primary_horizontal_mask );

    // Set default value

    for ( int i = 0; i <= CAknSlider::EElemMarkerSelected; ++i )

        {

        iGfx[i].iRgb = NULL;

        iGfx[i].iMask = NULL;

        iGfx[i].iCustomizedFlag = 0;

        }

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    }

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

// CAknSliderExtension::NewL

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

//

CAknSliderExtension* CAknSliderExtension::NewL()

    {

    CAknSliderExtension* self = new( ELeave ) CAknSliderExtension();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknSliderExtension::TryLoadNewSliderBitmap

//

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

//

void CAknSliderExtension::TryLoadNSliderBitmap( TBool aFromSkin, MAknsSkinInstance* aSkin )

    {

    const TInt iconIDArray[] = 

        {

        EMbmAvkonQgn_graf_nslider_end_left,

        EMbmAvkonQgn_graf_nslider_end_right,

        EMbmAvkonQgn_graf_nslider_middle,

        EMbmAvkonQgn_graf_nslider_marker,

        EMbmAvkonQgn_graf_nslider_marker_selected

        };

    const TInt iconMaskIDArray[] = 

        {

        EMbmAvkonQgn_graf_nslider_end_left_mask,

        EMbmAvkonQgn_graf_nslider_end_right_mask,

        EMbmAvkonQgn_graf_nslider_middle_mask,

        EMbmAvkonQgn_graf_nslider_marker_mask,

        EMbmAvkonQgn_graf_nslider_marker_selected_mask

        }; 

    const TAknsItemID iconSkinIDArray[] = 

        {

        KAknsIIDQgnGrafNsliderEndLeft,

        KAknsIIDQgnGrafNsliderEndRight,

        KAknsIIDQgnGrafNsliderMiddle,

        KAknsIIDQgnGrafNsliderMarker,

        KAknsIIDQgnGrafNsliderMarkerSelected

        };

    const TInt element[] = 

        {

        CAknSlider::EElemEmptyLeftCap,

        CAknSlider::EElemEmptyRightCap,

        CAknSlider::EElemEmptyLine,

        CAknSlider::EElemMarker,

        CAknSlider::EElemMarkerSelected

        };

    TInt arrayTotal = sizeof( iconIDArray )/sizeof(TInt);

    TInt err = KErrNone;

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

        {

        CFbsBitmap* bitmapPtr = NULL;

        CFbsBitmap* maskPtr = NULL;

        if( aFromSkin )

            {

            //find new graphic from Skinned bitmap

            TRAP(err, AknsUtils::CreateIconL( aSkin,

                iconSkinIDArray[i],

                bitmapPtr,

                maskPtr,

                KNullDesC,

                iconIDArray[i],

                iconMaskIDArray[i] ));

            }

        //find new graphic from mif file

        else

            {

             TRAP(err, AknIconUtils::CreateIconL(

                bitmapPtr,

                maskPtr,

                KAvkonBitmapFile,

                iconIDArray[i],

                iconMaskIDArray[i] ));            

            }

        if( !err )

            {

            SetGraphics( element[i], bitmapPtr, maskPtr );

            }           

        }

    }

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

// CAknSliderExtension::TryLoadNewSliderBitmap

//

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

//

void CAknSliderExtension::TryLoadNSliderVerticalBitmap( MAknsSkinInstance* aSkin )

    {

    const TInt iconIDArray[] = 

        {

        EMbmAvkonQgn_graf_nslider_vertical_top,        

        EMbmAvkonQgn_graf_nslider_vertical_bottom,

        EMbmAvkonQgn_graf_nslider_vertical_middle,

        EMbmAvkonQgn_graf_nslider_vertical_marker,

        EMbmAvkonQgn_graf_nslider_vertical_tick_major,