/*

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

*

*/

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsUtils.h>

#include <avkon.mbg>

#include <AknMarqueeControl.h>

#include "akntree.h"

#include "akntreelist.h"

#include "akntreeordering.h"

#include "aknhlistlib.h"

#include "akntreeiterator.h"

#include "akntreelisticon.h"

#include "akncustomtreeordering.h"

#include "akntreelistinternalconstants.h"

const TInt KObserverArrayGranularity = 1;

// Tree flag definitions

enum TAknTreeFlags

    {

    ETabModeFunctionIndicators

    };

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

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

// Two-phased constructor.

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

//

CAknTree* CAknTree::NewL( CAknTreeList& aList, CAknTreeOrdering* aOrdering )

    {

    CAknTree* self = new( ELeave ) CAknTree( aList, aOrdering );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CAknTree::~CAknTree()

    {

    delete iOrdering; iOrdering = NULL;

    iCustomOrdering = NULL;

    iObservers.Close();

    iItems.Close();

    iIcons.ResetAndDestroy();

    delete iMarquee; iMarquee = NULL;

    iMarqueeItem = NULL;

    }

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

// Id for the given item.

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

//

TAknTreeItemID CAknTree::Id( const CAknTreeItem* aItem ) const

    {

    if ( aItem == this )

        {

        return KAknTreeIIDRoot;

        }

    else

        {

        return reinterpret_cast<TInt>( aItem );

        }

    }

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

// Sets ordering for tree items. Previously set ordering is deleted and

// customized ordering interface discarded.

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

//

void CAknTree::SetOrdering( CAknTreeOrdering* aOrdering, TBool aDrawNow )

    {

    delete iOrdering;

    iOrdering = aOrdering;

    iCustomOrdering = NULL;

    Sort( aDrawNow );

    }

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

// Sets custom ordering for tree items.

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

//

void CAknTree::SetCustomOrdering( MAknCustomTreeOrdering* aOrdering,

    TBool aDrawNow )

    {

    iCustomOrdering = aOrdering;

    delete iOrdering;

    iOrdering = NULL;

    Sort( aDrawNow );

    }

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

// Sorts the specified tree node.

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

//

void CAknTree::Sort( TAknTreeItemID aNode, TBool aSortDescendants,

    TBool aDrawNow )

    {

    // The sorting can be done only when ordering is set for the tree.

    if ( iCustomOrdering || iOrdering )

        {

        CAknTreeNode* node = Node( aNode );

        node->Sort();

        if ( aSortDescendants )

            {

            // Iterate through the descendants of the node and sort

            // each descendant node separately.

            TAknTreeIterator iterator( node, NULL );

            while ( iterator.HasNext() )

                {

                node = iterator.Next()->Node();

                if ( node )

                    {

                    node->Sort();

                    }

                }

            }

        }

    NotifyObservers( MAknTreeObserver::ETreeSorted, this, aDrawNow );

    }

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

// Compares two tree list items.

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

//

TInt CAknTree::Compare( const CAknTreeItem& aFirst,

    const CAknTreeItem& aSecond ) const

    {

    TInt value = NULL;

    if ( iCustomOrdering )

        {

        value = iCustomOrdering->Compare( Id( &aFirst ), Id( &aSecond ) );

        }

    else if ( iOrdering )

        {

        value = iOrdering->Compare( aFirst, aSecond );

        }

    else

        {

        TInt first = KMaxTInt;

        TInt second = KMaxTInt;

        if ( aFirst.Parent() )

            {

            first = aFirst.Parent()->Index( &aFirst );

            }

        if  ( aSecond.Parent() )

            {

            second = aSecond.Parent()->Index( &aSecond );

            }

        value = first - second;

        }

    return value;

    }

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

// Returns the number of items in the tree.

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

//

TInt CAknTree::ItemCount() const

    {

    return iItems.Count();

    }

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

// Returns the number of visible items in the tree.

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

//

TInt CAknTree::VisibleItemCount() const

    {

    return VisibleDescendantCount();

    }

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

// Returns the index of specified item. The index equals to the number of

// tree items in the tree structure before the specified item.

// The value KErrNotFound is returned, if the specified item is not found,

// and this applies also to the root node.

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

//

TInt CAknTree::ItemIndex( const CAknTreeItem* aItem ) const

    {

    TInt count = KErrNotFound; // ( -1 )

    if ( iItems.FindInAddressOrder( aItem ) >= 0 )

        {

        const CAknTreeItem* item = aItem;

        const CAknTreeNode* parent = item->Parent();

        while ( parent )

            {

            // Add the number of descendants of each sibling preceeding the

            // item to the count.

            const TInt index = parent->Index( item );

            __ASSERT_DEBUG( index >= 0, User::Invariant() );

            for ( TInt ii = 0; ii < index; ++ii )

                {

                const CAknTreeNode* node = parent->Child( ii )->Node();

                if ( node )

                    {

                    count += node->DescendantCount();

                    }

                }

            // Add the item and its preceeding siblings to the count.

            count += index + 1;

            item = parent;

            parent = item->Parent();

            }

        }

    return count;

    }

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

// Similar to ItemIndex, but returns the index from subset of items that

// belong to expanded part of the tree.

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

//

TInt CAknTree::VisibleItemIndex( const CAknTreeItem* aItem ) const

    {

    TInt count = KErrNotFound; // ( -1 )

    if ( iItems.FindInAddressOrder( aItem ) >= 0 )

        {

        const CAknTreeItem* item = aItem;

        const CAknTreeNode* parent = item->Parent();

        while ( parent )

            {

            if ( !parent->IsExpanded() )

                {

                return KErrNotFound;

                }

            // Add the number of visible descentants of each sibling preceeding

            // the item to the count.

            const TInt index = parent->Index( item );

            __ASSERT_DEBUG( index >= 0, User::Invariant() );

            for ( TInt ii = 0; ii < index; ++ii )

                {

                const CAknTreeNode* node = parent->Child( ii )->Node();

                if ( node )

                    {

                    count += node->VisibleDescendantCount();

                    }

                }

            // Add the item and its preceeding siblings to the count.

            count += index + 1;

            // All ancestors of specified item has to be expanded in order to

            // the item to be in expanded tree structure.

            if ( parent->IsExpanded() )

                {

                item = parent;

                parent = item->Parent();

                }

            else

                {

                // Specified item is not visible, KErrNotFound returned.

                parent = NULL;

                count = KErrNotFound;

                }

            }

        }

    return count;

    }

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

// Returns the tree item at the specified index of the expanded tree.

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

//

CAknTreeItem* CAknTree::VisibleItem( TInt aIndex ) const

    {

    if ( aIndex < 0 || aIndex >= iItems.Count() )

        {

        return NULL;

        }

    TAknTreeIterator iterator = Iterator();

    while( aIndex && iterator.HasNext() )

        {

        iterator.Next();

        --aIndex;

        }

    return iterator.Next();

    }

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

// Returns the depth of the tree. Iterates through the whole tree structure.

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

//

TInt CAknTree::Depth() const

    {

    TAknTreeIterator iterator = Iterator();

    TInt depth = 0;

    while ( iterator.HasNext() )

        {

        CAknTreeItem* item = iterator.Next();

        depth = Max( depth, item->Level() );

        }

    return depth;

    }

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

// Finds the specified item from the sorted array of tree items. The constants

// KAknTreeIIDRoot and KAknTreeIIDNone are handled as special cases.

// 

// Note: Recently used items could be cached somehow to eliminate the need to

// lookup them from the table when consecutive calls refer to the same items,

// for example, when adding several items to the same node.

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

//

TInt CAknTree::GetItem( TAknTreeItemID aItemId, CAknTreeItem*& aItem ) const

    {

    TInt error = KErrNone;

    if ( aItemId == KAknTreeIIDRoot )

        {

        aItem = const_cast<CAknTree*>( this );

        }

    else if ( aItemId == KAknTreeIIDNone )

        {

        error = KErrNotFound;

        }

    else

        {

        TInt index = iItems.FindInAddressOrder(

            reinterpret_cast<CAknTreeItem*>( aItemId ) );

        if ( index == KErrNotFound )

            {

            error = KErrNotFound;

            }

        else

            {

            aItem = iItems[index];

            }

        }

    return error;

    }

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

// Retrieves an item from the tree structure. Panics if the item is not found.

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

//

CAknTreeItem* CAknTree::Item( TAknTreeItemID aItemId ) const

    {

    CAknTreeItem* item = NULL;

    TInt error = GetItem( aItemId, item );

    __ASSERT_ALWAYS( item && !error, Panic( EAknHListPanicInvalidItemID ) );

    return item;

    }

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

// Retrieves a node from the tree structure. Panics if the node is not found,

// or if the specified item is not a node.

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

//

CAknTreeNode* CAknTree::Node( TAknTreeItemID aNodeId ) const

    {

    CAknTreeNode* node = Item( aNodeId )->Node();

    __ASSERT_ALWAYS( node, Panic( EAknHListPanicInvalidItemType ) );

    return node;

    }

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

// Adds an item to the tree structure.

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

//

TAknTreeItemID CAknTree::AddItemL( CAknTreeItem* aItem,

    TAknTreeItemID aParent, TBool aDrawNow )

    {

    __ASSERT_DEBUG( aItem, User::Invariant() );

    // Add item to the specified parent node.

    CAknTreeNode* parent = Node( aParent );

    if ( iOrdering )

        {

        // Let ordering determine the position of the new child.

        parent->AddChildL( aItem );

        }

    else

        {

        // Append to the end, as custom ordering cannot be used to determine

        // the correct position when inserting new items to the tree.

        parent->AddChildL( aItem, parent->ChildCount() );

        }

    // Store pointer also in lookup table.

    TInt error = iItems.InsertInAddressOrder( aItem );

    if ( error )

        {

        parent->RemoveChild( aItem );

        User::Leave( error );

        }

    aItem->SetParent( parent );

    NotifyObservers( MAknTreeObserver::EItemAdded, aItem, aDrawNow );

    return Id( aItem );

    }

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

// Moves the specified item to specified target node. The method has to make

// sure that the target node is not a descendant of the moved item in order

// to keep the tree structure intact.

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

//

void CAknTree::MoveItemL( TAknTreeItemID aItem, TAknTreeItemID aTargetNode,

    TBool aDrawNow )

    {

    CAknTreeItem* item = Item( aItem );

    CAknTreeNode* targetNode = Node( aTargetNode );

    // The current parent of the moved item.

    CAknTreeNode* parent = item->Parent();

    // Move is necessary only when target node differs from current node.

    if ( targetNode != parent )

        {

        // Check that the moved item is neither the target node nor an ancestor

        // of target node. This should also ensure that the root is not moved.

        CAknTreeNode* ancestor = targetNode;

        while ( ancestor )

            {

            if ( ancestor == item )

                {

                User::Leave( KErrArgument );

                }

            ancestor = ancestor->Parent();

            }

        // Move the item to the target node.

        targetNode->AddChildL( item );

        item->SetParent( targetNode );

        if ( parent )

            {

            parent->RemoveChild( item );

            }

        NotifyObservers( MAknTreeObserver::EItemMoved, item, aDrawNow );

        }

    }

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

// Removes an item from the tree structure. If the specified item is not

// found, method is paniced with panic code EAknHListPanicInvalidItemID.

//

// When removed item is a node with descendants, the node and its descendants

// are removed from the list separately and each removal is also reported

// separately to the observers.

//

// Note: Observers are notified of the removal before the item is actually

// removed from the tree and deleted, so that the observers can still query

// the item's position in the tree.

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

//

void CAknTree::RemoveItem( TAknTreeItemID aItem, TBool aDrawNow )

    {

    // Get the item from the array.    

    CAknTreeItem* item = Item( aItem );

    TBool drawNow( EFalse );

    // Remove from array and delete the descendants of node non-recursively.

    if ( item->IsNode() )

        {

        TAknTreeIterator iterator = Iterator( item->Node(), NULL );

        CAknTreeItem* current = iterator.Last();

        iterator.SetCurrent( current ); 

        while ( current )

            {

            CAknTreeItem* previous = iterator.Previous();

            if ( previous == NULL)

            	{

            	drawNow = aDrawNow;

            	}

            // Notify tree observers of removal before the item is removed.

            NotifyObservers( MAknTreeObserver::EItemRemoveBegin, current, EFalse );

            // Remove item from the table.

            TInt index = iItems.FindInAddressOrder( current );