FCL/sf/mw/classicui: comparison classicui_pub/lists

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
+/*
+* Copyright (c) 1997-2009 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(__EIKLBV_H__)
+#define __EIKLBV_H__
+#if !defined(__E32BASE_H__)
+#include <e32base.h>
+#endif
+#if !defined(__GDI_H__)
+#include <gdi.h>
+#endif
+class CListItemDrawer;
+class MListBoxModel;
+class CWindowGc;
+class RWindowGroup;
+class CWsScreenDevice;
+class CWindowGc;
+class RWindow;
+class CListBoxViewExtension;
+class CEikListBox;
+//
+// class MListVisibiltyObserver
+//
+class MListVisibilityObserver
+	{
+public:
+	virtual TBool IsVisible() const = 0;
+	};
+/**
+* List box view.
+*
+* A list box view displays the list items which are currently visible in
+* a list box. List box views draw each of the items for display using
+* methods defined in their associated list box drawer.
+*
+* Together with its list item drawer, a @c CListBoxView encapsulates the
+* on-screen appearance of data in a list box.
+*
+* List box views also encapsulate item selection, the current item, and the
+* fundamentals of how the selection and the current item are updated according
+* to user input. Input events themselves are handled by @c CEikListBox,
+* which calls member functions of @c CListBoxView appropriately.
+*
+* This class is sufficient for plain list box views, and may be derived from
+* in order to provide more complex list views. @c TechView supplies and uses
+* the classes @c CHierarchicalListBoxView and @c CSnakingListBoxView, which
+* provide two kinds of indented list views.
+*/
+class CListBoxView : public CBase
+	{
+public:
+/**
+* Cursor movement flags. These describe the cursor movements recognised by
+* @c MoveCursorL().
+*/
+enum TCursorMovement
+		{
+/** Cursors movement to next item. */
+ECursorNextItem,
+/** Cursors movement to previous item. */
+ECursorPreviousItem,
+/** Cursors movement to next column. */
+ECursorNextColumn,
+/** Cursors movement to previous column. */
+ECursorPreviousColumn,
+/** Cursors movement to previous page. */
+ECursorPreviousPage,
+/** Cursors movement to next page. */
+ECursorNextPage,
+/** Cursors movement to the first item. */
+ECursorFirstItem,
+/** Cursors movement to the last item. */
+ECursorLastItem,
+/** Cursors movement to the next screen. */
+ECursorNextScreen,
+/** Cursors movement to the previous screen. */
+ECursorPrevScreen
+};
+/**
+* List box view flags.
+*
+* These flags may be combined with a logical OR to get a combination of
+* effects.
+*/
+	enum TFlags
+		{
+/** A selection anchor exists. */
+		EAnchorExists   = 0x0001,
+/** The view is emphasised. */
+		EEmphasized     = 0x0002,
+/** The view is dimmed. */
+		EDimmed         = 0x0004,
+/** List box view has a cursor for incremental matching. */
+		EHasMatcherCursor = 0x0008,
+/** Redraw is disabled. */
+		EDisableRedraw  = 0x0010,
+/** If set, selected items are painted. */
+		EPaintedSelection = 0x0020,
+/** Item marking enabled. */
+		EMarkSelection  = 0x0040,
+/** Item unmarking enabled. */
+		EUnmarkSelection = 0x0080,
+/** Item count changes enabled. */
+		EItemCountModified = 0x0100,
+/** Vertical offset has changed. */
+		EOffsetChanged = 0x0200,
+		};
+/**
+* Modes for modifying the selection.
+*
+* Changing the current item of a list box view may also affect which items
+* are selected. The selection mode of such an action describes how (or if)
+* the selection is altered by the action.
+*
+* Each function of @c CListBoxView which affects the current item is
+* passed an appropriate selection mode by the calling input handler method
+* of @c CEikListBox. The mode is varied according to the keyboard
+* modifiers held down by the user, or whether a pointer action was a tap
+* or a sweep.
+*
+* Note that the behaviour of list box views may vary with the target
+* phone due to the wide range of possible input devices.
+* The following description assumes a phone with a pointer and a keyboard.
+*/
+enum TSelectionMode
+{
+/**
+* The selection is not changed by actions while this is in effect,
+* holding CTRL while pressing cursor up or down for example.
+*/
+ENoSelection,
+/**
+* Only a single item in the list is allowed to be selected by an
+* action; when selecting individual items with the pointer, or
+* moving using the cursor keys without any modifiers for example.
+*/
+ESingleSelection,
+/**
+* A single continuous run of items can be added to the selection array
+* by an action, when keyboard-selecting with the shift key held down,
+* or when sweeping a selection with the pointer for example.
+*/
+EContiguousSelection,
+/**
+* Any single item in the list may be added to the selection by an
+* action, when selecting or drag-selecting with the pointer when the
+* @c CTRL key is held down for example.
+*/
+EDisjointSelection,
+/**
+* Any single item in the list may be removed from the selection by an
+* action, when unselecting for example.
+*/
+EDisjointMarkSelection,
+/**
+* Multiple items can be added to the selection array by an action,
+* when selecting with the edit key for example.
+*/
+EPenMultiselection,
+/**
+* Mark mode is changed to @c EUnmarkSelection if item is marked or
+* @c EMarkSelection if item is not marked by an action, when selecting
+* or unselecting item for example.
+*/
+EChangeMarkMode
+};
+/** The items which are selected within a list box list. */
+	typedef CArrayFix<TInt> CSelectionIndexArray;
+public:
+/**
+* Destructor.
+*/
+	IMPORT_C ~CListBoxView();
+/**
+* C++ default constructor.
+*
+* Allocates an area of memory for a @c CListBoxView, and begins its
+* initialisation.
+*/
+IMPORT_C CListBoxView();
+/**
+* By default Symbian 2nd phase constructor is private.
+*
+* This function completes the initialisation of a default-constructed list
+* box view. The item drawer’s graphics context is created on @c aScreen,
+* and the list item drawer’s graphics context is set to this. See
+* @c CListItemDrawer::SetGc().
+*
+* @param aListBoxModel The list box model to use.
+* @param aItemDrawer A default-constructed item drawer.
+* @param aScreen Screen on which to display.
+* @param aGroupWin This list box view’s window group.
+* @param aWsWindow Window for this view.
+* @param aDisplayArea The viewing rectangle this list box view is to use.
+* @param aItemHeight Height of a single list item.
+*/
+IMPORT_C virtual void ConstructL(MListBoxModel* aListBoxModel,
+CListItemDrawer* aItemDrawer,
+CWsScreenDevice* aScreen,
+RWindowGroup* aGroupWin,
+RWindow* aWsWindow,
+const TRect& aDisplayArea,
+TInt aItemHeight);
+// functions for accessing the view rect (the area of the host window in
+// which the items are drawn)
+/**
+* Gets the list box’s view rectangle.
+*
+* @return This list box’s view rectangle.
+*/
+IMPORT_C TRect ViewRect() const;
+/**
+* Sets the area within the list window in which the view can draw itself.
+*
+* @param aRect New view rectangle.
+*/
+	IMPORT_C void SetViewRect(const TRect& aRect);
+	// misc. access functions for the main attributes
+/**
+* Gets the current item’s index.
+*
+* @return Index number of the current item.
+*/
+	IMPORT_C virtual TInt CurrentItemIndex() const;
+/**
+* Set the index of the current item. This function changes the current
+* item, but does not redraw the list view or update the selection.
+*
+* @param aItemIndex Which item to make current.
+* @panic EEikPanicListBoxInvalidCurrentItemIndexSpecified Panics if the
+*        given index is not valid.
+*/
+	IMPORT_C void SetCurrentItemIndex(TInt aItemIndex);
+/**
+* Gets the index of the item at the top of the view.
+*
+* @return The item currently displayed at the top of this list box view.
+*/
+	IMPORT_C TInt TopItemIndex() const;
+/**
+* Sets the item at the top of the view by its index in the list of all
+* items. This function also invokes @c CalcBottomItemIndex().
+*
+* @param aItemIndex Index of the item to start the view at.
+* @panic EEikPanicListBoxInvalidTopItemIndexSpecified Panics if the given
+*        index is not valid.
+*/
+	IMPORT_C virtual void SetTopItemIndex(TInt aItemIndex);
+/**
+* Gets the index of the item at the bottom of this view.
+*
+* @return Index of the item at the bottom of this view.
+*/
+	IMPORT_C TInt BottomItemIndex() const;
+/**
+* Recalculates the index of the bottom item in the list by using the top
+* item index and the size of the display.
+*
+* This function is called by the owning list box control when either the
+* size of the list box or the number of items in its model changes.
+*/
+	IMPORT_C virtual void CalcBottomItemIndex();
+/**
+* Sets the item height.
+*
+* @param aItemHeight New item height.
+*/
+	IMPORT_C virtual void SetItemHeight(TInt aItemHeight);
+	// functions that support incremental matching
+/**
+* Sets the match cursor’s colour.
+*
+* @deprecated
+* @param aColor Colour in which to display the incremental match cursor.
+*/
+	IMPORT_C void SetMatcherCursorColor(TRgb aColor);
+/**
+* Sets the match cursor's position.
+*
+* @deprecated
+* @param aPosWithinCurrentItem Character position for the match cursor
+*        within the current item’s string.
+*/
+	IMPORT_C void SetMatcherCursorPos(TInt aPosWithinCurrentItem);
+/**
+* Gets the match cursor’s position.
+*
+* @deprecated
+* @return Character position of the match cursor within the current
+*         item’s string.
+*/
+	IMPORT_C TInt MatcherCursorPos() const;
+/**
+* Draws the match cursor in its current screen position if the matcher
+* cursor flag has been set.
+*
+* This is deprecated and broken and should not be used.
+*
+* @deprecated
+*/
+	IMPORT_C virtual void DrawMatcherCursor();
+/**
+* Hides the matcher cursor.
+*
+* @deprecated
+*/
+	IMPORT_C void HideMatcherCursor();
+/**
+* Sets whether the matcher cursor flag to specify whether the match
+* cursor is drawn.
+*
+* @deprecated
+* @param aMatcherCursor If @c ETrue, the view will draw match cursor.
+*/
+	IMPORT_C void SetMatcherCursor(TBool aMatcherCursor);
+/**
+* Sets whether or not items are drawn as emphasised.
+*
+* The function sets or resets the emphasised flag.
+*
+* @param aEmphasized If @c ETrue, this view will draw items emphasised.
+*        If @c EFalse will not draw items emphasised.
+*/
+	IMPORT_C void SetEmphasized(TBool aEmphasized);
+/**
+* Sets whether items will be drawn dimmed.
+*
+* The function sets or resets the dim flag.
+*
+* @param aDimmed If @c ETrue, this view will draw items dimmed.
+*        If @c EFalse this view will not draw items dimmed.
+*/
+	IMPORT_C void SetDimmed(TBool aDimmed);
+/**
+* Disables or enables redraws.
+*
+* If this flag is set to @c ETrue, all member functions which draw items
+* will return immediately without drawing anything. Functions which update
+* the internal state of the list box will still work, but nothing will be
+* drawn or updated on the screen.
+*
+* @param aDisableRedraw Disables redraw if @c ETrue.
+*/
+	IMPORT_C void SetDisableRedraw(TBool aDisableRedraw);
+/**
+* Tests whether redraw is disabled.
+*
+* @return ETrue if redraw is disabled.
+*/
+	IMPORT_C TBool RedrawDisabled() const;
+/**
+* Sets the painted selection flag.
+*
+* @deprecated
+* @param aPaintedSelection If @c ETrue the painted selection flag is set
+*        on. If @c EFalse the selection flag is set off. If NULL the
+*        painted selection flag is cleared.
+*/
+	IMPORT_C void SetPaintedSelection( TBool aPaintedSelection );
+	// functions that support selection
+/**
+* Gets a pointer to the selection list of this view.
+*
+* @return Pointer to an array describing the items
+*         in the list which are currently selected. The object pointed
+*         at is owned by the @c CListBoxView.
+*/
+IMPORT_C const CSelectionIndexArray* SelectionIndexes() const;
+/**
+* Gets a copy of the array of currently selected items.
+*
+* @param[in,out] aSelectionArray An instantiated @c CSelectionIndexArray.
+*                On return, contains a copy of selection indexes.
+* @panic EEikPanicListBoxInvalidSelIndexArraySpecified Panics if the given
+*        selection index array is not valid.
+* @panic EEikPanicListBoxNoSelIndexArray Panics if selection indexes have
+*        not been defined for this class.
+*/
+	IMPORT_C void GetSelectionIndexesL(
+CSelectionIndexArray* aSelectionArray) const;
+/**
+* Sets the currently selected items of this view from a selection index
+* array.
+*
+* @param aSelectionIndexes Items to select.
+* @panic EEikPanicListBoxInvalidSelIndexArraySpecified Panics if the given
+*        selection index array is not valid.
+*/
+IMPORT_C void SetSelectionIndexesL(const CSelectionIndexArray*
+aSelectionIndexes);
+/**
+* Resets the selection state so that there is nothing selected.
+*
+* @panic EEikPanicListBoxNoSelIndexArray Panics if selection indexes have
+*        not been defined for this class.
+*/
+IMPORT_C void ClearSelection();
+// select/highlight items without moving the cursor
+/**
+* Updates item selection.
+*
+* @param aSelectionMode The selection mode.
+*/
+IMPORT_C virtual void UpdateSelectionL(TSelectionMode aSelectionMode);
+/**
+* Toggles the selection of an item.
+*
+* @param aItemIndex Item to toggle.
+* @panic EEikPanicListBoxNoSelIndexArray Panics if selection indexes have
+*        not been defined for this class.
+*/
+IMPORT_C void ToggleItemL(TInt aItemIndex);
+/**
+* Selects an item by index.
+*
+* This function leaves if memory could not be allocated for an extra item
+* in the array of selected items.
+*
+* @param aItemIndex Item to select.
+* @panic EEikPanicListBoxNoSelIndexArray Panics if selection indexes have
+*        not been defined for this class.
+*/
+IMPORT_C void SelectItemL(TInt aItemIndex);
+/**
+* Deselects an item by index.
+*
+* @param aItemIndex Item to deselect.
+* @panic EEikPanicListBoxNoSelIndexArray Panics if selection indexes have
+*        not been defined for this class.
+*/
+IMPORT_C void DeselectItem(TInt aItemIndex);
+/**
+* Sets the anchor to the specified item.
+*
+* @param aItemIndex The index of the item at which the anchor is set.
+*/
+IMPORT_C void SetAnchor(TInt aItemIndex);
+/**
+* Resets the anchor index, the active end and the  @c EAnchorExists flag.
+*/
+IMPORT_C void ClearSelectionAnchorAndActiveIndex();
+	// functions that support scrolling
+/**
+* Scrolls vertically to make a particular item visible.
+*
+* @param aItemIndex The item to make visible.
+* @return @c ETrue if any scrolling was done, @c EFalse if no
+*         scrolling was necessary.
+*/
+	IMPORT_C virtual TBool ScrollToMakeItemVisible(TInt aItemIndex);
+/**
+* Sets the index of the item to be the top item.
+*
+* @param aNewTopItemIndex The item to scroll to.
+*/
+	IMPORT_C virtual void VScrollTo(TInt aNewTopItemIndex);
+/**
+* Sets the index of the item to be the top item.
+*
+* This two argument version returns the area which needs redrawing via
+* @c aMinRedrawRect&. This function does not perform the redraw.
+*
+* @param aNewTopItemIndex The distance by which to scroll.
+* @param aMinRedrawRect On return, the minimum rectangle to redraw.
+*/
+IMPORT_C virtual void VScrollTo(TInt aNewTopItemIndex,
+TRect& aMinRedrawRect);
+/**
+* Scrolls horizontally by the specified number of pixels.
+*
+* @param aHScrollAmount The distance to scroll by in pixels. A negative
+*        value scrolls to the left, a positive value scrolls to the right.
+*/
+IMPORT_C virtual void HScroll(TInt aHScrollAmount);
+/**
+* Gets the offset of the visible portion of the data from the left margin
+* in pixels.
+*
+* @return The horizontal scroll offset in pixels.
+*/
+IMPORT_C TInt HScrollOffset() const;
+/**
+* Sets the horizontal scroll offset in pixels.
+*
+* @param aHorizontalOffset New value for the horizontal scroll offset, in
+*        pixels.
+*/
+	IMPORT_C void SetHScrollOffset(TInt aHorizontalOffset);
+/**
+* Gets the width of the widest item in the list in pixels.
+*
+* @return Data width in pixels.
+*/
+	IMPORT_C TInt DataWidth() const;
+/**
+* Recalculates the data width of this list box view from the item width
+* of its list item drawer. This method is called directly by
+* @c CEikListBox when the list box’s size changes or when data is added.
+*/
+	IMPORT_C virtual void CalcDataWidth();
+/**
+* Gets the visible width of the specified rectangle in pixels. This
+* function is called by @c CListBoxView itself on its own viewing
+* rectangle.
+*
+* @param aRect The rectangle to get the visible width for.
+* @return Visible width of @c aRect.
+*/
+	IMPORT_C virtual TInt VisibleWidth(const TRect& aRect) const;
+/**
+* Calculates which item should be selected in order to make a
+* particular item visible. Calling
+* @c VScrollTo(CalcNewTopItemIndexSoItemIsVisible(idx)), for example,
+* would make the item whose index is @c idx visible.
+*
+* @param aItemIndex The index of the new top item.
+* @return The item to be selected.
+*/
+IMPORT_C virtual TInt CalcNewTopItemIndexSoItemIsVisible(
+TInt aItemIndex) const;
+	// functions that support drawing
+/**
+* Draws every visible item into the specified rectangle.
+*
+* As implemented in @c CListBoxView, this function's argument is ignored
+* and the internal viewing rectangle is used. See @c SetViewRect().
+*
+* @param aClipRect The rectangle to draw into, this is ignored. Default
+*        value is NULL.
+* @panic EEikPanicListBoxNoModel Panics if the list box model for this
+*        class has not been defined.
+*/
+	IMPORT_C virtual void Draw(const TRect* aClipRect = NULL) const;
+/**
+* Draws the specified item via @c CListBoxDrawer::DrawItem() if it is
+* visible.
+*
+* @param aItemIndex Index number of the item to draw.
+*/
+	IMPORT_C virtual void DrawItem(TInt aItemIndex) const;
+/**
+* Sets list box backroung text. This text is visible if the list box
+* has no items.
+*
+* @param aText The text for the empty list box background.
+*/
+	IMPORT_C void SetListEmptyTextL(const TDesC& aText);
+/**
+* Gets an empty list box text.
+*
+* @return Pointer the empty list box text.
+*/
+	inline const TDesC* EmptyListText() const;
+/**
+* Tests whether an item is selected.
+*
+* @param aItemIndex Index of item to test.
+* @return @c ETrue if the item is selected.
+*/
+IMPORT_C TBool ItemIsSelected(TInt aItemIndex) const;
+/**
+* Tests whether an item is visible.
+*
+* @param aItemIndex Index of item to be tested.
+* @return @c ETrue if the item is visible.
+*/
+	IMPORT_C TBool ItemIsVisible(TInt aItemIndex) const;
+/**
+* Gets the on-screen position of an item.
+*
+* @param aItemIndex Index of an item.
+* @return Position of the item.
+*/
+	IMPORT_C virtual TPoint ItemPos(TInt aItemIndex) const;
+/**
+* Gets the on-screen size of an item.
+*
+* As implemented in @c CListBoxView, all items report the same size.
+* The size returned may be larger than the width of the list box view, but
+* will not be smaller.
+*
+* @param aItemIndex Index of an item. Default value is 0.
+* @return Size of the item.
+*/
+	IMPORT_C virtual TSize ItemSize(TInt aItemIndex=0) const;
+/**
+* Sets the colour in which to display text.
+*
+* @param aColor Colour in which to display text.
+*/
+	IMPORT_C void SetTextColor(TRgb aColor);
+/**
+* Sets the background colour.
+*
+* @param aColor The background colour.
+*/
+	IMPORT_C void SetBackColor(TRgb aColor);
+/**
+* Gets the colour in which text is to be displayed.
+*
+* @return Current text colour.
+*/
+IMPORT_C TRgb TextColor() const;
+/**
+* Gets the background colour for this view.
+*
+* @return The background colour.
+*/
+	IMPORT_C TRgb BackColor() const;
+/**
+* Moves the current item cursor in the specified direction. This function
+* is called by @c CEikListBox in response to user input.
+*
+* @param aCursorMovement The cursor movement to apply.
+* @param aSelectionMode The selection mode of the calling list box.
+*/
+	IMPORT_C virtual void MoveCursorL(TCursorMovement aCursorMovement,
+TSelectionMode aSelectionMode);
+/**
+* Moves to the specified item, sets it as the current item and scrolls the
+* display to make the item visible.
+*
+* @param aTargetItemIndex The index of the item to which to move.
+* @param aSelectionMode The selection mode.
+*/
+IMPORT_C virtual void VerticalMoveToItemL(TInt aTargetItemIndex,
+TSelectionMode aSelectionMode);
+/**
+* Converts a pixel position into an item index.
+*
+* The function returns @c ETrue and sets @c aItemIndex to the index of the
+* item whose bounding box contains @c aPosition. Returns @c EFalse if no
+* such item exists.
+*
+* @param aPosition A position relative to the origin of the list box
+*                  control.
+* @param aItemIndex Is set to the item at that position.
+* @return @c ETrue if there was an item at @c aPosition.
+*/
+IMPORT_C virtual TBool XYPosToItemIndex(TPoint aPosition,
+TInt& aItemIndex) const;
+/**
+* Gets the number of items that will fit into a given rectangle.
+*
+* @param aRect The rectangle.
+* @return The number of items that will fit into the given rectangle.
+*/
+IMPORT_C virtual TInt NumberOfItemsThatFitInRect(const TRect& aRect) const;
+/**
+* Sets the visibility observer.
+*
+* @param aObserver New visibility observer for this control.
+*/
+void SetVisibilityObserver(MListVisibilityObserver* aObserver);
+/**
+* Tests if this view is visible.
+*
+* @return @c ETrue if this view is visible. @c EFalse if this view
+*         is not visible or does not exist.
+*/
+	IMPORT_C TBool IsVisible() const;
+/**
+* Gets the object used by this list box view to draw its items.
+*
+* @return Pointer to the list box item drawer.
+*/
+	inline CListItemDrawer* ItemDrawer() const;
+/**
+* Not implemented.
+*
+* @param aClientRect Not used.
+*/
+	IMPORT_C virtual void DrawEmptyList(const TRect &aClientRect) const;
+// disables vertical line drawing, useful only for certain
+//custom list boxes
+/**
+* Disables vertical line drawing.
+*
+* @param aDisable @c ETrue if disabled.
+*/
+void DisableVerticalLineDrawing( TBool aDisable );
+/**
+* Deselects range between given indexes.
+*
+* @deprecated
+* @param aItemIndex1 First index of selectable range.
+* @param aItemIndex2 Second index of selectable range.
+*/
+IMPORT_C void DeselectRangeL(TInt aItemIndex1, TInt aItemIndex2);
+/**
+* Sets the offset for view.
+*
+* @internal
+* @param aOffset Offset in pixels.
+*/
+IMPORT_C void SetItemOffsetInPixels(TInt aOffset);
+/**
+* Gets view offset.
+*
+* @internal
+* @return View's offset.
+*/
+IMPORT_C TInt ItemOffsetInPixels() const;
+/**
+* Sets scrolling state.
+	 *
+	 * @internal
+*/
+void SetScrolling( TBool aIsScrolling );
+	/**
+	 * Returns item's height. All items have the same height.
+	 *
+	 * @internal
+	 * @return Item height.
+	 */
+TInt ItemHeight() const { return iItemHeight; }
+/**
+* Tests whether an item is partially visible.
+* Note that this returns @c EFalse also when item is fully visible,
+* i.e. the whole item area is inside the list view rectangle.
+*
+* @param  aItemIndex  Index of item to be tested.
+*
+* @return @c ETrue if the item is partially visible,
+*         @c EFalse if it's not visible or fully visible.
+*/
+IMPORT_C TBool ItemIsPartiallyVisible( TInt aItemIndex ) const;
+/**
+* Resets the selection state so that there is nothing selected.
+*
+* @param  aDrawItems  Whether or not to draw the items which are
+*                     deselected.
+*
+* @panic  EEikPanicListBoxNoSelIndexArray  Panics if selection indexes
+*                                          have not been defined for
+*                                          this class.
+*/
+void ClearSelection( TBool aDrawItems );
+/**
+* Sets all items selected.
+*
+* @param  aDrawItems  Whether or not to draw the items which are
+*                     selected.
+*
+* @panic EEikPanicListBoxNoSelIndexArray Panics if selection indexes have
+*        not been defined for this class.
+*
+* @panic EEikPanicListBoxNoModel Panics if listbox model not existing.
+*
+*/
+void SelectAllL( TBool aDrawItems );
+protected:
+	// functions for accessing the flags
+/**
+* Gets this view’s flags.
+*
+* These flags are defined by the nested enum @c TFlags (below).
+*
+* @return List box's flags.
+*/
+	inline TInt Flags() const;
+/**
+* Sets this view’s flags according to a bitmask.
+*
+* These flags are defined by the nested enum @c TFlags (below).
+*
+* @param aMask Sets new flags for the list box.
+*/
+	inline void SetFlags(TInt aMask);
+/**
+* Clears this view’s flags according to a bitmask.
+*
+* These flags are defined by the nested enum @c TFlags (below).
+*
+* @param aMask Flags to be removed.
+*/
+	inline void ClearFlags(TInt aMask);
+/**
+* List box base class.
+* To access @c SetFlags()/ClearFlags().
+*/
+friend class CEikListBox;
+	// misc. functions
+/**
+* Selects items between given indexes.
+*
+* @deprecated
+* @param aItemIndex1 First index of selectable range.
+* @param aItemIndex2 Second index of selectable range.
+*/
+	IMPORT_C void SelectRangeL(TInt aItemIndex1, TInt aItemIndex2);
+private:
+/**
+* Set item index directly.
+* For CEikListBox.
+* @param aItemIndex New item index.
+*/
+void SetItemIndex( TInt aItemIndex );
+protected:
+/**
+* The flags for this list box. These flags are defined by the nested enum
+* @c TFlags (below).
+*/
+	TInt iFlags;
+/**
+* This view’s item drawer.
+* Not owned.
+*/
+	CListItemDrawer* iItemDrawer;
+/**
+* This view’s model.
+* Not owned.
+*/
+	MListBoxModel* iModel;
+/**
+* Width (in pixels) of the longest item in the model.
+*/
+	TInt iDataWidth;
+/**
+* Index of the item at the top of the view. This is not necessarily the
+* item at the start of the list.
+*/
+TInt iTopItemIndex;
+/**
+* Index of the item at the bottom of the view. This is not necessarily the
+* item at the end of the list.
+*/
+TInt iBottomItemIndex;
+/**
+* Pixel offset of the visible portion of the data from the left margin.
+*/
+TInt iHScrollOffset;
+/**
+* Index of the current item.
+*/
+TInt iCurrentItemIndex;
+/**
+* Height of each item in the list in pixels.
+*/
+TInt iItemHeight;
+/**
+* This list box view’s window.
+*/
+RWindow* iWin;
+/**
+* The window group of this view.
+*/
+RWindowGroup* iGroupWin;
+/**
+* Graphics context for the control.
+*/
+CWindowGc* iGc;
+/**
+* Graphics context for the control.
+*/
+TRect iViewRect;
+/**
+* The empty list text.
+*/
+	HBufC *iListEmptyText;
+/**
+* Indicates whether vertical line drawing is disabled.
+*/
+TBool iDisableVerticalLineDrawing /*TInt iSpare*/;
+private:
+	TInt iMatcherCursorPos;
+	TRgb iMatcherCursorColor;
+	TRgb iBackColor;
+	TRgb iTextColor;
+	TInt iAnchorIndex;
+	TInt iActiveEndIndex;
+	CSelectionIndexArray* iSelectionIndexes;
+	MListVisibilityObserver* iVisibilityObserver;
+protected:
+/**
+* Current vertical offset of the view in pixels.
+*/
+TInt iVerticalOffset;
+	CListBoxViewExtension* iExtension;
+TInt iSpare[4];
+	};
+NONSHARABLE_CLASS( CListBoxViewExtension ) : public CBase
+{
+public:
+static CListBoxViewExtension* NewL();
+~CListBoxViewExtension();
+private:
+void ConstructL();
+public:
+	CEikListBox* iListBox;
+	TBool iScrolling;
+	TBool iScrollingDisabled;
+};
+/**
+* Return text currently in the empty list text
+*/
+inline const TDesC* CListBoxView::EmptyListText() const
+	{ return(iListEmptyText); }
+class CSnakingListBoxView : public CListBoxView
+	{
+public:
+	IMPORT_C ~CSnakingListBoxView();
+	IMPORT_C CSnakingListBoxView();
+	inline TInt ColumnWidth() const;
+	IMPORT_C void SetColumnWidth(TInt aColumnWidth);
+	IMPORT_C virtual void MoveCursorL(TCursorMovement aCursorMovement, TSelectionMode aSelectionMode);
+	IMPORT_C virtual void SetTopItemIndex(TInt aItemIndex);
+	IMPORT_C virtual void SetItemHeight(TInt aItemHeight);
+	IMPORT_C virtual TBool XYPosToItemIndex(TPoint aPosition, TInt& aItemIndex) const;
+	IMPORT_C virtual TInt NumberOfItemsThatFitInRect(const TRect& aRect) const;
+	IMPORT_C virtual void HScroll(TInt aHScrollAmount);
+	IMPORT_C virtual void CalcDataWidth();
+	IMPORT_C virtual void CalcBottomItemIndex();
+	IMPORT_C virtual void Draw(const TRect* aClipRect = NULL) const;
+	IMPORT_C virtual TInt VisibleWidth(const TRect& aRect) const;
+	IMPORT_C virtual TBool ScrollToMakeItemVisible(TInt aItemIndex);
+	IMPORT_C virtual TInt CalculateHScrollOffsetSoItemIsVisible(TInt aItemIndex);
+	IMPORT_C virtual TInt CalcNewTopItemIndexSoItemIsVisible(TInt aItemIndex) const;
+	IMPORT_C virtual TPoint ItemPos(TInt aItemIndex) const;
+	IMPORT_C virtual TSize ItemSize(TInt aItemIndex=0) const;
+	IMPORT_C void CalcRowAndColIndexesFromItemIndex(TInt aItemIndex, TInt& aRowIndex, TInt& aColIndex) const;
+	IMPORT_C void CalcItemIndexFromRowAndColIndexes(TInt& aItemIndex, TInt aRowIndex, TInt aColIndex) const;
+	IMPORT_C virtual TInt NumberOfItemsPerColumn() const;
+protected:
+	IMPORT_C virtual void DrawItemRange(TInt aStartItemIndex, TInt aEndItemIndex) const;
+	IMPORT_C void DrawColumnRange(TInt aStartColIndex, TInt aEndColIndex) const;
+	IMPORT_C void MoveToPreviousColumnL(TSelectionMode aSelectionMode);
+	IMPORT_C void MoveToNextColumnL(TSelectionMode aSelectionMode);
+	IMPORT_C void ClearUnusedItemSpace(TInt aStartItemIndex, TInt aEndItemIndex) const;
+	IMPORT_C void UpdateHScrollOffsetBasedOnTopItemIndex();
+private: // overridden from CListBoxView
+	IMPORT_C virtual TAny* Reserved_1();
+protected:
+	TInt iColumnWidth;
+	};
+inline TInt CListBoxView::Flags() const
+	{ return iFlags; }
+inline void CListBoxView::SetFlags(TInt aMask)
+	{ iFlags|=aMask; }
+inline void CListBoxView::ClearFlags(TInt aMask)
+	{ iFlags&=(~aMask); }
+inline CListItemDrawer* CListBoxView::ItemDrawer() const
+	{ return iItemDrawer; }
+inline TInt CSnakingListBoxView::ColumnWidth() const
+	{ return iColumnWidth; }
+#endif  // __EIKLBV_H__

branch	RCL_3
changeset 56	d48ab3b357f1
child 72	a5e7a4f63858