/*

* 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 visualier class for the MultiLine item.

*

*/

//////SYSTEM INCLUDES

//////TOOLKIT INCLUDES

// <cmail> SF

#include "emailtrace.h"

#include <alf/alfenv.h>

#include <alf/alflayout.h>

#include <alf/alfanchorlayout.h>

#include <alf/alftextvisual.h>

#include <alf/alfimagevisual.h>

#include <alf/alftexture.h>

#include <alf/alfcontrol.h>

#include <alf/alfimage.h>

// </cmail>

//////PROJECT INCLUDES

#include "fsmultilineitemvisualizer.h"

#include "fsmultilineitemdata.h"

#include "fslayoutmanager.h"

//CONSTANTS

const TInt KZero = 0;

const TInt KOne = 1;

const TInt KTwo = 2;

const TInt KThree = 3;

const TInt KFour = 4;

const TInt KFive = 5;

const TInt KSix = 6;

const TInt KSeven = 7;

const TInt KEight = 8;

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

// Two-phased constructor.

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

//

EXPORT_C CFsMultiLineItemVisualizer* CFsMultiLineItemVisualizer::NewL( CAlfControl& aOwnerControl )

    {

    FUNC_LOG;

    CFsMultiLineItemVisualizer* self = new( ELeave ) CFsMultiLineItemVisualizer( aOwnerControl );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ destructor

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

//

CFsMultiLineItemVisualizer::~CFsMultiLineItemVisualizer()

    {

    FUNC_LOG;

    }

//item visualizer's interface

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

// The function sets how many lines the multiline item has when it's not extended.

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

//

void CFsMultiLineItemVisualizer::SetNumberOfLinesWhenNotExtended( TInt aNumberOfLines )

    {

    FUNC_LOG;

    if ( 1 <= aNumberOfLines && aNumberOfLines <= 4 && aNumberOfLines <= iNumLinesExtended )

        {

        iNumLinesNotExtended = aNumberOfLines;

        }

    }

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

// The function returns how many lines the item has when it's not extended.

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

//

TInt CFsMultiLineItemVisualizer::NumberOfLinesWhenNotExtended( ) const

    {

    FUNC_LOG;

    return iNumLinesNotExtended;

    }

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

// The function sets how many lines the multiline item has when it's extended.

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

//

void CFsMultiLineItemVisualizer::SetNumberOfLinesWhenExtended( TInt aNumberOfLines )

    {

    FUNC_LOG;

    if ( aNumberOfLines >= 1 && aNumberOfLines <= 4 && aNumberOfLines >= iNumLinesNotExtended )

        {

        iNumLinesExtended = aNumberOfLines;

        }

    }

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

// The function returns how many lines the item has when it's extended.

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

//

TInt CFsMultiLineItemVisualizer::NumberOfLinesWhenExtended( ) const

    {

    FUNC_LOG;

    return iNumLinesExtended;

    }

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

// The function sets state of the item's checkbox.

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

//

void CFsMultiLineItemVisualizer::SetCheckboxState( TBool aChecked )

    {

    FUNC_LOG;

    iCheckState = aChecked;

    }

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

// The function returns state of the item's checkbox. 

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

//

TBool CFsMultiLineItemVisualizer::CheckboxState () const

    {

    FUNC_LOG;

    return iCheckState;

    }

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

// The function sets whether place holders should be kept when icons in the 

// first column are not present. 

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

//

void CFsMultiLineItemVisualizer::SetKeepEmptyIconsPlaceHolders( TBool aKeep )

    {

    FUNC_LOG;

    iKeepPlaceHolders = aKeep;

    }

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

// The function returnes whether place holders are kept in case icons are

// not set.

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

//

TBool CFsMultiLineItemVisualizer::IsKeepEmptyIconsPlaceHolders( ) const

    {

    FUNC_LOG;

    return iKeepPlaceHolders;

    }

// from base class MFsTreeItemVisualizer

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

// From MFsTreeItemVisualizer.

// Returns the type of the item's visualizer. 

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

//

TFsTreeItemVisualizerType CFsMultiLineItemVisualizer::Type() const

    {

    FUNC_LOG;

    return EFsMultiLineItemVisualizer;

    }

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

// From MFsTreeItemVisualizer.

// Returns the size of an item in a normal (not extended) state.

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

//

TSize CFsMultiLineItemVisualizer::Size() const

    {

    FUNC_LOG;

    if ( IsAlwaysExtended() )

        {

        return ExtendedSize();

        }

    else

        {

        if ( iFlags & KFsTreeListItemManagedLayout )

            {

            return SizeWithNumberOfLines( iNumLinesNotExtended );

            }

        else

            {

            return iSize;

            }

        }

    }

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

// From MFsTreeItemVisualizer.

// Returns the size of an item in expanded state.

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

//    

TSize CFsMultiLineItemVisualizer::ExtendedSize() const

    {

    FUNC_LOG;

    if ( iFlags & KFsTreeListItemManagedLayout )

        {

        return SizeWithNumberOfLines( iNumLinesExtended );

        }

    else

        {

        return iExtendedSize;

        }    

    }

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

// From MFsTreeItemVisualizer.

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

// within specified parent layout. 

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

//

void CFsMultiLineItemVisualizer::ShowL( CAlfLayout& aParentLayout, const TUint aTimeout )

    {

    FUNC_LOG;

    if (!iLayout)

        {

        iParentLayout = &aParentLayout;

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

        iLayout->EnableBrushesL();

        iLayout->SetClipping(ETrue);

    ///////////////////////////first line///////////////////////////

        //text

        if (!iFirstLineTextVis)

            {

            iFirstLineTextVis = CAlfTextVisual::AddNewL(iOwnerControl, iLayout );

            }

        //icons

        if (!iFirstLineIconVis) //optional priority icon in first line

            {

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

            iFirstLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            }

        if (!iCheckBoxIconVis)

            {

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

            iCheckBoxIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            }

        if (!iMarkIconVis)

            {

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

            iMarkIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            }

        if(!iMenuIconVis)

            {

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

            iMenuIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            }

    ///////////////////////////second line///////////////////////////

        //text

        if (!iSecondLineTextVis)

            {

            iSecondLineTextVis = CAlfTextVisual::AddNewL(iOwnerControl, iLayout );

            }

        //icon

        if (!iSecondLineIconVis)

            {

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

            iSecondLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            }

    ///////////////////////////third line///////////////////////////

        //text

        if (!iThirdLineTextVis)

            {

            iThirdLineTextVis = CAlfTextVisual::AddNewL(iOwnerControl, iLayout );

            }

        //icon

        if (!iThirdLineIconVis)

            {

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

            iThirdLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            }

    ///////////////////////////fourth line///////////////////////////

        //text

        if (!iFourthLineTextVis)

            {

            iFourthLineTextVis = CAlfTextVisual::AddNewL(iOwnerControl, iLayout );

            }

        //icon

        if (!iFourthLineIconVis)

            {

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

            iFourthLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            }

        }

    else

        {

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

        if (!iLayout->Layout()) 

            {

            aParentLayout.Append(iLayout, aTimeout);

            iParentLayout = &aParentLayout;

            }

        }

    }

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

// From MFsTreeItemVisualizer.

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

// visual content. 

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

//

void CFsMultiLineItemVisualizer::UpdateL( const MFsTreeItemData& aData,

                                        TBool aFocused,

                                        const TUint aLevel,

                                        CAlfTexture*& aMarkIcon,

                                        CAlfTexture*& aMenuIcon,

                                        const TUint /*aTimeout*/,

                                        TBool aUpdateData)

    {

    FUNC_LOG;

    if (!iLayout)

        {

        return;

        }

    //text color

    TRgb textColor;

    if ( aFocused )

        {

        if (!iIsCustomTextFocusedColor)

            {//custom color not set, use color from skin - load it in case theme has changed

            iFocusedTextColor = FocusedStateTextSkinColor();

            }

        textColor = iFocusedTextColor;

        iFlags |= KFsTreeListItemFocused;

        }

    else

        {

        if (!iIsCustomTextNormalColor)

            {//custom color not set, use color from skin - load it in case theme has changed

            iNormalTextColor = NormalStateTextSkinColor( );

            }

        textColor = iNormalTextColor;

        iFlags &= ~KFsTreeListItemFocused;

        }

    //text aignment in visuals    

    TAlfAlignHorizontal currTextAlignment( EAlfAlignHLeft );            

    currTextAlignment = CurrentTextAlignmentL( iTextAlign, NULL, NULL ); //Western/AH layout

    //text's shadow

    TBool enableShadow(EFalse);

    enableShadow = iFlags & KFsTreeListItemTextShadow; 

    TInt styleId = ModifiedStyleIdL( );

    //set data to the proper visuals

    if ( aData.Type() == KFsMultiLineItemDataType )

        {

        const CFsMultiLineItemData* data = static_cast<const CFsMultiLineItemData*>(&aData);

        //set icons and texts to their visuals

///////////////////////////first line///////////////////////////////////////////

        //text

        if (iFirstLineTextVis && aUpdateData)

            {

            iFirstLineTextVis->Env().CancelCommands( iFirstLineTextVis );

            iFirstLineTextVis->EnableShadow( enableShadow );

            iFirstLineTextVis->SetWrapping(CAlfTextVisual::ELineWrapTruncate);

            iFirstLineTextVis->SetAlign( currTextAlignment, EAlfAlignVCenter );

            iFirstLineTextVis->SetTextStyle( styleId );

            iFirstLineTextVis->SetColor( textColor );

            iFirstLineTextVis->SetTextL( data->LineText( 0 ));

            }

        //icon

        if (iCheckBoxIconVis)

            {

            if ( CheckboxState() )

                {

                if ( data->CheckBoxCheckedIcon() )

                    {

                    iCheckBoxIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

                    iCheckBoxIconVis->SetImage( TAlfImage( *data->CheckBoxCheckedIcon() ) );

                    }

                else

                    {

                    //zero visual's opacity

                    }

                }

            else 

                {

                if ( data->CheckBoxUncheckedIcon() )

                    {

                    iCheckBoxIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

                    iCheckBoxIconVis->SetImage( TAlfImage( *data->CheckBoxUncheckedIcon() ) );

                    }

                else

                    {

                    //zero visual's opacity

                    }

                }

            }

        //icon            

        if ( iFirstLineIconVis && data->LineIcon( 0 ) )

            {

            iFirstLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            iFirstLineIconVis->SetImage( TAlfImage( *data->LineIcon( 0 ) ) );                

            }

        //mark icon

        if ( iMarkIconVis && IsMarked() && aMarkIcon )

            {

            iMarkIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            iMarkIconVis->SetImage( *aMarkIcon );

            }

        //menu icon

        if ( iMenuIconVis && (iFlags & KFsTreeListItemHasMenu) && aMenuIcon )

            {

            iMenuIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            iMenuIconVis->SetImage( *aMenuIcon );

            }

///////////////////////////second line//////////////////////////////////////////

        //text

        if ( iSecondLineTextVis && aUpdateData)

            {

            iSecondLineTextVis->Env().CancelCommands( iSecondLineTextVis );

            iSecondLineTextVis->SetWrapping(CAlfTextVisual::ELineWrapTruncate);

            iSecondLineTextVis->SetAlign( currTextAlignment, EAlfAlignVCenter );

            iSecondLineTextVis->EnableShadow( enableShadow );

            iSecondLineTextVis->SetTextStyle( styleId );

            iSecondLineTextVis->SetColor( textColor );

            iSecondLineTextVis->SetTextL( data->LineText( 1 ));

            }

        //icon            

        if ( iSecondLineIconVis && data->LineIcon( 1 ) )

            {

            iSecondLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            iSecondLineIconVis->SetImage( TAlfImage( *data->LineIcon( 1 ) ) );                

            }

///////////////////////////third line///////////////////////////////////////////

        //text

        if ( iThirdLineTextVis && aUpdateData )

            {

            iThirdLineTextVis->Env().CancelCommands( iThirdLineTextVis );

            iThirdLineTextVis->SetWrapping(CAlfTextVisual::ELineWrapTruncate);

            iThirdLineTextVis->SetAlign( currTextAlignment, EAlfAlignVCenter );

            iThirdLineTextVis->EnableShadow( enableShadow );

            iThirdLineTextVis->SetTextStyle( styleId );

            iThirdLineTextVis->SetColor( textColor );

            iThirdLineTextVis->SetTextL( data->LineText( 2 ) );

            }

        //icon

        if ( iThirdLineIconVis && data->LineIcon( 2 ) )

            {

            iThirdLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            iThirdLineIconVis->SetImage( TAlfImage( *data->LineIcon( 2 ) ) );

            }

///////////////////////////fourth line//////////////////////////////////////////

        //text

        if ( iFourthLineTextVis && aUpdateData)

            {

            iFourthLineTextVis->Env().CancelCommands( iFourthLineTextVis );

            iFourthLineTextVis->SetWrapping(CAlfTextVisual::ELineWrapTruncate);

            iFourthLineTextVis->SetAlign( currTextAlignment, EAlfAlignVCenter );

            iFourthLineTextVis->EnableShadow( enableShadow );

            iFourthLineTextVis->SetTextStyle( styleId );

            iFourthLineTextVis->SetColor( textColor );

            iFourthLineTextVis->SetTextL( data->LineText( 3 ) );

            }

        //icon

        if ( iFourthLineIconVis && data->LineIcon( 3 ) )

            {

            iFourthLineIconVis->SetScaleMode( CAlfImageVisual::EScaleFit );

            iFourthLineIconVis->SetImage( TAlfImage( *data->LineIcon( 3 ) ) );

            }

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

        UpdateLayout(data, indent);

        iLayout->UpdateChildrenLayout();

        }    

    }

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

// From MFsTreeItemVisualizer.

// A call to this function means that the item goes out of the visible