/*
* 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 );
        }

    if ( diff & KAknTreeListSmiley && !AknLayoutUtils::LayoutMirrored() )
        {
        Tree().InitSmiley();
        }

    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() );
        }
    
    // Update the marking of upper level node
    CAknTreeItem* item = Tree().Item( aItem );
    if ( item && item->Parent() && item->Parent()->IsNode() )
        {
        CAknTreeNode* node = item->Parent()->Node();
        if (node)
            {
            TBool wasMarked = node->IsMarked();
            
            if (node->IsMarkable())
                {
                if (node->AllChildrenMarked())
                    {
                    node->SetMarked(ETrue);
                    }            
                else
                    {
                    node->SetMarked(EFalse);
                    }
                }
            
            if (wasMarked != node->IsMarked())
                {
                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.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknTreeList::AddObserverL( MAknTreeListObserver* aObserver )
    {
    // Append observer to the end of the array. This does not affect the
    // index used in notification sequence.
    iObservers.AppendL( aObserver );
    }


// ---------------------------------------------------------------------------
// Removes the specified observer from the list of observers.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknTreeList::RemoveObserver( MAknTreeListObserver* aObserver )
    {
    TInt index = iObservers.Find( aObserver );
    if ( index != KErrNotFound )
        {
        iObservers.Remove( index );
        }
    }


// ---------------------------------------------------------------------------
// Notifies all of the tree list observers of the specified event.
// ---------------------------------------------------------------------------
//
void CAknTreeList::NotifyObservers( MAknTreeListObserver::TEvent aEvent,
    TAknTreeItemID aItem )
    {
    // Note: Local variable index is used instead of iIndex
    // Nested calls to NotifyObservers don't work with iIndex
    for ( TInt index = 0; index < iObservers.Count(); ++index )
        {
        iObservers[index]->HandleTreeListEvent( *this, aItem, aEvent );
        }

    // Change index to indicate that no notification sequence is ongoing.
    iIndex = KNotInNotificationSequence;

    // Notify also control observer.
    if ( Observer() )
        {
        TRAP_IGNORE( Observer()->HandleControlEventL( this,
            MCoeControlObserver::EEventStateChanged ) );
        }
    }


// ---------------------------------------------------------------------------
// Checks whether tabulator mode function indicators are used.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CAknTreeList::TabModeFunctionIndicators() const
    {
    return Tree().TabModeFunctionIndicators();
    }


// ---------------------------------------------------------------------------
// Changes expand and collapse function indicators.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknTreeList::EnableTabModeFunctionIndicatorsL( TBool aEnable )
    {
    Tree().EnableTabModeFunctionIndicatorsL( aEnable );
    }
    
// ---------------------------------------------------------------------------
//  Sets the focused item and moves view so that focused item is visible
// ---------------------------------------------------------------------------
//    
EXPORT_C void CAknTreeList::SetFocusedItem( TAknTreeItemID aItem )
	{
	View().SetFocusedItemAndView( Tree().Item( aItem ) );
	}

// ---------------------------------------------------------------------------
//  Returns the index of focused item
// ---------------------------------------------------------------------------
// 
EXPORT_C TInt CAknTreeList::FocusedItemIndex() const
	{
	return View().FocusedItemIndex();
	}
	
	
// ---------------------------------------------------------------------------
//  Returns the index of requested visible item
// ---------------------------------------------------------------------------
// 
EXPORT_C TInt CAknTreeList::VisibleItemIndex( TAknTreeItemID aItem ) const
	{
	return View().VisibleItemIndex( Tree().Item( aItem ) );
	}
	
	

// ---------------------------------------------------------------------------
// Sets the interface used for custom tree ordering.
// ---------------------------------------------------------------------------
// 
EXPORT_C void CAknTreeList::Sort( MAknCustomTreeOrdering* aOrdering,
    TFocusBehaviour aFocusBehaviour, TBool aDrawNow )
    {
    View().SetFocusBehaviour( ( aFocusBehaviour == ESaveFocus ) ? ETrue : EFalse );
    Tree().SetCustomOrdering( aOrdering, aDrawNow );
    }

// ---------------------------------------------------------------------------
// Sorts the specified node content with previously set ordering.
// ---------------------------------------------------------------------------
// 
EXPORT_C void CAknTreeList::Sort( TAknTreeItemID aNode,
    TFocusBehaviour aFocusBehaviour, TBool aSortDescendants, TBool aDrawNow )
    {
    View().SetFocusBehaviour( ( aFocusBehaviour == ESaveFocus ) ? ETrue : EFalse );
    Tree().Sort( aNode, aSortDescendants, aDrawNow );
    }

// ---------------------------------------------------------------------------
// Sets text for the empty list.
// ---------------------------------------------------------------------------
// 
EXPORT_C void CAknTreeList::SetEmptyTextL(const TDesC& aText)
	{
	View().SetEmptyTextL( aText );
	}


// ---------------------------------------------------------------------------
// CAknTreeList::SetMarkingModeObserver
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknTreeList::SetMarkingModeObserver( 
        MAknMarkingModeObserver* aObserver )
    {
    iMarkingModeObserver = aObserver;
    }


// ---------------------------------------------------------------------------
// Handles key events by mediating them to the view.
// ---------------------------------------------------------------------------
//
TKeyResponse CAknTreeList::OfferKeyEventL( const TKeyEvent& aKeyEvent,
    TEventCode aType )
    {
    if ( IsFocused() )
        {
        return View().OfferKeyEventL( aKeyEvent, aType );
        }
    else
        {
        return EKeyWasNotConsumed;
        }
    }


// ---------------------------------------------------------------------------
// Changes the visibility of the list.
// ---------------------------------------------------------------------------
//
void CAknTreeList::MakeVisible( TBool aVisible )
    {
    CAknControl::MakeVisible( aVisible );
    View().MakeVisible( aVisible );
    }


// ---------------------------------------------------------------------------
// Changes the dimming of the list.
// ---------------------------------------------------------------------------
//
void CAknTreeList::SetDimmed( TBool aDimmed )
    {
    CAknControl::SetDimmed( aDimmed );
    View().SetDimmed( aDimmed );
    }


// ---------------------------------------------------------------------------
// From class CCoeControl.
// Sets the control's containing window by copying it from aContainer.
// ---------------------------------------------------------------------------
//
void CAknTreeList::SetContainerWindowL( const CCoeControl& aContainer )
    {
    CAknControl::SetContainerWindowL( aContainer );
    if ( iView )
        {
        iView->SetContainerWindowL( *this );
        }
    }


// ---------------------------------------------------------------------------
// Sets the control as ready to be drawn.
// ---------------------------------------------------------------------------
//
void CAknTreeList::ActivateL()
    {
    CAknControl::ActivateL();
    }


// ---------------------------------------------------------------------------
// Handles resource changes. The tree needs notification of skin change, so
// it can reconstruct the icons for the new skin.
// ---------------------------------------------------------------------------
//
void CAknTreeList::HandleResourceChange( TInt aType )
    {
    CAknControl::HandleResourceChange( aType );
    if ( aType == KAknsMessageSkinChange )
        {
        TRAP_IGNORE( Tree().HandleSkinChangeL() );
        }
    }


// ---------------------------------------------------------------------------
// Gets the control's input capabilities.
// ---------------------------------------------------------------------------
//
TCoeInputCapabilities CAknTreeList::InputCapabilities() const
    {
    return TCoeInputCapabilities::ENavigation;
    }


// ---------------------------------------------------------------------------
// Handles pointer events. The pointer events are mediated to the view by
// control framework, as the view is set as component control of the list.
// ---------------------------------------------------------------------------
//
void CAknTreeList::HandlePointerEventL( const TPointerEvent& aPointerEvent )
    {
    CAknControl::HandlePointerEventL( aPointerEvent );
    }


// ---------------------------------------------------------------------------
// From class CCoeControl.
// ---------------------------------------------------------------------------
//
TInt CAknTreeList::CountComponentControls() const
    {
    return iView ? 1 : 0;
    }


// ---------------------------------------------------------------------------
// From class CCoeControl.
// ---------------------------------------------------------------------------
//
CCoeControl* CAknTreeList::ComponentControl( TInt /*aIndex*/ ) const
    {
    return iView;
    }


// ---------------------------------------------------------------------------
// Default C++ constructor.
// ---------------------------------------------------------------------------
//
CAknTreeList::CAknTreeList()
    : iObservers( KObserverArrayGranularity ),
      iIndex( KNotInNotificationSequence )
    {
    AKNTASHOOK_ADD( this, "CAknTreeList" );
    }


// ---------------------------------------------------------------------------
// Completes the construction of the base class. This variant creates a new
// window for the list and activates it.
// ---------------------------------------------------------------------------
//
void CAknTreeList::BaseConstructL()
    {
    CreateWindowL();
    BaseConstructL( *this );
    ActivateL();
    }


// ---------------------------------------------------------------------------
// Completes the construction of the base class. This variant assigns the
// window of the given container to the list.
// ---------------------------------------------------------------------------
//
void CAknTreeList::BaseConstructL( const CCoeControl& aContainer )
    {
    if ( this != &aContainer )
        {
        SetContainerWindowL( aContainer );
        }
    EnableDragEvents();
    iTree = CAknTree::NewL( *this, NULL );
    iView = CAknTreeListView::NewL( *this, *iTree, *this );
    
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
	// LISTBOX EFFECTS IMPLEMENTATION
	//
	// Creates a CTfxGc and replaces the original CWindowGc with that gc.
	//
    CWindowGc* transGc = CAknListLoader::CreateTfxGc( *this, iView->TopIndex(), 
    												iView->BottomIndex(), 
    												iView->HighlightIndex(), 
    												iView->ItemCountLimit()); 
    if( transGc )
        {
		iView->SetGc(transGc);
        }
	// END OF LISTBOX EFFECTS IMPLEMENTATION
#endif // RD_UI_TRANSITION_EFFECTS_LIST
    
    iTree->AddObserverL( iView );
    }


// ---------------------------------------------------------------------------
// References to the tree.
// ---------------------------------------------------------------------------
//
CAknTree& CAknTreeList::Tree()
    {
    __ASSERT_DEBUG( iTree != NULL, User::Invariant() );
    return *iTree;
    }


const CAknTree& CAknTreeList::Tree() const
    {
    __ASSERT_DEBUG( iTree != NULL, User::Invariant() );
    return *iTree;
    }


// ---------------------------------------------------------------------------
// References to the view.
// ---------------------------------------------------------------------------
//
CAknTreeListView& CAknTreeList::View()
    {
    __ASSERT_DEBUG( iView != NULL, User::Invariant() );
    return *iView;
    }


const CAknTreeListView& CAknTreeList::View() const
    {
    __ASSERT_DEBUG( iView != NULL, User::Invariant() );
    return *iView;
    }


// ---------------------------------------------------------------------------
// Mediates the focus change to the view.
// ---------------------------------------------------------------------------
//
void CAknTreeList::FocusChanged( TDrawNow aDrawNow )
    {
    View().SetFocus( IsFocused(), aDrawNow );
    }


// ---------------------------------------------------------------------------
// From class CCoeControl.
// Mediates the size and position change to the view.
// ---------------------------------------------------------------------------
//
void CAknTreeList::SizeChanged()
    {
    View().SetRect( Rect() );
    }


// ---------------------------------------------------------------------------
// From class CCoeControl.
// Mediates the position change to the view.
// ---------------------------------------------------------------------------
//
void CAknTreeList::PositionChanged()
    {
    View().SetPosition( TPoint() );
    }


// ---------------------------------------------------------------------------
// From class CCoeControl.
// Retrieves an object of the same type as that encapsulated in aId.
// ---------------------------------------------------------------------------
//
TTypeUid::Ptr CAknTreeList::MopSupplyObject( TTypeUid aId )
    {
    return CAknControl::MopSupplyObject( aId );
    }


// ---------------------------------------------------------------------------
// Marking mode observer
// ---------------------------------------------------------------------------
//
MAknMarkingModeObserver* CAknTreeList::MarkingModeObserver()
    {
    return iMarkingModeObserver;
    }


// ---------------------------------------------------------------------------
// Does nothing, the draw request is mediated to the view through component
// control structure.
// ---------------------------------------------------------------------------
//
void CAknTreeList::Draw( const TRect& /*aRect*/ ) const
    {
    }

