/*
* 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:  Freestyle list component implementation
*
*/



//////SYSTEM INCLUDES

//////TOOLKIT INCLUDES
// <cmail> SF
#include "emailtrace.h"
#include <alf/alfenv.h>
// </cmail>

//////PROJECT INCLUDES
//<cmail> removed __FS_ALFRED_SUPPORT flag
//#include <fsconfig.h>
//</cmail> removed __FS_ALFRED_SUPPORT flag
#include "fstreelist.h"
#include "fstreecontrol.h"
#include "fstree.h"
#include "fstreeitem.h"
#include "fstreenode.h"
#include "fsgenericpanic.h"
#include "fstreeitemdata.h"
#include "fstreeitemvisualizer.h"
#include "fstreenodevisualizer.h"
#include "fstreelistobserver.h"
#include "fstreevisualizerbase.h"
#include "fstextstylemanager.h"
#include "fstreeobserver.h"
#include "fsalftextstylemanager.h"
#include "fsscrollbarset.h"


// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
EXPORT_C CFsTreeList* CFsTreeList::NewL( CFsTreeVisualizerBase& aTreeV,
                                         CAlfEnv& aEnv )
    {
    FUNC_LOG;
    CFsTreeList* self = new( ELeave ) CFsTreeList( aEnv, aTreeV );
    CleanupStack::PushL( self );
    self->ConstructL( aEnv );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// C++ destructor.
// ---------------------------------------------------------------------------
//
EXPORT_C CFsTreeList::~CFsTreeList()
    {
    FUNC_LOG;
    delete iTree;
    delete iTreeVisualizer;
    delete iTextStyleManager;
    iObservers.Close();
    }

// ---------------------------------------------------------------------------
//  Adds observer to the list of observers
// ---------------------------------------------------------------------------
EXPORT_C void CFsTreeList::AddObserverL(
    MFsTreeListObserver& aTreeListObserver )
    {
    FUNC_LOG;
    iObservers.AppendL(&aTreeListObserver);
    }

// ---------------------------------------------------------------------------
//  Removes observer from the list of observers
// ---------------------------------------------------------------------------

EXPORT_C void CFsTreeList::RemoveObserver(
    MFsTreeListObserver& aTreeListObserver )
    {
    FUNC_LOG;
    TInt ind = iObservers.Find( &aTreeListObserver );
    if ( ind >= 0 )
        {
        iObservers.Remove( ind );
        }
    }

// ---------------------------------------------------------------------------
// Returns a control associated with the component.
// ---------------------------------------------------------------------------
//
EXPORT_C CAlfControl* CFsTreeList::TreeControl( ) const
    {
    FUNC_LOG;
    return iTreeControl;
    }

void CFsTreeList::BeginUpdate()
    {
    iTreeVisualizer->SetAutoRefreshAtInsert( EFalse );    
    }

void CFsTreeList::EndUpdateL()
    {
    iTreeVisualizer->SetAutoRefreshAtInsert( ETrue );        
    }

// ---------------------------------------------------------------------------
// Inserts new item as a child of parent given by Id with the given position.
// ---------------------------------------------------------------------------
//
EXPORT_C TFsTreeItemId CFsTreeList::InsertItemL( MFsTreeItemData& aItemD,
                                                 MFsTreeItemVisualizer& aItemV,
                                                 const TFsTreeItemId aParent,
                                                 const TInt aIndex,
                                                 const TBool aAllowRefresh )
    {
    FUNC_LOG;
    iTreeVisualizer->SetAutoRefreshAtInsert( aAllowRefresh );
    return iTree->InsertItemL(aItemD,aItemV,aParent,aIndex);
    }

// ---------------------------------------------------------------------------
// Inserts new node as a child of parent given by Id with the given position.
// ---------------------------------------------------------------------------
//
EXPORT_C TFsTreeItemId CFsTreeList::InsertNodeL( MFsTreeItemData& aItemD,
                                                 MFsTreeNodeVisualizer& aNodeV,
                                                 const TFsTreeItemId aParent,
                                                 const TInt aIndex,
                                                 const TBool aAllowRefresh )
    {
    FUNC_LOG;
    iTreeVisualizer->SetAutoRefreshAtInsert( aAllowRefresh );
    return iTree->InsertNodeL(aItemD, aNodeV, aParent, aIndex);
    }

// ---------------------------------------------------------------------------
//  Remove all items from the list.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::RemoveL( const TFsTreeItemId aItemId )
    {
    FUNC_LOG;
    iTree->RemoveL(aItemId);
    }

// ---------------------------------------------------------------------------
//  Remove all items from the list.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::RemoveAllL()
    {
    FUNC_LOG;
    iTree->RemoveL(KFsTreeRootID);
    }

// ---------------------------------------------------------------------------
//  Remove all children of the selected node.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::RemoveChildrenL( const TFsTreeItemId aNodeId )
    {
    FUNC_LOG;
    for ( TInt childIndex = 0; childIndex < iTree->CountChildren(aNodeId);
                                                    childIndex++ )
        {
        iTree->RemoveL(iTree->Child(aNodeId, childIndex));
        }
    }


// ---------------------------------------------------------------------------
//  Moves the item with given Id to the list of children of parent with
//  given id
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::MoveItemL( const TFsTreeItemId aItemId,
        const TFsTreeItemId aTargetNode, const TInt aIndex )
    {
    FUNC_LOG;
    TBool subtreeItem = EFalse;
    TFsTreeItemId treeItem = aTargetNode;
    while (treeItem!=KFsTreeRootID)
        {
        treeItem = iTree->Parent(treeItem);
        if (treeItem==aItemId)
            {
            subtreeItem = ETrue;
            break;
            }
        }

    if (subtreeItem)
        {
        User::Leave(EFsListPanicMovingNodeToItsChild);
        }
    else
        {
        iTree->MoveL( aItemId, aTargetNode, aIndex );
        }
    }

// ---------------------------------------------------------------------------
//  Checks if a node has children, if parameter is omitted, root of the list
//  is checked to indicate if the list is empty.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFsTreeList::IsEmpty( const TFsTreeItemId aNodeId ) const
    {
    FUNC_LOG;
    TBool result = ETrue;

    if (aNodeId == KFsTreeRootID)
        {
        if (iTree->Count() > 0)
            {
            result = EFalse;
            }
        }
    else
        {
        if (iTree->CountChildren(aNodeId) > 0)
            {
            result = EFalse;
            }
        }

    return result;
    }

// ---------------------------------------------------------------------------
//  Returns the level of an item in tree.
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CFsTreeList::Level( const TFsTreeItemId aItemId ) const
    {
    FUNC_LOG;
    return iTree->Level(aItemId);
    }

// ---------------------------------------------------------------------------
//  Remove all children of the selected node.
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CFsTreeList::Count() const
    {
    FUNC_LOG;
    return iTree->Count();
    }

// ---------------------------------------------------------------------------
//  Gets the number of children of the given node
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CFsTreeList::CountChildren( const TFsTreeItemId aNodeId ) const
    {
    FUNC_LOG;
    return iTree->CountChildren( aNodeId );
    }

// ---------------------------------------------------------------------------
//  Gets the id of a child of the specified node with the position given
// ---------------------------------------------------------------------------
//
EXPORT_C TFsTreeItemId CFsTreeList::Child( const TFsTreeItemId aNodeId,
                                            const TUint aIndex ) const
    {
    FUNC_LOG;
    return iTree->Child( aNodeId,  aIndex );
    }

// ---------------------------------------------------------------------------
//  Gets the index of a child with the specified id.
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CFsTreeList::ChildIndex(const TFsTreeItemId aNodeId,
        const TFsTreeItemId aItemId ) const
    {
    FUNC_LOG;
    return iTree->ChildIndex(aNodeId, aItemId);
    }

// ---------------------------------------------------------------------------
//  Gets the parent's id for the specified item.
// ---------------------------------------------------------------------------
//
EXPORT_C TFsTreeItemId CFsTreeList::Parent(const TFsTreeItemId aItemId) const
    {
    FUNC_LOG;
    return iTree->Parent(aItemId);
    }

// ---------------------------------------------------------------------------
//  Checks whether the item with specified id belongs to the list.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFsTreeList::Contains( const TFsTreeItemId aItemId ) const
    {
    FUNC_LOG;
    return iTree->Contains(aItemId);
    }

// ---------------------------------------------------------------------------
//  Checks if item is node or not.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFsTreeList::IsNode( const TFsTreeItemId aItemId ) const
    {
    FUNC_LOG;
    return iTree->IsNode(aItemId);
    }

//---------------------------------------------------------------------------
// Sets focus state of list component
//---------------------------------------------------------------------------
EXPORT_C void CFsTreeList::SetFocusedL( const TBool aFocused )
    {
    FUNC_LOG;
    iListFocused = aFocused;
    iTreeControl->SetFocused( iListFocused );
    iTreeVisualizer->SetFocusedL( iListFocused );
    }

//---------------------------------------------------------------------------
// Returns state of the focus
//---------------------------------------------------------------------------
EXPORT_C TBool CFsTreeList::IsFocused() const
    {
    FUNC_LOG;
    return iListFocused;
    }

// ---------------------------------------------------------------------------
//  The function sets duration of the slide-in effect.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetSlideInDuration ( TInt aTimeMiliseconds )
    {
    FUNC_LOG;
    iTreeVisualizer->SetSlideInDuration ( aTimeMiliseconds );
    }

// ---------------------------------------------------------------------------
//  The function returns slide in effect's duration.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::SlideInDuration ( ) const
    {
    FUNC_LOG;
    return iTreeVisualizer->SlideInDuration ( );
    }

// ---------------------------------------------------------------------------
//  The function sets direction of the slide in effect.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetSlideInDirection (
                                MFsTreeVisualizer::TFsSlideEffect aDirection )
    {
    FUNC_LOG;
    iTreeVisualizer->SetSlideInDirection ( aDirection );
    }

// ---------------------------------------------------------------------------
//  The function returns direction of the slide in effect.
// ---------------------------------------------------------------------------
//
EXPORT_C MFsTreeVisualizer::TFsSlideEffect
                                       CFsTreeList::SlideInDirection ( ) const
    {
    FUNC_LOG;
    return iTreeVisualizer->SlideInDirection ( );
    }

// ---------------------------------------------------------------------------
//  The function sets duration of the slide-out effect.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetSlideOutDuration ( TInt aTimeMiliseconds )
    {
    FUNC_LOG;
    iTreeVisualizer->SetSlideOutDuration ( aTimeMiliseconds );
    }

// ---------------------------------------------------------------------------
//  The function returns slide out effect's duration.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::SlideOutDuration ( ) const
    {
    FUNC_LOG;
    return iTreeVisualizer->SlideOutDuration ( );
    }

// ---------------------------------------------------------------------------
//  The function sets direction of the slide out effect.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetSlideOutDirection (
                                MFsTreeVisualizer::TFsSlideEffect aDirection )
    {
    FUNC_LOG;
    iTreeVisualizer->SetSlideOutDirection ( aDirection );
    }

// ---------------------------------------------------------------------------
//  The function returns direction of the slide out effect.
// ---------------------------------------------------------------------------
//
EXPORT_C MFsTreeVisualizer::TFsSlideEffect
                                      CFsTreeList::SlideOutDirection ( ) const
    {
    FUNC_LOG;
    return iTreeVisualizer->SlideOutDirection ( );
    }

// ---------------------------------------------------------------------------
//  Returns information about looping type of the list.
// ---------------------------------------------------------------------------
//
EXPORT_C TFsTreeListLoopingType CFsTreeList::LoopingType() const
    {
    FUNC_LOG;
    TFsTreeListLoopingType loopingType = EFsTreeListLoopingDisabled;

    if ( iTreeVisualizer )
        {
        loopingType = iTreeVisualizer->LoopingType();
        }

    return loopingType;
    }

// ---------------------------------------------------------------------------
// Returns information whether list is markable, non-markable or
// multi-markable
// ---------------------------------------------------------------------------
//
EXPORT_C CFsTreeList::TFsTreeListMarkType CFsTreeList::MarkType() const
    {
    FUNC_LOG;
    return iMarkType;
    }

// ---------------------------------------------------------------------------
// OLD API - to be removed.
// Returns information about scrollbars used by list visual
// ---------------------------------------------------------------------------
//
EXPORT_C CFsTreeList::TFsTreeListScrollbars CFsTreeList::HasScrollBars() const
    {
    FUNC_LOG;
    return iHasScrollBars;
    }

// ---------------------------------------------------------------------------
// Old API - to be removed
// Enables or disables scrollbars
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetScrollBarsL( const TFsTreeListScrollbars aFlag )
    {
    FUNC_LOG;
    iHasScrollBars = aFlag;
    if ( aFlag == EFsTreeListNoScrollbars )
        {
        iTreeVisualizer->SetVScrollBarL( EFalse );
        }
    else if ( aFlag == EFsTreeListVerticalScrollbar )
        {
        iTreeVisualizer->SetVScrollBarL( ETrue );
        }
    }

// ---------------------------------------------------------------------------
// Returns information about scrollbars used by list visual
// ---------------------------------------------------------------------------
//
EXPORT_C TFsScrollbarVisibility CFsTreeList::ScrollbarVisibility() const
    {
    FUNC_LOG;
    return iTreeVisualizer->ScrollbarVisibility();
    }

// ---------------------------------------------------------------------------
// Enables or disables scrollbars
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetScrollbarVisibilityL(const TFsScrollbarVisibility aVisibility)
    {
    FUNC_LOG;
    iTreeVisualizer->SetScrollBarVisibilityL(aVisibility);
    }

// ---------------------------------------------------------------------------
//  Sets type of list's looping.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetLoopingType(
                                   const TFsTreeListLoopingType aLoopingType )
    {
    FUNC_LOG;
    if ( iTreeVisualizer )
        {
        iTreeVisualizer->SetLoopingType( aLoopingType );
        }
    }

// ---------------------------------------------------------------------------
// The functions sets fade-in's effect duration.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetFadeInEffectTime( TInt aFadeTime )
    {
    FUNC_LOG;
    iTreeVisualizer->SetFadeInEffectTime( aFadeTime );
    }

// ---------------------------------------------------------------------------
// The functions returns fade-in's effect duration.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::FadeInEffectTime( )
    {
    FUNC_LOG;
    return iTreeVisualizer->FadeInEffectTime( );
    }

// ---------------------------------------------------------------------------
// The functions sets fade-out's effect duration.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetFadeOutEffectTime( TInt aFadeTime )
    {
    FUNC_LOG;
    iTreeVisualizer->SetFadeOutEffectTime ( aFadeTime );
    }

// ---------------------------------------------------------------------------
// The functions returns fade-out's effect duration.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::FadeOutEffectTime( )
    {
    FUNC_LOG;
    return iTreeVisualizer->FadeOutEffectTime();
    }

// ---------------------------------------------------------------------------
// Function sets the time of list scroll per item and the scroll
// acceleration rate.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetScrollTime ( TInt aScrollTime,
                                           TReal aScrollAcceleration )
    {
    FUNC_LOG;
    iTreeVisualizer->SetScrollTime( aScrollTime, aScrollAcceleration );
    }

// ---------------------------------------------------------------------------
// Function gets the values of scroll speed and its acceleration rate.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::GetScrollTime( TInt& aScrollTime,
                                          TReal& aScrollAcceleration )
    {
    FUNC_LOG;
    iTreeVisualizer->GetScrollTime( aScrollTime, aScrollAcceleration );
    }

// ---------------------------------------------------------------------------
// Gets the currently focused (highlighted) item id.
// ---------------------------------------------------------------------------
//
EXPORT_C TFsTreeItemId CFsTreeList::FocusedItem() const
    {
    FUNC_LOG;
    return iTreeVisualizer->FocusedItem();
    }

// ---------------------------------------------------------------------------
// Sets the focus (highlight) upon the item with given id.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetFocusedItemL( const TFsTreeItemId aItemId )
    {
    FUNC_LOG;
    iTreeVisualizer->SetFocusedItemL(aItemId);
    }

// ---------------------------------------------------------------------------
//  Checks whether the item with specified id is marked.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFsTreeList::IsMarked( const TFsTreeItemId aItemId ) const
    {
    FUNC_LOG;
    return iTreeVisualizer->IsMarked( aItemId );
    }

// ---------------------------------------------------------------------------
//  Marks the item.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::MarkItemL( const TFsTreeItemId aItemId, TBool aMarked )
    {
    FUNC_LOG;
    iTreeVisualizer-> MarkItemL( aItemId, aMarked );
    }

// ---------------------------------------------------------------------------
// Enables or disables marking of list items.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetMarkTypeL( const TFsTreeListMarkType aFlag )
    {
    FUNC_LOG;
    iMarkType = aFlag;

    switch ( iMarkType )
    {
    case EFsTreeListNonMarkable:
        {
        iTreeVisualizer->MarkAllItemsL( EFalse );
        break;
        }
    case EFsTreeListMarkable:
        {
        RArray<TFsTreeItemId> markedItems;
        iTreeVisualizer->GetMarkedItemsL( markedItems );
        iTreeVisualizer->MarkAllItemsL( EFalse );
        if ( markedItems.Count() > 0 )
            {
            iTreeVisualizer->MarkItemL( markedItems[0], ETrue );
            }
        break;
        }
    case EFsTreeListMultiMarkable:
        {
        break;
        }
    }
    }

// ---------------------------------------------------------------------------
//  Get items indentation in pixels.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::Indentation() const
    {
    FUNC_LOG;
    return iTreeVisualizer->Indentation();
    }

// ---------------------------------------------------------------------------
//  Set items indentation in pixels.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetIndentationL( const TInt aIndentation )
    {
    FUNC_LOG;
    iTreeVisualizer->SetIndentationL( aIndentation );
    }

// ---------------------------------------------------------------------------
//  The functions sets wether all item in the list should be always in
//  extended state or in normal state.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetItemsAlwaysExtendedL ( TBool aAlwaysExtended )
    {
    FUNC_LOG;
    iTreeVisualizer->SetItemsAlwaysExtendedL ( aAlwaysExtended );
    }

// ---------------------------------------------------------------------------
//  The function returns if items are always in extended state or in normal.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFsTreeList::IsItemsAlwaysExtended ( )
    {
    FUNC_LOG;
    TBool alwaysExtended = EFalse;
    alwaysExtended = iTreeVisualizer->IsItemsAlwaysExtended();
    return alwaysExtended;
    }

// ---------------------------------------------------------------------------
//  C++ constructor.
// ---------------------------------------------------------------------------
//
EXPORT_C CFsTreeList::CFsTreeList( CAlfEnv& aEnv, CFsTreeVisualizerBase& aTreeV )
    : iEnv(&aEnv),
      iListFocused (ETrue)
    {
    FUNC_LOG;
    iTreeVisualizer = &aTreeV;
    }

// ---------------------------------------------------------------------------
//  Second phase constructor.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::ConstructL( CAlfEnv& aEnv )
    {
    FUNC_LOG;
    iTextStyleManager = CFsAlfTextStyleManager::NewL( aEnv.TextStyleManager() );
    iTree = CFsTree::NewL(*iTreeVisualizer, *(iTreeVisualizer->RootItemData()),
                                      *(iTreeVisualizer->RootNodeVisualizer()));
    iTreeVisualizer->SetTreeData(*iTree);
    iTreeControl = CFsTreeControl::NewL(aEnv, *iTree, *iTreeVisualizer);
    iTreeVisualizer->ShowListL( EFalse );
    iTreeVisualizer->SetVisualizerObserver( this );
    }

// ---------------------------------------------------------------------------
//  Expand the node.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::ExpandNodeL( const TFsTreeItemId aNodeId )
    {
    FUNC_LOG;
    iTreeVisualizer->ExpandNodeL(aNodeId);
    }

// ---------------------------------------------------------------------------
//  Collapse the node.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::CollapseNodeL( const TFsTreeItemId aNodeId )
    {
    FUNC_LOG;
    iTreeVisualizer->CollapseNodeL(aNodeId);
    }

// ---------------------------------------------------------------------------
//  Copy the list of marked items.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::GetMarkedItemsL(
                                       RFsTreeItemIdList& aMarkedItems ) const
    {
    FUNC_LOG;
    iTreeVisualizer->GetMarkedItemsL(aMarkedItems);
    }

// ---------------------------------------------------------------------------
//  Gets the reference to the item/node data (const).
// ---------------------------------------------------------------------------
//
EXPORT_C MFsTreeItemData& CFsTreeList::ItemData(
        const TFsTreeItemId aItemId) const
    {
    FUNC_LOG;
    return iTree->ItemData(aItemId);
    }

// ---------------------------------------------------------------------------
//  Sets the reference to the item/node data.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetItemDataL( MFsTreeItemData& aData,
        const TFsTreeItemId aItemId )
    {
    FUNC_LOG;
    MFsTreeItemData* data = &iTree->ItemData(aItemId);
    delete data;
    iTree->SetItemData(aData, aItemId);
    iTreeVisualizer->TreeEventL(
            MFsTreeObserver::EFsTreeItemDataChanged,
            MFsTreeObserver::TFsTreeEventParams(aItemId, KFsTreeNoneID, -1) );
    }

// ---------------------------------------------------------------------------
//  Gets the reference to the item visualizer (const).
// ---------------------------------------------------------------------------
//
EXPORT_C MFsTreeItemVisualizer& CFsTreeList::ItemVisualizer(
        const TFsTreeItemId aItemId ) const
    {
    FUNC_LOG;
    return *iTree->ItemVisualizer(aItemId);
    }

// ---------------------------------------------------------------------------
//  Sets the pointer to the item visualizer and refreshes item.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetItemVisualizerL(
        MFsTreeItemVisualizer& aVisualizer,
        const TFsTreeItemId aItemId )
    {
    FUNC_LOG;
    MFsTreeItemVisualizer* visualizer = iTree->ItemVisualizer(aItemId);
    visualizer->Hide(iTreeVisualizer->ItemExpansionDelay());
    delete visualizer;
    iTree->SetItemVisualizer(aVisualizer, aItemId);
    iTreeVisualizer->TreeEventL(
            MFsTreeObserver::EFsTreeItemVisualizerChanged,
            MFsTreeObserver::TFsTreeEventParams(aItemId, KFsTreeNoneID, -1));
    }

// ---------------------------------------------------------------------------
//  Check whether the node is expanded or collapsed.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFsTreeList::IsExpanded( const TFsTreeItemId aNodeId )
    {
    FUNC_LOG;
    return iTree->NodeVisualizer(aNodeId)->IsExpanded();
    }

// ---------------------------------------------------------------------------
//  Gets the reference to the tree visualizer
// ---------------------------------------------------------------------------
//
EXPORT_C CFsTreeVisualizerBase& CFsTreeList::TreeVisualizer() const
    {
    FUNC_LOG;
    return *iTreeVisualizer;
    }

// ---------------------------------------------------------------------------
//  Sets a tree visualizer for the list
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetTreeVisualizer( CFsTreeVisualizerBase& aTreeV )
    {
    FUNC_LOG;
    iTreeVisualizer = &aTreeV;

    if (iTree)
        {
        iTreeVisualizer->SetTreeData(*iTree);
        }

    }

// ---------------------------------------------------------------------------
//  Shows the list visual
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::ShowListL( const TBool aFadeIn,
                                      const TBool aSlideIn )
    {
    FUNC_LOG;
    //SetFocusedL(ETrue);
    iTreeVisualizer->ShowListL( aFadeIn, aSlideIn );
    }

// ---------------------------------------------------------------------------
//  Shows the list visual
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetDirectTouchMode( const TBool aDirectTouchMode )
    {
    FUNC_LOG;
    iTreeVisualizer->SetDirectTouchMode( aDirectTouchMode );
    }


// ---------------------------------------------------------------------------
//  Hides the list visual
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::HideListL( const TBool aFadeOut,
                                     const TBool aSlideOut )
    {
    FUNC_LOG;
    //SetFocusedL(EFalse);
    iTreeVisualizer->HideList( aFadeOut, aSlideOut );
    }

// ---------------------------------------------------------------------------
//  Sets visiblity of the border
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetBorderL( const TBool aVisible,
    CAlfTexture* aBorderTexture )
    {
    FUNC_LOG;
    iTreeVisualizer->SetBorderL( aVisible, aBorderTexture );
    }

// ---------------------------------------------------------------------------
//  Sets visiblity of the border
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetShadowL( const TBool aVisible )
    {
    FUNC_LOG;
    iTreeVisualizer->SetShadowL( aVisible );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::GetItemDisplayRectTarget ( const TFsTreeItemId aItemId, TAlfRealRect& aRect )
    {
    FUNC_LOG;
    TInt retVal(KErrNotFound);
    if (iTree->Contains( aItemId ))
        {
        retVal = iTreeVisualizer->GetItemDisplayRectTarget( aItemId, aRect );
        }
    return retVal;
    }

// ---------------------------------------------------------------------------
//  Returns pointer to the menu list assigned to the item
// ---------------------------------------------------------------------------
//
EXPORT_C CFsTreeList* CFsTreeList::ItemMenu(
    TFsTreeItemId aItemId )
    {
    FUNC_LOG;
    return iTree->ItemVisualizer(aItemId)->Menu();
    }

// ---------------------------------------------------------------------------
//  Retrieves events from tree visualizer
// ---------------------------------------------------------------------------
//
// <cmail> Touch
EXPORT_C void CFsTreeList::TreeVisualizerEventL(
        const TFsTreeVisualizerEvent aEvent,
        const TFsTreeItemId aId,
        const TPoint& aPoint ) const
// </cmail>
    {
    FUNC_LOG;
    MFsTreeListObserver::TFsTreeListEvent listEvent;

    switch ( aEvent )
    {
    // <cmail> "Base class modifications for using touch"
    case MFsTreeVisualizerObserver::EFsTreeItemTouchAction:
        {
        listEvent = MFsTreeListObserver::EFsTreeListItemTouchAction;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeItemTouchLongTap:
        {
        listEvent = MFsTreeListObserver::EFsTreeListItemTouchLongTap;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeItemTouchFocused:
        {
        listEvent = MFsTreeListObserver::EFsTreeListItemTouchFocused;
        break;
        }

    // </cmail>

    case MFsTreeVisualizerObserver::EFsTreeItemSelected:
        {
        listEvent = MFsTreeListObserver::EFsTreeItemSelected;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeItemWithMenuSelected:
        {
        listEvent = MFsTreeListObserver::EFsTreeItemWithMenuSelected;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeKeyRightArrow:
        {
        listEvent = MFsTreeListObserver::EFsTreeListKeyRightArrow;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeKeyLeftArrow:
        {
        listEvent = MFsTreeListObserver::EFsTreeListKeyLeftArrow;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeListVisualizerShown:
        {
        listEvent = MFsTreeListObserver::EFsTreeListShown;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeListVisualizerHidden:
        {
        listEvent = MFsTreeListObserver::EFsTreeListHidden;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeItemWillGetFocused:
        {
        listEvent = MFsTreeListObserver::EFsTreeListItemWillGetFocused;
        break;
        }

    // <cmail>
    // Pass on the collapse/expand events.
    case MFsTreeVisualizerObserver::EFsTreeListItemCollapsed:
        {
        listEvent = MFsTreeListObserver::EFsTreeListItemCollapsed;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeListItemExpanded:
        {
        listEvent = MFsTreeListObserver::EFsTreeListItemExpanded;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeListCollapsedAll:
        {
        listEvent = MFsTreeListObserver::EFsTreeListCollapsedAll;
        break;
        }
    case MFsTreeVisualizerObserver::EFsTreeListExpandedAll:
        {
        listEvent = MFsTreeListObserver::EFsTreeListExpandedAll;
        break;
        }
    // </cmail>
    case MFsTreeVisualizerObserver::EFsChangeFocusVisibility:
        {
        listEvent = MFsTreeListObserver::EFsFocusVisibilityChange;
        break;
        }
    default:
        {
        return;
        }
    }

    for ( TInt c = 0; c < iObservers.Count(); c++ )
        {
        iObservers[c]->TreeListEventL( listEvent, aId, aPoint );
        }
    }

// ---------------------------------------------------------------------------
// Gets the reference to the text style manager.
// ---------------------------------------------------------------------------
EXPORT_C CFsAlfTextStyleManager& CFsTreeList::TextStyleManager() const
    {
    FUNC_LOG;
    return *iTextStyleManager;
    }


// ---------------------------------------------------------------------------
//  Sets the type of text marquee.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetTextMarqueeType(const TFsTextMarqueeType aMarquee)
    {
    FUNC_LOG;
    iTreeVisualizer->SetTextMarqueeType( aMarquee );
    }


// ---------------------------------------------------------------------------
//  Returns the type of text marquee.
// ---------------------------------------------------------------------------
//
EXPORT_C TFsTextMarqueeType CFsTreeList::TextMarqueeType() const
    {
    FUNC_LOG;
    return iTreeVisualizer->TextMarqueeType();
    }


// ---------------------------------------------------------------------------
//  Sets the speed of marquee.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetTextMarqueeSpeed ( const TInt aPixelsPerSec )
    {
    FUNC_LOG;
    iTreeVisualizer->SetTextMarqueeSpeed ( aPixelsPerSec );
    }


// ---------------------------------------------------------------------------
//  Returns the speed of marquee.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::TextMarqueeSpeed ( ) const
    {
    FUNC_LOG;
    return iTreeVisualizer->TextMarqueeSpeed( );
    }


// ---------------------------------------------------------------------------
//  Sets delay for text marquee start.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetTextMarqueeStartDelay ( const TInt aStartDelay )
    {
    FUNC_LOG;
    iTreeVisualizer->SetTextMarqueeStartDelay ( aStartDelay );
    }


// ---------------------------------------------------------------------------
//  Returns delay for text marquee.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::TextMarqueeStartDelay () const
    {
    FUNC_LOG;
    return iTreeVisualizer->TextMarqueeStartDelay( );
    }


// ---------------------------------------------------------------------------
//  Sets a delay for each cycle start.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetTextMarqueeCycleStartDelay ( const TInt aCycleStartDelay )
    {
    FUNC_LOG;
    iTreeVisualizer->SetTextMarqueeCycleStartDelay ( aCycleStartDelay );
    }


// ---------------------------------------------------------------------------
//  Returns a delay for each cycle start.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::TextMarqueeCycleStartDelay () const
    {
    FUNC_LOG;
    return iTreeVisualizer->TextMarqueeCycleStartDelay( );
    }


// ---------------------------------------------------------------------------
//  Sets number of marquee cycles.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::SetTextMarqueeRepetitions ( const TInt aMarqueeRepetitions )
    {
    FUNC_LOG;
    iTreeVisualizer->SetTextMarqueeRepetitions ( aMarqueeRepetitions );
    }


// ---------------------------------------------------------------------------
//  Returns number of marquee cycles.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFsTreeList::TextMarqueeRepetitions ( ) const
    {
    FUNC_LOG;
    return iTreeVisualizer->TextMarqueeRepetitions( );
    }

// ---------------------------------------------------------------------------
//  Returns number of marquee cycles.
// ---------------------------------------------------------------------------
//
EXPORT_C void CFsTreeList::DisableKineticScrolling( TBool aDisable )
    {
    iTreeVisualizer->DisableKineticScrolling( aDisable );
    }

//EOF