/*

* Copyright (c) 2006-2008 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:   base class for cnaves graphics context

*

*/

#include "huicanvasgc.h"

#include "uiacceltk/HuiGc.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiImage.h"

#include "uiacceltk/HuiCanvasVisual.h"

#include "uiacceltk/HuiCurvePath.h"

#include "uiacceltk/HuiMappingFunctions.h"

#include "HuiRenderSurface.h"

#include "uiacceltk/HuiStatic.h"

#include "huicanvasrenderbuffer.h"

#ifndef __SERIES60_30__     

#include "HuiTargetBitmap.h"

#endif

#include <e32math.h>

EXPORT_C CHuiCanvasGc::CHuiCanvasGc():

    iPenColor(KRgbBlack),

    iPenWidth(1.f),

    iOpacity(1.f),

    iPolygonDrawMode(EHuiNoFill),

    iVerticalTextAlign(EHuiAlignVTop),

    iHorizontalTextAlign(EHuiAlignHLeft),

    iTextStyleId(EHuiTextStyleNormal),

    iEffectiveOpacityEnabled(ETrue)

    {	    

    }

EXPORT_C CHuiCanvasGc::~CHuiCanvasGc()

    {

    iClippingRegion.Close();

    iDelayedClipRegion.Close();	

    iTempRegion.Close();

    iTempRegion2.Close();

    }

EXPORT_C void CHuiCanvasGc::SetGc(CHuiGc& aGc)

    {

    iGc = &aGc;        

    }

EXPORT_C void CHuiCanvasGc::SetVisual(const CHuiCanvasVisual& aVisual)

    {

    iVisual = (CHuiCanvasVisual*)&aVisual;    

    }

EXPORT_C void CHuiCanvasGc::Clip(const TRect& aClipRect)

    {

    if (!iGc)

       {

       return;    

       }

    switch (iClipMode)

        {

        case EHuiCanvasClipModeNormal:

        case EHuiCanvasClipModeDelayed:

            {

            if (iClippingRegion.Count())

                {

                CancelClipping();    

                }

            if (!aClipRect.IsEmpty())

                {

                iTempRegion.Clear();

                iTempRegion.AddRect(aClipRect);

                ClipRegion(iTempRegion);

                }

            break;    

            }

        case EHuiCanvasClipModeNone:

        default:

            {

            // Do nothing            

            break;    

            }

        }    

    }

EXPORT_C void CHuiCanvasGc::ClipRegion(const TRegion& aClipRegion)

    {

    if (!iGc)

       {

       return;    

       }

    switch (iClipMode)

        {

        case EHuiCanvasClipModeNormal:

            {

            // If previous clipping region set, cancel it first.

            if (iClippingRegion.Count())

                {

                CancelClipping();    

                }

            // Set new region, ignore empty rects if any

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

                {

                if (!aClipRegion[i].IsEmpty())

                    {

                    iClippingRegion.AddRect(aClipRegion[i]);    

                    }                                        

                }

            iClippingRegion.Tidy();

            if (iClippingRegion.Count() == 1)

                {

                // If only one rect, then do simple clipping...                    

                iGc->Enable(CHuiGc::EFeatureClipping);

                iGc->PushClip();

                iGc->Clip(iClippingRegion[0]);                

                }

            else if (iClippingRegion.Count() > 1)

                {

                // ...otherewise must do region clipping.

                iGc->Enable(CHuiGc::EFeatureClipping);

                iGc->PushClip();

                if (MaxNumberOfClipRects() > 1)

                    {

                    iGc->Clip(iClippingRegion);                    

                    }

                else

                    {

                    // region clipping is not available, try boundingrect

                    iGc->Clip(iClippingRegion.BoundingRect());                                        

                    }

                }

            else

                {

                // No clip rects set, do nothing here.    

                }                                

            break;

            }

        case EHuiCanvasClipModeDelayed:

            {

            // If previous clipping region set, cancel it first.

            if (iClippingRegion.Count())

                {

                CancelClipping();    

                }

            // Set new region, ignore empty rects if any

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

                {

                if (!aClipRegion[i].IsEmpty())

                    {

                    iClippingRegion.AddRect(aClipRegion[i]);    

                    }                    

                }

            iClippingRegion.Tidy();

            break;    

            }

        case EHuiCanvasClipModeNone:

        default:

            {

            // Do nothing            

            break;    

            }

        }    

    }  

EXPORT_C void CHuiCanvasGc::CancelClipping()

    {

    if (!iGc)

       {

       return;    

       }

    switch (iClipMode)

        {

        case EHuiCanvasClipModeNormal:

            {

            if (iClippingRegion.Count())

                {

                iClippingRegion.Clear();

                iGc->Enable(CHuiGc::EFeatureClipping);

                iGc->PopClip();                            

                }

            break;

            }

        case EHuiCanvasClipModeDelayed:

            {

            iDelayedClipRegion.Clear();

            iClippingRegion.Clear();

            break;    

            }

        case EHuiCanvasClipModeNone:

        default:

            {

            // Do nothing            

            break;    

            }

        }    

    }

EXPORT_C void CHuiCanvasGc::DrawImage(const CHuiTexture& aImage, const THuiRealRect& aDestinationRect)

    {

    if (!iGc)

        {

        return;    

        }

    THuiRealRect srcRect = THuiRealRect(TPoint(0,0), aImage.Size() );

    DrawImage(aImage, aDestinationRect, srcRect);

    }

EXPORT_C void CHuiCanvasGc::DrawText(const CHuiTextMesh& aTextMesh, const THuiRealRect& aDestinationRect)

    {

    if (!iGc)

        {

        return;    

        }

    Setup();

    EnableBlendingIfNeeded();

    THuiTextStyle* textStyle = CHuiStatic::Env().TextStyleManager().TextStyle(iTextStyleId);

    if (textStyle)

        {

        iGc->SetFont(textStyle->Font());        

        }    

    iGc->SetAlign(iHorizontalTextAlign, iVerticalTextAlign);

    EnableDelayedClippingIfNeeded(aDestinationRect);	

    while (ClipNext())

        {

        iGc->DrawText(aTextMesh, aDestinationRect, 0.f);                              

        }

    DisableDelayedClippingIfNeeded();       

    Cleanup();

    }

EXPORT_C void CHuiCanvasGc::DrawLines(RArray<THuiRealLine>& aLines)

	{

	if (!iGc)

        {

        return;    

        }

    Setup();

    EnableBlendingIfNeeded();

    EnableDelayedClippingIfNeeded(aLines);

    while (ClipNext())

        {

        DoDrawLines(aLines);

        }

    DisableDelayedClippingIfNeeded();    

    Cleanup();

	}

EXPORT_C void CHuiCanvasGc::DoDrawLines(RArray<THuiRealLine>& aLines)

	{

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

 	   	{

 	   	TPoint start = aLines[i].iStart; 

 	   	TPoint end = aLines[i].iEnd;

    	iGc->DrawLine(start, end, iPenWidth);

    	}        

	}

EXPORT_C void CHuiCanvasGc::DrawEllipse(const THuiRealRect& aDestinationRect)

	{

	if (!iGc)

	    {

	    return;    

	    }

	double startx = aDestinationRect.iTl.iX + aDestinationRect.Width();

    double starty = aDestinationRect.iTl.iY + aDestinationRect.Height()/2;   

    DrawArc(aDestinationRect, THuiRealPoint(startx,starty), THuiRealPoint(startx,starty));	

	}

EXPORT_C void CHuiCanvasGc::DrawRoundRect(const THuiRealRect& aDestinationRect, 

        const THuiRealSize& aSize)

    {   

    if (!iGc)

        {

        return;    

        }

    Setup();

    EnableDelayedClippingIfNeeded(aDestinationRect);    

    while (ClipNext())

        {

        DoDrawRoundRect(aDestinationRect, aSize);

        }

    DisableDelayedClippingIfNeeded();    

    Cleanup();

    }

EXPORT_C void CHuiCanvasGc::DoDrawRoundRect(const THuiRealRect& aDestinationRect, 

        const THuiRealSize& aSize)

    {   

    THuiRealSize cornerRectSize = THuiRealSize( 2*aSize.iWidth, 2*aSize.iHeight);

    THuiRealPoint topLeftCornerRectTL=aDestinationRect.iTl;

    THuiRealRect topLeftCornerRect = THuiRealRect(topLeftCornerRectTL,cornerRectSize);

    THuiRealPoint topRightCornerRectTL=THuiRealPoint

    (aDestinationRect.iTl.iX + aDestinationRect.Width()-2*(aSize.iWidth), aDestinationRect.iTl.iY);

    THuiRealRect topRightCornerRect = THuiRealRect(topRightCornerRectTL, cornerRectSize);

    THuiRealPoint bottomRightCornerRectTL = THuiRealPoint

    (aDestinationRect.iBr.iX-(2*aSize.iWidth),aDestinationRect.iBr.iY-(2*aSize.iHeight));

    THuiRealRect bottomRightCornerRect = THuiRealRect(bottomRightCornerRectTL, cornerRectSize);

    THuiRealPoint bottomLeftCornerRectTL = THuiRealPoint(aDestinationRect.iTl.iX, 

            aDestinationRect.iTl.iY + aDestinationRect.Height() -2*(aSize.iHeight));   

    THuiRealRect bottomLeftCornerRect = THuiRealRect(bottomLeftCornerRectTL,cornerRectSize);

    THuiRealPoint topLeftArcStart = THuiRealPoint(topLeftCornerRectTL.iX + aSize.iWidth, topLeftCornerRectTL.iY);

    THuiRealPoint topLeftArcEnd = THuiRealPoint(topLeftCornerRectTL.iX, topLeftCornerRectTL.iY + aSize.iHeight);

    DoDrawArc(topLeftCornerRect, topLeftArcStart,topLeftArcEnd);

    THuiRealPoint topRightArcStart = THuiRealPoint(topRightCornerRectTL.iX + 2*aSize.iWidth, 

            topRightCornerRectTL.iY + aSize.iHeight);

    THuiRealPoint topRightArcEnd = THuiRealPoint(topRightCornerRectTL.iX + aSize.iWidth, topRightCornerRectTL.iY);

    DoDrawArc(topRightCornerRect, topRightArcStart, topRightArcEnd);

    THuiRealPoint bottomRightArcStart = THuiRealPoint(bottomRightCornerRectTL.iX + aSize.iWidth, 

            bottomRightCornerRectTL.iY + 2*aSize.iHeight);

    THuiRealPoint bottomRightArcEnd = THuiRealPoint(bottomRightCornerRectTL.iX + 2*aSize.iWidth, 

            bottomRightCornerRectTL.iY + aSize.iHeight);

    DoDrawArc(bottomRightCornerRect,bottomRightArcStart ,bottomRightArcEnd);

    THuiRealPoint bottomLeftArcStart = THuiRealPoint(bottomLeftCornerRectTL.iX, bottomLeftCornerRectTL.iY +

            aSize.iHeight);

    THuiRealPoint bottomLeftArcEnd = THuiRealPoint(bottomLeftCornerRectTL.iX + 

            aSize.iWidth, bottomLeftCornerRectTL.iY + 2*aSize.iHeight);

    DoDrawArc(bottomLeftCornerRect, bottomLeftArcStart, bottomLeftArcEnd);

    if(iPolygonDrawMode)

        {

        RArray<THuiRealRect> rects;

        rects.Append(THuiRealRect(topLeftArcStart,bottomRightArcStart));        

        rects.Append(THuiRealRect(topLeftArcEnd, THuiRealSize(aSize.iWidth,aDestinationRect.Height()-(2*aSize.iHeight))));

        rects.Append(THuiRealRect(THuiRealPoint(topRightArcStart.iX - aSize.iWidth,topRightArcStart.iY),

                 THuiRealSize(aSize.iWidth,aDestinationRect.Height()-(2*aSize.iHeight))));

        DoDrawRects(rects);

        rects.Close();

        }

    else

        {

        RArray<THuiRealLine> lines;

        lines.Append(THuiRealLine(topLeftArcStart,topRightArcEnd));        

        lines.Append(THuiRealLine(topLeftArcEnd, bottomLeftArcStart));

        lines.Append(THuiRealLine(bottomLeftArcEnd, bottomRightArcStart));

        lines.Append(THuiRealLine(bottomRightArcEnd, topRightArcStart));

        DoDrawLines(lines);

        lines.Close();

        }

    }

EXPORT_C void CHuiCanvasGc::DrawPie(const THuiRealRect& aDestinationRect, 

        const THuiRealPoint& aStart, const THuiRealPoint& aEnd)

    {   

    if (!iGc)

       {

       return;    

       }

    Setup();

    EnableDelayedClippingIfNeeded(aDestinationRect);    

    while (ClipNext())

        {

        DoDrawPie( aDestinationRect, aStart, aEnd);

        }

    DisableDelayedClippingIfNeeded();    

    Cleanup();

    }

EXPORT_C void CHuiCanvasGc::DoDrawPie(const THuiRealRect& aDestinationRect, 

        const THuiRealPoint& aStart, const THuiRealPoint& aEnd)

    {

    double startx = aDestinationRect.iTl.iX + aDestinationRect.Width()/2;

    double starty = aDestinationRect.iTl.iY + aDestinationRect.Height()/2;      

    DoDrawPie( aDestinationRect, aStart, aEnd);

    }

EXPORT_C void CHuiCanvasGc::DrawArc(const THuiRealRect& aDestinationRect, 

        const THuiRealPoint& aStart, const THuiRealPoint& aEnd)

    {    

	if (!iGc)

        {

        return;    

        }

    Setup();

    EnableBlendingIfNeeded();

    EnableDelayedClippingIfNeeded(aDestinationRect);    

    while (ClipNext())

        {

        DoDrawArc(aDestinationRect, aStart, aEnd);

        }

    DisableDelayedClippingIfNeeded();    

    Cleanup();

	}

EXPORT_C void CHuiCanvasGc::DoDrawArc(const THuiRealRect& aDestinationRect, 

        const THuiRealPoint& aStart, const THuiRealPoint& aEnd)

    {    

    TPoint start = aStart;

    TPoint end = aEnd;

    TReal startx = aDestinationRect.iTl.iX;

    TReal starty = aDestinationRect.iTl.iY;

    TReal rx = aDestinationRect.Width()/2;

    TReal ry = aDestinationRect.Height()/2; 

    startx += rx;

    starty += ry;

    //Check if given start and end point lie on ellipse, if not, 

    //Find the point of intersection of ellipse with line joing to ellipse origin and start point

    //and ellipse origin and end point

    if ( ((aStart.iX-startx)*(aStart.iX-startx)/(rx*rx) + (aStart.iY-starty)*(aStart.iY-starty)/(ry*ry))!=1 )

       {

       TReal m = (aStart.iY-starty)/(aStart.iX - startx);

       TReal intersectionPointX;

       TReal src = (rx*rx*ry*ry)/((ry*ry)+(rx*rx*m*m));

       Math::Sqrt(intersectionPointX,src);

       TReal intersectionPointY = starty + (m*intersectionPointX);

       intersectionPointX = intersectionPointX + startx;       

       start.iX = intersectionPointX;

       start.iY = intersectionPointY;

       }

    if ( ((aEnd.iX-startx)*(aEnd.iX-startx)/(rx*rx) + (aEnd.iY-starty)*(aEnd.iY-starty)/(ry*ry))!=1 )

       {

       TReal m = (aEnd.iY-starty)/(aEnd.iX - startx);

       TReal intersectionPointX;

       TReal src = (rx*rx*ry*ry)/((ry*ry)+(rx*rx*m*m));

       Math::Sqrt(intersectionPointX,src);

       TReal intersectionPointY = (m*intersectionPointX) + starty;

       intersectionPointX = intersectionPointX + startx;       

       end.iX = intersectionPointX;

       end.iY = intersectionPointY;

       }  

    TReal startAngle = 0;

    Math::ATan(startAngle,(starty-start.iY),(start.iX-startx));

    startAngle = (startAngle*180)/KPi;

    TReal endAngle = 0;

    Math::ATan(endAngle,(starty-end.iY),(end.iX-startx));

    endAngle = (endAngle*180)/KPi;

    if ( endAngle <= startAngle )

        endAngle = 360 + endAngle;

    // this is very slow, needs to be re-implemented    

    if(iPolygonDrawMode)

       {     

       TReal x,y,newx,newy;

       x = startx;

       y = starty;

       newx = x;

       newy = y;

       RArray<THuiRealPoint> points;

       for(TInt i = -endAngle; i <-startAngle ; i++)

	        {

	        double a = double(i) * KPi / 180.0;        

	        double sin, cos;

	        Math::Sin( sin, a );

	        Math::Cos( cos, a );

	        newx = startx + cos * rx;

	        newy = starty + sin * ry;        

	        points.Append(THuiRealPoint(x,y));

	        points.Append(THuiRealPoint(newx, newy));

	        x = newx;

	        y = newy;

	        }

	    DoDrawPolygon(points);

	    points.Close();

	    }

    else

	    {