/*

* Copyright (c) 2006, 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:  Implementation for hierarchical list base class.

*

*/

#include <akntreelistobserver.h>

#include <AknsConstants.h>

#include <AknTasHook.h> // for testability hooks

#include "akntreelist.h"

#include "akntreelistview.h"

#include "akntree.h"

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistboxtfxinternal.h> // LISTBOX EFFECTS IMPLEMENTATION

#include <aknlistloadertfx.h>

#endif

const TInt KObserverArrayGranularity = 1;

const TInt KNotInNotificationSequence = -1;

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

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

// Destructor.

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

//

CAknTreeList::~CAknTreeList()

    {

    AKNTASHOOK_REMOVE();

    iObservers.Close();

    delete iTree;

    delete iView;

    }

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

// Sets the flags for the list.

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

//

EXPORT_C void CAknTreeList::SetFlags( TUint32 aFlags )

    {

    TUint32 diff = aFlags ^ iFlags;

    if ( diff & KAknTreeListLooping )

        {

        View().SetLooping( aFlags & KAknTreeListLooping );

        }

    if ( diff & KAknTreeListNoStructureLines )

        {

        View().SetStructureLineVisibility( 

            !( aFlags & KAknTreeListNoStructureLines ) );

        }

    if ( diff & KAknTreeListMarqueeScrolling )

        {

        Tree().EnableMarquee( aFlags & KAknTreeListMarqueeScrolling );

        }

    if ( diff & KAknTreeListNoIndention )

        {

        View().EnableIndention( !( aFlags & KAknTreeListNoIndention ) );

        }

    if ( diff & KAknTreeListMarkable )

        {

        View().EnableMarking( aFlags & KAknTreeListMarkable );

        }

    iFlags = aFlags;

    }

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

// Returns the flags set for the list.

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

//

EXPORT_C TUint32 CAknTreeList::Flags() const

    {

    return iFlags;

    }

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

// Moves the specified item to specfied target node.

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

//

EXPORT_C void CAknTreeList::MoveItemL( TAknTreeItemID aItem,

    TAknTreeItemID aTargetNode, TBool aDrawNow )

    {

    if ( aItem != KAknTreeIIDNone && aTargetNode != KAknTreeIIDNone )

        {

        Tree().MoveItemL( aItem, aTargetNode, aDrawNow );

        }

    else if ( aDrawNow )

        {

        // Redraw is requested, although no item is moved.

        Window().Invalidate( View().Rect() );

        }

    }

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

// Removes the specified item from the tree.

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

//

EXPORT_C void CAknTreeList::RemoveItem( TAknTreeItemID aItem, TBool aDrawNow )

    {

    if ( aItem != KAknTreeIIDNone )

        {

        Tree().RemoveItem( aItem, aDrawNow );

        }

    else if ( aDrawNow )

        {

        // Redraw is requested, although no item is removed.

        Window().Invalidate( View().Rect() );

        }

    }

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

// Expands the specified node.

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

//

EXPORT_C void CAknTreeList::ExpandNode( TAknTreeItemID aNode, TBool aDrawNow )

    {

    Tree().ExpandNode( aNode, aDrawNow );

    }

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

// Collapses the specified node.

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

//

EXPORT_C void CAknTreeList::CollapseNode( TAknTreeItemID aNode, TBool aDrawNow )

    {

    Tree().CollapseNode( aNode, aDrawNow );

    }

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

// Checks whether the specified node is expanded.

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

//

EXPORT_C TBool CAknTreeList::IsExpanded( TAknTreeItemID aNode ) const

    {

    return Tree().IsExpanded( aNode );

    }

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

// Returns the item ID of focused item.

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

//

EXPORT_C TAknTreeItemID CAknTreeList::FocusedItem() const

    {

    return Tree().Id( View().FocusedItem() );

    }

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

// Sets the focused item.

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

//

EXPORT_C void CAknTreeList::SetFocusedItem( TAknTreeItemID aItem,

    TInt aIndex, TBool aDrawNow )

    {

    View().SetFocusedItem( Tree().Item( aItem ), aIndex, aDrawNow );

    }

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

// Returns the highlight rectangle of currently focused item.

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

//

EXPORT_C TRect CAknTreeList::HighlightRect() const

    {

    return View().HighlightRect();

    }

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

// Adds icon to the tree.

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

//

EXPORT_C TInt CAknTreeList::AddIconL( const TAknsItemID& aId,

    const TDesC& aFilename, TInt aBitmapId, TInt aMaskId,

    TScaleMode aScaleMode )

    {

    return Tree().AddIconL( aId, aFilename, aBitmapId, aMaskId, aScaleMode );

    }

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

// Adds icon to the tree. This overload gets only the bitmaps instead of 

// parameters for creating the bitmaps.

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

//

EXPORT_C TInt CAknTreeList::AddIconL( CFbsBitmap* aIcon, CFbsBitmap* aMask,

    TBool aTransferOwnership, TScaleMode aScaleMode )

    {

    return Tree().AddIconL( aIcon, aMask, aTransferOwnership, aScaleMode );

    }

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

// Adds colored icon to the tree.

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

//

EXPORT_C TInt CAknTreeList::AddColorIconL( const TAknsItemID& aId,

    const TAknsItemID& aColorId, TInt aColorIndex, const TDesC& aFilename,

    TInt aBitmapId, TInt aMaskId, TRgb aDefaultColor, TScaleMode aScaleMode )

    {

    return Tree().AddColorIconL( aId, aColorId, aColorIndex, aFilename,

        aBitmapId, aMaskId, aDefaultColor, aScaleMode );

    }

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

// Assigns icon for specified icon ID.

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

//

EXPORT_C void CAknTreeList::AssignIconL( TInt aIconId, const TAknsItemID& aId,

    const TDesC& aFilename, TInt aBitmapId, TInt aMaskId,

    TScaleMode aScaleMode )

    {

    if ( aIconId <= AknTreeListIconID::KLineStraightIndication )

        {

        // Specified icon ID is out of allowed range.

        User::Leave( KErrArgument );

        }

    Tree().SetIconL( aIconId, aId, aFilename, aBitmapId, aMaskId, aScaleMode );

    }

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

// Assigns icon for specified icon ID.

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

//

EXPORT_C void CAknTreeList::AssignIconL( TInt aIconId, CFbsBitmap* aIcon,

    CFbsBitmap* aMask, TBool aTransferOwnership, TScaleMode aScaleMode )

    {

    if ( aIconId <= AknTreeListIconID::KLineStraightIndication )

        {

        // Specified icon ID is out of allowed range.

        User::Leave( KErrArgument );

        }

    Tree().SetIconL( aIconId, aIcon, aMask, aTransferOwnership, aScaleMode );

    }

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

// Assigns color icon for specified icon ID.

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

//

EXPORT_C void CAknTreeList::AssignColorIconL( TInt aIconId,

    const TAknsItemID& aId, const TAknsItemID& aColorId, TInt aColorIndex,

    const TDesC& aFilename, TInt aBitmapId, TInt aMaskId, TRgb aDefaultColor,

    TScaleMode aScaleMode )

    {

    if ( aIconId <= AknTreeListIconID::KLineStraightIndication )

        {

        // Specified icon ID is out of allowed range.

        User::Leave( KErrArgument );

        }

    Tree().SetColorIconL( aIconId, aId, aColorId, aColorIndex, aFilename,

        aBitmapId, aMaskId, aDefaultColor, aScaleMode );

    }

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

// Removes previously added icon from the tree.

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

//

EXPORT_C void CAknTreeList::RemoveIconL( TInt aIconId )

    {

    Tree().RemoveIconL( aIconId );

    }

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

// Returns the child count for specified node.

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

//

EXPORT_C TInt CAknTreeList::ChildCount( TAknTreeItemID aNode ) const

    {

    return Tree().ChildCount( aNode );

    }

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

// Returns the specified child.

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

//

EXPORT_C TAknTreeItemID CAknTreeList::Child( TAknTreeItemID aNode,

                                             TInt aIndex ) const

    {

    return Tree().Child( aNode, aIndex );

    }

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

// Returns the ID of specified item's parent.

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

//

EXPORT_C TAknTreeItemID CAknTreeList::Parent( TAknTreeItemID aItem ) const

    {

    return Tree().Parent( aItem );

    }

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

// Returns whether the list contains the specified item.

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

//

EXPORT_C TBool CAknTreeList::Contains( TAknTreeItemID aItem ) const

    {

    CAknTreeItem* item;

    TInt error = Tree().GetItem( aItem, item );

    if ( !error )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// Checks whether the specified item is a node.

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

//

EXPORT_C TBool CAknTreeList::IsNode( TAknTreeItemID aItem ) const

    {

    CAknTreeItem* item = Tree().Item( aItem );

    return item->IsNode();

    }

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

// Checks whether the specified item is a leaf.

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

//

EXPORT_C TBool CAknTreeList::IsLeaf( TAknTreeItemID aItem ) const

    {

    CAknTreeItem* item = Tree().Item( aItem );

    return item->IsLeaf();

    }

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

// Checks whether the specified item is marked.

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

//

EXPORT_C TBool CAknTreeList::IsMarked( TAknTreeItemID aItem ) const

    {

    return Tree().IsMarked( aItem );

    }

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

// Changes the specified item marked or unmarked.

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

//

EXPORT_C void CAknTreeList::SetMarked( TAknTreeItemID aItem,

    TBool aMarked, TBool aDrawNow )

    {

    if ( aItem != KAknTreeIIDNone )

        {

        Tree().SetMarked( aItem, aMarked, aDrawNow );

        }

    else if ( aDrawNow )

        {

        Window().Invalidate( View().Rect() );

        }

    }

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

// Enables/disables marking for specified list item.

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

//

EXPORT_C void CAknTreeList::EnableMarking( TAknTreeItemID aItem,

    TBool aEnable )

    {

    Tree().EnableMarking( aItem, aEnable );

    }

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

// Appends all the marked item from the list to the given array.

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

//

EXPORT_C void CAknTreeList::GetMarkedItemsL(

    RArray<TAknTreeItemID>& aMarkedItems ) const

    {

    Tree().GetMarkedItemsL( KAknTreeIIDRoot, aMarkedItems );

    }

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

// Appends marked items from the specified node to the given array.

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

//

EXPORT_C void CAknTreeList::GetMarkedItemsL( TAknTreeItemID aNode,

    RArray<TAknTreeItemID>& aMarkedItems ) const

    {

    Tree().GetMarkedItemsL( aNode, aMarkedItems );

    }

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

// Returns whether the specified node is empty.

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

//

EXPORT_C TBool CAknTreeList::IsEmpty( TAknTreeItemID aNode ) const

    {

    return Tree().IsEmpty( aNode );

    }

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

// Sets the specified item to appear non-empty, or removes the setting.

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

//

EXPORT_C void CAknTreeList::SetNonEmpty( TAknTreeItemID aNode,

    TBool aNonEmpty, TBool aDrawNow )

    {

    Tree().SetNonEmpty( aNode, aNonEmpty, aDrawNow );

    }

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

// Checks whether the specified item is persistent.

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

//

EXPORT_C TBool CAknTreeList::IsPersistent( TAknTreeItemID aItem ) const

    {

    return Tree().IsPersistent( aItem );

    }

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

// Sets the specified item persistent or non-persistent.

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

//

EXPORT_C void CAknTreeList::SetPersistent( TAknTreeItemID aItem,

    TBool aPersistent )

    {

    Tree().SetPersistent( aItem, aPersistent );

    }

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

// Sets the interface used for custom tree ordering.

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

//

EXPORT_C void CAknTreeList::Sort( MAknCustomTreeOrdering* aOrdering,

    TBool aDrawNow )

    {

    // move view to beginning, lose focus

    View().SetFocusBehaviour( EFalse );

    Tree().SetCustomOrdering( aOrdering, aDrawNow );

    }

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

// Sorts the specified node content with previously set ordering.

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

//

EXPORT_C void CAknTreeList::Sort( TAknTreeItemID aNode,

    TBool aSortDescendants, TBool aDrawNow )

    {

    // move view to beginning, lose focus

    View().SetFocusBehaviour( EFalse );

    Tree().Sort( aNode, aSortDescendants, aDrawNow );

    }

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

// Adds the observer to the list of observers.

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

//