/*

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

*

*/

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "aknsinglestyletreenode.h"

#include "akntree.h"

#include "akntreelistinternalconstants.h"

using AknTreeListIconID::KDefault;

using AknTreeListIconID::KNone;

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

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

// Two-phased constructor.

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

//

CAknSingleStyleTreeNode* CAknSingleStyleTreeNode::NewL( const TDesC& aText,

    TUint32 aFlags )

    {

    CAknSingleStyleTreeNode* self =

        CAknSingleStyleTreeNode::NewLC( aText, aFlags );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CAknSingleStyleTreeNode* CAknSingleStyleTreeNode::NewLC( const TDesC& aText,

    TUint32 aFlags )

    {

    CAknSingleStyleTreeNode* self =

        new ( ELeave ) CAknSingleStyleTreeNode( aFlags );

    CleanupStack::PushL( self );

    self->ConstructL( aText );

    return self;

    }

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

// Destructor.

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

//

CAknSingleStyleTreeNode::~CAknSingleStyleTreeNode()

    {

    delete iText;

    }

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

// Returns the text set for the the node.

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

//

const TDesC& CAknSingleStyleTreeNode::Text() const

    {

    return iText ? *iText : KNullDesC();

    }

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

// Allocates new heap based descriptor for the text, and if the allocation

// succeeds, deletes the old descriptor and replaces it with the new.

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

//

void CAknSingleStyleTreeNode::SetTextL( const TDesC& aText, TBool aDrawNow )

    {

    HBufC* tmp = aText.AllocL();

    delete iText;

    iText = tmp;

    if ( aDrawNow )

        {

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

        Root()->ItemModified( this );

        }

    }

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

// Returns the icon ID set for the specified tree node icon type.

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

//

TInt CAknSingleStyleTreeNode::Icon( TIconType aType ) const

    {

    TInt iconId = KDefault;

    switch ( aType )

        {

        case EExpandedIcon:

            iconId = iExpandedIcon;

            break;

        case ECollapsedIcon:

            iconId = iCollapsedIcon;

            break;

        case EOptIcon1:

            iconId = iOptIcon1;

            break;

        case EOptIcon2:

            iconId = iOptIcon2;

            break;

        case EHighlightedExpandedIcon:

            iconId = iHighlightedExpandedIcon;

            break;

        case EHighlightedCollapsedIcon:

            iconId = iHighlightedCollapsedIcon;

            break;

        case EHighlightedOptIcon1:

            iconId = iHighlightedOptIcon1;

            break;

        case EHighlightedOptIcon2:

            iconId = iHighlightedOptIcon2;

            break;

        default:

            break;

        }

    return iconId;

    }

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

// Sets the icon ID for specified tree node icon type.

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

//

void CAknSingleStyleTreeNode::SetIcon( TIconType aType, TInt aIconId,

    TBool aDrawNow )

    {

    switch ( aType )

        {

        case EExpandedIcon:

            iExpandedIcon = aIconId;

            break;

        case ECollapsedIcon:

            iCollapsedIcon = aIconId;

            break;

        case EOptIcon1:

            iOptIcon1 = aIconId;

            break;

        case EOptIcon2:

            iOptIcon2 = aIconId;

            break;

        case EHighlightedExpandedIcon:

            iHighlightedExpandedIcon = aIconId;

            break;

        case EHighlightedCollapsedIcon:

            iHighlightedCollapsedIcon = aIconId;

            break;

        case EHighlightedOptIcon1:

            iHighlightedOptIcon1 = aIconId;

            break;

        case EHighlightedOptIcon2:

            iHighlightedOptIcon2 = aIconId;

            break;

        default:

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

            break;

        }

    if ( aDrawNow )

        {

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

        Root()->ItemModified( this );

        }

    }

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

// Icon ID.

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

//

TInt CAknSingleStyleTreeNode::IconId( TBool aFocused ) const

    {

    TInt iconId = KNone;

    if ( IsExpanded() )

        {

        iconId = CAknTree::EOpenFolderIndication;

        if ( aFocused && iHighlightedExpandedIcon != KDefault )

            {

            iconId = iHighlightedExpandedIcon;

            }

        else if ( iExpandedIcon != KDefault )

            {

            iconId = iExpandedIcon;

            }

        }

    else

        {

        iconId = CAknTree::EClosedFolderIndication;

        if ( aFocused && iHighlightedCollapsedIcon != KDefault )

            {

            iconId = iHighlightedCollapsedIcon;

            }

        else if ( iCollapsedIcon != KDefault )

            {

            iconId = iCollapsedIcon;

            }

        }

    return iconId;

    }

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

// Optional icon ID.

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

//

TInt CAknSingleStyleTreeNode::OptionalIconId( TInt aIndex,

    TBool aFocused ) const

    {

    __ASSERT_DEBUG( aIndex == 0 || aIndex == 1, User::Invariant() );

    // Default ID for optional icon.

    TInt optIconId = AknTreeListIconID::KNone; 

    // Determine ID for specified optional icon.

    if ( aIndex == 0 )

        {

        if ( aFocused && iHighlightedOptIcon1 != KDefault )

            {

            optIconId = iHighlightedOptIcon1;

            }

        else if ( iOptIcon1 != KDefault )

            {

            optIconId = iOptIcon1;

            }

        }

    else if ( aIndex == 1 )

        {

        if ( aFocused && iHighlightedOptIcon2 != KDefault )

            {

            optIconId = iHighlightedOptIcon2;

            }

        else if ( iOptIcon2 != KDefault )

            {

            optIconId = iOptIcon2;

            }

        }

    return optIconId;

    }

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

// Text variety depending on optional icons.

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

//

TInt CAknSingleStyleTreeNode::TextVariety( TInt aOptIconId1,

    TInt aOptIconId2 ) const

    {

    TInt textVariety = 0;

    if ( aOptIconId1 != AknTreeListIconID::KNone )

        {

        textVariety = 1;

        }

    if ( aOptIconId2 != AknTreeListIconID::KNone )

        {

        textVariety = 2;

        }

    return textVariety;

    }

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

// From class CAknTreeItem.

// Returns the type of concrete item class.

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

//

TInt CAknSingleStyleTreeNode::Type() const

    {

    return AknTreeList::KSingleStyleTreeNode;

    }

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

// From class CAknTreeItem.

// Draws the content of the node to given graphic context.

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

//

void CAknSingleStyleTreeNode::Draw( CWindowGc& aGc, const TRect& aItemRect,

    const TRect& /*aRect*/, TBool aFocused ) const

    {

    CAknTree* root = Root();

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

    // Icon.

    TInt iconVariety = 2; // Arbitrarily selected variety.

    TRect iconRect = RectFromLayout( aItemRect, AknLayoutScalable_Avkon::

        list_single_graphic_hl_pane_g2( iconVariety ) );

    TInt iconId = IconId( aFocused );

    // dragging / flicking

    if ( iconId != AknTreeListIconID::KNone )

        {

        root->DrawIcon( iconId, iconRect.Size(), aGc, iconRect.iTl,

            iconRect.Size() );

        }

    // Non-empty folder indication icon.

    if ( !IsEmpty() )

        {

        TInt indicatorVariety = 2; // Arbitrarily selected variety.

        TRect indicatorRect = RectFromLayout( aItemRect, AknLayoutScalable_Avkon::

            list_single_graphic_hl_pane_g3( indicatorVariety ) );

        TInt indicatorId = IsExpanded() ?

            CAknTree::ECollapseFunctionIndication : 

            CAknTree::EExpandFunctionIndication;

        root->DrawIcon( indicatorId, indicatorRect.Size(), aGc,

            indicatorRect.iTl, indicatorRect.Size() );

        }

    // Optional icon IDs.

    TInt optIconId1 = OptionalIconId( 0, aFocused );

    TInt optIconId2 = OptionalIconId( 1, aFocused );

    // Text variety is set according to required optional icons.

    TInt textVariety = TextVariety( optIconId1, optIconId2 );

    // Text.

    TAknLayoutText layoutText;

    layoutText.LayoutText( aItemRect, AknLayoutScalable_Avkon::

        list_single_graphic_hl_pane_t1( textVariety ).LayoutLine() );

    root->DrawText( aGc, aItemRect, AknLayoutScalable_Avkon::

        list_single_graphic_hl_pane_t1( textVariety ), *iText, NULL, this,

        aFocused, ETrue );

    // Optional item state indication icon.

    TInt optIconVariety1 = 1;

    TRect optIconRect1 = RectFromLayout( aItemRect, AknLayoutScalable_Avkon::

        list_single_graphic_hl_pane_g4( optIconVariety1 ) );

    if ( optIconId1 != KNone )

        {

        root->DrawIcon( optIconId1, optIconRect1.Size(), aGc,

            optIconRect1.iTl, optIconRect1.Size() );

        }

    // Another optional item state indication icon.

    TInt optIconVariety2 = 1;

    TRect optIconRect2 = RectFromLayout( aItemRect, AknLayoutScalable_Avkon::

        list_single_graphic_hl_pane_g5( optIconVariety2 ) );

    if ( optIconId2 != KNone )

        {

        root->DrawIcon( optIconId2, optIconRect2.Size(), aGc,

            optIconRect2.iTl, optIconRect2.Size() );

        }    

    }

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

// From class CAknTreeItem.

// Handles pointer events.

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

//

void CAknSingleStyleTreeNode::HandlePointerEventL(

    const TPointerEvent& /*aPointerEvent*/, const TRect& /*aItemRect*/ )

    {

    }

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

// C++ constructor.

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

//

CAknSingleStyleTreeNode::CAknSingleStyleTreeNode( TUint32 aFlags )

    : CAknTreeNode( aFlags ),

    iExpandedIcon( KDefault ),

    iCollapsedIcon( KDefault ),

    iOptIcon1( KDefault ),

    iOptIcon2( KDefault ),

    iHighlightedExpandedIcon( KDefault ),

    iHighlightedCollapsedIcon( KDefault ),

    iHighlightedOptIcon1( KDefault ),

    iHighlightedOptIcon2( KDefault )

    {

    }

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

// Second phase constructor.

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

//

void CAknSingleStyleTreeNode::ConstructL( const TDesC& aText )

    {

    iText = aText.AllocL();

    }