/*

* Copyright (c) 1997-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:

*

*/

#if !defined(__EIKSCRLB_H__)

#define __EIKSCRLB_H__

#if !defined(__EIKBCTRL_H__)

#include <eikbctrl.h>

#endif

#if !defined(__EIKSBOBS_H__)

#include <eiksbobs.h>

#endif

#if !defined(__AKNSCBUT_H__)

#include <aknscbut.h>

#endif

#include <lafpublc.h>

class CEikCba;

class CAknDoubleSpanScrollIndicator;

class CEikScrollBarExtensionImpl;

class CEikScrollBarExtension;

class CAknDoubleSpanScrollBarExtension;

const TInt KEikScrollEventFromVBar=0;

const TInt KEikScrollEventFromHBar=0x01;

const TInt KEikScrollEventBarMask=0x01;

// sets all bits in EButtonsXxx range

const TInt KButtonPositionMask=KLafScrollBarButtonPositionMask; 

// sets all bits in determining which components exist

const TInt KDisplayComponentsMask=0x1f; 

/**

 * Scroll bar models encapsulate the range of integers which a scroll bar can 

 * represent, from zero to n, and the current position of the scroll bar thumb

 * within that range.

 *

 * Supported from Symbian 5.0.

 */

class TEikScrollBarModel

    {

public:

    /**

     * C++ default constructor. Creates, allocates and initialises a new @c 

     * TEikScrollBarModel.

     */

    inline TEikScrollBarModel();

    /**

     * Constructor. Creates, allocates and initialises a new @c 

     * TEikScrollBarModel.

     *

     * @param aScrollSpan The span of this model, numbered from zero.

     * @param aThumbSpan Number of positions spanned by the thumb.In default

     *        this is zero.

     * @param aThumbPosition Position of the thumb within the model span. In

     *        default this is zero.

     */	

    IMPORT_C TEikScrollBarModel(TInt aScrollSpan,

                                TInt aThumbSpan=0,

                                TInt aThumbPosition=0);

    /**

     * Tests two models for equality. The two models are the current model and

     * the model specified by @c aModel.

     *

     * @param The model against which the current model is tested. 

     *

     * @return @c ETrue if the two models are equal.

     */	

    IMPORT_C TBool operator==(const TEikScrollBarModel aModel) const;

    /**

     * Tests two models for inequality. The two models are the current model 

     * and the model specified by @c aModel.

     *

     * @param The model against which the current model is tested. 

     * @return @c ETrue if the two models are not equal.

     */	

    inline TBool operator!=(const TEikScrollBarModel aModel) const; 

public:

    /** 

     * Tests whether the scroll bar model is useful. Scroll bar models are only

     * useful if their thumb span is smaller than their entire span.

     *

     * @return Whether this scroll bar can be used.

     */

    IMPORT_C TBool ScrollBarUseful() const;

    /**

     * Gets the maximum position possible for the low edge of the thumb within

     * the total span.

     *

     * @return Maximum value possible for @c iThumbPosition.

     */

    IMPORT_C TInt MaxThumbPos() const;

    /**

     * Ensures that the thumb position remains within its valid range by

     * altering it if necessary.

     */

    IMPORT_C void CheckBounds();

    /** 

     * Type of scroll bar model. The different models store the scrolling

     * information in different way, so correct model must be used with correct

     * scrollbar type.

     */

    enum TEikScrollBarModelType

        {

        /** This model type is for storing data for the arrowhead scrollbar. */

        EEikScrollBarModel               = 0x00000000,

        /** This model type is for storing data for the spanned scrollbar. */

        EAknDoubleSpanScrollBarModel     = 0x80000000

        };        

    /**

     * Gets type of scroll bar model which is one of the enum values from @c 

     * TEikScrollBarModelType enum.

     */

    TEikScrollBarModel::TEikScrollBarModelType ScrollBarModelType() const;

public:

    /** Entire range of integers for this model. */

    TInt iScrollSpan;

    /** Range spanned by the thumb. */

    TInt iThumbSpan;

    /** Position of the low edge of the thumb within 0...@c iScrollSpan. */

    TInt iThumbPosition;            

    };

inline TEikScrollBarModel::TEikScrollBarModel() {}

inline TBool TEikScrollBarModel::operator!=(const TEikScrollBarModel aModel) const { return !(*this==aModel); }

//

// TAknDoubleSpanScrollBarModel class

//

// This class is binary compatible with TEikScrollBarModel and can

// be used in places where TEikScrollBarModel is used but few restrictions exist:

//

// - Base class (TEikScrollBarModel) public members must NOT be accessed directly.

// - Base class (TEikScrollBarModel) public methods must NOT be called.

//

// If this model is not supported by the scrollbar system, then values are stored

// as in the base class for compatibility resons. See ModelIsSupported()-method 

// documentation for more information.

//

class TAknDoubleSpanScrollBarModel : public TEikScrollBarModel

	{

public:

   /**

    * Default constructor.

    */

    IMPORT_C TAknDoubleSpanScrollBarModel();

   /**

    * Constructor which converts TEikScrollBarModel into TAknDoubleSpanScrollBarModel.

    *

    * @since    2.6

    * @param    aEikModel a model that will be converted.

    * 

    * Allowed range for TEikScrollBarModel values is from 0x1FFF7FFF to -0x1FFF7FFF. 

    * Values outside the allowed range will be truncated to max or min value. 

    * Value will be internally  stored with 15 bit accuracy, this means 

    * that the actual stored value may differ from the value given as parameter.

    * 

    * Values will be converted as:

    * 

    * TEikScrollBarModel        TAknDoubleSpanScrollBarModel

    * ------------------        ----------------------------

    * iScrollSpan          ->    ScrollSpan

    * iThumbPosition       ->    FocusPosition

    * iThumbSpan           ->    WindowSize

    * 0                    ->    FieldPosition            

    * 0                    ->    FieldSize

    *

    *

    * Values will be internally  stored with 15 bit accuracy, this means that the 

    * actual stored value may differ from the value given inside parameter.

    *

    */

    IMPORT_C TAknDoubleSpanScrollBarModel(const TEikScrollBarModel& aEikModel);

   /**

    *  Set methods for model attributes. These MUST be used instead of setting

    *  base class model values directly.

    *

    *  @since    2.6

    *  @param    aValue Value to be stored. Allowed range 0x1FFF7FFF to -0x1FFF7FFF. 

    *                   Value outside the allowed range will be truncated to max

    *                   or min value. Value will be internally  stored with 

    *                   15 bit accuracy, this means that the actual stored value

    *                   may differ from the value given as parameter.

    *

    *                   This inaccuracy means that e.g. following can happen:

    *                       TInt value1 = 23456789;                   

    *                       TInt value2 = 0;                   

    *

    *                       model.SetScrollSpan(value1);

    *                       value2 = model.ScrollSpan();

    *                       if (value1 != value2)

    *                           {

    *                           // we can end up here !!!!  

    *                           }

    *

    */

    IMPORT_C void SetScrollSpan(TInt aValue);    // Size of the scrolled list. 

    IMPORT_C void SetFocusPosition(TInt aValue); // Position of the current field in the list.

    IMPORT_C void SetWindowSize(TInt aValue);    // Size of the visible part of the list. 

    IMPORT_C void SetFieldSize(TInt aValue);     // Size of the current field. (Optional double span)

    IMPORT_C void SetFieldPosition(TInt aValue); // Position inside the current field. (Optional double span)  

   /**

    *  Get methods for model attributes. These MUST be used instead of getting

    *  base class model values directly.

    *

    * @since    2.6

    * @return   Values from range 0x1FFF7FFF to -0x1FFF7FFF. 

    *           Values are internally  stored with 15 bit accuracy, this means that 

    *           the returned value may differ from the value which was set using the

    *           corresponding set method. Difference can be about 0x3FFF in the high

    *           end of the range.

    *

    */

    IMPORT_C TInt ScrollSpan() const;    // Size of the scrolled list.

    IMPORT_C TInt FocusPosition() const; // Position of the current field in the list.

    IMPORT_C TInt WindowSize() const;    // Size of the visible part of the list. 

    IMPORT_C TInt FieldSize() const;     // Size of the current field. (Optional double span)

    IMPORT_C TInt FieldPosition() const; // Position inside the current field. (Optional double span)

   /**

    * This method can be used to query if this model type is supported by the device. If model 

    * is not supported then this model and the behaviour of ALL methods defaults to TEikScrollBarModel 

    * behaviour with following rules:

    *

    * TAknDoubleSpanScrollBarModel              TEikScrollBarModel

    * ----------------------------              ------------------  

    * ScrollSpan methods                ->      iScrollSpan

    * FocusPosition methods             ->      iThumbPosition

    * WindowSize methods                ->      iThumbSize

    * FieldPosition methods             ->      N/A

    * FieldSize methods                 ->      N/A

    *

    * @since    2.6

    * @return   ETrue if this model is supported by the devices scrollbar system. Otherwise EFalse is

    *           returned.

    *

    */

    static TBool ModelIsSupported();

private:   

   /**

    * Gets the internal scale value. 

    *

    * @since    2.6

    * @return   Internal scaling value.

    *

    */

    TUint16 Scale() const;

   /**

    * Sets the internal scale value. 

    *

    * @since    2.6

    * @param    aScale  New internal scaling value.

    *

    */

    void SetScale(TUint16 aScale);    

private:   

   /**

    *  Get methods for model attributes values without scaling.

    *

    *  @since    2.6

    *  @return   Stored value without scaling. 

    *

    */

    TInt16 ScrollSpanValue() const;

    TInt16 FocusPositionValue() const;

    TInt16 FieldPositionValue() const;

    TInt16 FieldSizeValue() const;

    TInt16 WindowSizeValue() const;

   /**

    *  Set methods for model attributes values without scaling.

    *

    *  @since    2.6

    *  @param    aValue Value without scaling to be stored. 

    *

    */

    void SetScrollSpanValue(TInt16 aValue);

    void SetFocusPositionValue(TInt16 aValue);

    void SetFieldPositionValue(TInt16 aValue);

    void SetFieldSizeValue(TInt16 aValue);

    void SetWindowSizeValue(TInt16 aValue);

   /**

    *  Gets two lowest bytes from TInt and constructs TInt16 from those.

    *

    *  @since    2.6

    *  @param    aInt  Value from which the lowest bytes are extracted.     

    *  @return   TInt16 constructed from two lowest bytes.

    */

    TInt16 LowBytes(TInt aInt) const;

   /**

    *  Gets two highest bytes from TInt and constructs TInt16 from those.

    *

    *  @since    2.6

    *  @param    aInt  Value from which the highest bytes are extracted.     

    *  @return   TInt16 constructed from two highest bytes.

    */    

    TInt16 HighBytes(TInt aInt) const;

   /**

    *  Sets two lowest bytes of TInt.

    *

    *  @since    2.6

    *  @param    aInt    TInt of which the lowest bytes are set.     

    *  @param    aValue  Value for the lowest bytes.     

    */    

    void SetLowBytes(TInt& aInt, TInt16 aValue);

   /**

    *  Sets two highest bytes of TInt.

    *

    *  @since    2.6

    *  @param    aInt    TInt of which the highest bytes are set.     

    *  @param    aValue  Value for the highest bytes.     

    */        

    void SetHighBytes(TInt& aInt, TInt16 aValue);

   /**

    *  Constructs a scaled TInt16 value from given TInt value. Changes

    *  internal member variable values using ReScale()-method if needed.

    *

    *  @since    2.6

    *  @param    aNonScaledValue    Value which will be changed to scaled one.

    *  @return   Scaled value.

    */        

    TInt16 PrepareScaledValue(TInt aNonScaledValue);

   /**

    *  Changes the used scale value and updates all stored attribute values

    *  if needed.

    *

    *  @since    2.6

    *  @param    aNewScale    New value to be used scaling.

    *

    */        

    void ReScale(TUint16 aNewScale);

   /**

    *  Sets the scrollbar type.

    *

    *  @since    2.6

    *  @param    aModelType    Scrollbar type. Supported types are 

    *                          EEikScrollBarModel and EAknDoubleSpanScrollBarModel.

    *

    */        

    void SetScrollBarModelType(TEikScrollBarModelType aModelType);

   /**

    *  Checks if given parameter is between internal min and max values.

    *

    *  @since    2.6

    *  @param    aValue        Value to be checked.

    *  @return                 Checked value which will be between internal min 

    *                          and max values. 

    *

    */        

    TInt CheckMinMaxValue(TInt aValue);

    };

//

// CEikScrollBar

//

class CEikScrollThumb;

class CEikScrollBarFrame;

/**

 * The CEikScrollBar class implements a scroll bar. Scroll bars are used when

 * the contents of a view require a greater area than can be physically 

 * displayed. Scroll bars allow a user to move different parts of the content

 * into the view and to indicate what proportion of the total contents are 

 * visible at any one time.

 */

class CEikScrollBar : public CEikBorderedControl, public MCoeControlObserver

	{

friend class CEikScrollBarExtension;

friend class CAknDoubleSpanScrollBarExtension;

public:

    /** Scroll bar orientation. */

    enum TOrientation

        {

        /** Scroll bar is oriented vertically. */

        EVertical = SLafScrollBar::EVertical,

        /** Scroll bar is oriented horizontally. */

        EHorizontal = SLafScrollBar::EHorizontal

        };

    /** Type of the scroll bar.*/	

    enum TScrollBarType

        {

        /** Normal scrollbar. */		

        ENormalScrollBar =0x0,

        /** Used scrollbar type is an old one. (arrows in the CBA-area) */		

        EArrowHead =0x200,

        /** 

         * The created scrollbar is the current and commonly used in Series 60

         * platform, spanned scrollbar. (scrollable bar on the right side of

         *  the control, like in windows etc.).

         */		

        EDoubleSpan =0x400

        };

    /** 

     * Scroll bar initialisation flags. The default is for the scroll bar

     * to have both a shaft and a thumb. 

     */	

    enum TEikScrollBarFlags

    	{

    	/**  */	

    	EEikScrollBarDefaultBehaviour = 

    	    SLafScrollBar::EEikScrollBarDefaultBehaviour,

    	/** Does not display nudge buttons.*/	

    	EEikScrollBarNoNudgeButtons =

    	    SLafScrollBar::EEikScrollBarNoNudgeButtons,

    	/** Has buttons which move it a page at a time. */	

    	EEikScrollBarHasPageButtons =

    	    SLafScrollBar::EEikScrollBarHasPageButtons,	

    	/** Has buttons which move it its entire extent. */	

    	EEikScrollBarHasHomeEndButtons =

    	    SLafScrollBar::EEikScrollBarHasHomeEndButtons,

    	/** Central area is empty. */	

    	EEikScrollBarNoShaftOrThumb =

    	    SLafScrollBar::EEikScrollBarNoShaftOrThumb,	

    	/** Central area has no scroll thumb. */	

    	EEikScrollBarShaftButNoThumb =

    	    SLafScrollBar::EEikScrollBarShaftButNoThumb,	

    	/** Buttons are placed at the start of the bar. */	

    	EButtonsAtStartOfShaft =

    	    SLafScrollBar::EButtonsAtStartOfShaft,	

    	/** Buttons are placed at the end of the bar. */	

    	EButtonsAtEndOfShaft =

    	    SLafScrollBar::EButtonsAtEndOfShaft,			

    	/** 

    	 * Buttons are placed at either end of the bar @c

    	 * (EButtonsAtStartOfShaft | @c EButtonsAtEndOfShaft).

    	 */	

    	EButtonsEitherSideOfShaft =

    	    SLafScrollBar::EButtonsEitherSideOfShaft,

    	/** 

    	 * Buttons do not automatically dim when scroll bar is at its maximum

    	 * extent.

    	 */	

    	ENoAutoDimming =

    	    SLafScrollBar::ENoAutoDimming,

    	/** Enable the nudge buttons. */

    	EEnableNudgeButtons = 0x0200,

    	/** Disable the expanded touch area. */

    	EDisableExpandedTouchArea = 0x0400

    	};

    /** Type of the scroll extension area.*/

     enum TScrollBarExtensionAreaType

        {

        /** Normal scrollbar extension area. */

        ENormalExpandedTouchArea,

        /** Scale scrollbar extension area. */

        EScaleExpandedTouchArea,

        /** none scrollbar extension area. */

        ENoExpandedTouchArea

        };

    typedef TEikScrollBarFlags TAknScrollBarFlags;

public:

    /**

     * Destructor.

     */

    IMPORT_C ~CEikScrollBar();

    /**

     * C++ default constructor.

     */	

    IMPORT_C CEikScrollBar();

public:

    /** 

     * Second phase constructor of the scroll bar. 

     *

     * @param aScrollBarObserver The scroll bar observer which is to be 

     *        informed of scroll events by this scroll bar. 

     * @param aParent Parent control for this new scroll bar. 

     * @param aOrientation Orientation of the new scroll bar. 

     * @param aLength Not used. 

     * @param aScrollBarFlags Not used. 

     */

    IMPORT_C virtual void ConstructL(

                MEikScrollBarObserver* aScrollBarObserver,

                const CCoeControl* aParent,

                TOrientation aOrientation,

                TInt aLength,

                TInt aScrollBarFlags=EEikScrollBarDefaultBehaviour);

    /** 

     * Not implemented.

     * 

     * @param aLength Not used.

     */

    IMPORT_C void SetLengthL(TInt aLength);

    /** 

     * Change the scrollbar model.

     * 

     * @param aModel The new model to use.

     */

    IMPORT_C void SetModelL(const TEikScrollBarModel* aModel);

    /** 

     * Change the scrollbar model.

     * 

     * @param aModel The new model to use.

     */

    IMPORT_C void SetModel(const TEikScrollBarModel* aModel);

    /** 

     * Change the model at once to avoid a double update of the scroll bar.

     * 

     * @param aLength Not used. 

     * @param aModel New scroll bar model.

     */

    IMPORT_C void SetLengthAndModelL(TInt aLength,

                                     const TEikScrollBarModel* aModel);

    /** 

     * Not implemented.

     * 

     * @param aThumbPos Not used.

     */

    IMPORT_C void SetModelThumbPosition(TInt aThumbPos);

    /** 

     * Not implemented.

     * 

     * @param aFocusPosition Not used.

     */

    IMPORT_C void SetFocusPosToThumbPos(TInt aFocusPosition);

    /** 

     * Gets the default width of the scroll bar.

     * 

     * @return Default scroll bar breadth.

     */

    IMPORT_C static TInt DefaultScrollBarBreadth();

    /**

     * Allows scroll bar observer to be changed also after the construction. 

     * This function is not exported, but the applications can use it via

     * @c CEikScrollBarFrame::SetScrollBarFrameObserver function.

     *

     * @param aScrollBarObserver New observer replacing the previous (if any).

     */

    void SetScrollBarObserver(MEikScrollBarObserver* aScrollBarObserver);

    /**

     * Gets the scroll bar model used by this scroll bar.

     */

    inline const TEikScrollBarModel* Model() const;

    /** 

     * Gets the position within the scroll bar model. This function would

     * normally be called by an @c MEikScrollBarObserver implementation in 

     * response to a scroll bar event.

     * 

     * @return Current position within the scroll bar model’s range.

     */

    IMPORT_C TInt ThumbPosition() const;

    /** 

     * Gets the height of a horizontal scrollbar or width of a vertical 

     * scrollbar.

     * 

     * @return Scroll bar breadth.

     */

    IMPORT_C TInt ScrollBarBreadth() const;

    /** 

     * Not implemented.

     * 

     * @param aScrollBarFlags Not used.

     *

     * @return Zero.

     */

    IMPORT_C static TInt MinVisibleLength(const TInt aScrollBarFlags);

    /** 

     * Not implemented.

     * 

     * @param aDimmed Not used.

     */

    IMPORT_C void SetDecreaseButtonsDimmed(TBool aDimmed);

    /** 

     * Not implemented.

     * 

     * @param aDimmed Not used.

     */

    IMPORT_C void SetIncreaseButtonsDimmed(TBool aDimmed);

    /** 

     * Not implemented.

     * 

     * @param aDimmed Not used.

     */

    IMPORT_C void SetAllButtonsDimmed(TBool aDimmed);

    /** 

     * Gets handle to the controls that draw arrows in the both ends of spanned

     * scrollbar. These arrows are for pen support to enable exact moving of

     * the scrollbar with pen. The arrow is tapped with the pen to move the

     * scrollbar with one step.

     *

     * @return Pointer to the increace button.

     */

    inline CAknScrollButton* IncreaseNudgeButton() const;

    /** 

     * Gets handle to the controls that draw arrows in the both ends of spanned

     * scrollbar. These arrows are for pen support to enable exact moving of

     * the scrollbar with pen. The arrow is tapped with the pen to move the

     * scrollbar with one step.

     *

     * @return Pointer to the decreace button.

     */

    inline CAknScrollButton* DecreaseNudgeButton() const;

    // This function should only be used by CEikCba

    /** 

     * Sets command button area. This function should only be used by @c 

     * CEikCba.

     * 

     * @param aCba Command button area.

     * @panic EEikPanicScrollBarExtensionNotCreated Extension of 

     *        the scroll bar not created.

     */

    IMPORT_C void SetContainingCba(CEikCba* aCba);

    /** 

     * From @c CCoeControl.

     *

     * Sets this control as visible or invisible.

     * 

     * If @c MakeVisible() is used to make a component visible, and the control

     * captures the pointer (see @c CapturesPointer()), @c MakeVisible() throws

     * away any pending pointer events for that control.

     * 

     * @param aVisible @c ETrue to make the control visible, @c EFalse to make 

     *        it invisible.

     */

    IMPORT_C void MakeVisible(TBool aVisible);

    // 

    /** 

     * From @c CCoeControl

     *

     * Called by the framework to handle pointer events. 

     * 

     * @param aPointerEvent A pointer event.

     */

    IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

    /**

     * Not implemented.

     *

     * @param aType The extension area to use.

     */

    IMPORT_C void SetExtensionAreaType(TScrollBarExtensionAreaType aType);

protected:      

    /** 

     * From @c CCoeControl

     *

     * Gets the specified scrollbar component. Each component control is 

     * identified by an index, where the index depends on the order the 

     * controls were added: the first is given an index of 0, the next an index

     * of 1.

     * 

     * @param aIndex The index of the control to get.

     *

     * @return The component control with an index of aIndex.

     */

    IMPORT_C CCoeControl* ComponentControl(TInt aIndex) const;

    /** 

     * From @cCCoeControl.

     *

     * Gets the number of controls contained in this scrollbar.

     * 

     * @return The number of component controls contained by this scrollbar.

     */

    IMPORT_C TInt CountComponentControls() const;

private: // from MCoeControlObserver

    IMPORT_C virtual void HandleControlEventL(CCoeControl* aControl, 

                                              TCoeEvent aEventType);

private: // virtual - reserved from CCoeControl

    IMPORT_C virtual void Reserved_2();

private:

    /**

    * From CAknControl

    */

    IMPORT_C void* ExtensionInterface( TUid aInterface );

protected:

    /**

     * The scroll bar frame is a control assemblage manager that relates a 

     * control, or control body, to two scroll bars and a corner window. A 

     * corner window is that part of the screen that is common to both the 

     * horizontal, and the vertical elements of a scroll bar.

     *

     * This class helps with access to, and set up of, scroll bars and also

     * with the layout of the scrolled control or control body. A scroll bar

     * frame is not a control, but it does implement the standard control 

     * composite pattern to manage the assemblage.

     */

    friend class CEikScrollBarFrame;

    // enums

    /** 

     * Flags to determine whether there are visible components and whether to

     * dim the increase, or decrease, buttons.

     */

    enum TPrivateScrollBarFlags

        {

        /** There are no visible components in the scroll bar. */

        ENoComponentsToDisplay          =0x10000,

        /** Dim the increase buttons. */

        EIncreaseButtonsDimmed          =0x20000,

        /** Dim the decrease buttons. */

        EDecreaseButtonsDimmed          =0x40000

        };

    /** Determines where on a scroll bar a pointer down event occurred. */

    enum TPointerDownOn

        {

        /** No pointer down event occurred on the scroll bar. */

        ENone,

        /** A pointer down event occurred on the home button. */

        EHomeButton,

        /** A pointer down event occurred on the decrease page button. */

        EDecreasePageButton,

        /** A pointer down event occurred on the decrease nudge button. */

        EDecreaseNudgeButton,

        /** A pointer down event occurred on the decrease shaft button. */

        EDecreaseShaft,

        /** A pointer down event occurred on the scroll bar thumb. */

        EThumb,

        /** A pointer down event occurred on the increase shaft button. */

        EIncreaseShaft,

        /** A pointer down event occurred on the increase nudge button. */

        EIncreaseNudgeButton,

        /** A pointer down event occurred on the increase page button. */

        EIncreasePageButton,

        /** A pointer down event occurred on the end button. */

        EEndButton

        };

    /** Determines whether to redraw the scroll bar shaft. */

    enum TShaftRedrawRequired

        {

        /** Do not redraw the scroll bar shaft. */

        ENoRedrawRequired,

        /** Redraw the scroll bar shaft. */

        ERedrawShaft

        };

    /** Determines which buttons are displayed. */

    enum TWhichButtons

        {

        /** Display the increase buttons only. */

        EIncreaseOnly,

        /** Display the decrease buttons only. */

        EDecreaseOnly,

        /** Display all buttons. */

        EAll

        };

    /** 

     * Encapsulates pointers to the scroll bar buttons. A maximum of three 

     * pairs of buttons are available, you may choose to use only one pair or

     * two pairs.

     */

    struct SEikScrollBarButtons

        {

        /** Pointer to the decrease nudge button. */

        CAknScrollButton* iDecreaseNudge;

        /** Pointer to the increase nudge button. */

        CAknScrollButton* iIncreaseNudge;

        };

private:

    // construction/destruction

    IMPORT_C virtual void CreateButtonL(CAknScrollButton*& aButton,

                                        CAknScrollButton::TType aType);

    void SizeChanged();

    // set state functions

    void DoSetModel(const TEikScrollBarModel* aModel);

    CEikCba* Cba() const;

    // These functions are for use only be CEikScrollBarFrame (a friend class)

    void AddExternalFrameL(CEikScrollBarFrame* aFrame);

    void RemoveExternalFrame(CEikScrollBarFrame* aFrame);

    void DisconnectExternalFrames();

protected:

    /** 

     * Allocates and constructs all the required components of the scrollbar.

     */

    void CreateRequiredComponentsL();

    /** 

     * Destroys a button.

     *

     * @param aButton A button that will be destroyed.

     */

    void DestroyButton(CAknScrollButton*& aButton);

    /** 

     * Not implemented 

     * 

     * @param aButton Not used. 

     */

    IMPORT_C virtual void SetButtonPositionL(CAknScrollButton* aButton);

public:

    /** 

     * Gets the scroll bar type.

     * 

     * @return Value of the enum @c TScrollBarType.

     */

    TScrollBarType ScrollBarType();

public:

    /** Not used, but cannot be removed due binary compatibility issues. */

    TDblQueLink iSBLink;

protected:

    /** Scroll bar buttons struct. */

    SEikScrollBarButtons iButtons;

    /** Scroll bar orientation. */

    TOrientation iOrientation;

private:

    TEikScrollBarModel iModel;

protected:    

    /** A pointer to @c CEikScrollBarExtensionImpl class. */

    CEikScrollBarExtensionImpl* iExtension;

  };

/**

 * The CEikArrowHeadScrollBar class is a scroll bar which uses only

 * two small nudge button arrows to scroll up and down. It has no shaft.

 * It therefore takes up very little space.

 *

 * @since ER5U 

 * @ internal

 * Internal to Symbian

 *

 */

class CEikArrowHeadScrollBar : public CEikScrollBar

	{

public:

	IMPORT_C CEikArrowHeadScrollBar(CCoeControl* aParentWindow);

	IMPORT_C ~CEikArrowHeadScrollBar();

public: // from CEikScrollBar

	IMPORT_C void ConstructL(MEikScrollBarObserver* aScrollBarObserver,const CCoeControl* aParent,

				TOrientation aOrientation,TInt aLength,TInt aScrollBarFlags=EEikScrollBarDefaultBehaviour);

public: // From CCoeControl

    IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);	

private: // from CEikScrollBar

	void CreateButtonL(CAknScrollButton*& aButton,CAknScrollButton::TType aType);

	void SetButtonPositionL(CAknScrollButton* aButton);

private:

private:

    /**

    * From CAknControl

    */

    IMPORT_C void* ExtensionInterface( TUid aInterface );

private:

	CCoeControl* iParentControl;

    TInt iSpare;

	};

/**

 * The CAknDoubleSpanScrollBar class is a scroll bar without buttons, 

 * but it has a shaft. Additionally it has in its shaft a double 

 * span feature which means that there can be another thumb inside the thumb 

 * if needed.

 *

 * This class uses TAknDoubleSpanScrollBarModel instead of TEikScrollBarModel