/*

* Copyright (c) 2003 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:  SVG Engine source file

 *

*/

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

#include <utf.h>

#include <s32mem.h>

#include "SVGDOMImplementationImpl.h"

#include "SVGElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGSvgElementImpl.h"

#include "SVGUseElementImpl.h"

#include "SVGAnimationElementImpl.h"

#include "SVGTextElementImpl.h"

//#include "SVGAudioElementImpl.h"

#include "Gfx2dGcOpenVG.h"

#include "SVGSchemaData.h"

#include "SVGPathElementImpl.h"

#include "SVGAnimationBase.h"

#include "SVGElementTimeControl.h"

#include "SVGRequestObserver.h"

#include "SVGHyperlinkListener.h"

#include "SVGListener.h"

#include "SVGAnimationListener.h"

#include "SVGAElementImpl.h"

#include "SVGTextAreaElementImpl.h"

#include "SVGTimer.h"

#include "SVGEventHandler.h"

#include "SVGEngineImpl.h"

#include "SVGErrorImpl.h"

#include "SVGFloatCssValueImpl.h"

#include "SVGTimeContainer.h"

#include "SVGMediaAnimationElementImpl.h"

// Constants

// length of </text>

const TInt KClosingTextTagLength = 7;

// Length of </textArea>

const TInt KClosingTextAreaTagLength = 11;

// Length of <

const TInt KClosingBracesLength = 1;

// Number of chars to be converted at a time to Unicode

const TInt KMaxConversionChars = 20;

_LIT(KClosingTextTag,"</text>");

_LIT(KClosingTextAreaTag,"</textArea>");

_LIT(KClosingBraces,">");

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

// Two phase constructor for this class

// JSR 226 API

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

CSvgEngineImpl* CSvgEngineImpl::NewL(CSvgBitmapFontProvider *aSvgBitmapFontProvider)

    {

    CSvgEngineImpl* self    = new ( ELeave ) CSvgEngineImpl();

    CleanupStack::PushL( self );

    self->ConstructL(aSvgBitmapFontProvider);

    CleanupStack::Pop();

    return self;

    }

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

// CSvgEngineImpl* CSvgEngineImpl::NewLC()

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

CSvgEngineImpl* CSvgEngineImpl::NewLC(CSvgBitmapFontProvider *aSvgBitmapFontProvider)

    {

    CSvgEngineImpl* self    = new ( ELeave ) CSvgEngineImpl();

    CleanupStack::PushL( self );

    self->ConstructL(aSvgBitmapFontProvider);

    return self;

    }

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

// CSvgEngineImpl::CSvgEngineImpl() : iTextAreaHandle( NULL ),

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

CSvgEngineImpl::CSvgEngineImpl() : iTextAreaHandle( NULL ),

                                   iRequestObserver( NULL ),

                                   iFrameBuffer( NULL ),

                                   iFrameBufferSize(TSize(0,0)),

                                   iFontHashMap ( NULL ),

                                   iSvgDocument( NULL ),

                                   iBackgroundColor(0x00000000),

                                   iShowDebugInfo( EFalse ),

                                   iSvgEngineState(ESVGEngineNotStarted),

                                   iTimeoutSeconds( 0 ),

                                   iRenderQuality(2), // Set To Rendering quality "high"

                                   iCustomOption( ETrue ),

                                   iFrameBufferOverridesViewport( EFalse ),

                                   iClientDefinedViewPort(EFalse)

    {

    }

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

// void CSvgEngineImpl::ConstructL()

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

void CSvgEngineImpl::ConstructL(CSvgBitmapFontProvider *aSvgBitmapFontProvider)

    {

    iGfxContext = NULL;

	iSvgBitmapFontProvider = aSvgBitmapFontProvider ; 

    // create CSvgErrorImpl object

    iSvgError = CSvgErrorImpl::NewL();

    iFontHashMap = CSvgFontHashMap::NewL();

    SetIgnoreUpdateScreen( EFalse );

   // The iCustomOption need to be initialized for JSR

	iCustomOption = ETrue;

    }

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

// Two phase constructor for this class

// Accepts a frame buffer and a MSvgRequestObserver object from the client

// Buffer is used for rasterization of SVG content

// Observer object, if provided, is used for notifying the client on updates

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

CSvgEngineImpl* CSvgEngineImpl::NewL( CFbsBitmap* aFrameBuffer,

                                      MSvgRequestObserver* aReqObserver, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider )

    {

    CSvgEngineImpl* self    = new ( ELeave ) CSvgEngineImpl( aFrameBuffer,

                                                             aReqObserver );

    CleanupStack::PushL( self );

    self->ConstructL(aFontSpec, aSvgBitmapFontProvider);

    CleanupStack::Pop();

    return self;

    }

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

// Two phase constructor for this class

// Accepts a frame buffer and a MSvgRequestObserver object from the client

// Buffer is used for rasterization of SVG content

// Observer object, if provided, is used for notifying the client on updates

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

CSvgEngineImpl* CSvgEngineImpl::NewLC( CFbsBitmap* aFrameBuffer,

                                       MSvgRequestObserver* aReqObserver, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider )

    {

    CSvgEngineImpl* self    = new ( ELeave ) CSvgEngineImpl( aFrameBuffer, aReqObserver );

    CleanupStack::PushL( self );

    self->ConstructL(aFontSpec, aSvgBitmapFontProvider);

    return self;

    }

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

// Symbian style private method that is used to construct heap objects

// Builds the Graphics device objects with the client's frame buffer info

// Builds the event handler object

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

void CSvgEngineImpl::ConstructL( TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider)

    {

    iBitmapFontSpec = aFontSpec;

// iGfxContext is created through CSvgEngineInterfaceImpl::ConstructL

   // iGfxContext = CGfx2dGcVGR::NewL( iFrameBuffer->SizeInPixels(), iBitmapFontSpec );

    iSvgBitmapFontProvider = aSvgBitmapFontProvider ; 

    iGfxContext = CGfx2dGcOpenVG::NewL( iFrameBuffer->SizeInPixels(), iBitmapFontSpec, iSvgBitmapFontProvider );

    // create CSvgErrorImpl object

    iSvgError = CSvgErrorImpl::NewL();

    iFontHashMap = CSvgFontHashMap::NewL();

    iSvgNames = new (ELeave) CDesC16ArrayFlat(5);

    }

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

CSvgEngineImpl* CSvgEngineImpl::NewL( CFbsBitmap* aFrameBuffer,

                                      MSvgRequestObserver* aReqObserver, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider ,SVGRendererId aRendererType)

    {

    CSvgEngineImpl* self    = new ( ELeave ) CSvgEngineImpl( aFrameBuffer,

                                                             aReqObserver );

    CleanupStack::PushL( self );

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

    CleanupStack::Pop();

    return self;

    }

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

// Two phase constructor for this class

// Accepts a frame buffer and a MSvgRequestObserver object from the client

// Buffer is used for rasterization of SVG content

// Observer object, if provided, is used for notifying the client on updates.

//This contains the renderer selector parameter

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

CSvgEngineImpl* CSvgEngineImpl::NewLC( CFbsBitmap* aFrameBuffer,

                                       MSvgRequestObserver* aReqObserver, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider,SVGRendererId aRendererType )

    {

    CSvgEngineImpl* self    = new ( ELeave ) CSvgEngineImpl( aFrameBuffer, aReqObserver );

    CleanupStack::PushL( self );

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

    return self;

    }

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

// Symbian style private method that is used to construct heap objects

// Builds the Graphics device objects with the client's frame buffer info

// Builds the event handler object.

//This contains the renderer selector parameter NGA

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

void CSvgEngineImpl::ConstructL( TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider,SVGRendererId aRendererType)

    {

    iBitmapFontSpec = aFontSpec;

// iGfxContext is created through CSvgEngineInterfaceImpl::ConstructL

   // iGfxContext = CGfx2dGcVGR::NewL( iFrameBuffer->SizeInPixels(), iBitmapFontSpec );

    iSvgBitmapFontProvider = aSvgBitmapFontProvider ; 

    iGfxContext = CGfx2dGcOpenVG::NewL( iFrameBufferSize, iBitmapFontSpec, iSvgBitmapFontProvider ,aRendererType);

    // create CSvgErrorImpl object

    iSvgError = CSvgErrorImpl::NewL();

    iFontHashMap = CSvgFontHashMap::NewL();

    iSvgNames = new (ELeave) CDesC16ArrayFlat(5);

    }

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

// Private constructor

// Initializes private attributes

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

CSvgEngineImpl::CSvgEngineImpl( CFbsBitmap* aFrameBuffer,

                                MSvgRequestObserver* aReqObserver ) : iTextAreaHandle( NULL ),

                                                                      iRequestObserver( aReqObserver ),

                                                                      iFrameBuffer( aFrameBuffer ),

                                                                      iFrameBufferSize(TSize(0,0)),

                                                                      iFontHashMap ( NULL),

                                                                      iSvgDocument( NULL ),

                                                                      iBackgroundColor(0x00000000),

                                                                      iShowDebugInfo( EFalse ),

                                                                      iSvgEngineState(ESVGEngineNotStarted),

                                                                      iCustomOption( ETrue ),

                                                                      iFrameBufferOverridesViewport( EFalse )

    {

        if(aFrameBuffer && aFrameBuffer->Handle()>0)

            {

                iFrameBufferSize = aFrameBuffer->SizeInPixels();

            }

    }

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

// Destructor

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

CSvgEngineImpl::~CSvgEngineImpl()

    {

    Destroy();

    if ( iFontHashMap )

    {

		delete iFontHashMap;

		iFontHashMap = NULL;

    }

	iSvgTextBoundingBoxes.ResetAndDestroy();

	iSvgTextBoundingBoxes.Close();

    if ( iGfxContext )

        {

        delete iGfxContext;

        iGfxContext = NULL;

        }

    if ( iSvgError )

        {

        delete iSvgError;

        iSvgError = NULL;

        }

    if (iTextAreaHandle)

    {

    delete iTextAreaHandle;

    iTextAreaHandle = NULL;

    }

    iTextAreaListeners.Close();

    iTextListeners.Close();

    iHyperlinkListeners.Close();

    iAnimationListeners.Close();

    iSvgMouseListeners.Close();

    iInteractiveElementListeners.Close();

    delete iSvgNames;

    }

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

// Draws aRootElement and calls itself for children.

// Handles switch element differently, as it only draws one of its children.

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

void CSvgEngineImpl::DrawElementsL( CSvgElementImpl* aRootElement)

    {

    if ( aRootElement != NULL)

        {

        TInt32 displayValue = 0;

        //  while we have next elements

        CSvgElementImpl* newElement = aRootElement;

        while( newElement != NULL )

            {

		    if(newElement->GetAttributeIntL( KCSS_ATTR_DISPLAY, displayValue ) == KErrNoAttribute)

		        {

		        newElement = ( CSvgElementImpl* ) newElement->FirstChild();

		        while ( newElement != NULL )

		            {

		            DrawElementsL( newElement );

		            newElement = ( CSvgElementImpl * ) newElement->NextSibling();

		            }

		            return;

		         }

            if(displayValue != KDisplayEnumNone) // is it a hidden element

                {

                CCssValue*  CssValue = NULL;

                TReal32 opacity = 1;

                // check visisbility

                TInt32  visbilityValue = 0;

                TInt visibility = newElement->GetAttributeIntL( KCSS_ATTR_VISIBILITY, visbilityValue );

                newElement->FindProperty( KCSS_ATTR_GROUP_OPACITY, CssValue, newElement );

                if ( CssValue )

                    {

                    opacity = ((CFloatCssValueImpl*)CssValue)->Value();

                    }

                if( opacity != 1 && !newElement->IsInherited( KCSS_ATTR_GROUP_OPACITY ) )

                    {

                    iGfxContext->BindToImageL();

                    // Group opacity

                    if ( newElement->ElemID() == KSvgGElement && newElement->FirstChild() )

                        {

                        // recurse with right context.

                        DrawElementsL( ( CSvgElementImpl* )newElement->FirstChild());

                        }

                    // Element opacity

                    else

                        {

                        TBool canDraw = ETrue;

                        if( (visibility == KErrNone) && (visbilityValue == 0) )

                            {

                            canDraw = newElement->DrawL( iGfxContext, NULL ) ;

                             }

                        if( canDraw && newElement->FirstChild() )

                            {

                            DrawElementsL( ( CSvgElementImpl* )newElement->FirstChild() );

                            }

                        }

                    // Blend opacity context buffer with parent's gfx context buffer

                    iGfxContext->UnbindFromImageL( opacity );

                    }

                else // no opacity or is inherited from above....

                    {

                    TBool canDraw = ETrue;

                    if( (visibility == KErrNone) && (visbilityValue == 0) )

                        {

                        canDraw = newElement->DrawL(iGfxContext, NULL );

                        }

                    if( canDraw && newElement->FirstChild() )

                        {

                        DrawElementsL( ( CSvgElementImpl* )newElement->FirstChild());

                        }

                    }

				}

            newElement = ( CSvgElementImpl * )newElement->NextSibling();

            }// end while....

        }

    }

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

//CFbsBitmap* CSvgEngineImpl::CreateOpacityFrameBufferL()

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

CFbsBitmap* CSvgEngineImpl::CreateOpacityFrameBufferL()

{

    CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap();

    if ( iFrameBuffer != NULL )

        {

/*NGA reverse*/if ( bitmap->Create( iFrameBufferSize, EColor16MU ) != KErrNone )

            {

            delete bitmap;

            bitmap = NULL;

            }

        }

    return bitmap;

    }

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

// Copy 32-bit buffer

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

void CSvgEngineImpl::CopyBuffer( TUint32* aSrc, TUint32* aDest, const TSize aSize )

    {

    if ( aSrc && aDest )

        {

        Mem::Copy( aDest, aSrc, aSize.iWidth * aSize.iHeight * sizeof( TUint32 ) );

        }

    }

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

// Positions the root element and calls itself (recursively) for all the

// descendant elements

// CTM stands for 'Current Transformation Matrix'.

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

void CSvgEngineImpl::UpdateCTM(CSvgDocumentImpl* aSvgDocument)

    {

    if (aSvgDocument)

    {

        ((CSvgElementImpl*)aSvgDocument->RootElement())->UpdateCTM();

    }

    }

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

// Initializes the SVG Engine primarily with width and height informtion

// This is based on the attribute specifications for the root 'svg' element

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

void CSvgEngineImpl::InitializeEngineL()

    {

    // VIEWBOX

    // If x, y, w, h of outmost svg not defined, then put default values: 0 0 100% 100%

    // return;

    // Set locale, so that there is no thousands separator

    if( !iSvgDocument )

        return;

    iSvgDocument->iInitialDrawFlag = ETrue;

    if(!((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iIsWidthSet)

    {

        ((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iIsWidthSet = ETrue;

    }

    if(!((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iIsHeightSet)

    {

        ((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iIsHeightSet = ETrue;

    }

    TLocale locale; // locale object

    locale.SetCurrencyTriadsAllowed( EFalse ); // change setting

    TSize   lSize   = GetSize();

    iSvgDocument->iReqExReqFtrSysLTested = EFalse;

    if ( iSvgDocument->RootElement() != NULL &&

         ((CSvgElementImpl*)iSvgDocument->RootElement())->ElemID() == KSvgSvgElement )

        {

        // Scale width & height to fit to screen size

        CSvgSvgElementImpl*     el      = ( CSvgSvgElementImpl* )

                                          (iSvgDocument->RootElement());

        TFloatFixPt                  width, height;

        TInt                    widthInt, heightInt;

        TFloatFixPt scrnW( lSize.iWidth ), scrnH( lSize.iHeight );

        TFloatFixPt                  zero    ( 0 );

        if ( iFrameBufferOverridesViewport )

        {

        		//special case for Aknicon

    				//the don't care what the contents viewport is they just want it to scale to the framebuffer's size

        		width = scrnW;

        		height= scrnH;

        }

        else

        {

            //bitmap from the client overrides width height specified in svg

            if(iViewPortListener != NULL)

            {

                TInt tempWidth=0,tempHeight=0;

                iViewPortListener->GetViewPort(

                ((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iWidthInUserCoordinate, 

                ((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iHeightInUserCoordinate, 

                ((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iWidthInPercentage, 

                ((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iHeightInPercentage,

                tempWidth,

                tempHeight);

                width = (TFloatFixPt) tempWidth;

                height = (TFloatFixPt) tempHeight;

                //used in SetWindowViewportTrans of svgSvgElementImpl

                iClientDefinedViewPort = ETrue;

            }

        else

            {

                TReal32 per = 100;

                if(((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iWidthInPercentage)

                {   

                    width = ( TFloatFixPt ) (( lSize.iWidth/per ) * ((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iWidthInUserCoordinate);

                }

                else

                {   

                    width  = (TFloatFixPt)  (((CSvgSvgElementImpl *)(iSvgDocument->RootElement()))->iWidthInUserCoordinate);

                }