/*

* Copyright (c) 2006-2010 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 CAknTreeListView class.

*

*/

#include <AknUtils.h>

#include <skinlayout.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsBasicBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <barsread.h>

#include <aknappui.h>

#include <aknitemactionmenu.h>

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

#include <AknPriv.hrh>

#include "akntreelistview.h"

#include "akntree.h"

#include "akntreelist.h"

#include "akntreeiterator.h"

#include "akntreelistphysicshandler.h"

#include "akntrace.h"

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

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

#include <aknlistloadertfx.h>

#endif // RD_UI_TRANSITION_EFFECTS_LIST

// Value selected so that enough items fit in the array with vga resolution.

const TInt KVisibleItemsArrayGranularity = 16;

// Timeout for long keypress used in markable lists.

const TInt KLongPressInterval = 600000; // 0.6 seconds

// Number of additional items to draw

const TInt KAdditionalItems = 2;

// Tree list view flag definitions.

enum TAknTreeListViewFlags

    {

    EFlagStructureLines,

    EFlagIndention,

    EFlagLooping,

    EFlagUpdateBackground,

    EFlagMarkingEnabled, // Marking of list items is enabled.

    EFlagMarkingMode, // List in marking mode (MSK controlled by list). 

    EFlagMark, // List items are being marked.

    EFlagUnmark, // List items are being unmarked.

    EFlagSimultaneousMarking, // Simultaneous marking ongoing.

    EFlagHashKeyPressed,

    EFlagCtrlKeyPressed,

    EFlagShiftKeyPressed,

    EFlagSaveFocusAfterSorting,

    EFlagSingleClickEnabled,

    EFlagHighlightEnabled, // Is highlight drawing enabled

    EFlagIgnoreButtonUpEvent // Up event ignored (when styluspopup menu open)

    };

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

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

// Two-phased constructor.

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

//

CAknTreeListView* CAknTreeListView::NewL( const CCoeControl& aContainer,

    CAknTree& aTree, CAknTreeList& aList )

    {

    CAknTreeListView* self = new( ELeave ) CAknTreeListView( aTree, aList );

    CleanupStack::PushL( self );

    self->ConstructL( aContainer );

    CleanupStack::Pop( self );

    AKNTASHOOK_ADDL( self, "CAknTreeListView" );

    return self;

    }

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

// Destructor.

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

//

CAknTreeListView::~CAknTreeListView()

    {

    AKNTASHOOK_REMOVE();

    AknsUtils::DeregisterControlPosition( this );

    iItems.Close();

    iFocusedItem = NULL; // Not owned.

    delete iEmptyListText;

    delete iScrollbarFrame;

    delete iAnimation;

    delete iLongPressTimer;

    delete iPhysicsHandler;

    if ( iItemActionMenu )

        {

        iItemActionMenu->RemoveCollection( *this );

        }

    delete iLongTapDetector;

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    if ( CAknListLoader::TfxApiInternal( iGc ) )

        {

        delete iGc;

        }

#endif //RD_UI_TRANSITION_EFFECTS_LIST

    }

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

// Returns the specified layout rectangle.

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

//

TRect CAknTreeListView::RectFromLayout( const TRect& aParent,

    const TAknWindowComponentLayout& aComponentLayout )

    {

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect( aParent, aComponentLayout.LayoutLine() );

    return layoutRect.Rect();

    }

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

// Sets the focused item and its position in the view.

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

//

void CAknTreeListView::SetFocusedItem( CAknTreeItem* aItem,

    TInt aIndex, TBool aDrawNow )

    {

    if ( FocusedItem() != aItem || FocusIndex() != aIndex )

        {

        SetFocusedItem( aItem );

        if ( aItem )

            {

            UpdateVisibleItems( aIndex, aItem );

            UpdateViewLevel();

            if ( IsMarkable() )

                {

                UpdateMSKCommand();

                }

            }

        }

    // Updates the highlight animation, if the size or background of focused

    // item has been changed.

    UpdateAnimation();

    if ( aDrawNow )

        {

        Window().Invalidate( Rect() );

        }

    UpdateScrollbars( ETrue );

    }

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

// Sets the focused item and its position in the view.

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

//

void CAknTreeListView::SetFocusedItemAndView( CAknTreeItem* aItem )

    {

    if ( FocusedItem() != aItem)

        {

        SetFocusedItem( aItem );

        iPreviouslyFocusedItem = FocusedItem();

        if ( aItem )

            {   

            TInt index = iTree.ItemIndex( aItem );

            if ( index < iItems.Count() )

            {

                // focused item in first page,

                // set focused item to correct line and update view

                // to the beginning of list

                UpdateVisibleItems( index, aItem );

            }

            else

            {

                // focused item not in first page,

                // set focused item and update view so that focused item

                // is at the lowest line on the screen

                UpdateVisibleItems( iItems.Count() - 1, aItem );

            }

            UpdateViewLevel();

            if ( IsMarkable() )

                {

                UpdateMSKCommand();

                }

            }

        }

    // Updates the highlight animation, if the size or background of focused

    // item has been changed.

    UpdateAnimation();

    // Draw always

    Window().Invalidate( Rect() );

    UpdateScrollbars( ETrue );

    }

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

//

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

//

TInt CAknTreeListView::FocusedItemIndex() const

    {

    if ( FocusedItemVisible() )

        {

        return FocusIndex();

        }

    return -1;  

    }

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

//

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

//  

TInt CAknTreeListView::VisibleItemIndex( CAknTreeItem* aItem ) const

    {

    for ( TInt ii = 0; ii < iItems.Count(); ++ii )

        {

        if ( aItem == iItems[ii].Item() )

            {

            return ii;

            }

        }

    return -1;

    }

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

//

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

//  

void CAknTreeListView::SetFocusBehaviour( TBool saveFocus )

{

    if ( saveFocus)

        {

        iFlags.Set( EFlagSaveFocusAfterSorting );

        }

    else

        {

        iFlags.Clear( EFlagSaveFocusAfterSorting );

        }

}

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

// Returns pointer to the focused item.

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

//

CAknTreeItem* CAknTreeListView::FocusedItem() const

    {

    return iFocusedItem;

    }

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

// Returns the highlight rectangle for the focused item.

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

//

TRect CAknTreeListView::HighlightRect() const

    {

    if ( IsFocused() && FocusedItemVisible() )

        {

        TRect rect = iItems[FocusIndex()].HighlightRect( iViewLevel,

            Indention(), IndentionWidth() );

        TPoint position;

        if ( AknsUtils::GetControlPosition( this, position ) != KErrNone )

            {

            position = PositionRelativeToScreen();

            }

        rect.Move( position );

        return rect;

        }

    else

        {

        return TRect();

        }

    }

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

// Returns whether the list is set looping.

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

//

TBool CAknTreeListView::IsLooping() const

    {

    return iFlags.IsSet( EFlagLooping );

    }

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

// Sets the list to looping or non-looping mode.

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

//

void CAknTreeListView::SetLooping( TBool aLooping )

    {

    iFlags.Assign( EFlagLooping, aLooping );

    }

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

// Returns whether the structure lines are set visible.

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

//

TBool CAknTreeListView::StructureLines() const

    {

    return iFlags.IsSet( EFlagStructureLines ) && 

        iFlags.IsSet( EFlagIndention );

    }

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

// Sets the visibility of structure lines.

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

//

void CAknTreeListView::SetStructureLineVisibility( TBool aVisible )

    {

    iFlags.Assign( EFlagStructureLines, aVisible );

    Window().Invalidate( Rect() );

    }

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

// Checks whether indention is enabled.

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

//

TBool CAknTreeListView::Indention() const

    {

    return iFlags.IsSet( EFlagIndention );

    }

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

// Enables or disables indention of list items.

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

//

void CAknTreeListView::EnableIndention( TBool aEnable )

    {

    iFlags.Assign( EFlagIndention, aEnable );

    iMaxViewLevel = aEnable ? iTree.Depth() - 1 : 0;

    Window().Invalidate( Rect() );

    }

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

// Returns the width of single indention step.

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

//

TInt CAknTreeListView::IndentionWidth() const

    {

    if ( StructureLines() )

        {

        return -1;

        }

    else

        {

        return iIndentionWidth;

        }

    }

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

// Sets the width of one indention step.

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

//

void CAknTreeListView::SetIndentionWidth( TInt aIndentionWidth )

    {

    iIndentionWidth = aIndentionWidth;

    }

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

// Checks whether marking is enabled.

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

//

TBool CAknTreeListView::IsMarkable() const

    {

    return iFlags.IsSet( EFlagMarkingEnabled );

    }

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

// Enables or disables the marking of list items.

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

//

void CAknTreeListView::EnableMarking( TBool aEnable )

    {

    iFlags.Assign( EFlagMarkingEnabled, aEnable );

    }

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

// Sets text for the empty list.

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

//   

void CAknTreeListView::SetEmptyTextL(const TDesC& aText)

    {

    delete iEmptyListText;

    iEmptyListText = NULL;

    iEmptyListText = aText.AllocL();

    UpdateScrollbars( ETrue ); 

    }

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

// InitPhysicsL

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

//   

void CAknTreeListView::InitPhysicsL()

    {

    if ( iPhysicsHandler )

        {

        iPhysicsHandler->InitPhysicsL();

        }

    }

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

// SetHighlight

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

//     

void CAknTreeListView::SetHighlight( CAknTreeItem* aItemToBeFocused,

                                     const TInt& aIndexToBeFocused )

    {

    if ( aItemToBeFocused )

        {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

        MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal( iGc );

        if ( transApi && !transApi->EffectsDisabled() && !aItemToBeFocused->Node() )

            {

            transApi->SetMoveType( MAknListBoxTfxInternal::EListTap );

            }

#endif

        SetFocusedItem( aItemToBeFocused, aIndexToBeFocused, ETrue );

        iPreviouslyFocusedItem = aItemToBeFocused;

        }

    }

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

// SelectItem

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

//     

void CAknTreeListView::SelectItem( CAknTreeItem* aSelectedItem )

    {

    SelectItem( aSelectedItem, EFalse );

    }

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

// VisibleItemCount

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

//     

TInt CAknTreeListView::VisibleItemCount() const

    {

    TInt count( iItems.Count() );

    count += KAdditionalItems;

    return count;

    }

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

// SetPressedDownState

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

//     

void CAknTreeListView::SetPressedDownState( const TBool& aPressedDown )

    {

    iIsPressedDownState = aPressedDown;

    }

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

// UpdateTreeListView

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

//     

void CAknTreeListView::UpdateTreeListView( const TInt& aFirstItem,

                                           const TBool& aDrawNow )

    {

    CAknTreeItem* first = iTree.VisibleItem( aFirstItem );

    UpdateVisibleItems( 0, first );

    UpdateScrollbars( ETrue );

    UpdateAnimation();

    if ( aDrawNow )

        {

        DrawNow();

        }

    else

        {

        Window().Invalidate( Rect() );

        } 

    }

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

// Offset

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

//     

TInt CAknTreeListView::Offset() const

    {