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