/*

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

#define __EIKSBFRM_H__

#include <lafpublc.h>

#if !defined(__AKNSCRLB_H__)

#include <aknscrlb.h>

#endif

class CEikCba;

/**

 * Enables setting of the frame layout for a scroll bar.

 */

class TEikScrollBarFrameLayout

    {

public:

    /** 

     * Determines whether the client rectangle or the inclusive rectangle

     * remains constant.

     */

    enum TTilingMode

        {

        /** The client rectangle remains constant. */

        EClientRectConstant,

        /** The inclusive rectangle remains constant. */

        EInclusiveRectConstant

        };

public:

    /**

     * C++ default constructor.

     */

    IMPORT_C TEikScrollBarFrameLayout();

    /**

     * Sets all inclusive margins.

     *

     * @param aMargin The value to use for all inclusive margins.

     */

    IMPORT_C void SetInclusiveMargin(TInt aMargin);

    /**

     * Sets all client margins. These surround the client rectangle which is

     * the client area viewport onto the larger canvas to be scrolled.

     *

     * @param aMargin The value to use for all client margins.

     */

    IMPORT_C void SetClientMargin(TInt aMargin);

public:

    /** The inclusive margin (in twips or pixels). */

    TMargins iInclusiveMargin;

    /** 

     * The amount of screen movement performed when the nudge button is 

     * pressed.

     */

    TMargins iClientMargin;

    /** 

     * The amount of screen movement performed when the nudge button is

     * pressed.

     */

    TSize iClientAreaGranularity;

    /** 

     * Determines whether the client rectangle, or the inclusive rectangle,

     * remains constant.

     */

    TTilingMode iTilingMode;

    };

class CEikCornerWindow;

class CEikScrollBarFrameExtension;

/**

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

 */

class CEikScrollBarFrame : public CBase

    {

public:	// enums 

    DECLARE_TYPE_ID(0x101F8672)   

    /** Defines the scroll bar’s visibility.*/

    enum TScrollBarVisibility

        {

        /** Scroll bar not visible.*/

        EOff,

        /** Scroll bar visible.*/

        EOn,

        /** Scroll bar visible if required.*/

        EAuto

        };

    /** Defines the type of scroll bar.*/	

    enum TScrollBarType

        {

        /** Scroll bar complete with shaft. Not used.*/

        ENormalScrollBar =0x0,

        /** Floating arrow head scroll bar, without shaft. Legacy type. */

        EArrowHead =0x200,

        /** Spanned scroll bar. */

        EDoubleSpan =0x400

        };

    /** Defines where the scroll bar is located. */		

    enum TScrollBarSide

        {

        /** 

         * Scroll bar located at the bottom, or to the right of the scroll bar

         * frame.

         */

        EBottomOrRight =0x0,

        /** 

         * Scroll bar located at the top, or to the left of the scroll bar

         * frame.

         */

        ETopOrLeft =0x800

        };

    /** Determines how the scroll bar frame manages scroll bars.*/

    enum TScrollBarManagement 

        {

        /** 

         * The scroll bar frame creates, destroys and recreates, scroll bars

         * according to the visibility mode. The scroll bar frame also acts as

         * an intermediary with its owning control so that the scroll bars can

         * be treated as component controls.

         */

        EComponent                  ,//=SLafScrollBarFrame::EComponent,

        /** 

         * The scroll bar frame creates, destroys and recreates, scroll bars 

         * according to the visibility mode. In this case, the scroll bars are

         * not treated as component controls. Instead, the scroll bars are 

         * geometry managed in windows floating above the control window and

         * their position is determined in relation to the frame’s position on

         * the screen.

         */

        EFloating                   ,//=SLafScrollBarFrame::EFloating,

        /** 

         * The scroll bar frame uses the central application scroll bar as held

         * in the environment. This scroll bar is neither owned by the frame 

         * nor treated as a component control of the frame’s owner.

         */

        EApplicationScrollBar       //=SLafScrollBarFrame::EApplicationScrollBar

        };

    /**

     * Defines that is the horizontal or the vertical (spanned) scroll bar

     * visible. Applicaple  only for spanned scroll bars.

     */

    enum TScrollBarFrameFlags

        {

        /** Horizontal spanned scroll bar visible. */

        EHVisible           =0x01,

        /** Vertical spanned scroll bar visible. */

        EVVisible           =0x02,

        /** 

         * Enables nudge buttons in touch devices. This flag MUST

         * be set before the creation of the doublespan scrollbar.

         */

        EEnableNudgeButtons = 0x04,

        /** 

         * Disables expanded touch area, which is on by default

         * in touch devices. This flag MUST be set before the

         * creation of the doublespan scrollbar.

         */

        EDisableExpandedTouchArea = 0x08      

        };

private:

    enum TMarginsAdjustmentMode

        {

        EGrow,

        EShrink

        };

public:	// specific

    /**

     * C++ default constructor.

     */

    CEikScrollBarFrame(){}

    /**

     * Constructor. Constructs a scroll bar frame object.

     *

     * @param aParentWindow The scroll bar’s parent control.

     * @param aObserver The scroll bar observer.

     * @param aPreAlloc Not used.

     */  	

    IMPORT_C CEikScrollBarFrame(CCoeControl* aParentWindow, 

                                MEikScrollBarObserver* aObserver, 

                                TBool aPreAlloc=EFalse);

    /**

     * Destructor.

     */  

    IMPORT_C ~CEikScrollBarFrame();

    /**

     * Constructor. Internal only to Eikcoctl.lib use. Parameter @c aDoubleSpan

     * offers possibility to optimize scroll bar loading (if @c ETrue,

     * arrowhead scroll bar will never be loaded).

     *

     * @since S60 3.0

     * @param aParentWindow The scroll bar’s parent control.

     * @param aObserver The scroll bar observer.

     * @param aPreAlloc Not used.

     * @param aDoubleSpan If @c ETrue, spanned scroll bar is created.

     */     

    CEikScrollBarFrame(CCoeControl* aParentWindow, 

                       MEikScrollBarObserver* aObserver, 

                       TBool aPreAlloc, 

                       TBool aDoubleSpan);

    /**

     * Initializes a new @c CEikScrollBarFrameExtension object.

     *

     * @since S60 3.0

     * @param aParentWindow The scroll bar’s parent control.

     * @param aObserver The scroll bar observer.

     */

    void InitExtension(CCoeControl* aParentWindow, 

                       MEikScrollBarObserver* aObserver);

    /**

     * Forces any scroll bars and the corner window if it is visible to be 

     * redrawn.

     */     

    IMPORT_C void DrawScrollBarsNow() const;

	/**

     * Tell scroll bars and the corner window to redraw if it is visible

     */     

    void DrawScrollBarsDeferred() const;

    /**

     * Sets the visibility state for both the horizontal and the vertical scroll

     * bars. This is used when tiling.

     *

     * @param aHVisibility Horizontal scroll bar visibility.

     * @param aVVisibility Vertical scroll bar visibility.

     */     

    IMPORT_C void SetScrollBarVisibilityL(TScrollBarVisibility aHVisibility, 

                                          TScrollBarVisibility aVVisibility);

    /**

     * Determines the vertical scroll bar’s visibility. @c 

     * CEikScrollBarFrame::ScrollBarVisibility @c 

     * (CEikScrollBar::TOrientation aOrientation) can be used instead of this

     * method.

     * 

     * @return Visibility for vertical scroll bar.

     */     

    inline TScrollBarVisibility VScrollBarVisibility() const;

    /**

     * Sets scrollbar observers.

     *

     * @param aObserver The scroll bar observer. 

     */     

    IMPORT_C void SetScrollBarFrameObserver(MEikScrollBarObserver* aObserver);

    // Model setting. 

    /**

     * Sets the vertical scrollbar mode. Does not actually draw anything until 

     * the thumb or focus setting functions are called.

     *

     * @param aVModel Model for the vertical scrollbar.

     * @return @c EFalse.

     */     

    IMPORT_C TBool Tile(TEikScrollBarModel* aVModel);

    /**

     * Tiles the client area and the scroll bars managed by the frame. The 

     * scroll bars are set up according to the scroll bar models; @c aHModel and

     * @c aVModel. Ownership is not transferred as a result of passing these

     * parameters as pointers. The result of tiling geometry management is 

     * observable through the two rectangles @c aClientRect and @c 

     * aInclusiveRect. Depending on the tiling layout @c aLayout and the scroll 

     * bar visibility settings, either of these rectangles can be made constant

     * and the other rectangle adjusted accordingly.

     *

     * For @c EArrowhead type scrollbar the layout is always fixed, it cannot be

     * altered by using this method.

     *

     * For @c EDoublespan type scrollbar the layout can be set also with two 

     * helper methods from the @c AknLayoutUtils class:

     *

     * @code

     * AknLayoutUtils::LayoutVerticalScrollBar(

     *           CEikScrollBarFrame* aScrollBarFrame, 

     *           const TRect& aControlParent, 

     *           const TAknWindowLineLayout& aLayout);

     * AknLayoutUtils::LayoutHorizontalScrollBar(

     *           CEikScrollBarFrame* aScrollBarFrame, 

     *           const TRect& aControlParent, 

     *           const TAknWindowLineLayout& aLayout);

     * @endcode

     *   

     * @param aHModel Horizontal scroll bar model.

     * @param aVModel Vertical scroll bar model.

     * @param aClientRect Client rectangle.

     * @param aInclusiveRect A rectangle that includes the area to be scrolled 

     *        and the scroll bars themselves.

     * @param aLayout Tiling layout.

     * 

     * @return @c ETrue if the non-constant rectangle is adjusted, otherwise @c 

     *         EFalse.

     */     

    IMPORT_C TBool TileL(TEikScrollBarModel* aHModel, 

                         TEikScrollBarModel* aVModel,

                         TRect& aClientRect,

                         TRect& aInclusiveRect,

                         const TEikScrollBarFrameLayout& aLayout);

    /**

     * Moves the scroll bar thumbs by the specified amounts. This updates the 

     * scroll bars after an external scroll. The values of the parameters should

     * be supplied in terms of the horizontal and vertical scrolling models 

     * respectively. The scrolling models are presumed not to have changed 

     * spans.

     *

     * @param aDeltaX The amount to move the horizontal scroll bar.

     * @param aDeltaY The amount to move the vertical scroll bar.

     */     

    IMPORT_C void MoveThumbsBy(TInt aDeltaX, TInt aDeltaY);

    /**

     * Moves the horizontal scroll bar thumb to the position @c aHorizThumbPos.

     * This function is used to update the scroll bar after an external scroll.

     * The value of @c aThumbPos should be supplied in terms of the scrolling

     * model, which is presumed not to have changed spans.

     * 

     * @param aHorizThumbPos The required thumb position.

     */     

    IMPORT_C void MoveHorizThumbTo(TInt aHorizThumbPos);

    /**

     * Moves the vertical scroll bar thumb to the position @c aVertThumbPos. 

     * This function is used to update the scroll bar after an external scroll.

     * The value of aThumbPos should be supplied in terms of the scrolling 

     * model, which is presumed not to have changed spans.

     * 

     * @param aVertThumbPos The required thumb position.

     */     

    IMPORT_C void MoveVertThumbTo(TInt aVertThumbPos);

    /**

     * Moves the vertical scroll bar thumb to the position @c aFocusPosition. 

     * This function is used to update the scroll bar after an external scroll. 

     * The value of @c aFocusPosition should be supplied in terms of the 

     * scrolling model, which is presumed not to have changed spans.

     * 

     * @param aFocusPosition The required thumb position.

     */     

    IMPORT_C void SetVFocusPosToThumbPos(TInt aFocusPosition);

    /**

     * Returns the breadth of the scroll bar idenitified by @c aOrientation, or

     * zero if none exists.

     *

     * @param  aOrientation The orientation of the scroll bar for which you wish

     *         to obtain the breadth.

     *

     * @return The specified scroll bar's breadth. This is zero if none exists.

     */     

    IMPORT_C TInt ScrollBarBreadth(

        CEikScrollBar::TOrientation aOrientation) const;

    // scroll bar frame behavior functions

    /**

     * Not implemented.

     *

     * @param aAdjusts Not used. 

     */     

    IMPORT_C void SetAdjustsHorizontalModel(TBool aAdjusts); 

    /**

     * Not implemented.

     *

     * @param aAdjusts Not used. 

     */      

    IMPORT_C void SetAdjustsVerticalModel(TBool aAdjusts);

    /**

     * Sets scrollbar frame flags. 

     *

     * @param aMask Bitmask of the bits that are to be set.

     */     

    inline void SetScrollBarFrameFlags(TInt aMask);

    /**

     * Determines whether the scroll bar specified by aOrientation exists

     * 

     * @param aOrientation The scroll bar’s orientation.

     * @return @c ETrue if the specified scroll bar exists otherwise @c EFalse.

     */     

    IMPORT_C TBool ScrollBarExists(

        CEikScrollBar::TOrientation aOrientation) const;

    /**

     * From @c CCoeControl

     *

     * Gets the number of controls contained in a compound control.

     * 

     * @return The number of component controls contained in this control.

     */     

    IMPORT_C TInt CountComponentControls() const;

    /**

     * From @c CCoeControl

     *

     * Gets the component specified by index. Within a compound control, 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, and so on.

     * 

     * @return The component control with an index of aIndex

     */         

    IMPORT_C CCoeControl* ComponentControl(TInt aIndex) const;

    /**

     * Returns a pointer to the scroll bar identified by orientation @c 

     * aOrientation.

     * 

     * @param aOrientation The orientation of the scroll bar for which you wish

     *        to obtain a pointer.

     * @return A pointer to the scroll bar with orientation @c aOrientation if 

     *         the scrollbar is visible.

     */         

    IMPORT_C CEikScrollBar* GetScrollBarHandle(

        CEikScrollBar::TOrientation aOrientation) const;

    /**

     * Returns a pointer to the vertical scroll bar.

     * 

     * @return A pointer to the vertical scroll bar.

     */         

    IMPORT_C CEikScrollBar* VerticalScrollBar() const;

    /**

     * Sets the type of horizontal scroll bar. Possible values are @c EArrowHead

     * and @c EDoubleSpan.

     *

     * @param aType Type of the scrollbar. 

     */         

    IMPORT_C void SetTypeOfHScrollBar(TScrollBarType aType);

    /**

     * Sets the type of vertical scroll bar. Possible values are @c EArrowHead

     * and @c EDoubleSpan.

     *

     * @param aType Type of the scrollbar. 

     */         

    IMPORT_C void SetTypeOfVScrollBar(TScrollBarType aType);

    /**

     * Returns the control type of the horizontal scroll bar 

     * 

     * @return Type of the scrollbar.

     */         

    IMPORT_C TScrollBarType TypeOfHScrollBar() const;

    /**

     * Returns the control type of the vertical scroll bar 

     * 

     * @return Type of the scrollbar.

     */         

    IMPORT_C TScrollBarType TypeOfVScrollBar() const;

    /**

     * Checks if the vertical scrollbar type is @c EArrowHead.

     *

     * @param aFlag Not used.

     * @return @c ETrue if the type of the scrollbar is @c EArrowHead.

     */         

    IMPORT_C TBool IsArrowHeadScrollBar(TInt aFlag) const;

    // application scroll bar utilities

    /**

     * This method is used only internally by the @c CEikScrollBar. Disconnects

     * externally connected scrollbar.

     * 

     * @param aScrollBar Scrollbar to be disconnected.

     */     

    void DisconnectExternalScrollBar(CEikScrollBar* aScrollBar);

    /**

     * This method creates double span type scrollbars into this frame. Old

     * scrollbars are deleted or disconnected.

     *

     * @since S60 2.6

     * @param aWindowOwning Tells wheter created scrollbar should be 

     *        a window owning control or not. Selection for this is 

     *        relevant especially because skinned scrollbar draws            

     * @param aRemote @c True if this method should instead of creating own 

     *        scrollbar try to connect to a remote scrollbar frame and 

     *        start using its scrollbars. Connecting is done using 

     *        through object provider mechanism, so the object supply 

     *        chain must be valid. Also if true, then parameter @c 

     *        aWindowOwning will be ignored.

     *

     * Example of use:

     *

     * @code

     *    iSBFrame=new(ELeave) CEikScrollBarFrame(this, NULL, ETrue);

     *    iSBFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,

     *                                      CEikScrollBarFrame::EAuto);

     *    iSBFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse);

     *

     *    Note that double span scrollbar types requires different model classes

     *    to be used in places of @c TEikScrollBarModel of this scrollbar frame 

     *    API:s other method calls.

     *    

     *    Scrollbar type        Required model (in places of TEikScrollBarModel)

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

     *    EDoubleSpan           TAknDoubleSpanScrollBarModel 

     *    EArrowHead            TEikScrollBarModel

     *

     *   // model for double span type scrollbar

     *   TAknDoubleSpanScrollBarModel vModel; 

     *   // model for double span type scrollbar

     *   TAknDoubleSpanScrollBarModel hModel; 

     *   

     *   iSBFrame->Tile(vModel, iVRect);

     * @endcode

     */ 

    IMPORT_C void CreateDoubleSpanScrollBarsL(TBool aWindowOwning, 

                                              TBool aRemote);

    /**

     * This method creates double span type scrollbars into this frame. Old 

     * scrollbars are deleted or disconnected.

     *

     * @since S60 2.8

     * @param aWindowOwning Tells wheter created scrollbar should be a window 

     *        owning control or not. Selection for this is relevant especially

     *        because skinned scrollbar draws its background using its parent 

     *        windows background context.                   

     * @param aRemote True if this method should instead of creating own

     *        scrollbar try to connect to a remote scrollbar frame and start

     *        using its scrollbars. Connecting is done using through object 

     *        provider mechanism, so the object supply chain must be valid. Also

     *        if true, then parameter @c aWindowOwning will be ignored.

     * @param aVertical If @c ETrue vertical scrollbar will be created to 

     *        scrollbar frame.

     * @param aHorizontal If @c ETrue horizontal scrollbar will be created to

     *        scrollbar frame.

     * @leave KErrNotFound Parent object doesn't have scrollbar frame.

     */ 

    IMPORT_C void CreateDoubleSpanScrollBarsL(TBool aWindowOwning, 

                                              TBool aRemote, 

                                              TBool aVertical, 

                                              TBool aHorizontal);

    /**

     * Tiles the vertical @c EDouble span type scroll bar managed by the frame.

     * The scroll bar is set up according to the scroll bar model and given 

     * rectangle which is relative to the parent window of the frame.

     *

     * @since S60 2.6

     * @param aVModel Vertical scrollbar model.         

     * @param aVScrollBar Vertical scrollbar rectangle.            

     *

     * For @c EDoublespan type scrollbar the layout can be set also with a 

     * helper method from the @c AknLayoutUtils class:

     *

     * @code

     * AknLayoutUtils::LayoutVerticalScrollBar(

     *                                   CEikScrollBarFrame* aScrollBarFrame, 

     *                                   const TRect& aControlParent, 

     *                                   const TAknWindowLineLayout& aLayout);

     * @endcode

     */     

    IMPORT_C void Tile(TEikScrollBarModel* aVModel, TRect& aVScrollBar);

    /**

     * Sets the models of the scrollbars. 

     * 

     * @since S60 2.6

     * @param aHModel The model of the horizontal scrollbar.

     * @param aVModel The model of the vertical scrollbar.

     *

     */     

    IMPORT_C void Tile(TEikScrollBarModel* aHModel,

                       TEikScrollBarModel* aVModel);

    /**

     * Gets the visibility of given scrollbar orientation. 

     * 

     * This method should be used instead of a deprecated method @c

     * CEikScrollBarFrame::HScrollBarVisibility() and

     * also can be used instead of @c CEikScrollBarFrame::VScrollBarVisibility()

     *

     * @since S60 2.6

     * @param aOrientation The orientation of a scrollbar in the frame.

     * @return The visibility of requested scrollbar.

     */     

    IMPORT_C TScrollBarVisibility ScrollBarVisibility(

            CEikScrollBar::TOrientation aOrientation) const;

	/**

    * Sets the background drawing for the double spanned scrollbars 

    * 

    * This method can be used to enable or disable the drawing of the scrollbar 

    * background via mop chain.

    *

    * @since    3.0

    * @param    aDrawHorizontal sets the state of the background drawing of 

    * 			the horizontal scrollbar.

    * @param    aDrawVertical sets the state of the background drawing of 

    * 			the vertical scrollbar.

    * @return   Success of the call, KErrNotSupported if the scrollbars 

    * 			are not doublespan scrollbars.

    *

    */

	IMPORT_C TInt DrawBackground(TBool aDrawHorizontal, TBool aDrawVertical);

	/**

    * Gets the state of the background drawing for the double spanned scrollbars.

    * 

    * This method can be used to get the state of drawing of the scrollbar 

    * background via mop chain.

    *

    * @since    3.0

    * @param    aDrawHorizontal gets the state of the background drawing of 

    * 			the horizontal scrollbar.

    * @param    aDrawVertical gets the state of the background drawing of 

    * 			the vertical scrollbar.

    * @return   Success of the call, KErrNotSupported if the scrollbars 

    * 			are not doublespan scrollbars.

    *

    */

	IMPORT_C TInt DrawBackgroundState(TBool& aDrawHorizontal, TBool& aDrawVertical);

public:

    /**

     * Gets a pointer to the horizontal scroll bar.

     * 

     * @return A pointer to the horizontal scroll bar.

     */         

    CEikScrollBar* HorizontalScrollBar() const;

    /**

     * Sets scrollbar observers.

     *

     * @param aObserver The scroll bar observer. 

     */

    MEikScrollBarObserver* ScrollBarFrameObserver();

protected:

    // Accessor methods

    /**

     * Sets parent window.

     * 

     * @param aParentWindow A pointer to the parent window.

     */ 

    void SetParentWindow(CCoeControl* aParentWindow);

    /**

     * Gets a pointer to the parent window.

     *  

     * @return A pointer to the parent window.

     */ 

    CCoeControl* ParentWindow() const;

protected:

    /** Struct */ 

    struct SBarData

        {

        /** Pointer to the @c CAknScrollBar class */

        CAknScrollBar* iBar;

        /** Enum @c TEikScrollBarModel */

        TEikScrollBarModel iModel;

        /** Enum @c TScrollBarVisibility. */

        TScrollBarVisibility iVisibility;

        /** Boolean value if external scroll bar is attached. */

        TBool iExternalScrollBarAttached;

        };

private:

    void CalcTheoreticalScrollBarVisibility(const TEikScrollBarModel* aVModel);

    void ApplyModel(SBarData& aSBar);

    void MakeSBarVisible(SBarData& aSBar, TBool aVisible);

    void GetScrollBars(TBool aDoubleSpan);

    CEikCba* GetCurrentCba();

    void DeleteScrollBars();

    void CreateArrowHeadScrollBarsL();

    void CalcTheoreticalScrollBarVisibility(const TEikScrollBarModel* aVModel,

                                            const TEikScrollBarModel* aHModel);

protected:

    /** Struct object.*/

    SBarData iV;

private:

    CEikScrollBarFrameExtension* iExtension; 

    TInt iScrollBarFrameFlags;

    friend class CEikScrollBarFrameExtension;

    };

inline CEikScrollBarFrame::TScrollBarVisibility CEikScrollBarFrame::VScrollBarVisibility() const

    { return iV.iVisibility; }

inline void CEikScrollBarFrame::SetScrollBarFrameFlags(TInt aMask)

    { iScrollBarFrameFlags|=aMask; }

// Cba scroll bar frame (with it's own scrollbar creation methods)

class CEikCbaScrollBarFrame : public CEikScrollBarFrame

    {

public:

    CEikCbaScrollBarFrame(CCoeControl* aParentWindow, MEikScrollBarObserver* aObserver, TBool aPreAlloc=EFalse);

    void ConstructL();

    void SwitchToArrowHeadScrollBarL();  // @since 3.0

    };

#endif