/*

* Copyright (c) 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:  A visualizer for nodes with plain text.

*

*/

//<cmail> removed __FS_ALFRED_SUPPORT flag

//#include <fsconfig.h>

//</cmail> removed __FS_ALFRED_SUPPORT flag

#include "emailtrace.h"

#include "fstreeplainonelinenodevisualizer.h"

#include "fstreeplainonelinenodedata.h"

#include "fsgenericpanic.h"

#include "fstreelist.h"

#include "fslayoutmanager.h"

#include "fsmarqueeclet.h"

#include <touchlogicalfeedback.h>

// <cmail> SF

#include <alf/alfanchorlayout.h>

#include <alf/alfimagevisual.h>

#include <alf/alfviewportlayout.h>

#include <alf/alftextvisual.h>

#include <alf/alfimage.h>

#include <alf/alfenv.h>

#include <alf/alfevent.h>

#include <alf/alfmappingfunctions.h>

// </cmail>

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

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

// Two-phased constructor.

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

//

EXPORT_C CFsTreePlainOneLineNodeVisualizer*

    CFsTreePlainOneLineNodeVisualizer::NewL(

                                                  CAlfControl& aOwnerControl )

    {

    CFsTreePlainOneLineNodeVisualizer* self = new( ELeave )

                            CFsTreePlainOneLineNodeVisualizer( aOwnerControl);

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ destructor.

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

//

CFsTreePlainOneLineNodeVisualizer::~CFsTreePlainOneLineNodeVisualizer()

    {

    FUNC_LOG;

    delete iTextMarquee;

    }

// from base class MFsTreeItemVisualizer

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

// From MFsTreeItemVisualizer.

// Returns visualizer's type.

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

//

TFsTreeItemVisualizerType CFsTreePlainOneLineNodeVisualizer::Type() const

    {

    FUNC_LOG;

    return EFsTreePlainOneLineNodeVisualizer;

    }

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

// From MFsTreeItemVisualizer.

// Sets multiple flags for a node at one time.

// KFsTreeListItemExtendable flag has no effect.

// KFsTreeListItemExtended flag has no effect.

// KFsTreeListItemAlwaysExtended  flag has no effect.

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

//

void CFsTreePlainOneLineNodeVisualizer::SetFlags( TUint32 aFlags )

    {

    FUNC_LOG;

    iFlags = aFlags;

    iFlags &= ~KFsTreeListItemExtendable;

    iFlags &= ~KFsTreeListItemExtended;

    iFlags &= ~KFsTreeListItemAlwaysExtended;

    }

void CFsTreePlainOneLineNodeVisualizer::SetExpanded( TBool aFlag, const MFsTreeItemData* aData )

    {

    CFsTreeNodeVisualizerBase::SetExpanded(aFlag, aData);

    if (aData)

        {

        const CFsTreePlainOneLineNodeData* data =

                                static_cast<const CFsTreePlainOneLineNodeData*>(aData);

        if (iIconVisual)

            {

            if ( IsExpanded())

                {

                if (data->IsIconExpandedSet())

                    {

                    iIconVisual->SetImage(TAlfImage( data->IconExpanded ()));

                    }

                }

            else

                {

                if (data->IsIconCollapsedSet())

                    {

                    iIconVisual->SetImage(TAlfImage( data->IconCollapsed()));

                    }

                }

            }

        }

    }

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

// From MFsTreeItemVisualizer.

// Sets item's visualization state to extended.

// Node cannot be extended - the function has no effect.

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

//

void CFsTreePlainOneLineNodeVisualizer::SetExtended( TBool /*aIsExtended*/ )

    {

    FUNC_LOG;

    iFlags &= ~KFsTreeListItemExtended;

    }

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

// From MFsTreeItemVisualizer.

// Returns extended/not extended state of the item visualization.

// Node cannot be extended - the function always returns EFalse.

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

//

TBool CFsTreePlainOneLineNodeVisualizer::IsExtended() const

    {

    FUNC_LOG;

    return EFalse;

    }

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

// From MFsTreeItemVisualizer.

// Sets if an item can be in expanded state or not.

// Node is not extendable - the function has no effect.

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

//

void CFsTreePlainOneLineNodeVisualizer::SetExtendable( TBool /*aIsExtendable*/ )

    {

    FUNC_LOG;

    iFlags &= ~KFsTreeListItemExtendable;

    }

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

// From MFsTreeItemVisualizer.

// Returns an information if item can be in expanded state.

// Node is not extendable - the function always returns EFalse.

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

//

TBool CFsTreePlainOneLineNodeVisualizer::IsExtendable( )

    {

    FUNC_LOG;

    return EFalse;

    }

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

// From MFsTreeItemVisualizer.

// This functions sets wether an item should always be in extended state.

// Node cannot be made always extended. This function has no effect.

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

//

void CFsTreePlainOneLineNodeVisualizer::SetAlwaysExtended( TBool /*aAlwaysExtended*/ )

    {

    FUNC_LOG;

    iFlags &= ~KFsTreeListItemAlwaysExtended;

    }

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

// From MFsTreeItemVisualizer.

// This function returns wether an item is always in extended state.

// Node cannot be made always extended. The function always returns EFalse.

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

//

TBool CFsTreePlainOneLineNodeVisualizer::IsAlwaysExtended( ) const

    {

    FUNC_LOG;

    return EFalse;

    }

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

// From class MFsTreeItemVisualizer.

// Sets the size of the item visualization when item is not in expanded

// state. The value is taken from layout manager.

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

//

void CFsTreePlainOneLineNodeVisualizer::UpdateLayout(

        const CFsTreePlainOneLineNodeData* aData,

        const TInt aIndentation,

        CAlfTexture*& /*aMarkIcon*/,

        CAlfTexture*& /*aMenuIcon*/

        )

    {

    FUNC_LOG;

    TRect rect;

    TAlfTimedPoint tpMainIconTl, tpMainIconBr;

    TAlfTimedPoint tpTextTl, tpTextBr;

    TAlfTimedPoint tpMarkIconTl, tpMarkIconBr;

    TAlfTimedPoint tpMenuIconTl, tpMenuIconBr;

    CFsLayoutManager::TFsLayoutMetrics mainIconMetrics =

        CFsLayoutManager::EFsLmListSingleDycRowPaneG1;

    CFsLayoutManager::TFsLayoutMetrics markIconMetrics =

        CFsLayoutManager::EFsLmListSingleDycRowPaneG4;

    CFsLayoutManager::TFsLayoutMetrics menuIconMetrics =

        CFsLayoutManager::EFsLmListSingleDycRowPaneG3;

    CFsLayoutManager::TFsLayoutMetrics textMetrics =

        CFsLayoutManager::EFsLmListSingleDycRowTextPaneT1;

    TInt mainIconVariety( 0 );

    TInt markIconVariety( 0 );

    TInt menuIconVariety( 0 );

    TInt textPaneVariety( 0 );

    if (aData->IsIconCollapsedSet())

        {

        if (iFlags & KFsTreeListItemMarked)

            {

            if ((iFlags & KFsTreeListItemHasMenu)

                    && (iFlags & KFsTreeListItemFocused))

                {

                //mainIcon + markIcon + menuIcon

                //the metrics defined when declared

                mainIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG1;

                menuIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG3;

                markIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG4;

                mainIconVariety = 3;

                textPaneVariety = 3;

                menuIconVariety = 1;

                markIconVariety = 2;

                }

            else

                {

                //mainIcon + markIcon

                mainIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG1;

                markIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG4;

                mainIconVariety = 4;

                textPaneVariety = 4;

                markIconVariety = 3;

                }

            }

        else

            {

            if ((iFlags & KFsTreeListItemHasMenu)

                    && (iFlags & KFsTreeListItemFocused))

                {

                //mainIcon + menuIcon

                mainIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG1;

                menuIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG4;

                mainIconVariety = 4;

                textPaneVariety = 4;

                menuIconVariety = 3;

                }

            else

                {

                if ( IsLayoutHintSet( EFolderLayout ) )

	                {

	                //mainIcon

	                mainIconMetrics = CFsLayoutManager::EFsLmFolderListMediumLineG1;

	                textMetrics     = CFsLayoutManager::EFsLmFolderListMediumLineT1;

	                }

	            else

		            {

	                //mainIcon

                    mainIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG1;

                    mainIconVariety = 5;

                    textPaneVariety = 5;

		            }

                }

            }

        }

    else

        {

        if (iFlags & KFsTreeListItemMarked)

            {

            if ((iFlags & KFsTreeListItemHasMenu)

                    && (iFlags & KFsTreeListItemFocused))

                {

                //markIcon + menuIcon

                menuIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG3;

                markIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG4;

                menuIconVariety = 2;

                markIconVariety = 4;

                textPaneVariety = 6;

                }

            else

                {

                //markIcon

                markIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG4;

                markIconVariety = 5;

                textPaneVariety = 7;

                }

            }

        else

            {

            if ((iFlags & KFsTreeListItemHasMenu)

                    && (iFlags & KFsTreeListItemFocused))

                {

                //menuIcon

                menuIconMetrics = CFsLayoutManager::EFsLmListSingleDycRowPaneG4;

                menuIconVariety = 5;

                textPaneVariety = 7;

                }

            else

                {

                //plain item

                textPaneVariety = 8;

                }

            }

        }

    //layout manager is queried for medium values - LM returnes rects based on phone's global text settings

    TRect parentLayoutRect = TRect(iParentLayout->Size().Target().AsSize());

    parentLayoutRect.Resize(-(iParentLayout->HorizontalPadding()*2), 0);

    if (iFlags & KFsTreeListItemManagedLayout)

        {

        CFsLayoutManager::LayoutMetricsSize(

                parentLayoutRect,

                CFsLayoutManager::EFsLmListSingleFsDycPane,

                iSize );

        }

    //one line node is not extendable

    TRect currentSize = iSize;

    if ( !IsLayoutHintSet( EFolderLayout ) )

        {

        CFsLayoutManager::LayoutMetricsRect(currentSize, CFsLayoutManager::EFsLmListSingleDycRowPane, currentSize);

        }

    if (CFsLayoutManager::IsMirrored())

        {

        currentSize.iBr = currentSize.iBr - TPoint(aIndentation, 0);

        }

    else

        {

        currentSize.iTl = currentSize.iTl + TPoint(aIndentation, 0);

        }

    CFsLayoutManager::LayoutMetricsRect(

                currentSize,

                mainIconMetrics,

                rect,

                mainIconVariety );

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK

    if (rect.iTl.iY < 15)

        {

        rect.Move(0, 15 - rect.iTl.iY);    

        }

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK   

    tpMainIconTl.SetTarget(TAlfRealPoint(rect.iTl));

    tpMainIconBr.SetTarget(TAlfRealPoint(rect.iBr));

    CFsLayoutManager::LayoutMetricsRect(

            currentSize,

            markIconMetrics,

            rect,

            markIconVariety );

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK

    if (rect.iTl.iY < 15)

        {

        rect.Move(0, 15 - rect.iTl.iY);    

        }

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK   

    tpMarkIconTl.SetTarget(TAlfRealPoint(rect.iTl));

    tpMarkIconBr.SetTarget(TAlfRealPoint(rect.iBr));

    CFsLayoutManager::LayoutMetricsRect(

            currentSize,

            menuIconMetrics,

            rect,

            menuIconVariety );

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK

    if (rect.iTl.iY < 15)

        {

        rect.Move(0, 15 - rect.iTl.iY);    

        }

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK   

    tpMenuIconTl.SetTarget(TAlfRealPoint(rect.iTl));

    tpMenuIconBr.SetTarget(TAlfRealPoint(rect.iBr));

    TRect textRect( currentSize );

    if (textMetrics == CFsLayoutManager::EFsLmListSingleDycRowTextPaneT1)

        {

        CFsLayoutManager::LayoutMetricsRect(

                    currentSize,

                    CFsLayoutManager::EFsLmListSingleDycRowTextPane,

                    textRect,

                    textPaneVariety );

        }

    CFsLayoutManager::TFsText textInfo;

    CFsLayoutManager::LayoutMetricsText(textRect,

            textMetrics, textInfo, textPaneVariety);

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK

    if (textInfo.iTextRect.iTl.iY < 15)

        {

        textInfo.iTextRect.Move(0, 15 - textInfo.iTextRect.iTl.iY);    

        }

    // WORKAROUND FIX FOR LAYOUT PROBLEM -- RETURN THIS TO NORMAL WHEN LAYOUT'S ARE OK

    tpTextTl.SetTarget(TAlfRealPoint(textInfo.iTextRect.iTl)); 

    tpTextBr.SetTarget(TAlfRealPoint(textInfo.iTextRect.iBr));

    TInt visualIconIndex = iLayout->FindVisual(iIconVisual);

    if ( visualIconIndex != KErrNotFound )

        {

        iLayout->SetAnchor( EAlfAnchorTopLeft,

                visualIconIndex,

                EAlfAnchorOriginLeft, EAlfAnchorOriginTop,

                EAlfAnchorMetricAbsolute,

                EAlfAnchorMetricAbsolute,

                tpMainIconTl );

        iLayout->SetAnchor( EAlfAnchorBottomRight,

                visualIconIndex,

                EAlfAnchorOriginLeft, EAlfAnchorOriginTop,

                EAlfAnchorMetricAbsolute,

                EAlfAnchorMetricAbsolute,

                tpMainIconBr );

        }

    if ((iFlags & KFsTreeListItemHasMenu)

            && (iFlags & KFsTreeListItemFocused))

        {

        TInt iconMenuVisIndex = iLayout->FindVisual(iIconMenu);

        if ( iconMenuVisIndex != KErrNotFound )

            {

            iLayout->SetAnchor(EAlfAnchorTopLeft,

                    iconMenuVisIndex,

                    EAlfAnchorOriginLeft,EAlfAnchorOriginTop,

                    EAlfAnchorMetricAbsolute,EAlfAnchorMetricAbsolute,

                    tpMenuIconTl );

            iLayout->SetAnchor(EAlfAnchorBottomRight,

                    iconMenuVisIndex,

                    EAlfAnchorOriginLeft,EAlfAnchorOriginTop,

                    EAlfAnchorMetricAbsolute,EAlfAnchorMetricAbsolute,

                    tpMenuIconBr );

            TAlfTimedValue opacity;

            opacity.SetValueNow(1.0f);

            iIconMenu->SetOpacity(opacity);

            }

        }

    else

        {

        TAlfTimedValue opacity;

        opacity.SetValueNow(0.0f);

        iIconMenu->SetOpacity(opacity);

        }

    if (iViewportLayout)

        {

        TInt textVisIndex = iLayout->FindVisual(iViewportLayout);

        if ( textVisIndex != KErrNotFound )

            {

            iLayout->SetAnchor(EAlfAnchorTopLeft,

                    textVisIndex,

                    EAlfAnchorOriginLeft,EAlfAnchorOriginTop,

                    EAlfAnchorMetricAbsolute,

                    EAlfAnchorMetricAbsolute,

                    tpTextTl );

            iLayout->SetAnchor(EAlfAnchorBottomRight,

                    textVisIndex,

                    EAlfAnchorOriginLeft, EAlfAnchorOriginTop,

                    EAlfAnchorMetricAbsolute,

                    EAlfAnchorMetricAbsolute,

                    tpTextBr );

            }

        }

    if ( iFlags & KFsTreeListItemMarked )

        {

        TInt iconMarkedVisIndex =

                            iLayout->FindVisual(iIconMarked);

        if ( iconMarkedVisIndex != KErrNotFound )

            {

            iLayout->SetAnchor(EAlfAnchorTopLeft,

                    iconMarkedVisIndex,

                    EAlfAnchorOriginLeft,EAlfAnchorOriginTop,

                    EAlfAnchorMetricAbsolute,

                    EAlfAnchorMetricAbsolute,

                    tpMarkIconTl );

            iLayout->SetAnchor(EAlfAnchorBottomRight,

                    iconMarkedVisIndex,

                    EAlfAnchorOriginLeft, EAlfAnchorOriginTop,

                    EAlfAnchorMetricAbsolute,

                    EAlfAnchorMetricAbsolute,

                    tpMarkIconBr );

            TAlfTimedValue opacity;

            opacity.SetValueNow(1.0f);

            iIconMarked->SetOpacity(opacity);

            }

        }

    else

        {

        if (iIconMarked)