/*

* 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 data items with plain text.

*

*/

//<cmail> removed __FS_ALFRED_SUPPORT flag

//#include <fsconfig.h>

//</cmail> removed __FS_ALFRED_SUPPORT flag

#include "emailtrace.h"

#include "fstreeplainonelineitemvisualizer.h"

#include "fstreeplainonelineitemdata.h"

#include "fstreelist.h"

#include "fslayoutmanager.h"

#include "fstextstylemanager.h"

#include "fsalftextstylemanager.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/alftextstyle.h>

#include <alf/alfevent.h>

#include <alf/alfmappingfunctions.h>

// </cmail>

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

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

// Two-phased constructor.

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

//

EXPORT_C CFsTreePlainOneLineItemVisualizer*

    CFsTreePlainOneLineItemVisualizer::NewL( CAlfControl& aOwnerControl )

    {

    CFsTreePlainOneLineItemVisualizer* self =

        new( ELeave ) CFsTreePlainOneLineItemVisualizer( aOwnerControl );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ destructor.

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

//

CFsTreePlainOneLineItemVisualizer::~CFsTreePlainOneLineItemVisualizer()

    {

    FUNC_LOG;

    delete iTextMarquee;

    }

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

// Returns visualizer's type.

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

//

TFsTreeItemVisualizerType CFsTreePlainOneLineItemVisualizer::Type() const

    {

    FUNC_LOG;

    return EFsTreePlainOneLineItemVisualizer;

    }

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

// 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 CFsTreePlainOneLineItemVisualizer::UpdateLayout(

        const CFsTreePlainOneLineItemData* aData,

        const TInt aIndentation )

    {

    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->IsIconSet() || IsLayoutHintSet( CFsTreeItemVisualizerBase::EPopupLayout ))

        {

        if (iFlags & KFsTreeListItemMarked)

            {

            if (iMenu && (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

                    textMetrics     = CFsLayoutManager::EFsLmMainSpFsCtrlbarDdmenuPaneT1;

                    mainIconMetrics = CFsLayoutManager::EFsLmMainSpFsCtrlbarDdmenuPaneG2;

                    mainIconVariety = 0;

                    textPaneVariety = 2;

                    }

                }

            }

        }

    else // !aData->IsIconSet()

        {

        if (iFlags & KFsTreeListItemMarked)

            {

            if (iMenu && (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::EFsLmListSingleDycRowPane,

                iSize );

        }

    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 );

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

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

    CFsLayoutManager::LayoutMetricsRect(

            currentSize,

            markIconMetrics,

            rect,

            markIconVariety );

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

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

    CFsLayoutManager::LayoutMetricsRect(

            currentSize,

            menuIconMetrics,

            rect,

            menuIconVariety );

    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(currentSize, textMetrics, textInfo);*/

    CFsLayoutManager::LayoutMetricsText(textRect,

            textMetrics,

            textInfo, textPaneVariety);

    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)

            {

            TAlfTimedValue opacity;

            opacity.SetValueNow(0.0f);

            iIconMarked->SetOpacity(opacity);

            }

        }

    iLayout->UpdateChildrenLayout();

    }

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

// From class MFsTreeItemVisualizer.

// A call to this function means that the item is requested to draw itself

// within specified parent layout.

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

//

void CFsTreePlainOneLineItemVisualizer::ShowL( CAlfLayout& aParentLayout,

                                        const TUint aTimeout )

    {

    FUNC_LOG;

    if (!iLayout)

        {

        iParentLayout = &aParentLayout;

        iLayout = CAlfAnchorLayout::AddNewL(iOwnerControl,iParentLayout);

        iLayout->SetTactileFeedbackL( ETouchEventStylusDown, ETouchFeedbackBasic );

        iLayout->EnableBrushesL();

        iLayout->SetClipping(ETrue);

        if (!iIconVisual)

            {

            iIconVisual =

                        CAlfImageVisual::AddNewL(iOwnerControl, iLayout);

            // <cmail> aspect ratio preserved

            iIconVisual->SetScaleMode( CAlfImageVisual::EScaleFitInside);

            iIconVisual->SetFlag( EAlfVisualFlagIgnorePointer );

            }

        if (!iViewportLayout) 

            {

            iViewportLayout =

                      CAlfViewportLayout::AddNewL(iOwnerControl, iLayout);

            iViewportLayout->SetFlag( EAlfVisualFlagIgnorePointer );

            }

        if (!iTextVisual)

            {

            iTextVisual =

                      CAlfTextVisual::AddNewL(iOwnerControl, iViewportLayout);

            iTextVisual->SetFlag( EAlfVisualFlagIgnorePointer );

            }

        if (!iIconMarked)

            {

            iIconMarked = CAlfImageVisual::AddNewL(iOwnerControl, iLayout);

            iIconMarked->SetScaleMode( CAlfImageVisual::EScaleFitInside);

            iIconMarked->SetFlag( EAlfVisualFlagIgnorePointer );

            }

        if (!iIconMenu)

            {

            iIconMenu = CAlfImageVisual::AddNewL(iOwnerControl, iLayout);

            iIconMenu->SetScaleMode(CAlfImageVisual::EScaleFitInside);

            iIconMenu->SetFlag( EAlfVisualFlagIgnorePointer );

            }

        iTextMarquee = new (ELeave) TFsMarqueeClet(iOwnerControl, *iViewportLayout, TFsMarqueeClet::EScrollFromRight, TFsMarqueeClet::EScrollForth);

        }

    else

        {

        //visuals are already created but not attached to the list layout

        if (!iLayout->Layout())

            {

            aParentLayout.Append(iLayout, aTimeout);

            iParentLayout = &aParentLayout;

            }

        }

    }

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

// A call to this function means that the item is requested to update its

// visual content.

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

//

void CFsTreePlainOneLineItemVisualizer::UpdateL( const MFsTreeItemData& aData,

                                          TBool aFocused,

                                          const TUint aLevel,

                                          CAlfTexture*& aMarkIcon,

                                          CAlfTexture*& aMenuIcon,

                                          const TUint /*aTimeout*/,

                                          TBool aUpdateData)

    {

    FUNC_LOG;

    if (iLayout)

        {

        iSize.iWidth = iParentLayout->Size().Target().iX;

        iExtendedSize.iWidth = iSize.iWidth;

        TSize layoutSize(iLayout->Size().Target().iX, iLayout->Size().Target().iY);

        layoutSize.iWidth = iSize.iWidth;

        iLayout->SetSize(layoutSize);

        if (aFocused)

            {

            if (IsFocusable())

                {

                iFlags |= KFsTreeListItemFocused;

                }

            }

        else

            {

            iFlags &= ~KFsTreeListItemFocused;

            }

        if ( aData.Type() == KFsTreePlainOneLineItemDataType )

            {

            const CFsTreePlainOneLineItemData* data =

                      static_cast<const CFsTreePlainOneLineItemData*>(&aData);

            //update the ancors for current item settings

            const TInt indent( iTextIndentation * ( aLevel - 1 ) );

            UpdateLayout(data, indent);

            if (iIconVisual && data->IsIconSet())

                {