/*

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

*

*/

#include "aknsinglestyletreelist.h"

#include "aknsinglestyletreenode.h"

#include "aknsinglestyletreeleaf.h"

#include "aknsinglestyletreeordering.h"

#include "akntree.h"

#include "aknhlistlib.h"

#include "akntreelistinternalconstants.h"

#include "akntreelistview.h"

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

/** Set of flags that cannot be set for single style hierarchical list. */

const TInt KRestrictedListFlags = KAknTreeListMarkable;

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

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

// Two-phased constructor.

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

//

EXPORT_C CAknSingleStyleTreeList* CAknSingleStyleTreeList::NewL()

    {

    CAknSingleStyleTreeList* self = CAknSingleStyleTreeList::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CAknSingleStyleTreeList* CAknSingleStyleTreeList::NewLC()

    {

    CAknSingleStyleTreeList* self = new( ELeave ) CAknSingleStyleTreeList;

    CleanupStack::PushL( self );

    self->ConstructL();

    AKNTASHOOK_ADDL( self, "CAknSingleStyleTreeList" );

    return self;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CAknSingleStyleTreeList* CAknSingleStyleTreeList::NewL(

    const CCoeControl& aContainer )

    {

    CAknSingleStyleTreeList* self

        = CAknSingleStyleTreeList::NewLC( aContainer );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CAknSingleStyleTreeList* CAknSingleStyleTreeList::NewLC(

    const CCoeControl& aContainer )

    {

    CAknSingleStyleTreeList* self = new ( ELeave ) CAknSingleStyleTreeList;

    CleanupStack::PushL( self );

    self->ConstructL( aContainer );

    AKNTASHOOK_ADDL( self, "CAknSingleStyleTreeList" );

    return self;

    }

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

// Destructor.

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

//

CAknSingleStyleTreeList::~CAknSingleStyleTreeList()

    {

    AKNTASHOOK_REMOVE();

    }

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

// Construct and add new leaf to the tree.

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

//

EXPORT_C TAknTreeItemID CAknSingleStyleTreeList::AddLeafL(

    TAknTreeItemID aParent, const TDesC& aText, TUint32 aFlags,

    TBool aDrawNow )

    {

    TUint32 flags = NULL;

    if ( aFlags & EPersistent )

        {

        flags |= CAknSingleStyleTreeLeaf::EPersistent;

        }

    if ( aFlags & EMarked )

        {

        flags |= CAknSingleStyleTreeLeaf::EMarked;

        }

    CAknSingleStyleTreeLeaf* leaf = 

        CAknSingleStyleTreeLeaf::NewLC( aText, flags );

    TAknTreeItemID id = Tree().AddItemL( leaf, aParent, aDrawNow );

    CleanupStack::Pop( leaf );

    return id;

    }

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

// Construct and add new node to the tree.

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

//

EXPORT_C TAknTreeItemID CAknSingleStyleTreeList::AddNodeL(

    TAknTreeItemID aParent, const TDesC& aText, TUint32 aFlags,

    TBool aDrawNow )

    {

    TUint32 flags = NULL;

    if ( aFlags & EPersistent )

        {

        flags |= CAknSingleStyleTreeNode::EPersistent;

        }

    if ( aFlags & EMarked )

        {

        flags |= CAknSingleStyleTreeNode::EMarked;

        }

    if ( aFlags & EExpanded )

        {

        flags |= CAknSingleStyleTreeNode::EExpanded;

        }

    if ( aFlags & ENonEmpty )

        {

        flags |= CAknSingleStyleTreeNode::ENonEmpty;

        }

    CAknSingleStyleTreeNode* node = 

        CAknSingleStyleTreeNode::NewLC( aText, flags );

    TAknTreeItemID id = Tree().AddItemL( node, aParent, aDrawNow );

    CleanupStack::Pop( node );

    return id;

    }

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

// Sorts the list.

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

//

EXPORT_C void CAknSingleStyleTreeList::SortL( TOrdering aOrdering,

    TBool aDrawNow )

    {

    CAknSingleStyleTreeOrdering::TOrderingType type = 

        CAknSingleStyleTreeOrdering::EAscending;

    if ( aOrdering == EDescendingAlphabeticalOrdering )

        {

        type  = CAknSingleStyleTreeOrdering::EDescending;

        }

    CAknSingleStyleTreeOrdering* ordering = 

        CAknSingleStyleTreeOrdering::NewL( type );

    Tree().SetOrdering( ordering, aDrawNow );

    }

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

// Sets the given text for specified tree item.

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

//

EXPORT_C void CAknSingleStyleTreeList::SetTextL( TAknTreeItemID aItem,

    const TDesC& aText, TBool aDrawNow )

    {

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

    if ( item->Type() == AknTreeList::KSingleStyleTreeLeaf )

        {

        static_cast<CAknSingleStyleTreeLeaf*>( item )->SetTextL( aText,

            aDrawNow );

        }

    else if ( item->Type() == AknTreeList::KSingleStyleTreeNode )

        {

        static_cast<CAknSingleStyleTreeNode*>( item )->SetTextL( aText,

            aDrawNow );

        }

    else

        {

        Panic( EAknHListPanicInvalidItemType );

        }

    }

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

// Return text for the specified tree item.

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

//

EXPORT_C const TDesC& CAknSingleStyleTreeList::Text( TAknTreeItemID aItem ) const

    {

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

    if ( item->Type() == AknTreeList::KSingleStyleTreeLeaf )

        {

        __ASSERT_DEBUG( item->IsLeaf(), User::Invariant() );

        return static_cast<CAknSingleStyleTreeLeaf*>( item )->Text();

        }

    else if ( item->Type() == AknTreeList::KSingleStyleTreeNode )

        {

        __ASSERT_DEBUG( item->IsNode(), User::Invariant() );

        return static_cast<CAknSingleStyleTreeNode*>( item )->Text();

        }

    else

        {

        return KNullDesC;

        }

    }

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

// Set icon for specified item.

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

//

EXPORT_C void CAknSingleStyleTreeList::SetIcon( const TAknTreeItemID aItem,

    const TIconType aType, const TInt aIconId, const TBool aDrawNow )

    {

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

    if ( item->Type() == AknTreeList::KSingleStyleTreeLeaf )

        {

        CAknSingleStyleTreeLeaf::TIconType type;

        switch ( aType )

            {

            case ELeaf:

                type = CAknSingleStyleTreeLeaf::EIcon;

                break;

            case EHighlightedLeaf:

                type = CAknSingleStyleTreeLeaf::EHighlightedIcon;

                break;

            case EOptionalIcon1:

                type = CAknSingleStyleTreeLeaf::EOptIcon1;

                break;

            case EHighlightedOptionalIcon1:

                type = CAknSingleStyleTreeLeaf::EHighlightedOptIcon1;

                break;

            case EOptionalIcon2:

                type = CAknSingleStyleTreeLeaf::EOptIcon2;

                break;

            case EHighlightedOptionalIcon2:

                type = CAknSingleStyleTreeLeaf::EHighlightedOptIcon2;

                break;

            default:

                // Invalid icon type for tree leaf.

                Panic( EAknHListPanicInvalidItemType );

                return;

            }

        static_cast<CAknSingleStyleTreeLeaf*>( item )->SetIcon( type,

            aIconId, aDrawNow );

        }

    else if ( item->Type() == AknTreeList::KSingleStyleTreeNode )

        {

        __ASSERT_DEBUG( item->IsNode(), User::Invariant() );

        CAknSingleStyleTreeNode::TIconType type;

        switch ( aType )

            {

            case EExpandedNode:

                type = CAknSingleStyleTreeNode::EExpandedIcon;

                break;

            case EHighlightedExpandedNode:

                type = CAknSingleStyleTreeNode::EHighlightedExpandedIcon;

                break;

            case ECollapsedNode:

                type = CAknSingleStyleTreeNode::ECollapsedIcon;

                break;

            case EHighlightedCollapsedNode:

                type = CAknSingleStyleTreeNode::EHighlightedCollapsedIcon;

                break;

            case EOptionalIcon1:

                type = CAknSingleStyleTreeNode::EOptIcon1;

                break;

             case EHighlightedOptionalIcon1:

                type = CAknSingleStyleTreeNode::EHighlightedOptIcon1;

                break;

            case EOptionalIcon2:

                type = CAknSingleStyleTreeNode::EOptIcon2;

                break;

            case EHighlightedOptionalIcon2:

                type = CAknSingleStyleTreeNode::EHighlightedOptIcon2;

                break;

           default:

                // Invalid icon type for tree node.

                Panic( EAknHListPanicInvalidItemType );

                return;

            }

        static_cast<CAknSingleStyleTreeNode*>( item )->SetIcon( type,

            aIconId, aDrawNow );

        }

    else

        {

        // Invalid item type.

        Panic( EAknHListPanicInvalidItemType );

        }

    }

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

// Returns the icon ID set for the specified tree item.

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

//

EXPORT_C TInt CAknSingleStyleTreeList::Icon( TAknTreeItemID aItem,

    TIconType aType ) const

    {

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

    if ( item->Type() == AknTreeList::KSingleStyleTreeLeaf )

        {

        CAknSingleStyleTreeLeaf::TIconType type;

        switch ( aType )

            {

            case ELeaf:

                type = CAknSingleStyleTreeLeaf::EIcon;

                break;

            case EHighlightedLeaf:

                type = CAknSingleStyleTreeLeaf::EHighlightedIcon;

                break;

            case EOptionalIcon1:

                type = CAknSingleStyleTreeLeaf::EOptIcon1;

                break;

            case EHighlightedOptionalIcon1:

                type = CAknSingleStyleTreeLeaf::EHighlightedOptIcon1;

                break;

            case EOptionalIcon2:

                type = CAknSingleStyleTreeLeaf::EOptIcon2;

                break;

            case EHighlightedOptionalIcon2:

                type = CAknSingleStyleTreeLeaf::EHighlightedOptIcon2;

                break;

            default:

                // Invalid icon type for tree leaf.

                return KErrNotFound;

            }

        return static_cast<CAknSingleStyleTreeLeaf*>( item )->Icon( type );

        }

    else if ( item->Type() == AknTreeList::KSingleStyleTreeNode )

        {

        __ASSERT_DEBUG( item->IsNode(), User::Invariant() );

        CAknSingleStyleTreeNode::TIconType type;

        switch ( aType )

            {

            case EExpandedNode:

                type = CAknSingleStyleTreeNode::EExpandedIcon;

                break;

            case EHighlightedExpandedNode:

                type = CAknSingleStyleTreeNode::EHighlightedExpandedIcon;

                break;

            case ECollapsedNode:

                type = CAknSingleStyleTreeNode::ECollapsedIcon;

                break;

            case EHighlightedCollapsedNode:

                type = CAknSingleStyleTreeNode::EHighlightedCollapsedIcon;

                break;

            case EOptionalIcon1:

                type = CAknSingleStyleTreeNode::EOptIcon1;

                break;

             case EHighlightedOptionalIcon1:

                type = CAknSingleStyleTreeNode::EHighlightedOptIcon1;

                break;

            case EOptionalIcon2:

                type = CAknSingleStyleTreeNode::EOptIcon2;

                break;

            case EHighlightedOptionalIcon2:

                type = CAknSingleStyleTreeNode::EHighlightedOptIcon2;

                break;

           default:

                // Invalid icon type for tree node.

                return KErrNotFound;

            }

        return static_cast<CAknSingleStyleTreeNode*>( item )->Icon( type );

        }

    else

        {

        return KErrNotFound;

        }

    }

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

// From class CAknTreeList.

// Sets flags for the list.

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

//

void CAknSingleStyleTreeList::SetFlags( TUint32 aFlags )

    {

    aFlags &= ~KRestrictedListFlags;

    CAknTreeList::SetFlags( aFlags );

    }

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

// Default C++ constructor.

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

//

CAknSingleStyleTreeList::CAknSingleStyleTreeList()

    {

    }

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

// Second phase constructor.

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

//

void CAknSingleStyleTreeList::ConstructL()

    {

    BaseConstructL();

    }

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

// Second phase constructor.

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

//

void CAknSingleStyleTreeList::ConstructL( const CCoeControl& aContainer )

    {

    BaseConstructL( aContainer );

    }