/*

* 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 CHuiBorderBrush class - a brush that draws 

*                a border at the edges of visuals.

*

*/

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

#include "uiacceltk/HuiDrawing.h"

#include "uiacceltk/HuiVisual.h"

EXPORT_C CHuiBorderBrush* CHuiBorderBrush::NewL(

                      TInt aThicknessWidth, TInt aThicknessHeight,

                      TInt aEdgeOffsetX, TInt aEdgeOffsetY)

    {

    CHuiBorderBrush* self = NewLC(aThicknessWidth, aThicknessHeight,

                                  aEdgeOffsetX, aEdgeOffsetY);

    CleanupStack::Pop();

    return self;

    }

EXPORT_C CHuiBorderBrush* CHuiBorderBrush::NewLC(

                       TInt aThicknessWidth, TInt aThicknessHeight,

                       TInt aEdgeOffsetX, TInt aEdgeOffsetY)

    {

    CHuiBorderBrush* self = new (ELeave)

        CHuiBorderBrush(aThicknessWidth, aThicknessHeight,

                        aEdgeOffsetX, aEdgeOffsetY);

    CleanupStack::PushL(self);

    return self;

    }

CHuiBorderBrush::CHuiBorderBrush(TInt aThicknessWidth, TInt aThicknessHeight,

                                 TInt aEdgeOffsetX, TInt aEdgeOffsetY)

        : CHuiBrush(),

          iColor(KRgbWhite),

          iThickness( TReal32(aThicknessWidth), TReal32(aThicknessHeight)),

          iEdgeOffset( TReal32(aEdgeOffsetX), TReal32(aEdgeOffsetY))

    {

    SetClipToVisual(EFalse);

    }

EXPORT_C CHuiBorderBrush* CHuiBorderBrush::NewL(const THuiXYMetric& aThickness,

                                                const THuiXYMetric& aEdgeOffset)

    {

    CHuiBorderBrush* self = NewLC(aThickness, aEdgeOffset);

    CleanupStack::Pop();

    return self;

    }

EXPORT_C CHuiBorderBrush* CHuiBorderBrush::NewLC(const THuiXYMetric& aThickness,

                                                 const THuiXYMetric& aEdgeOffset)

    {

    CHuiBorderBrush* self = new (ELeave)

        CHuiBorderBrush(aThickness, aEdgeOffset);

    CleanupStack::PushL(self);

    return self;

    }

CHuiBorderBrush::CHuiBorderBrush(const THuiXYMetric& aThickness,

                                 const THuiXYMetric& aEdgeOffset)

        : CHuiBrush(),

          iColor(KRgbWhite),

          iThickness(aThickness.iX.iMagnitude, aThickness.iY.iMagnitude),

          iEdgeOffset(aEdgeOffset.iX.iMagnitude, aEdgeOffset.iY.iMagnitude),

          iThicknessMetric(aThickness),

          iEdgeOffsetMetric(aEdgeOffset)

    {

    SetClipToVisual(EFalse);

    }

CHuiBorderBrush::~CHuiBorderBrush()

    {

    }

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

    {

    iImage = aImage;

    SetChanged();

    }

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

    {

    iColor = aColor;

    SetChanged();

    }

EXPORT_C void CHuiBorderBrush::SetThickness(const THuiXYMetric& aThickness)

    {

    iThicknessMetric = aThickness;

    iThickness.iX.Set(aThickness.iX.iMagnitude);    

    iThickness.iY.Set(aThickness.iY.iMagnitude);    

    }

EXPORT_C void CHuiBorderBrush::SetEdgeOffset(const THuiXYMetric& aEdgeOffset)

    {

    iEdgeOffsetMetric = aEdgeOffset;

    iEdgeOffset.iX.Set(aEdgeOffset.iX.iMagnitude);    

    iEdgeOffset.iY.Set(aEdgeOffset.iY.iMagnitude);            

    }

EXPORT_C void CHuiBorderBrush::SetImageOffset(const THuiXYMetric& aImageOffset)

    {

    iImageOffsetMetric = aImageOffset;

    iImageOffset.iX.Set(aImageOffset.iX.iMagnitude);    

    iImageOffset.iY.Set(aImageOffset.iY.iMagnitude);                    

    }

TBool CHuiBorderBrush::Changed() const

    {

    if ( CHuiBrush::Changed() )

        {

        return ETrue;

        }

    return iThickness.Changed() || iEdgeOffset.Changed() || iImageOffset.Changed() || iImage.Changed();

    }

void CHuiBorderBrush::ClearChanged()

    {

    CHuiBrush::ClearChanged();

    iThickness.ClearChanged();

    iEdgeOffset.ClearChanged();

    iImageOffset.ClearChanged();

    iImage.ClearChanged();

    }

void CHuiBorderBrush::ExpandVisualRect(TRect& aRect) const

    {

    // We need access to visual to convert metric units into pixels,

    // currently a pointer to visual is provided through separate

    // method since we want to avoid breaking binary compatibility 

    // of this class.

    THuiRealPoint edgeOffsetInPixels = EdgeOffsetInPixels(BrushGuide());

    aRect.Grow((TInt)edgeOffsetInPixels.iX,

               (TInt)edgeOffsetInPixels.iY);    

    }

void CHuiBorderBrush::Draw(CHuiGc& aGc, const MHuiBrushGuide& aGuide) const

    {

    THuiRealRect content = aGuide.BrushRect();

    TReal32 opacity = aGuide.BrushOpacity() * iOpacity.Now();

    THuiRealPoint edgeOffsetInPixels = EdgeOffsetInPixels(BrushGuide());

    THuiRealPoint thicknessInPixels = ThicknessInPixels(BrushGuide());

    THuiRealPoint imageOffsetInPixels = ImageOffsetInPixels(BrushGuide());

    aGc.SetPenColor(iColor);

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

    if(iImage.HasTexture())

        {

        aGc.Enable(CHuiGc::EFeatureTexturing);

        iImage.Texture().Bind();

        }

    else

        {

        aGc.Disable(CHuiGc::EFeatureTexturing);

        }

    aGc.Enable(CHuiGc::EFeatureBlending);

    // Apply the texture offset manually.

    aGc.Push(EHuiGcMatrixTexture);

    aGc.LoadIdentity(EHuiGcMatrixTexture);

    aGc.Translate(EHuiGcMatrixTexture, 

                    -imageOffsetInPixels.iX, -imageOffsetInPixels.iY, 0.f);

    content.Grow(edgeOffsetInPixels.iX, edgeOffsetInPixels.iY);

    aGc.DrawBorders(content.Round(), 

                    thicknessInPixels.iX, thicknessInPixels.iX,

                    thicknessInPixels.iY, thicknessInPixels.iY,

                    CHuiGc::EBorderFixedCorners, 

                    &iImage);

    aGc.Pop(EHuiGcMatrixTexture);

    }

THuiRealPoint CHuiBorderBrush::ThicknessInPixels(const CHuiVisual* aVisual) const 

    {

    return PointInPixels(aVisual, iThickness, iThicknessMetric);    

    }

THuiRealPoint CHuiBorderBrush::EdgeOffsetInPixels(const CHuiVisual* aVisual) const 

    {

    return PointInPixels(aVisual, iEdgeOffset, iEdgeOffsetMetric);            

    }

THuiRealPoint CHuiBorderBrush::ImageOffsetInPixels(const CHuiVisual* aVisual) const 

    {

    return PointInPixels(aVisual, iImageOffset, iImageOffsetMetric);            

    }

THuiRealPoint CHuiBorderBrush::PointInPixels(const CHuiVisual* aVisual, const THuiTimedPoint& aPoint, const THuiXYMetric& aMetric) const 

    {

    THuiRealPoint pointInPixels = aPoint.RealNow(); // Init, if no visual available for conversion then defaults to pixels

    if (aVisual)

        {

        THuiXYMetric metric = aMetric;

        metric.iX.iMagnitude = pointInPixels.iX;        

        metric.iY.iMagnitude = pointInPixels.iY;        

        pointInPixels = aVisual->MetricToPixels(metric); // Convert metric width in pixels  

        }    

    return pointInPixels;                    

    }