/*

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

#include <babitflags.h>

//////TOOLKIT INCLUDES

// <cmail> SF

#include <alf/alfenv.h> //MAlfActionObserver

// </cmail>

//////PROJECT INCLUDES

//<cmail> removed __FS_ALFRED_SUPPORT flag

//#include <fsconfig.h>

//</cmail> removed __FS_ALFRED_SUPPORT flag

#include <aknphysicsobserveriface.h>

#include "fstreevisualizer.h"

#include "fstreeobserver.h"

#include "fsfadeeffectobserver.h"

#include "fsslideeffectobserver.h"

#include "fsscrollbarset.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 CAknDoubleSpanScrollBar;

class CAknPhysics;

/**

 * 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<TFsTreeItemId>& aItems, TInt aY, TInt aHeight, TInt& aOffset );

    /**

     * 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 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<MObserver> iObservers;

    // World items

    RArray<TItem> 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<TFsTreeItemId>& aItemsToBeRemoved, RArray<TFsTreeItemId>& aItemsToBeAdded, TInt& aOffset, TBool& aFullUpdate  );

    /**

      * Get items visible in viewport's area.

      */

    void GetVisibleItemsL(RArray<TFsTreeItemId>& 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<TFsTreeItemId>& aItems, RArray<TFsTreeItemId>& aItemsToBeRemoved, RArray<TFsTreeItemId>& aItemsToBeAdded, TBool& aFullUpdate );

        /**

         * Returns top most item from the cache.

         */

        TFsTreeItemId TopItem() const;