/*

* Copyright (c) 2002 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:  Graphics Extension Library source file

*

*/

#include "Gfx2dGcOpenVG.h"

//#include "Gfx2dDevice.h"

#include "GfxLine2D.h"

#include "GfxStroke.h"

#include "GfxGeneralPath.h"

#include "GfxFlatteningPathIterator.h"

#include "GfxColor.h"

#include "GfxImageTransformer.h"

//#include "hal.h"

//#include "hal_data.h"

#include "gdi.h"

#include "biditext.h"

#include "GfxFloatFixPt.h"

#include "GfxShape.h"

#include "GfxEllipse2D.h"

#include "GfxRoundRectangle2D.h"

//#include "svgBackendStd.h"

//#include "gulutil.h"

#include <AknFontAccess.h>

//#include <AknUtils.h>

//#include <featmgr.h>

#include<e32cmn.h>

#include<e32uid.h>//NGA

#include <e32math.h>

// OpenVG Includes

#include <VG/vgu.h>

#include <vg/vgcontext.h>

// OpenVG API Binding Symbian specific

#include <vg/vgcontext_symbian.h>

// For allocating path segment type array

// Found 130 to be max size at bootup

const TInt KPathSegmentTypeInitialSize = 130;

const TInt KPathSegmentTypeMaxSize = 1000;

const TInt KRenderQualityLow  = 1;

const TInt KRenderQualityHigh = 2;

_LIT( KDefaultFont, "serif" ); // Similar changes should be applied to \

                                //SvgTextElementImpl.cpp file

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

// CGfx2dGcOpenVG::CGfx2dGcOpenVG() : iScale( 1 ),

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

CGfx2dGcOpenVG::CGfx2dGcOpenVG( TBool /* aIsMainContext */ ) :

                        iFillOpacity( 1 ),

                        iScale( 1 ),

                        iStrokeColor( 0 ),

                        iStrokeOpacity( 1 ),

                        iBackgroundColor( 0xffffff ),

                       iFontSize( 10 ),

                       iFontWeight( -1 ),

                       iFontStyle( -1 ),

                       iFamilies( NULL ),

                       iTextAnchor( EGfxTextAnchorNone ),

                       iTextDecoration( EGfxTextDecorationNone ),

                       iGraphicsContextCreated( EFalse ),

                       iRenderQuality(VG_RENDERING_QUALITY_BETTER),

		       						iCurrentRendererType(ESVGRendererSW)

    {

    }

//

// ==========================================================================

// Create a new instance.

// ==========================================================================

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

// CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )

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

 CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider, TBool aIsMainContext )

    {

    CGfx2dGcOpenVG* self = new( ELeave ) CGfx2dGcOpenVG( aIsMainContext );

    CleanupStack::PushL( self );

    self->ConstructL( aBufferSize, aFontSpec, aSvgBitmapFontProvider);

    CleanupStack::Pop();

    return self;

    }

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

// void CGfx2dGcOpenVG::ConstructL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )

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

void CGfx2dGcOpenVG::ConstructL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider )

    {

   /* iApacAvailable = EFalse;

    FeatureManager::InitializeLibL();

    iApacAvailable = ( AknLayoutUtils::Variant() == EApacVariant );

    FeatureManager::UnInitializeLib();*/

    iFontSpec = aFontSpec;

    if (iFontSpec.iTypeface.iName.Length() == 0)

        {

    	//just for a safety check in case client didnt put it in

    	iFontSpec = TFontSpec(KDefaultFont, 100);

        }

	iSvgBitmapFontProvider = aSvgBitmapFontProvider	;

    // Allocate path segment type array

    iPathSegmentTypeCount = KPathSegmentTypeInitialSize;

    iPathSegmentTypes = new (ELeave) VGubyte[KPathSegmentTypeInitialSize];

    iDashArray = new ( ELeave ) CArrayFixFlat<VGfloat>( 32 );

    iVgRenderer  = CVGRenderer::NewL(ESVGRendererSW, 0);

    iVgSurface   = iVgRenderer->GetCurrentSurface();

    ChangeBufferSizeL( aBufferSize );

    }

//NGA

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

// CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )

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

 CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider,SVGRendererId aRendererType,TBool aIsMainContext )

    {

    CGfx2dGcOpenVG* self = new( ELeave ) CGfx2dGcOpenVG( aIsMainContext );

    CleanupStack::PushL( self );

    self->ConstructL( aBufferSize, aFontSpec, aSvgBitmapFontProvider,aRendererType);

    CleanupStack::Pop();

    return self;

    }

//NGA    

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

// void CGfx2dGcOpenVG::ConstructL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )

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

void CGfx2dGcOpenVG::ConstructL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider,SVGRendererId aRendererType )

    {

    iFontSpec = aFontSpec;

    if (iFontSpec.iTypeface.iName.Length() == 0)

        {

    	//just for a safety check in case client didnt put it in

    	iFontSpec = TFontSpec(KDefaultFont, 100);

        }

		iSvgBitmapFontProvider = aSvgBitmapFontProvider	;

    // Allocate path segment type array

    iPathSegmentTypeCount = KPathSegmentTypeInitialSize;

    iPathSegmentTypes = new (ELeave) VGubyte[KPathSegmentTypeInitialSize];

    iDashArray = new ( ELeave ) CArrayFixFlat<VGfloat>( 32 );

    iCurrentRendererType = aRendererType;

    iVgRenderer = CVGRenderer::NewL(aRendererType, 0);

    iVgSurface   = iVgRenderer->GetCurrentSurface();

    iVgSurface->InitializeSurface( aBufferSize, VGI_COLORSPACE_SRGB );

    iVgSurface->CreateSurface(EColor16MA, 0, 0);

    ChangeBufferSizeL( aBufferSize );

    }    

// ==========================================================================

// Destructor.

// ==========================================================================

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

//  CGfx2dGcOpenVG::~CGfx2dGcOpenVG()

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

 CGfx2dGcOpenVG::~CGfx2dGcOpenVG()

    {

    if ( iDashArray )

        {

        delete iDashArray;

        iDashArray = NULL;

        }

    // This is no longer needed, the Font is owned by TextElement

    // now as each text element may have its own specific font

    // and keeping one copy at Gc level will not work.

    // Gc is just refering to the Font from Textelement, so

    // now need to free it here.

    //

    //if (iFont && iWsScreenDevice)

    //	{

	//	iWsScreenDevice->ReleaseFont(iFont);

	//	iFont = NULL;

 	//   }

    DestroyContext();

    iGroupOpacityImages.Close();

    TInt bufferCount = iGroupOpacityBuffers.Count();

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

        {

        delete [] iGroupOpacityBuffers[i];

        }

    iGroupOpacityBuffers.Close();

    if ( iPathSegmentTypes )

        {

        delete [] iPathSegmentTypes;

        }

    delete iVgRenderer;

    }

// private method

void CGfx2dGcOpenVG::DestroyContext()

    {

       if ( iGraphicsContextCreated )

       {

            // Destroy OpenVG context

            iVgSurface->TerminateSurface();

            ResetContextHandle();

            iFillOpacity = 1;

            iScale = 1;

            iStrokeOpacity = 1;

       }

    }

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

//  void CGfx2dGcOpenVG::SetFrameBufferL( CFbsBitmap* aFrameBuffer )

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

 void CGfx2dGcOpenVG::ChangeBufferSizeL( const TSize aBufferSize )

    {

    if ( aBufferSize.iWidth <= 0 || aBufferSize.iHeight <= 0 || aBufferSize == iColorBufferSize )

        {

        return;

        }

    iColorBufferSize = aBufferSize;

    // First time: creating OpenVG context

    if( !iGraphicsContextCreated )

    {

        // Create OpenVG context

             TInt err = iVgSurface->InitializeSurface( iColorBufferSize, VGI_COLORSPACE_SRGB );

        if (!((err == KErrNone) || (err == KErrAlreadyExists)))

            {

            #ifdef _DEBUG

            RDebug::Printf("SVG can't initialize OpenVG Context %d", err);

            #endif //_DEBUG

            iGraphicsContextCreated = EFalse;

            User::Leave(err);

            }

        iGraphicsContextCreated = ETrue;

        // By default the Rendering quality is VG_RENDERING_QUALITY_BETTER

        iVgRenderer->vgSeti( VG_RENDERING_QUALITY, iRenderQuality );

        }

    // Only need to update context with color-buffer info

    // when frame buffer size changes

    else

    { 

        TInt err = iVgSurface->ResizeSurface( iColorBufferSize );

        if( err != KErrNone )

        {

            if(err == KErrNoMemory )

            {

                #ifdef _DEBUG

                RDebug::Printf("OpenVG Context destroyed %d", err);

                #endif //_DEBUG

                // This indicates that OpenVG has destroyed the current context handle

                // and also the Path, StrokePaint and FillPaint handles are no more valid.

                // Thus reinitialize them to 0, so that they can be recreated.

                ResetContextHandle();

            }

            #ifdef _DEBUG

            RDebug::Printf("SVG can't RESIZE OpenVG Context %d", err);

            #endif //_DEBUG

            User::Leave(err);

        }

    }

    iRenderInfo.SetDevice( 0, /*this parameter will be ignored */

                           iColorBufferSize.iWidth,

                           iColorBufferSize.iHeight,

                           0 /*this parameter will be ignored */);

    }

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

// TInt CGfx2dGcOpenVG::OpenVGErrorToSymbianError( int aError )

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

TInt CGfx2dGcOpenVG::OpenVGErrorToSymbianError( TInt aError )

{

    TInt error = KErrNone;

    switch( aError )

    {

        case VGI_OK:

        {

            error = KErrNone;

            break;

        }

        case VGU_OUT_OF_MEMORY_ERROR:

        case VG_OUT_OF_MEMORY_ERROR:

        case VGI_ERROR_OUT_OF_MEMORY:

        {

            error = KErrNoMemory;   

            break;

        }

        case VG_ILLEGAL_ARGUMENT_ERROR:

        case VGI_ERROR_INVALID_ARGUMENTS:

        case VGU_ILLEGAL_ARGUMENT_ERROR:

        {

            error = KErrArgument; 

            break;

        }

        case VGI_ERROR_ALREADY_EXISTS:

        {

            error = KErrAlreadyExists;

            break;

        }

        case VG_UNSUPPORTED_PATH_FORMAT_ERROR:

        case VGI_ERROR_COLORSPACE_NOT_SUPPORTED:

        case VG_UNSUPPORTED_IMAGE_FORMAT_ERROR:

        case VGI_ERROR_NOT_SUPPORTED:

        {

            error = KErrNotSupported; 

            break;

        }

        case VGI_ERROR_ILLEGAL_IMAGE_HANDLE:

        {

            error = KErrBadHandle; 

            break;

        }

        case VG_IMAGE_IN_USE_ERROR:

        case VGI_ERROR_IMAGE_IN_USE:

        {

            error = KErrInUse; 

            break;

        }

        case VGI_ERROR_ILLEGAL_OPERATION:

        {

            error = KErrPermissionDenied;       

            break;

        }

        case VG_BAD_HANDLE_ERROR:

        case VG_PATH_CAPABILITY_ERROR:

        case VGU_PATH_CAPABILITY_ERROR:

        case VGU_BAD_WARP_ERROR:

        case VGU_BAD_HANDLE_ERROR:

        {

            error = KErrUnknown;

            break;

        }

        default:

        {

            error = KErrUnknown; 

        }

    }

    return error;

}

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

// void CGfx2dGcOpenVG::DoDrawL( MGfxShape* aShape )

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

void CGfx2dGcOpenVG::DoDrawL( MGfxShape* aShape )

    {

    VGbitfield drawMode = 0x0;

    VGUErrorCode vguret;

    // Do not render if both stroke and fill are none

    if ( iStrokeColor.GetARGB() == KGfxColorNull && iFillColor == NULL )

        return;

    iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE );

    if ( !iPath )

        {

        const float KScale = 1.0f / 65536.0f;

   iPath = iVgRenderer->vgCreatePath( VG_PATH_FORMAT_STANDARD,

                              VG_PATH_DATATYPE_S_32, KScale, 0.0f, 0, 0,

                              VG_PATH_CAPABILITY_APPEND_TO );

        if ( iPath == VG_INVALID_HANDLE )

            {

                 VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();                    

            if (error == VG_OUT_OF_MEMORY_ERROR)

                {

				#ifdef _DEBUG

                RDebug::Printf("OOM: vgCreatePath");

				#endif

                User::Leave(KErrNoMemory);

                }

            // handle other errors...

			#ifdef _DEBUG

            RDebug::Printf("SVG GFX2D Error: vgCreatePath");

			#endif

            }

        }

    if (iFillColor)

	    {

	    if(!iFillPaint)

	    	{

                iFillPaint  = iVgRenderer->vgCreatePaint();

            if ( iFillPaint == VG_INVALID_HANDLE )

                {

                    VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();                    

                if (error == VG_OUT_OF_MEMORY_ERROR)

                    {

            		RDebug::Printf("SVG GFX2D Error OOMs: vgCreatePaint");

                    User::Leave(KErrNoMemory);

                    }

                // handle other errors...

			#ifdef _DEBUG

                RDebug::Printf("SVG GFX2D Error: vgCreatePaint");

			#endif

                }

	    	}

	    }

    if(iStrokeColor.GetARGB() != KGfxColorNull)

		{

		if(!iStrokePaint)

			{

			iStrokePaint = iVgRenderer->vgCreatePaint();  

            if ( iStrokePaint == VG_INVALID_HANDLE )

                {

                     VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();                    

                if (error == VG_OUT_OF_MEMORY_ERROR)

                    {

                    RDebug::Printf("SVGT CGfx2dGcOpenVG::DoDrawL vgCreatePaint OOM");

                    User::Leave(KErrNoMemory);

                    }

                #ifdef _DEBUG

                RDebug::Printf("SVGT CGfx2dGcOpenVG::DoDrawL vgCreatePaint failed %d", error);

                #endif

                }

			}

		}

	TGfxRectangle2D bbRect;

    TGfxAffineTransform identityMat;

    //vgClear( 0, 0, VG_MAXINT, VG_MAXINT );

    switch(aShape->ShapeType())

        {

        case MGfxShape::ERect:

            {

                TGfxRectangle2D* rect = (TGfxRectangle2D*)aShape;

                rect->GetBounds( identityMat, bbRect );

                drawMode = SetFillStroke(iFillPaint, iStrokePaint, bbRect);

                vguret =    (VGUErrorCode)iVgRenderer->vguRect(

                                iPath,

                                (VGfloat)rect->iX,

                                (VGfloat)rect->iY,

                                (VGfloat)rect->iWidth,

                                (VGfloat)rect->iHeight );

                if( vguret != KErrNone )                    

                {

                    User::LeaveIfError(OpenVGErrorToSymbianError(vguret));

                }

   iVgRenderer->vgDrawPath( iPath, drawMode );

            }

            break;

        case MGfxShape::ERoundRect:

            {

            float rx, ry;

            TGfxRoundRectangle2D* rect = (TGfxRoundRectangle2D*)aShape;

            TFloatFixPt tWidth = rect->iArcWidth;

            TFloatFixPt tHeight = rect->iArcHeight;

            tWidth.iValue <<= 1;

            tHeight.iValue <<= 1;

            rx = (VGfloat)tWidth;

            ry = (VGfloat)tHeight;

			//If a properly specified value is provided for ry but not for rx,

			// then the user agent must process the 'rect' element with the

			// effective value for rx as equal to ry.  However clamp to 0.

            if ( rx <= 0 )

                {

                rx = ry;

                }

            if ( ry <= 0)

                {

                ry = rx;

                }

			if(rx < 0)

				{

				rx = 0;

				}

			if(ry < 0)

				{

				ry = 0;

				}

    		rect->GetBounds( identityMat, bbRect );

			drawMode = SetFillStroke(iFillPaint, iStrokePaint, bbRect);

            // Rounded rectangle

            if ( rx == 0.0f && ry == 0.0f )

                {

                    vguret =     (VGUErrorCode)iVgRenderer->vguRect(iPath,

                                (VGfloat)rect->iX, (VGfloat)rect->iY,

                                (VGfloat)rect->iWidth, (VGfloat)rect->iHeight );

                }

            else

                {