diff -r 000000000000 -r 2f259fa3e83a classicui_pub/scroller_api/inc/EIKSCRLB.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/classicui_pub/scroller_api/inc/EIKSCRLB.H Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,1123 @@ +/* +* 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 +#endif + +#if !defined(__EIKSBOBS_H__) +#include +#endif + +#if !defined(__AKNSCBUT_H__) +#include +#endif + +#include + +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 + * as its internal scrollbar model. TAknDoubleSpanScrollBarModel in binary + * compatible with TEikScrollBarModel. User must take care that TAknDoubleSpanScrollBarModel + * is really used in API calls in places where TEikScrollBarModel is declared. + * + * @since 2.6 + * + */ +class CAknDoubleSpanScrollBar : public CEikScrollBar + { +public: + IMPORT_C CAknDoubleSpanScrollBar(CCoeControl* aParentWindow); + IMPORT_C ~CAknDoubleSpanScrollBar(); + + /** + * Sets fixed layout to scrollbar. If set, then scrollbar size + * changes done by the CEikScrollBarFrame class are disabled. + * + * @since 2.6 + * @param aScrollBarRect Scrollbar rectangle. + * + */ + IMPORT_C void SetFixedLayoutRect(TRect aScrollBarRect); + + /** + * Method for constructing the object. + * + * @since 2.6 + * @param aWindowOwning True if scrollbar is to be a window owning control. + * @param aScrollBarObserver Same as in CEikScrollBar::ConstructL() + * @param aParent Same as in CEikScrollBar::ConstructL() + * @param aOrientation Same as in CEikScrollBar::ConstructL() + * @param aLength Same as in CEikScrollBar::ConstructL() + * @param aScrollBarFlags Same as in CEikScrollBar::ConstructL() + * + */ + IMPORT_C void ConstructL(TBool aWindowOwning, MEikScrollBarObserver* aScrollBarObserver,const CCoeControl* aParent, + TOrientation aOrientation,TInt aLength,TInt aScrollBarFlags=EEikScrollBarDefaultBehaviour); + + /** + * Sets scroll popup info text to be shown while dragging with stylus. + * Popup is shown until next pointer up event. + * KNullDesC parameter can be used to hide popup earlier. + * + * @since 3.2 + * @param aText Text to be shown + * + */ + IMPORT_C void SetScrollPopupInfoTextL( const TDesC& aText ); + + /** + * Gets the fixed layoutrect of the scrollbar. + * @since 2.6 + * @return Scrollbar rectangle. + * + */ + TRect FixedLayoutRect(); + +public: // from CEikScrollBar + IMPORT_C void ConstructL(MEikScrollBarObserver* aScrollBarObserver,const CCoeControl* aParent, + TOrientation aOrientation,TInt aLength,TInt aScrollBarFlags=EEikScrollBarDefaultBehaviour); + IMPORT_C void MakeVisible(TBool aVisible); + +public: // from CCoeControl + IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); + +protected: // from CCoeControl + IMPORT_C CCoeControl* ComponentControl(TInt aIndex) const; + IMPORT_C TInt CountComponentControls() const; + +private: // from CCoeControl + IMPORT_C void SizeChanged(); + +public: + + TBool DrawBackgroundState(); + + void DrawBackground(TBool aDrawHorizontal); + + /** + * Resets pressed down highlight so that default highlight is used when + * the scrollbar is drawn. + * + * @since S60 5.2 + */ + void ResetPressedDownHighlight(); + +private: + /** + * From CAknControl + */ + IMPORT_C void* ExtensionInterface( TUid aInterface ); +private: // from CEikScrollBar + void CreateButtonL(CAknScrollButton*& aButton,CAknScrollButton::TType aType); + void SetButtonPositionL(CAknScrollButton* aButton); + + /** + * Sets scrollbar background transparency as given in the parameter. + * + * @param aTransparentBackground If ETrue then scrollbar will have transparent background. + * @since 2.6 + * + */ + void SetTransparentBackground(TBool aTransparentBackground); + + /** + * Calculates scrollbar's extension area relative to its own position. + */ + TRect ExtensionArea() const; +private: + CCoeControl* iParentControl; + TInt iSpare; + }; + + +// +// Inlines +// + + +inline const TEikScrollBarModel* CEikScrollBar::Model() const + { return &iModel; } + +inline CAknScrollButton* CEikScrollBar::IncreaseNudgeButton() const + { return iButtons.iIncreaseNudge; } + +inline CAknScrollButton* CEikScrollBar::DecreaseNudgeButton() const + { return iButtons.iDecreaseNudge; } + + +#endif