diff -r d189ee25cf9d -r 3533d4323edc emailuis/uicomponents/inc/fstreevisualizerbase.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emailuis/uicomponents/inc/fstreevisualizerbase.h Wed Sep 01 12:28:57 2010 +0100 @@ -0,0 +1,2395 @@ +/* +* Copyright (c) 2007 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: Visualizer class for the hierarchical tree list. +* +*/ + + +#ifndef C_FSTREEVISUALIZER_H +#define C_FSTREEVISUALIZER_H + + +//////SYSTEM INCLUDES +#include +#include + +//////TOOLKIT INCLUDES +#include //MAlfActionObserver + +//////PROJECT INCLUDES +#include + +#include "fstreevisualizer.h" +#include "fstreeobserver.h" +#include "fsfadeeffectobserver.h" +#include "fsslideeffectobserver.h" +#include "fsscrollbarset.h" +#include "muicscrollbar.h" + +//////TOOLKIT CLASSES +class CAlfLayout; +class CAlfTexture; +class CAlfBrush; +class TAlfEvent; +class CAlfGridLayout; +class CAlfDeckLayout; +class CAlfFlowLayout; +class CAlfImageVisual; +class CAlfImageBrush; + +//////PROJECT CLASSES +class MFsTreeItemData; +class MFsTreeNodeVisualizer; +class MFsTreeVisualizerObserver; +class CFsTree; +class CFsTreeListLayoutData; +class CFsFadeEffect; +class CFsSlideEffect; +class CFsTreePlainOneLineItemData; +class CFsWatermark; +class MFsTreeItemVisualizer; +class CFsInteractionInterval; +class CFsAlfTextStyleManager; +class CAknPhysics; +class CAlfAnchorLayout; + +/** + * Contains the visual structure of the list. + * + */ + +enum TUpdatedByPhysic{ + ENotUpdatedByPhisic = 0, + EUpdatedByPhisic, + EUpdatedByPhisicEnd + }; + +NONSHARABLE_CLASS( TWorld ) + { + +public: + + /** + * World observer interface + */ + class MObserver + { + public: + + /** + * This method is called when world is changed. + */ + virtual void WorldUpdatedL( const TWorld& aWorld ) = 0; + + }; + +public: + + /** + * Constructor + */ + TWorld(); + + /** + * Destructor + */ + ~TWorld(); + + /** + * Add new observer to the world + */ + void AddObserverL( MObserver& aObserver ); + + /** + * Remove observer from the world, if the observer is not found, does nothing. + */ + void RemoveObserver( MObserver& aObserver ); + + /** + * Append new item to the bottom of world. + */ + void AppendL( const TFsTreeItemId aId, const TSize& aSize ); + + /** + * Insert new item to the world. Items after inserted item will be shifted down. + */ + void InsertL( const TFsTreeItemId aId, const TSize& aSize, const TInt aSlot ); + + /** + * Remove item from the world. Items after removed item will be shifted up. + */ + void RemoveL( const TFsTreeItemId aId ); + + /** + * Clear the world. + */ + void RemoveAllL(); + + /** + * Get items in range aY to aY + aHeight. Also returns offset by which the listlayout + * needs to be scrolled (e.g. the first item in list might be only partly visible) + */ + void GetItemsL( RArray& aItems, TInt aY, TInt aHeight, TInt& aOffset, + TInt& aBeginIndex ); + + /** + * Returns full height of the world (in pixels). + */ + TInt Height() const; + + /** + * Begin batch update. When batch update is going on, single modifications to the world + * will not be signalled to the observers. + */ + void BeginUpdate(); + + /** + * End batch update. Observers will be signalled. + */ + void EndUpdateL(); + + /** + * Returns item's rect. + */ + TInt GetItemRect( const TFsTreeItemId, TRect& aRect ) const; + + /** + * Returns item's rect, scan starts from aStartIndex. + */ + TInt GetItemRect( const TFsTreeItemId, TRect& aRect, const TInt aStartIndex ) const; + + /** + * Returns item's rect by index in world. + */ + TInt GetItemRectByIndex(const TInt aIndex, TRect& aRect) const; + + /** + * Returns ETrue if batch update is going on. + */ + TBool IsUpdating() const; + + /** + * Reconstructs the whole world from given tree. + */ + void Recalculate( const CFsTree& aTree ); + + // for debug print + + /** + * Checks world's integrity (e.g. there cannot be any overlapping items in the world) + */ + TBool CheckIntegrity() const; + + /** + * Returns number of items in the world. + */ + TInt ItemCount() const; + + /** + * Returns item id for the item at index aIndex. + */ + TFsTreeItemId Item( TInt aIndex ) const; + + /** + * Returns index of item with id aItem. + */ + TInt IndexOfItem( TFsTreeItemId aItem ) const; + +private: + + /** + * Move items from aSlot onwards down by aDelta amount. + */ + void MoveBy( const TInt aSlot, const TInt aDelta); + + /** + * Called when world has been updated. + */ + void UpdatedL(); + +private: + + /** + * World item. Contains tree Id and visual rect. + */ + class TItem + { + + public: + + /** + * Constructor + */ + TItem( const TFsTreeItemId aId, const TRect& aRect ); + + /** + * Item rect + */ + TRect Rect() const; + + /** + * Sets item's rect + */ + void SetRect( const TRect& aRect ); + + /** + * Move item by given amount. + */ + void Move( TInt aDy ); + + /** + * Item's top Y coordinate + */ + TInt Top() const; + + /** + * Item's top left coordinate + */ + TPoint TopLeft() const; + + /** + * Item's height + */ + TInt Height() const; + + /** + * Item's bottom Y coordinate + */ + TInt Bottom() const; + + /** + * Item's bottom right coordinate + */ + TPoint BottomRight() const; + + public: + + // Tree item id + TFsTreeItemId iId; + + private: + + // Top left Y coordinate of the item + TInt iY; + + // Height of the item + TInt iHeight; + + }; + +private: + + // World observers + RPointerArray iObservers; + + // World items + RArray iItems; + + // Total height of the world + TInt iHeight; + + // True if batch update is going on + TBool iBatchUpdateOngoing; + + }; + +/** + * ViewPort to the list World. Is used to access the visible set of + * the list. + * + */ +NONSHARABLE_CLASS( TViewPort ) : public TWorld::MObserver + { + +public: + + /** + * Hints for item repositioning inside the viewport. + */ + enum TPositionHint + { + /** Keep the item position exactly same. */ + EPositionExact, + + /** Allow repositioning method to modify original position, + * because item was expanded + */ + EPositionAfterExpand + }; + +public: + + /** + * Viewport observer interface. + */ + class MObserver + { + + public: + + /** + * This method is called when the viewport changes. + */ + virtual void ViewPortUpdatedL( TViewPort& aViewPort, TUpdatedByPhysic aUpdateByPhysic = ENotUpdatedByPhisic ) = 0; + + }; + +public: + + /** + * Constructor + */ + TViewPort( MObserver& aObserver, TWorld& aWorld ); + + /** + * Set viewport position to aPosition. If aInformUpdate is set to ETrue, observer + * will be signalled. + */ + void SetPositionL( const TPoint& aPosition, TBool aInformUpdate = ETrue ); + + /** + * Center viewport around position aPosition. If aInformUpdate is set to ETrue, observer + * will be signalled. + */ + void SetCenterPositionL( const TPoint& aPosition, TBool aInformUpdate = ETrue, TUpdatedByPhysic aUpdateByPhysic = ENotUpdatedByPhisic ); + + /** + * Returns viewport position (i.e. topleft corner). + */ + const TPoint& Position() const; + + /** + * Returns viewport center position. + */ + TPoint CenterPosition() const; + + /** + * Sets viewport size. + */ + void SetSizeL( const TSize& aSize ); + + /** + * Returns viewport's size. + */ + const TSize& Size() const; + + /** + * Get items visible in viewport's area. + */ + void GetVisibleItemsL( RArray& aItemsToBeRemoved, RArray& aItemsToBeAdded, TInt& aOffset, TBool& aFullUpdate ); + + /** + * Get items visible in viewport's area. + */ + void GetVisibleItemsL(RArray& aVisible, TInt& aOffset); + + /** + * Returns ETrue if the world is higher than viewport. + */ + TBool IsScrollBarNeeded() const; + + /** + * Scroll viewport to item aItemId. If aInformUpdate is set to ETrue, observer + * will be signalled. + */ + void ScrollToItemL( const TFsTreeItemId aItemId, TBool aInformUpdate = ETrue ); + + /** + * Center viewport to item aItemId. If aInformUpdate is set to ETrue, observer + * will be signalled. + */ + void CenterToItemL( const TFsTreeItemId aItemId, TBool aInformUpdate = ETrue ); + + /** + * Scroll viewport so that aItemId becomes visible. If aInformUpdate is set to + * ETrue, observer will be signalled. + */ + void ScrollItemToViewL( const TFsTreeItemId aItemId, TBool aInformUpdate = ETrue ); + + /** + * Scroll viewport so that whole view is fully occupied by the list (if possible). + */ + void MakeViewFullyOccupiedL( TBool aInformUpdate = ETrue ); + + /** + * Scoll viewport so that given item is shown in given position in view. + * If aInformUpdate is set to ETrue, observer will be signalled. + */ + void ItemToPositionL( const TFsTreeItemId aItemId, const TPoint& aPosition, + TBool aInformUpdate = ETrue, + const TPositionHint aHint = EPositionExact ); + + /** + * Returns viewport top item. + */ + TFsTreeItemId TopItem() const; + + /** + * Returns viewport bottom item. + */ + TFsTreeItemId BottomItem() const; + + /** + * Clears cache to do full list update. + */ + void ClearCache(); + + /** + * Fetches item rect in viewport. If TRect::Height() is non zero, then item + * is visible in viewport and TRect contains item coordinates. + */ + TRect ItemRect( const TFsTreeItemId aItemId ) const; + + /** + * Returns ETrue if the item is fully visible in viewport. + */ + TBool ItemFullyVisible( const TFsTreeItemId aItemId ) const; + +private: + + /** + * Limits given top value so that whole list is correctly layouted. + */ + void LimitTop( TInt& aTop ) const; + +private: + + /** + * Called when viewport is updated. + */ + void UpdatedL(TUpdatedByPhysic aUpdateByPhysic = ENotUpdatedByPhisic); + + + +private: // from TWorld::MObserver + + /** + * @see TWorld::MObserver::WorldUpdatedL + */ + virtual void WorldUpdatedL( const TWorld& aWorld ); + +private: + + /** + * Viewport cache class. Contains items from previous visible item query. On following + * queries only changed items will be returned. For performance reasons array will contain + * NULL items in slots that have not changed. + */ + NONSHARABLE_CLASS( TCache ) + { + + public: + + /** + * Constructor + */ + TCache(); + + /** + * Destructor + */ + ~TCache(); + + /** + * Clears cache + */ + void Clear(); + + /** + * Check if the cache is clear. + */ + TBool IsClear() const; + + /** + * Check if the given item is in cache. + */ + TBool ContainsItem( const TFsTreeItemId aItemId ) const; + + /** + * Updates cache. + */ + void UpdateL( const RArray& aItems, RArray& aItemsToBeRemoved, RArray& aItemsToBeAdded, TBool& aFullUpdate ); + + /** + * Returns top most item from the cache. + */ + TFsTreeItemId TopItem() const; + + /** + * Returns bottom most item from the cache. + */ + TFsTreeItemId BottomItem() const; + + private: + + // Cached items + RArray iCachedItems; + + // True if the cache is clear + TBool iClear; + }; + +private: + + // Viewport observer + MObserver& iObserver; + + // World to which this viewport is related to + TWorld& iWorld; + + // Viewport position (topleft corner) + TPoint iPosition; + + // Size of the viewport + TSize iSize; + + // Viewport cache + TCache iCache; + + // Wold index of the first item in Cache + TInt iWorldIndex; + + }; + +/** + * Visualizer class for the hierarchical tree list. + * + * The tree visualizer is responsible for visualizing tree structure in a + * hierarchical list form. It is responsible for updating the list view based + * on events that come from the tree structure (through MFsTreeObserver + * interface). For example refreshing the list view after an item was added to + * the tree. + * + * @code + * + * @endcode + * + * @lib + */ +NONSHARABLE_CLASS( CFsTreeVisualizerBase ) : public CBase, + public MFsTreeVisualizer, + public MFsTreeObserver, + public MFsFadeEffectObserver, + public MFsSlideEffectObserver, + public MAlfActionObserver, + public MUiCScrollBar::MObserver, + public TWorld::MObserver, + public TViewPort::MObserver, + public MAknPhysicsObserver + { + +private: + + /** + * Event types + */ + enum TPointerEventType + { + EPointerDown = 0, + ELongTap, + EPointerUp + }; + +private: + + /** + * Drag handler class for handling pointer event and drag. + */ + NONSHARABLE_CLASS( CDragHandler ) : public CBase + { + private: + + /** + * Drag handler's internal flags + */ + enum TFlag { + + /** + * Flicking mode on + */ + EFlicking, + + /** + * Pointer repeat was received + */ + EWasRepeat, + + /** + * Pointer down was received + */ + EPointerDownReceived, + + }; + + /** + * Drag direction enumeration + */ + enum TDragDirection { + EDraggingNone, + + /** + * Drag direction up + */ + EDraggingUp, + + /** + * Drag direction down + */ + EDraggingDown + }; + + public: + /** + * Leave-safe constructor + */ + static CDragHandler* NewL(CFsTreeVisualizerBase& aTree, const TInt aHighlightTimeout, + const TBitFlags& aFlags ); + + /** + * Destructor + */ + ~CDragHandler(); + + /** + * Pointer down event handling + */ + void PointerDown(const TPointerEvent& aEvent, const TFsTreeItemId aItemId); + + /** + * Pointer repeat event handling + */ + void PointerRepeat(const TPointerEvent& aEvent); + + /** + * Pointer up event handling + */ + void PointerUp(const TPointerEvent& aEvent, const TFsTreeItemId aItemId); + + /** + * Pointer drag event handling + */ + TPoint PointerDrag(const TPointerEvent& aEvent, const TFsTreeItemId aItemId); + + /** + * Returns currect drag delta + */ + TInt DragDelta(const TPointerEvent& aEvent) const; + + /** + * Set flicking mode on + */ + void EnableFlicking(); + + /** + * Test if flicking + */ + TBool IsFlicking() const; + + /** + * Reset state + */ + void Reset(); + + /** + * Calculate drag direction from given arguments + */ + TDragDirection DragDirection( const TPoint& aCurrent, const TPoint aPrevious ) const; + + private: + + /** + * Private constructor + */ + CDragHandler(CFsTreeVisualizerBase& aTree, const TInt aHighlightTimeout, const TBitFlags& aFlags); + + /** + * Leave safe construct. + */ + void ConstructL(); + + /** + * Timer callback. + */ + static TInt HighlightTimerCallback(TAny* aPtr); + + private: + + CFsTreeVisualizerBase& iTree; + TBitFlags iFlags; + TTimeIntervalMicroSeconds32 iHighlightTimeout; + CPeriodic* iHighlightTimer; + TTime iStartTime; + TPoint iPosition; + TPoint iLastPointerPosition; + TPoint iDrag; + TFsTreeItemId iItemId; + const TBitFlags& iTreeVisualizerFlags; + TDragDirection iDragDirection; + }; + + +public: + + enum TFsTreeVisualizerMove + { + EFsTreeVisualizerMoveLineUp, + EFsTreeVisualizerMoveLineDown, + EFsTreeVisualizerMovePageUp, + EFsTreeVisualizerMovePageDown + }; + + enum TFsSelectorMovement + { + /** + * The selector moves immediately between list's items. + */ + EFsSelectorMoveImmediately, + + /** + * The selector moves smoothly between list's items. + */ + EFsSelectorMoveSmoothly + }; + +public: // Construction + + /** + * Two-phased constructor + * + * @param aOwnerControl Owner control. + * @param aParent Parent layout for all the new layouts constructed by + * this class. + * + * @return Pointer to the newly constructed object. + */ + IMPORT_C static CFsTreeVisualizerBase* NewL( CAlfControl* aOwnerControl, + CAlfLayout& aParent, const TBool aPopUpMode = EFalse ); + + /** + * C++ destructor + */ + virtual ~CFsTreeVisualizerBase(); + +public: + + /** + * Sets data model for the visualizer. + * + * @param aTreeData Data model visualized by the tree visualizer. + */ + void SetTreeData( CFsTree& aTreeData ); + + /** + * Adds custom key which triggers page-up event. + * + * @param aKey Key code. + */ + virtual void AddCustomPageUpKey(TInt aKeyCode); + + /** + * Removes given key code from custom page-up event key codes. + * + * @param aKey Key code. + * + * @return ETrue if the key code was removed. + */ + virtual TBool RemoveCustomPageUpKey(TInt aKeyCode); + + /** + * Checks whether given key is a custom key for page-up event. + * + * @param aKey Key code. + * + * @return ETrue if the given key code triggers page-up event. + */ + virtual TBool IsCustomPageUpKey(TInt aKeyCode); + + /** + * Adds custom key which triggers page-down event. + * + * @param aKey Key code. + */ + virtual void AddCustomPageDownKey(TInt aKeyCode); + + /** + * Removes given key code from custom page-down event key codes. + * + * @param aKey Key code. + * + * @return ETrue if the key code was removed. + */ + virtual TBool RemoveCustomPageDownKey(TInt aKeyCode); + + /** + * Checks whether given key is a custom key for page-down event. + * + * @param aKey Key code. + * + * @return ETrue if the given key code triggers page-down event. + */ + virtual TBool IsCustomPageDownKey(TInt aKeyCode); + + /** + * Sets icon for a mark sign. + * + * @param aMarkIcon Icon to mark items. + */ + virtual void SetMarkIcon( CAlfTexture& aMarkIcon ); + + /** + * Returns icon used to mark items. + */ + virtual CAlfTexture* MarkIcon( ); + + /** + * Checks if item is marked and return status + * @param aItemId item id to be checked + */ + virtual TBool IsMarked( const TFsTreeItemId aItemId ) const; + + /** + * Sets status of the item to be marked/unmarked + * @param aItemId item id which of the mark/unmark status will be set + * @param aMarked Marked/Unmarked status + */ + virtual void MarkItemL( const TFsTreeItemId aItemId, TBool aMarked ); + + /** + * Returns list of marked items + * @param aMarkedItems list to which the id's of marked items will be + * added + */ + virtual void GetMarkedItemsL( RFsTreeItemIdList& aMarkedItems ) const; + + /** + * Function marks/unmarks all items in the list. + * + * @param aMarkAll ETrue to mark all items, EFalse to unmark. + */ + virtual void MarkAllItemsL( TBool aMarkAll ); + + /** + * Sets item indentation per hierarchy level. + * + * @param aIndentation Indentation in pixels + */ + virtual void SetIndentationL( TInt aIndentation ); + + /** + * Returns indentation per hierarchy level in pixels. + * + * @return Indentation per hierarchy level in pixels. + */ + virtual TInt Indentation() const; + + /** + * Sets icon for a menu sign. + * + * @param aMenuIcon Menu icon. + */ + virtual void SetMenuIcon( CAlfTexture& aMenuIcon ); + + /** + * Returns menu icon. + */ + virtual CAlfTexture* MenuIcon( ) const; + + /** + * Update flip state + * @param aOpen ETrue if flip is open + */ + virtual void SetFlipState( TBool aOpen ); + + /** + * Update focus visibility state + * @param aShow ETrue if the focus should be shown + */ + virtual void SetFocusVisibility( TBool aShow ); + + /** + * Used internally by the list. To make the list focused/not focused use + * CFsTreeList::SetFocusedL() instead. + */ + void SetFocusedL( const TBool aFocused ); + + /** + * + * @param aTexture A custom texture for the selector. + * The texture is used to create an image brush. + * Ownership is not transferred. + * If the parameter is NULL, the selector is taken from + * the s60 skin. + * + * @param aMovementType Defines the way the selector moves between items. + * Currently only EFsSelectorMoveImmediately is + * supported. + * @param aLeftBorderWidth Left border value. + * Positive values extend the image border and + * negative values decrease the visual area. + * Zero values - draw without border. + * @param aRightBorderWidth Right border value. + * Positive values extend the image border and + * negative values decrease the visual area. + * Zero values - draw without border. + * @param aTopBorderHeight Top border value. + * Positive values extend the image border and + * negative values decrease the visual area. + * Zero values - draw without border. + * @param aBottomBorderHeight Bottom border value. + * Positive values extend the image border and + * negative values decrease the visual area. + * Zero values - draw without border. + */ + virtual void SetSelectorPropertiesL ( CAlfTexture* aTexture = NULL, + TFsSelectorMovement aMovementType = + EFsSelectorMoveImmediately, + TInt aLeftBorderWidth = 0, + TInt aRightBorderWidth = 0, + TInt aTopBorderHeight = 0, + TInt aBottomBorderHeight = 0 ); + + /** + * Set some of the selector's properties. + * + * @param aSelectorBrush A custom brush for selector's visual. + * Ownership is not transferred. + * If the parameter is NULL, the selector is taken + * from the s60 skin. + * + * @param aMovementType Defines the way the selector moves between items. + * Currently only EFsSelectorMoveImmediately is + * supported. + * + * @param aOpacity Opacity for the selector visual. + * + */ + virtual void SetSelectorPropertiesL ( CAlfBrush* aSelectorBrush, + TReal32 aOpacity = 1.0, + TFsSelectorMovement aMovementType = EFsSelectorMoveImmediately ); + + + /** + * The function returns selector's properties. + */ + virtual void GetSelectorProperties ( CAlfTexture*& aTexture, + TFsSelectorMovement& aMovementType, + TInt& aLeftBorderWidth, + TInt& aRightBorderWidth, + TInt& aTopBorderHeight, + TInt& aBottomBorderHeight ); + + // from base class MFsTreeVisualizer + + /** + * @see MFsTreeVisualizer::HandleKeyEventL + */ + virtual TBool HandleKeyEventL(const TAlfEvent& aEvent); + + /** + * @see MFsTreeVisualizer::HandlePointerEventL + */ + virtual TBool HandlePointerEventL( const TAlfEvent& aEvent ); + + + /** + * Sets the specified item as focused. + * + * @param aItem indicates item to be focused. + * + * @panic EFsListPanicInvalidItemID Item with specified ID is not found. + */ + // + virtual void SetFocusedItemL( const TFsTreeItemId aItem, TBool aCheckFocus = ETrue ); + // + + /** + * Gets item vertical position in the list + * + * @param aIdx indicates item index + */ + virtual TInt GetItemWorldPosition( const TInt aIdx ); + + /** + * Returns item id of the currently focused item. + * + * @return Id of the focused item. + */ + virtual TFsTreeItemId FocusedItem() const; + + /** + * Checks if the specified item is focused. + * + * @param aItem Item to be checked. + * + * @return ETrue If item is focused. EFalse if item is not focused or + * item does not exist in the tree. + */ + virtual TBool IsFocused( const TFsTreeItemId aItemId ) const; + + /** + * Sets an item as first visible one in the list. + * + * @param aItemId Id of an item that will be displayed as first. + */ + // + virtual void SetFirstVisibleItemL( const TFsTreeItemId aItemId ); + // + + /** + * Get an id of the first visible item. + * + * @return Id of the first visible item. + */ + virtual TFsTreeItemId FirstVisibleItem(); + + /** + * Gets a pointer to the root's item data object. + * + * @return Pointer to the root's item data object. + */ + MFsTreeItemData* RootItemData(); + + /** + * Gets a pointer to the root's item visualizer object. + * + * @return Pointer to the root's item visualizer object. + */ + MFsTreeNodeVisualizer* RootNodeVisualizer(); + + /** + * Displays the list. + * + * @param aFadeIn Defines if list visual should or shouldn't fade in to + * the screen. + * @param aSlideIn ETrue if slide in effect should be used, EFalse if not. + */ + virtual void ShowListL( const TBool aFadeIn = EFalse, + const TBool aSlideIn = EFalse ); + + /** + * Hides the list. + * + * @param aFadeOut Defines if list visual should or shouldn't fade out + * from the screen. + * @param aSlideOut ETrue if slide out effect should be used,EFalse if not + */ + virtual void HideList( const TBool aFadeOut = EFalse, + const TBool aSlideOut = EFalse ); + + /** + * The function sets duration of the slide-in effect. + * + * @param aTimeMiliseconds Slide in time in milliseconds. + */ + virtual void SetSlideInDuration ( TInt aTimeMiliseconds ); + + /** + * The function returns slide in effect's duration. + * + * @return Slide in duration in miliseconds. + */ + virtual TInt SlideInDuration ( ) const; + + /** + * The function sets direction of the slide in effect. + * + * @param aDirection A direction of the slide in effect. + */ + virtual void SetSlideInDirection ( TFsSlideEffect aDirection ); + + /** + * The function returns direction of the slide in effect. + * + * @return A direction of the slide in effect. + */ + virtual MFsTreeVisualizer::TFsSlideEffect SlideInDirection ( ) const; + + /** + * The function sets duration of the slide-out effect. + * + * @param aTimeMiliseconds Slide out time in milliseconds. + */ + virtual void SetSlideOutDuration ( TInt aTimeMiliseconds ); + + /** + * The function returns slide out effect's duration. + * + * @return Slide out duration in miliseconds. + */ + virtual TInt SlideOutDuration ( ) const; + + /** + * The function sets direction of the slide out effect. + * + * @param aDirection A direction of the slide out effect. + */ + virtual void SetSlideOutDirection ( TFsSlideEffect aDirection ); + + /** + * The function returns direction of the slide out effect. + * + * @return A direction of the slide out effect. + */ + virtual MFsTreeVisualizer::TFsSlideEffect SlideOutDirection ( ) const; + + /** + * Returns information about looping type of the list. + * + * @return Type of list looping. EFsTreeListLoopingDisabled when looping + * is turned off. + */ + virtual TFsTreeListLoopingType LoopingType() const; + + /** + * Sets type of list's looping. + * + * @param aLoopingType type of list looping. + */ + virtual void SetLoopingType( const TFsTreeListLoopingType aLoopingType ); + + /** + * Sets the delay for the item expansion animation. + * + * @param aDelay Delay in miliseconds. + */ + virtual void SetItemExpansionDelay( const TInt aDelay ); + + /** + * + */ + virtual void SetItemSeparatorColor( const TRgb& aColor ); + + /** + * The functions sets fade-in's effect duration. + * @param aFadeTime A time in miliseconds for fade in effect. + */ + virtual void SetFadeInEffectTime( TInt aFadeTime ); + + /** + * Get the current parent layout of tree visualizer. + * + * @return Tree visualizer's current parent layout. + */ + CAlfLayout& ParentLayout() const; + + /** + * The functions sets fade's effect duration. + * + * @param aFadeTime A time in miliseconds for fade in/out effect. + */ + virtual TInt FadeInEffectTime( ); + + /** + * The functions sets fade-out's effect duration. + * @param aFadeTime A time in miliseconds for fade-out effect. + */ + virtual void SetFadeOutEffectTime( TInt aFadeTime ); + + /** + * The functions returns fade's effect duration. + * + * @return A time in miliseconds for fade in/out effect. + */ + virtual TInt FadeOutEffectTime( ); + + /** + * Set the item separator size (item border). + * + * @param aSize + */ + virtual void SetItemSeparatorSize( const TSize aSize ); + + /** + * Sets item border's thickness. To have one pixel border between items in + * the list pass TAlfTimedPoint(0.0f, 0.5f) as a parameter. + * + * @param aThickness Thickness of the border. + */ + virtual void SetItemSeparatorSize( const TAlfTimedPoint& aThickness ); + + /** + * Function sets the time of list scroll per item and the scroll + * acceleration rate. + * + * @param aScrollTime Time (in miliseconds) at which the list items are + * scrolled. + * @param aScrollAcceleration Rate of scroll acceleration when the up/down + * key is pressed for a long time. This is + * multiplied by the number of up/down key + * repeats. Acceleration rate should be in + * 0.0-1.0 range. + */ + virtual void SetScrollTime ( TInt aScrollTime, + TReal aScrollAcceleration = 0.0 ); + + /** + * Gets the delay for the item expansion animation. + * + * @return Delay in miliseconds. + */ + virtual TInt ItemExpansionDelay( ) const; + + /** + * Function gets the values of scroll speed and its acceleration rate. + * + * @param aScrollTime Time (in miliseconds) at which the list items are + * scrolled. + * + * @param aScrollAcceleration Rate of scroll acceleration when the up/down + * key is pressed for a long time. + */ + virtual void GetScrollTime(TInt& aScrollTime, TReal& aScrollAcceleration); + + /** + * Expands node, causes list refresh. + * + * @param aNodeId Id of the node to be expanded. + */ + virtual void ExpandNodeL( const TFsTreeItemId aNodeId ); + + /** + * Collapses node, causes list refresh. + * + * @param aNodeId Id of the node to be collapseded. + */ + virtual void CollapseNodeL( const TFsTreeItemId aNodeId ); + + /** + * Expands all nodes in the list, causes list refresh. + */ + virtual void ExpandAllL( ); + + /** + * Collapses all nodes in the list, causes list refresh. + */ + virtual void CollapseAllL( ); + + /** + * Updates item, if visible. + * + * @param aItemId Id of the item to be refreshed. + */ + virtual void UpdateItemL( const TFsTreeItemId aItemId ); + + /** + * The functions sets wether all item in the list should be always in + * extended state or in normal state. + * The function refreshes the list view. + * + * @param aAlwaysExtended ETrue if items should be always extended. EFalse + * if items should be in normal state. + */ + virtual void SetItemsAlwaysExtendedL ( TBool aAlwaysExtended ); + + /* + * The function returns if items are always in extended state or in normal + * + * @return ETrue if items are always in extended state, EFalse if items + * are in normal state. + */ + virtual TBool IsItemsAlwaysExtended ( ); + + /** + * The function sets a text for empty list's view. + * The function does not refresh the view automatically. + * + * @param aText Text to be displayed. + */ + virtual void SetEmptyListTextL( const TDesC& aText ); + + /** + * The function returns a text for empty list's view. + * + * @return Text displayed when a list is empty. + */ + virtual TDesC& GetEmptyListText( ) const; + + /** + * Sets the background texture, clears the background color. + * + * @param aBgTexture Texture to be set as list background. + */ + IMPORT_C void SetBackgroundTextureL( CAlfTexture& aBgTexture ); + + /** + * Sets the background color, clears the background texture. + * + * @param aBgTexture Texture to be set as list background. + */ + IMPORT_C void SetBackgroundColorL( TRgb aColor ); + + + /** + * Sets a given brush as a list background. + * + * @param aBrush Brush to be used as background. + */ + IMPORT_C void SetBackgroundBrushL( CAlfBrush* aBrush ); + + /** + * The function clears list's background. + */ + IMPORT_C void ClearBackground(); + + /** + * Sets watermark position. + * + * @param aPosition New position for the watermark. + */ + IMPORT_C void SetWatermarkPos( const TPoint& aPosition ); + + /** + * Sets watermark size. + * + * @param aSize New size for the watermark. + */ + IMPORT_C void SetWatermarkSize( const TSize& aSize ); + + /** + * Sets watermark opacity. + * If new opacity is equal to 0 then watermark is fully transparent, + * if it is equal to 1 then watermark is not transparent at all. + * + * @param aOpacity New opacity for the watermark. + */ + IMPORT_C void SetWatermarkOpacity( const float aOpacity ); + + /** + * Sets watermark texture. + * Pass NULL as a parameter to disable watermark. + * + * @param aTexture New texture for the watermark. + */ + IMPORT_C void SetWatermarkL( CAlfTexture* aTexture ); + + // from base class MFsTreeObserver + + /** + * + */ + virtual void TreeEventL( const TFsTreeEvent aEvent, + const MFsTreeObserver::TFsTreeEventParams& aParams ); + + /** + * Sets vertical scrollbar visibility status. + * + * @param aSetOn Visibility status for the scrollbar + */ + virtual void SetScrollBarVisibilityL(const TFsScrollbarVisibility aVisibility); + + /** + * Gets vertical scrollbar visibility status. + * + * @return Visibility status for the scrollbar + */ + virtual TFsScrollbarVisibility ScrollbarVisibility() const; + + /** + * Old API to be removed. Sets vertical scrollbar visibility status. + * + * @param aSetOn Visibility status for the scrollbar + */ + virtual void SetVScrollBarL( const TBool aSetOn ); + + + /** + * Sets border status. + * + * @param aVisible Visibility status of border + * @param aBorderTexture pointer to texture to be set for border + */ + virtual void SetBorderL( const TBool aVisible, + CAlfTexture* aBorderTexture = 0 ); + + /** + * Sets shadow status. + * + * @param aVisible Visibility status of shadow + */ + virtual void SetShadowL( const TBool aVisible ); + + /** + * Sets visualizer observer. + * + * @param aObserver Sets new tree visualizer observer. + */ + void SetVisualizerObserver( MFsTreeVisualizerObserver* aObserver ); + + /** + * Function which refreshes list display. + */ + virtual void RefreshListViewL(); + + /** + * Hide item. + * + * @param aItemId Id of the item to be hidden. + */ + virtual void HideItemL(const TFsTreeItemId aItemId); + + /** + * Unhide item. + * + * @param aItemId Id of the item to be shown. + */ + virtual void UnhideItemL(const TFsTreeItemId aItemId); + + /** + * + */ + virtual void SetPadding( const TAlfBoxMetric& aPadding ); + + /** + * List pane's padding taken from Layout Manager or switched off. + */ + void EnableListPanePadding( TBool aEnable ); + + /** + * Sets the type of text marquee. + * + * @param aMarquee Type of marquee. + */ + virtual void SetTextMarqueeType(const TFsTextMarqueeType aMarquee); + + /** + * Returns the type of text marquee. + * + * @return Type of marquee. + */ + virtual TFsTextMarqueeType TextMarqueeType() const; + + /** + * Sets the speed of marquee. + * + * @param aPixelsPerSec How many pixels per second. + */ + virtual void SetTextMarqueeSpeed ( const TInt aPixelsPerSec ); + + /** + * Returns the speed of marquee. + * + * @return How many pixels per second. + */ + virtual TInt TextMarqueeSpeed ( ) const; + + /** + * Sets delay for text marquee start. + * + * @param aStartDelay Time after which the text marquee starts (in miliseconds). + */ + virtual void SetTextMarqueeStartDelay ( const TInt aStartDelay ); + + /** + * Returns delay for text marquee. + * + * @return Time after which the text marquee starts (in miliseconds). + */ + virtual TInt TextMarqueeStartDelay () const; + + /** + * Sets a delay for each cycle start. + * + * @param aCycleStartDelay Time after which the text marquee cycle starts (in miliseconds). + */ + void SetTextMarqueeCycleStartDelay ( const TInt aCycleStartDelay ); + + /** + * Returns a delay for each cycle start. + * + * @return Time after which the text marquee cycle starts (in miliseconds). + */ + TInt TextMarqueeCycleStartDelay () const; + + /** + * Sets number of marquee cycles. + * + * @param aRepetitions Number of marquee cycles. Negetive values - infinite loop. + */ + virtual void SetTextMarqueeRepetitions ( const TInt aMarqueeRepetitions ); + + /** + * Returns number of marquee cycles. + * + * @return Number of marquee cycles. Negetive values - infinite loop. + */ + virtual TInt TextMarqueeRepetitions ( ) const; + + /** + * Returns the items's target bounding rectangle in display coordinates if the item is visible. + * Display coordinates are defined relative to the display's visible area. + * + * @param aItemId Item's ID. + * @param aRect Out parameter. If successfull, contains item's rectangle. + * @return KErrNone if successfull, + * KErrNotFound 1. the list does not contain item with given ID. + * 2. item is not visible + */ + virtual TInt GetItemDisplayRectTarget ( const TFsTreeItemId aItemId, TAlfRealRect& aRect ); + + /** + * Internall to TreeList. Do not use directly. + * + * Used to block update during addition of many items/nodes. Currently only + * scrollbar is blocked from beign updated. + * @param aDoRefresh ETrue + */ + virtual void SetAutoRefreshAtInsert( TBool aAllowRefresh ); + + /** + * Internall to TreeList. Do not use directly. + * + * Used to block update during addition of many items/nodes. Currently only + * scrollbar is blocked from beign updated. + * @return Auto update of scrollbar On/off + */ + virtual TBool IsAutoRefreshAtInsert(); + + /** + * Internall to TreeList. Do not use directly. + * + * Used to enable direct touch mode for the list. + */ + void SetDirectTouchMode( const TBool aDirectTouchMode ); + + /** + * Sets whether a long tap on a node should invoke expand/collapse all + * functionality. + * + * @param aExpandCollapse ETrue if long tap should expand/collapse all, + * EFalse if no action should be taken. + */ + virtual void SetExpandCollapseAllOnLongTap ( TBool aExpandCollapse ); + + /* + * The function returns if long tapping on a node results in + * expand/collapse all. + * + * @return ETrue if items are always in extended state, EFalse if items + * are in normal state. + */ + virtual TBool IsExpandCollapseAllOnLongTap ( ); + + /** + * Function shows selector or hides it. + * + * @param aVisible ETrue to make selector visible, EFalse to hide + * selector. + */ + IMPORT_C void MakeSelectorVisibleL( TBool aVisible ); + + /** + * Function shows selector or hides it. + * + * @aDelay for changing the opacity + * @param aVisible ETrue to make selector visible, EFalse to hide + * selector. + */ + void MakeSelectorVisibleL( TBool aVisible, TInt aDelay ); + +public: //From MFsFadeEffectObserver + + /** + * From MFsFadeEffectObserver + * Function which will receive notifications about fade effect state changes. + */ + virtual void FadeEffectEvent(MFsFadeEffectObserver::TFadeEffectState aState); + +public: //From MFsSlideEffectObserver + + /** + * From MFsSlideEffectObserver + * Function which will receive notifications about slide effect state changes. + * @param aState Current state of slide affect + */ + virtual void SlideEffectEvent(MFsSlideEffectObserver::TSlideEffectState aState); + +public: //From MAlfActionObserver + + /** + * Called by the server when an action command is executed. + * + * @param aActionCommand The command that is being executed. + */ + virtual void HandleActionL(const TAlfActionCommand& aActionCommand); + +public: + + /** + * @see MUiCScrollBar::MObserver::HandleScrollEventL + */ + void HandleScrollEventL( const MUiCScrollBar& aScrollBar, + MUiCScrollBar::TEvent aEvent ); + + /** + * + */ + void NotifyControlVisibilityChange( TBool aIsVisible ); + + /** + * Disables kinetic scrolling (Drag events will not scroll the list). + * + * @param aDisable ETrue if kinetic scrolling should be disabled. + */ + void DisableKineticScrolling( TBool aDisable ); + + /** + * Returns status of kinetic scrolling. + * + * @return ETrue if kinetic scrolling is disabled. + */ + TBool IsKineticScrollingDisabled() const; + + /** + * Returns viewPort top-left position + */ + virtual TPoint ViewPortTopPosition() const; + +public: // from MAknPhysicsObserver + + /** + * @see MAknPhysicsObserver::ViewPositionChanged + */ + virtual void ViewPositionChanged( const TPoint& aNewPosition, TBool aDrawNow = ETrue, TUint aFlags = 0 ); + + /** + * @see MAknPhysicsObserver::PhysicEmulationEnded + */ + virtual void PhysicEmulationEnded(); + + /** + * @see MAknPhysicsObserver::ViewPosition + */ + virtual TPoint ViewPosition() const; + +private: + + /** + * Hides off-screen list items, or clears the whole list. + * + * @param aRemoveAll ETrue if destroy all item visualizers, EFalse if + * destroy only off-screen visualizers + */ + void ClearVisibleItemsListL( TBool aRemoveAll = ETrue, + TBool aScrollList = ETrue ); + + /** + * Returns id of tree item if pointer event has hit the area. + * If item cannot be located KErrNotFound will be returned. + * + * @param aEvent Pointer event to investigate. + * @return TFsTreeItemId of item. + */ + TFsTreeItemId EventItemId( const TAlfEvent& aEvent ) const; + + TFsTreeItemId VisualItemId( const CAlfVisual* aVisual ) const; + + const CAlfVisual* FindVisualUnderDrag( const TPoint& aPosition ) const; + + /** + * Moves focus visual from one item to another. + * + * @param aPrevious Id of the previously focused item. + */ + void ChangeFocusL( const TFsTreeItemId aPrevious = KFsTreeNoneID ); + + /** + * Move focus in the list. + * + * @param aMoveType Type of a move, down, up, page down, page up. + */ + void MoveSelectionL(const TFsTreeVisualizerMove aMoveType); + + /** + * Moves focus by one item in the upper direction. + * + * @param aChangeFocus tells whether the selector should be updated or not + * + * @return Height of items that were traversed + */ + TInt MoveSelectionByLineUpL(const TBool aChangeFocus = ETrue); + + /** + * Moves focus by one item in the lower direction. + * + * @param aChangeFocus tells whether the selector should be updated or not + * + * @return Height of items that were traversed + */ + TInt MoveSelectionByLineDownL(const TBool aChangeFocus = ETrue); + + /** + * Scrolls list layout. + * + * @param aPrevious + * @param aAlignTop + */ + void Scroll( const TFsTreeItemId aPrevious = KFsTreeNoneID, + TBool aAlignTop=ETrue ); + + /** + * Returns the height of all visible items. + * + * @param aPrevious + * + * @return Height of all visible items in pixels. + */ + TInt VisibleItemsHeight( const TFsTreeItemId aPrevious ); + + /** + * Check if item is in expanded node. + * + * @param aItemId + * + * @return Etrue if item is in expanded node, EFalse otherwise + */ + TBool IsInExpanded( TFsTreeItemId aItemId ); + + void UpdateViewPortL(); + + /** + * Update scrollbar and list layout respectively. + * + * @param aTimeout Timeout needed for the update. + */ + void UpdateScrollBarL( const TInt aTimeout = 0 ); + TInt UpdateScrollBar( const TInt aTimeout = 0 ); + void UpdateScrollBarIfNeededL(); + void SetScrollBarModelValues(); + + /** + * Finds next focusable item. + * + * @param aItemId Focusable item for whom next focusable should be + * found. + * + * @return Focusable item id. + */ + TFsTreeItemId NextFocusableItem( const TFsTreeItemId aItemId ); + + /** + * Finds previous focusable item. + * + * @param aItemId Focusable item for whom previous focusable should be + * found. + * + * @return Focusable item id. + */ + TFsTreeItemId PrevFocusableItem( const TFsTreeItemId aItemId ); + + /** + * Function sets current scroll speed based on the up/down key repeats. + * + * @param aKeyRepeats Number of up/down key repeats. + */ + void SetCurrentScrollSpeed( TInt aKeyRepeats ); + + /** + * Gets default settings from Central Repository. + */ + void ReadDefaultValuesFromCenRep(); + + /** + * Sets values to an item which are default for the whole list (e.g. if + * items are always extended. + * + * @param aItemVis Item's visualizer. + */ + void ApplyListSpecificValuesToItem (MFsTreeItemVisualizer *aItemVis); + + + /** + * The function calculates tree height up to the specified item. + * + * @param aItemId Id on an item up to which the tree height should be + * calculated. + * @param aHeight Calculated height. + * + * @return KErrNone if successful. KErrNotFound if item id was invalid or + * item is in collapsed node. + */ + TInt CalculateTreeHeightUpToItem( const TFsTreeItemId aItemId, + TInt& aHeight ) const; + + /** + * Update list's visual content by appending items into empty gap in list + * + * @param aHeight Height of the empty gap to be filled. + */ + void FillGapWithItemsL( const TInt aHeight ); + + /** + */ + void UpdateListItemSizes( ); + + /** + */ + void UpdateListItemSize( TInt aIndex ); + + /** + * The function scrolls list layouts to the given offset in a given time. + */ + void ScrollListLayoutsL( TInt aScrollOffset, TInt aScrollTime ); + TInt ScrollListLayouts( TInt aScrollOffset, TInt aScrollTime ); + + void AdjustVisibleItemsL(); + + /* + * Appends item to the top of the list layout. + */ + void InsertItemL( TFsTreeItemId aItemId, const TInt aSlot = 0); + + /** + * The function deletes selector visual. + */ + void DestroySelectorVisualL( ); + + /** + * The function creates selector visual. + */ + void CreateSelectorVisualL( ); + + /** + */ + void UpdateSelectorVisualL(TInt aTime = 0); + + /** + The function implements tree observer's reaction to removing a list item + from the model. If the item was visible then it's removed from the visible + area. If the focused item was removed then the focus is moved to the next + item in the tree hierarchy (if the next item is not present, then the focus + is moved to the previous one). + */ + void RemoveItemL( TFsTreeItemId aItemId ); + + /** + The function checks whether the focused item is not outside the visible + area and if needed scrolls the list so that selected item is fully visible. + */ + void MakeFocusedItemFullyVisible(); + + /** + * The function assures that the list view is correct. + * It sets focused item as fully visible.Neighbouring items are also made, if possible, + * fully visible to fullfil the scrolling rules. + */ + void ValidateListLayoutL( TInt aTime = 0 ); + + /** + * The function checks if the given item id matches the focused one. + * + * @param aItemId Item id to be checked. + * + * @return ETrue if the id matches the focused id && list has focus && + * there is a defined focused item. + */ + TBool IsItemFocused( TFsTreeItemId aItemId ) const; + +private: + /** + * Tree visualization state + */ + enum TFsTreeVisualState + { + /** + * + */ + EFsTreeVisible, + EFsTreeHidden, + EFsTreeFadingIn, + EFsTreeFadingOut, + EFsTreeSlidingIn, + EFsTreeSlidingOut, + EFsTreeFadingInSlidingIn, + EFsTreeFadingOutSlidingOut + }; + /** + * C++ constructor + * + * @param aOwnerControl Owner control. + * @param aParent Parent layout for all the new layouts constructed by + * this class. + */ + CFsTreeVisualizerBase( CAlfControl* aOwnerControl, + CAlfLayout& aParent, const TBool aPopUpMode ); + + /** + * Second phase constructor + * + */ + void ConstructL( ); + + +// TREE OPTIMIZATIONS + + TInt TreeHeight() const; + + //void SetTreeHeightL( const TInt aValue ); + + TBool AllNodesCollapsed() const; + TBool AllNodesExpanded() const; + +private: // from TWorld::MObserver + + virtual void WorldUpdatedL( const TWorld& aWorld ); + + +private: // from TViewPort::MObserver + + virtual void ViewPortUpdatedL( TViewPort& aViewPort, TUpdatedByPhysic aUpdateByPhysic = ENotUpdatedByPhisic); + +// TREE OPTIMIZATIONS + + /** + * Updates world size and view position. + */ + void UpdatePhysicsL(); + + /** + * + */ + void SetPanningPosition(const TPoint& aDelta); + + /** + * + */ + void StartPhysics(TPoint& aDrag, const TTime& aStartTime); + + /** + * Sets focused item and send event of touch focusing. + */ + void SetFocusedItemAndSendEventL( const TFsTreeItemId aItem, + TPointerEventType aEventType, const TPoint& aPoint ); + + /** + * Just a wrapper for SetFocusedItemAndSendEventL which returns the + * error code instead of leaving. + */ + TInt SetFocusedItemAndSendEvent( const TFsTreeItemId aItem, + TPointerEventType aEventType, const TPoint& aPoint ); + +private: // from MAknPhysicsObserver + + virtual TBool IsFocusShown(); + +private: //Data members + /* + * Visualization state + */ + TFsTreeVisualState iVisualizationState; + + /* + * A parent control for the tree visualizer. + */ + CAlfControl* iOwnerControl; + + /* + * A parent layout for the tree visualizer. + */ + CAlfLayout& iParentLayout; + + /** + * Data model. + * Not owned. + */ + CFsTree* iTreeData; + + /** + * Id of the currently selected item.. + */ + TFsTreeItemId iFocusedItem; + + /** + * Visualizer for the empty list component. Visualizes the list when only + * root "is visible". + * Own. + */ + MFsTreeNodeVisualizer* iRootVisualizer; + + /** + * Data for the root visualizer. Used for example to store "empty" text. + * Own. + */ + CFsTreePlainOneLineItemData* iRootData; + + /** + * Main layout of the component. + */ + CAlfGridLayout* iComponentLayout; + + /** + * + */ + CAlfDeckLayout* iListDeck; + + /** + * + */ + CAlfFlowLayout* iListItemBackgroundLayout; + + /** + * + */ + CAlfDeckLayout* iSelectorLayout; + + /** + * Layout in which items are placed. + */ + CAlfFlowLayout* iListLayout; + + /** + * Layout in which scroll bar is shown (on top of others) + */ + CAlfAnchorLayout* iScrollBarLayout; + + /** + * Layout in which watermark is placed. + */ + CAlfDeckLayout* iWatermarkLayout; + + /** + * A list of currently visible items. + */ + RArray iVisibleItems; + + /** + * + */ + RArray iVisibleItemsBackground; + + /** + * Type of List's looping. + */ + TFsTreeListLoopingType iLooping; + + /** + * A brush holding item separator color. + */ + CAlfBrush* iBorderBrush; + + /** + * A table of keys which trigger page-up event. + */ + RArray iCustomPageUpKeys; + + /** + * A table of keys which trigger page-down event. + */ + RArray iCustomPageDownKeys; + + /** + * Scrollbar + */ + CAlfImageVisual* iDummyScrollbar; + MUiCScrollBar* iScrollBar; + TUiCScrollBarModel iScrollBarModel; + TFsScrollbarVisibility iScrollbarVisibility; + + /** + * Image visual for the selector. + * Own. + */ + CAlfImageVisual* iSelectorVisual; + + /** + * Texture for the selector. + * Not own. + */ + CAlfTexture* iSelectorTexture; + + /** + * Selector's brush. + * Not own. + */ + CAlfBrush* iSelectorBrush; + + /** + Selector's opacity. + */ + TReal32 iSelectorOpacity; + + /** + * Selector's left border width. + */ + TInt iLeftSelectorBorderWidth; + + /** + * Selector's right border width. + */ + TInt iRightSelectorBorderWidth; + + /** + * Selector's top border height. + */ + TInt iTopSelectorBorderHeight; + + /** + * Selector's bottom border height. + */ + TInt iBottomSelectorBorderHeight; + + /** + * Type of the selector's movement. + */ + TFsSelectorMovement iSelectorMovementType; + + /** + * Class for controlling the fade effects + */ + CFsFadeEffect* iFadeEffect; + + /** + * Class for controlling the slide effects + */ + CFsSlideEffect* iSlideEffect; + + /** + * Root layout - for shadow + */ + CAlfDeckLayout* iRootLayout; + + /** + * Shadow layout, holds shadow brush when shadow is enabled. + */ + CAlfDeckLayout* iShadowLayout; + + /** + * Border layout, holds border brush if it is enabled.. + */ + CAlfDeckLayout* iBorderLayout; + + /** + * Icon used to mark items. + */ + CAlfTexture* iMarkIcon; + + /** + * Icon indicating that item has menu. + */ + CAlfTexture* iMenuIcon; + + /** + * Item text marquee speed. In pixels per second. + * Own. + */ + TUint iMarqueeSpeed; + + /** + * Visualizer observer + * Not own. + */ + MFsTreeVisualizerObserver* iVisualizerObserver; + + /** + * Speed of scrolling. + */ + TInt iScrollSpeed; + + /** + * Current speed of scrolling. Can vary from iScrollSpeed by rate of + * scroll acceleration. + */ + TInt iCurrentScrollSpeed; + + /** + * The rate at which scroll speed accelerates when up/down key is pressed + * for a long time. + */ + TReal iScrollAccelerationRate; + + /** + * Duration of fade-in effect. + */ + TInt iFadeInEffectTime; + + /** + * Duration of fade-out effect. + */ + TInt iFadeOutEffectTime; + + /** + * Watermark used by the list. + */ + CFsWatermark* iWatermark; + + /** + * Hierarchy level indentation in pixel. + */ + TInt iLevelIndentation; + + /** + * Duration of a slide in effect. + */ + TInt iSlideInDuration; + + /** + * Direction of a slide in effect. + */ + MFsTreeVisualizer::TFsSlideEffect iSlideInDirection; + + /** + * Duration of a slide out effect. + */ + TInt iSlideOutDuration; + + /** + * Direction of a slide out effect. + */ + MFsTreeVisualizer::TFsSlideEffect iSlideOutDirection; + + /** + * Instance of text style manager. + * Own. + */ + CFsAlfTextStyleManager* iTextStyleManager; + + /** + * List layout scroll offset. + */ + TInt iScrollOffset; + + /** + * Time interval. + * Own. + */ + CFsInteractionInterval* iIntx; + + /** + * List item text marquee setting. + */ + TFsTextMarqueeType iMarqueeType; + + /** + * Marquee start delay in miliseconds. + */ + TInt iMarqueStartDelay; + + /** + * Marquee cycle start delay in miliseconds. + */ + TInt iMarqueCycleStartDelay; + + /** + * Number of marquee cycles. + * Negative value - infinite loop. + */ + TInt iMarqueeRepetitions; + + /** + * Pointer drag handler instance (owned) + */ + CDragHandler* iDragHandler; + + /** + * AknPhysics instance (owned) + */ + CAknPhysics* iPhysics; + + /** + * Visual structure of the whole list. + */ + TWorld iWorld; + + /* + * List viewport. + */ + TViewPort iViewPort; + + /** + * Boolean flags + */ + enum TFlag { + /** + * Set if the physics action is going on + */ + EPhysicsOn, + + /** + * Do auto refresh during addition of items. + * Currently scrollbar refresh can be blocked. + */ + EAutoRefresh, + + /** + * Holds information wether items are always extended. + */ + EItemsAlwaysExtended, + + /** + * Page down event is being handled. + */ + EIsPageUpDownActive, + + /** + * If this flag is set, tree will work in direct touch mode + */ + EDirectTouchMode, + + /** + * The list is focused or not. + */ + EListFocused, + + /** + * Long tap on node invokes expand/collapse all. + */ + EExpandCollapseOnLongTap, + + /** + * Do physics update when simulation has finished. + */ + EUpdatePhysicsAfterSimulationFinished, + + /** + * Ignore next pointer up event. + */ + EIgnorePointerUpAction, + + /** + * List is shown in popup mode. + */ + EPopupMode, + + /** + * Informs tactile feedback that item was added i.e. does not + * play feedback. + */ + EListModelUpdate, + + /** + * This flag is checked when trying to focus item. Focus is ignored + * if list is being panned. + */ + EListPanning + }; + + // Flags + TBitFlags iFlags; + + // ETrue when the stylus/finger is currently pressed down + TBool iTouchPressed; + + // Keyboard flip state + TBool iFlipOpen; + + // Focus visibility state (e.g. will be hidden after a delay) + TBool iFocusVisible; + + /** + * States status of kinetic scrolling. + */ + TBool iKineticScrollingDisabled; + }; + +#endif // C_FSTREEVISUALIZER_H +