/*

* 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 separator.

*

*/

//#include <fsconfig.h>

#include "emailtrace.h"

#include "fsseparatorvisualizer.h"

#include "fsseparatordata.h"

#include "fstreelist.h"

#include "fslayoutmanager.h"

#include <alf/alfanchorlayout.h>

#include <alf/alfcurvepath.h>

#include <alf/alflinevisual.h>

#include <alf/alfenv.h>

#include <alf/alfevent.h>

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

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

// Two-phased constructor.

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

//

EXPORT_C CFsSeparatorVisualizer* 

    CFsSeparatorVisualizer::NewL( CAlfControl& aOwnerControl )

    {

    FUNC_LOG;

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

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ destructor.

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

//

CFsSeparatorVisualizer::~CFsSeparatorVisualizer() 

    {

    FUNC_LOG;

    }

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

// The function sets separator's thickness in pixels.

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

//

void CFsSeparatorVisualizer::SetSeparatorThickness( const TInt aThickness )

    {

    FUNC_LOG;

    iThickness = aThickness;

    }

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

// The function returns thikness of the separator line.

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

//

TInt CFsSeparatorVisualizer::SeparatorThickness( ) const

    {

    FUNC_LOG;

    return iThickness;

    }

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

// Sets the width of separator line. The separator line is always centered 

// horizontaly. The line width is given as the percentage of the whole item's width.

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

//

void CFsSeparatorVisualizer::SetSeparatorWidth ( TReal32 aWidth )

    {

    FUNC_LOG;

    iWidth = aWidth;

    if ( iWidth > 1.0 )

        {

        iWidth = 1.0;

        }

    else if ( iWidth < 0.1 )

        {

        iWidth = 0.1;

        }

    }

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

// Returns the width of the separator line.

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

//

TReal32 CFsSeparatorVisualizer::SetSeparatorWidth ( ) const

    {

    FUNC_LOG;

    return iWidth;

    }

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

// From class MFsTreeItemVisualizer.

// Returns visualizer's type.

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

//

TFsTreeItemVisualizerType CFsSeparatorVisualizer::Type() const

    {

    FUNC_LOG;

    return EFsSeparatorVisualizer;

    }

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

// From class MFsTreeItemVisualizer.

// Sets multiple flags for an item at one time.

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

//

void CFsSeparatorVisualizer::SetFlags( TUint32 aFlags )

    {

    FUNC_LOG;

    iFlags = aFlags;

    iFlags &= ~KFsTreeListItemFocusable;

    iFlags &= ~KFsTreeListItemManagedLayout;

    iFlags &= ~KFsTreeListItemExtendable;

    iFlags &= ~KFsTreeListItemExtended;

    iFlags &= ~KFsTreeListItemAlwaysExtended;

    }

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

// From class MFsTreeItemVisualizer.

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

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

//

TSize CFsSeparatorVisualizer::Size() const

    {

    FUNC_LOG;

    return iSize;

    }

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

// From class MFsTreeItemVisualizer.

//  Sets the item's visualization state to extended. 

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

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

//

void CFsSeparatorVisualizer::SetExtended( TBool /*aFlag*/ )

    {

    FUNC_LOG;

    iFlags &= ~KFsTreeListItemExtended;

    }

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

// From class MFsTreeItemVisualizer.

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

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

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

//

TBool CFsSeparatorVisualizer::IsExtended() const

    {

    FUNC_LOG;

    return EFalse;

    }

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

// From class MFsTreeItemVisualizer.

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

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

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

//

void CFsSeparatorVisualizer::SetExtendable( TBool /*aFlag*/ )

    {

    FUNC_LOG;

    iFlags &= ~KFsTreeListItemExtendable;

    }

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

// From class MFsTreeItemVisualizer.

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

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

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

//

TBool CFsSeparatorVisualizer::IsExtendable( )

    {

    FUNC_LOG;

    return EFalse;

    }

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

// From class MFsTreeItemVisualizer.

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

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

//

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

    {

    FUNC_LOG;

    iFlags &= ~KFsTreeListItemAlwaysExtended;

    }

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

// From class MFsTreeItemVisualizer.

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

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

//

TBool CFsSeparatorVisualizer::IsAlwaysExtended( ) const

    {

    FUNC_LOG;

    return EFalse;

    }

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

// From class MFsTreeItemVisualizer.

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

// within specified parent layout.

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

//

void CFsSeparatorVisualizer::ShowL( CAlfLayout& aParentLayout,

                                        const TUint aTimeout )

    {

    FUNC_LOG;

    if (!iLayout)

        {

        iParentLayout = &aParentLayout;

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

        iLayout->EnableBrushesL();

        iLayout->SetClipping(ETrue);

        iLayout->SetFlag( EAlfVisualFlagIgnorePointer );

        CAlfCurvePath* path = CAlfCurvePath::NewLC( iOwnerControl.Env() );

        path->AppendLineL(TPoint(0, 1), TPoint(100, 1), 1 );

        iLineVisual = CAlfLineVisual::AddNewL( iOwnerControl, iLayout );

        iLineVisual->SetPath(path, EAlfHasOwnership);

        iLineVisual->SetThickness( TAlfTimedValue(static_cast<TReal32>(iThickness), 0) );

        iLineVisual->SetColor(KRgbBlack);

        CleanupStack::Pop(path);

        iLineVisual->SetFlag( EAlfVisualFlagIgnorePointer );

        }

    else

        {

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

        if (!iLayout->Layout()) 

            {

            aParentLayout.Append(iLayout, aTimeout);

            iParentLayout = &aParentLayout;

            }

        }

    }

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

// From class MFsTreeItemVisualizer.

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

// visual content.

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

//

void CFsSeparatorVisualizer::UpdateL( const MFsTreeItemData& aData,

                                          TBool /*aFocused*/,

                                          const TUint aLevel,

                                          CAlfTexture*& /*aMenuIcon*/,

                                          const TUint /*aTimeout*/,

                                          TBool /*aUpdateData*/)

    {

    FUNC_LOG;

    if ( iLayout && iLineVisual )

        {

        if ( aData.Type() == KFsSeparatorDataType )

            {

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

            TSize size;

            size = Size();

            size.iWidth = iParentLayout->Size().Target().iX - iParentLayout->HorizontalPadding()*2;

            //shrink width if we are at some level in the hierarchy

            TInt indentation(0);

            indentation = iTextIndentation * ( aLevel - 1 );

            TRect currentSize = size;

            if (CFsLayoutManager::IsMirrored())

                {

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

                }

            else

                {

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

                }

            CAlfCurvePath* path(NULL);

            path = iLineVisual->Path();

            if ( path )

                {

                path->Reset();

                //draw the line in the middle of item's height

                TInt y(0);

                y = ( currentSize.Height() - iThickness ) / 2;

                //width

                TRect separatorRect = currentSize;

                separatorRect.iTl.iY = y;

                separatorRect.iBr.iY = y;

                TInt lineWidth(0), space(0);

                lineWidth = currentSize.Width() * iWidth;

                space = ( currentSize.Width() - lineWidth ) / 2;

                separatorRect.iTl += TPoint( space, 0 );

                separatorRect.iBr -= TPoint( space, 0 );

                path->AppendLineL( separatorRect.iTl, separatorRect.iBr, 1 );

                iLineVisual->SetThickness( TAlfTimedValue(static_cast<TReal32>(iThickness), 0) );

                iLineVisual->SetColor( data->SeparatorColor() );                

                }

            }        

        iLayout->UpdateChildrenLayout( 0 );

        }

    }

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

// From class MFsTreeItemVisualizer.

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

// scope.

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

//

void CFsSeparatorVisualizer::Hide( const TInt aTimeout )

    {

    FUNC_LOG;

    if ( iLayout )

        {

        iParentLayout->Remove(iLayout, aTimeout);

        iLayout->RemoveAndDestroyAllD();

        iLayout = NULL;

        iParentLayout = NULL;

        iLineVisual = NULL;

        }

    }

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

//  From class MFsTreeItemVisualizer.

//  Method to marquee the text when it's too long.

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

//

void CFsSeparatorVisualizer::MarqueeL(const TFsTextMarqueeType /*aMarqueeType*/,

                                                 const TUint /*aMarqueeSpeed*/,

                                                 const TInt /*aMarqueeStartDelay*/,

                                                 const TInt /*aMarqueeCycleStartDelay*/,

                                                 const TInt /*aMarqueeRepetitions*/)

    {

    FUNC_LOG;

    }

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

//  C++ constructor.

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

//

CFsSeparatorVisualizer::CFsSeparatorVisualizer( CAlfControl& aOwnerControl )

    : CFsTreeItemVisualizerBase( aOwnerControl ),

    iThickness( KDefaultSeparatorThickness ),

    iWidth( 1.0 )

    {

    FUNC_LOG;

    TUint flags(0);

    SetFlags( flags );

    SetSize( TSize( KDefaultWidth, KDefaultHeight ));

    }

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

//  Second phase constructor.

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

//

void CFsSeparatorVisualizer::ConstructL( )

    {

    FUNC_LOG;

    CFsTreeItemVisualizerBase::ConstructL();

    }

void CFsSeparatorVisualizer::OffWrapping()

	{

	FUNC_LOG;

	}