/*

* Copyright (c) 2006-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:   Implementation of CHuiLineVisual, Visual that is able to draw 

*                lines onto a curve path.

*

*/

#include "uiacceltk/HuiLineVisual.h"  // Class definition

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiDrawing.h"

#include "uiacceltk/HuiUtil.h"

EXPORT_C CHuiLineVisual* CHuiLineVisual::AddNewL(CHuiControl& aOwnerControl,

                                                 CHuiLayout* aParentLayout)

    {

    CHuiLineVisual* line = STATIC_CAST(CHuiLineVisual*,

        aOwnerControl.AppendVisualL(EHuiVisualTypeLine, aParentLayout));

    return line;

    }

CHuiLineVisual::CHuiLineVisual(MHuiVisualOwner& aOwner)

        : CHuiVisual(aOwner), iColor(KRgbWhite)

    {

    iThickness.Set(12.f);

    iEndPos.Set(1.f);

    }

void CHuiLineVisual::ConstructL()

    {

    CHuiVisual::ConstructL();

    // Use the default line texture by default.

    iImage = THuiImage(Env().Skin().TextureL(EHuiSkinLineTexture));

    }

CHuiLineVisual::~CHuiLineVisual()

    {

    iAlphaFunction = NULL;

    iWidthFunction = NULL;

    }

/*EXPORT_C void CHuiLineVisual::LayoutToPath()

    {

    TRect bounds(TPoint(0, 0), TSize(1, 1));

    for(TInt i = 0; i < iPath.Count(); ++i)

        {

        bounds.BoundingRect(TRect(iPath[i].iPoint, TSize(1, 1)));

        }

    SetSize(bounds.Size());

    }*/

EXPORT_C void CHuiLineVisual::SetPath(CHuiCurvePath* aPath,

                                      THuiOwnership aOwnership)

    {

    iPath.Set(aPath, aOwnership);

    SetChanged();

    }

EXPORT_C CHuiCurvePath& CHuiLineVisual::Path()

    {

    SetChanged();

    return iPath.Ref();

    }

void CHuiLineVisual::DrawSelf(CHuiGc& aGc, const TRect& aDisplayRect) const

    {

    if(!iPath.Ptr())

        {

        // If the path is empty, ie has no data, return without drawing anything.

        return;

        }

    aGc.Enable(CHuiGc::EFeatureBlending);

    aGc.SetPenAlpha(TInt(EffectiveOpacity() * 255));

    aGc.SetPenColor(iColor);

    // By default, use the current thickness for the entire path.

    if ( !HuiUtil::RealCompare( iDefaultWidthFunction.iValue, iThickness.Now() ) )

        {

        iPath.NonConstRef().SetNeedsUpdate();

        iDefaultWidthFunction.iValue = iThickness.Now();

        }

	aGc.Enable(CHuiGc::EFeatureTexturing);

	if(iImage.HasTexture())

		{

		iImage.Texture().Bind();

		}

    iPath->SetVisual(this);

    aGc.DrawPath(iPath.Ref(), aDisplayRect.iTl,

                 iStartPos.Now(), iEndPos.Now(),

                 iAlphaFunction,

                 iWidthFunction == 0? &iDefaultWidthFunction : 0);

    iPath->SetVisual(NULL);

    }

TBool CHuiLineVisual::Changed() const

    {

    if(CHuiVisual::Changed())

        {

        return ETrue;

        }

    return iThickness.Changed() || iShadowThickness.Changed() ||

           iStartPos.Changed() || iEndPos.Changed() || iImage.Changed();

    }

void CHuiLineVisual::ClearChanged()

    {

    CHuiVisual::ClearChanged();

    iThickness.ClearChanged();

    iShadowThickness.ClearChanged();

    iStartPos.ClearChanged();

    iEndPos.ClearChanged();

    iImage.ClearChanged();

    }

EXPORT_C void CHuiLineVisual::SetImage(const THuiImage& aImage)

    {

    iImage = aImage;

    SetChanged();

    }

EXPORT_C void CHuiLineVisual::SetAlphaFunction(MHuiMappingFunction* aFunction)

    {

    iAlphaFunction = aFunction;

    SetChanged();

    }

EXPORT_C void CHuiLineVisual::SetWidthFunction(MHuiMappingFunction* aFunction)

    {

    iWidthFunction = aFunction;

    SetChanged();

    }

EXPORT_C void CHuiLineVisual::SetColor(const TRgb& aColor)

    {

	iColor = aColor;

    SetChanged();

    }

void CHuiLineVisual::ExpandRectWithContent(TRect& aRect) const

    {

    if(!iPath.Ptr())

        {

        // If the path is empty, ie has no data, return directly

        return;

        }

    const TInt segmentCount = iPath->SegmentCount();    

    if(!Clipping() && segmentCount)

        {

        // calculate each segment

        THuiRealRect segmentsCoverRectInMetrics;

        for ( TInt i = 0 ; i < segmentCount ; i++ )

            {

            const CHuiCurvePath::TSegment segment = iPath->Segment(i);

            THuiRealRect segmentAreaInMetrics;

            if ( segment.iType == CHuiCurvePath::ESegmentTypeLine )

                {

                segmentAreaInMetrics = THuiRealRect( 

                    THuiRealPoint( segment.iOrigin.iX,segment.iOrigin.iY ),

                    THuiRealSize( segment.iDelta.AsSize().iWidth, segment.iDelta.AsSize().iHeight ) );

                }

            else // ESegmentTypeArc

                {

                segmentAreaInMetrics = THuiRealRect( 

                    THuiRealPoint( 

                        segment.iOrigin.iX - segment.iDelta.AsSize().iWidth,

                        segment.iOrigin.iY - segment.iDelta.AsSize().iHeight ),

                    THuiRealPoint( 

                        segment.iOrigin.iX + segment.iDelta.AsSize().iWidth,

                        segment.iOrigin.iY + segment.iDelta.AsSize().iHeight ));        

                }

            if ( i == 0 )

                {

                // first rect

                segmentsCoverRectInMetrics = segmentAreaInMetrics;

                }

            else

                {

                // append to previous rect combination

                segmentsCoverRectInMetrics.BoundingRect( segmentAreaInMetrics );

                }

            }

        // Change metrics to pixels

        THuiRealRect segmentsCoverRectInPixels( 

            LocalPointInPixels( segmentsCoverRectInMetrics.iTl ),

            LocalPointInPixels( segmentsCoverRectInMetrics.iBr ) );

        // check that both height and width != zero    

        if ( !HuiUtil::RealCompare( segmentsCoverRectInPixels.Height(), 0.f ) && 

             !HuiUtil::RealCompare( segmentsCoverRectInPixels.Width(), 0.f ) )

            {

            // move by offset: assume that iOffset is in pixels

            const THuiRealPoint offsetNowInPixels = iPath->iOffset.Now();

            segmentsCoverRectInPixels.Move( offsetNowInPixels.iX,offsetNowInPixels.iY);

            // move into relation of the visual area (aRect in pixels)

            segmentsCoverRectInPixels.Move( aRect.iTl.iX, aRect.iTl.iY );

            // add the thickness

            THuiRealSize thicknessInPixels = LocalPointInPixels(THuiRealPoint( iThickness.Now()/2.f, iThickness.Now()/2.f )).AsSize();

            // Take the average of the x and y dimensions - what would be the correct behaviour?

            const TInt averageThincknessInPixels = 

                HUI_ROUND_FLOAT_TO_INT( (

                    thicknessInPixels.iWidth + 

                    thicknessInPixels.iHeight

                    )/2.f );

            segmentsCoverRectInPixels.Grow( averageThincknessInPixels, averageThincknessInPixels );

            // Finally round to TRect

            const TRect finalSegmentsCoverArea(

                HUI_ROUND_FLOAT_TO_INT(segmentsCoverRectInPixels.iTl.iX),

                HUI_ROUND_FLOAT_TO_INT(segmentsCoverRectInPixels.iTl.iY),

                HUI_ROUND_FLOAT_TO_INT(segmentsCoverRectInPixels.iBr.iX),

                HUI_ROUND_FLOAT_TO_INT(segmentsCoverRectInPixels.iBr.iY) );

            // combine the calculated segment area and the 

            aRect.BoundingRect(finalSegmentsCoverArea);

            }

        }

    CHuiVisual::ExpandRectWithContent(aRect);

    }