/*

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

// ---------------------------------------------------------------------------