/*

* 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

 *

*/

#include <e32def.h>

#include <e32base.h>

#include <s32mem.h>

#include "Svgdecoder.h"

#include "SVGClrCssValueImpl.h"

#include "SVGFloatCssValueImpl.h"

#include "SVGIntCssValueImpl.h"

#include "SVGStrCssValueImpl.h"

#include "SVGVectorCssValueImpl.h"

#include "GfxAffineTransform.h"

#include "SVGTextElementImpl.h"

#include "SVGFontFaceElementImpl.h"

#include "SvgStopElementImpl.h"

#include "SVGUseElementImpl.h"

#include "SVGAnimationBase.h"

#include "SVGAnimateMotionElementImpl.h"

#include "SVGMpathElementImpl.h"

#include "SVGGradientElementImpl.h"

#include "SVGDiscardElementImpl.h"

#include "SVGMediaElementBase.h"

#include "SVGMediaAnimationElementImpl.h"

#include "SVGTimedEntityInterface.h"

//#include "SVGAudioElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGEngineImpl.h"

#include "SVGMemoryManager.h"

#include <languages.hrh>

_LIT(OFFSET, "offset");

_LIT(ZEROVALUE, "0");

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

// CSvgDecoder* CSvgDecoder::NewL(const TDesC& aFileName )

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

CSvgDecoder* CSvgDecoder::NewL(const TDesC& aFileName )

{

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

	CleanupStack::PushL(self);

    self->ConstructL(aFileName);

	CleanupStack::Pop();

	return self;

}

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

// void CSvgDecoder::ConstructL(const TDesC& aFileName)

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

void CSvgDecoder::ConstructL(const TDesC& aFileName)

{

	User::LeaveIfError(iFs.Connect() );

	User::LeaveIfError (iFStream.Open(iFs, aFileName, EFileRead));

	iStream= iFStream;

	/*Arrays Added For forward referencing in USE and Animate elements*/

	iUseElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

	iUseElementArray->Reset();

	iAnimRefElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

	iAnimRefElementArray->Reset();

}

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

// CSvgDecoder* CSvgDecoder::NewL(const TDesC8& aByteData )

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

CSvgDecoder* CSvgDecoder::NewL(const TDesC8& aByteData )

{

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

	CleanupStack::PushL(self);

    self->ConstructL(aByteData);

	CleanupStack::Pop();

	return self;

}

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

// void CSvgDecoder::ConstructL(const TDesC8& aByteData)

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

void CSvgDecoder::ConstructL(const TDesC8& aByteData)

{

	iDStream.Open(aByteData);

	iStream= iDStream;

	iUseElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

	iUseElementArray->Reset();

	iAnimRefElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

	iAnimRefElementArray->Reset();

	// added to hold switch element handles so we can go back and delete false children of the switch

	iSwitchElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

    iSwitchElementArray->Reset();

	// Arrays added to reset event listeners for animation element

	iAnimationElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

	iAnimationElementArray->Reset();

    //added to hold elements with required features, attributes, or sys language

    //so we can go back and delete the ones that dont pass at the start.

    iReqFetAttSysArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

	iReqFetAttSysArray->Reset();

}

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

// CSvgDecoder::CSvgDecoder()

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

CSvgDecoder::CSvgDecoder()

		:iRootElement( NULL ),

		 iIsAnimElement(EFalse),

		 iIsFixPt(EFalse),

		 iIsRGB(EFalse),

		 iEmbeddedImagesCount(0)

{

}

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

// CSvgDecoder::~CSvgDecoder()

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

CSvgDecoder::~CSvgDecoder()

{

	iStream.Close();

	iDStream.Close();

	iFStream.Close();

	iFs.Close();

	if(iUseElementArray)

	    {

		iUseElementArray->Reset();

		iUseElementArray->Close();

		delete iUseElementArray;

		iUseElementArray = NULL;

		}

	if(iAnimRefElementArray)

	    {

		iAnimRefElementArray->Reset();

		iAnimRefElementArray->Close();

		delete iAnimRefElementArray;

		iAnimRefElementArray = NULL;

		}

	if(iSwitchElementArray)

        {

        iSwitchElementArray->Close();

        delete iSwitchElementArray;

        }

    if (iReqFetAttSysArray)

        {

        iReqFetAttSysArray->Close();

        delete iReqFetAttSysArray;

        }

    if(iAnimationElementArray)

        {

		iAnimationElementArray->Reset();

        iAnimationElementArray->Close();

        delete iAnimationElementArray;

        }

        iImageElements.Close();

}

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

// TDesC& CSvgDecoder::DecodeTDesCLC()

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

TDesC& CSvgDecoder::DecodeTDesCLC()

{

	TUint8 lUniCodeLen = 2;

	TUint8 uStrLen;

	iStream >> uStrLen ;

	HBufC *lBuf = NULL;

	if (uStrLen)

		{

		lBuf = HBufC::NewLC(uStrLen/lUniCodeLen);

        TPtr lTmp= lBuf->Des();

    	iStream.ReadL (lTmp, (TInt)  (uStrLen/lUniCodeLen));

		}

	else

		{

		lBuf = HBufC::NewLC(0);

		}

		return (TDesC &) *lBuf;

}

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

// TDesC& CSvgDecoder::DecodeImageEmbeddedTDesCLC()

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

TDesC& CSvgDecoder::DecodeImageEmbeddedTDesCLC()

{

//	TUint8 lUniCodeLen = 2;

	TInt32 lImageSize;

	iStream >> lImageSize ;

	HBufC *lBuf = NULL;

    HBufC8* lBuffer =NULL;

	if (lImageSize)

		{

        lBuffer = HBufC8::NewLC(lImageSize);

        TPtr8 lTemp= lBuffer->Des();

    	iStream.ReadL (lTemp, (TInt)  (lImageSize));

		lBuf = HBufC::NewLC(lImageSize);

        TPtr lTmp= lBuf->Des();

        lTmp.Copy(lTemp);

		}

	else

		{

        lBuffer = HBufC8::NewLC(0);

		lBuf = HBufC::NewLC(0);

		}

	return (TDesC &) *lBuf;

}

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

// Decodig Attribute

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

TInt CSvgDecoder::DecodeAttributeL(const TUint16 aName)

	{

	if( DecodePresentationAttributeL (aName) ||

		DecodeSVGTAttributeL (aName) ||

		DecodeSvgElementAttributeL (aName) ||

		DecodeIdAndXmlAttributeL ( aName ) ||

		DecodeUriRefAttributeL ( aName ) ||

		DecodeAnimationAttributeL (aName) ||

		DecodeTransformAttributeL (aName) ||

		DecodeLangSpaceAttributeL (aName) ||

		DecodeTestAttributeL ( aName ) ||

		DecodeDiscardAttributeL ( aName )

	  )

		{

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}

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

// TBool CSvgDecoder::DecodePresentationAttributeL(const TUint16 aName)

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

TBool CSvgDecoder::DecodePresentationAttributeL(const TUint16 aName)

	{

	if(aName<=KCSS_MAX_ATTR)

		{

		if (aName== KCSS_ATTR_FILL )

			{

		    CCssValue* tParentValue = NULL;

			CCssValue* tValue = NULL;

			iCurrentElement->FindProperty (KCSS_ATTR_FILL,tValue);

			if(iCurrentElement!= iRootElement)

				{

				iCurrentParentElement->FindProperty (KCSS_ATTR_FILL,tParentValue);

				}

			if (tParentValue == tValue || tValue == NULL)

				{

				if (iDocument)

				{

					tValue = iDocument->iMemoryManager->GetCssPaintObjectL(iCurrentElement);

				}

				SetPaintValueL (tValue);

			    iCurrentElement->SetPresentationAttribute (KCSS_ATTR_FILL,tValue);

				}

			else

				{

				SetPaintValueL (tValue);

				}

			return ETrue;

			}

		if (aName== KCSS_ATTR_STROKE || aName== KCSS_ATTR_COLOR)

			{

		 	return DecodeColorCssValueL(aName);

			}

		if (aName== KCSS_ATTR_GROUP_OPACITY)

			{

			iDocument->iHasGroupOpacity = ETrue;

			return DecodeFloatCssValueL(aName);

			}

		if (aName== KCSS_ATTR_FILL_OPACITY ||

			aName== KCSS_ATTR_STROKE_OPACITY ||

			aName== KCSS_ATTR_STROKEWIDTH ||

			aName== KCSS_ATTR_FONTSIZE ||

			aName== KCSS_ATTR_STROKE_MITERLIMIT ||

			aName== KCSS_ATTR_STROKE_DASHOFFSET

			)

			{

			return DecodeFloatCssValueL(aName);

			}

		if (aName== KCSS_ATTR_VISIBILITY ||

			aName== KCSS_ATTR_FONTSTYLE ||

			aName== KCSS_ATTR_FONTWEIGHT ||

			aName== KCSS_ATTR_DISPLAY ||

            aName== KCSS_ATTR_TEXTANCHOR ||

			aName== KCSS_ATTR_TEXTDECORATION

			)

			{

			return DecodeIntCssValueL(aName);

			}

		if (aName== KCSS_ATTR_FONTFAMILY ||

			aName== KCSS_ATTR_FILLRULE ||

			aName== KCSS_ATTR_STROKE_LINECAP ||

			aName== KCSS_ATTR_STROKE_LINEJOIN

			)

			{

			return DecodeStringCssValueL(aName);

			}

		if (aName== KCSS_ATTR_STROKE_DASHARRAY)

			{

			CArrayFix<TFloatFixPt>* lArrayFix;

			TInt8 lCount;

			iStream >> lCount;

			if (lCount)

				{

				lArrayFix= new ( ELeave ) CArrayFixFlat<TFloatFixPt>( lCount );

				}

			else

				{

				lArrayFix= new ( ELeave ) CArrayFixFlat<TFloatFixPt>( 1 );

				}

			 CleanupStack::PushL(lArrayFix); //cleanup

			TFloatFixPt lTempFix;

			TReal32 lTempReal;

			for(TInt8 i=0; i<lCount; i++)

				{

					if (iIsFixPt)

					{

					//was encoded as fixed point

					lTempFix.iValue = iStream.ReadInt32L();

					lArrayFix->AppendL( lTempFix );	

					}

					else

					{

					//was encoded as floats

					iStream >> lTempReal;

					lArrayFix->AppendL( (TFloatFixPt) lTempReal);	

					}

				}

			CCssValue* tParentValue = NULL;

		    CCssValue* tValue = NULL;

			iCurrentElement->FindProperty ((TInt8)aName,tValue);

			if(iCurrentElement!= iRootElement)

				{

				iCurrentParentElement->FindProperty ((TInt8)aName,tParentValue);

				}

            if ( tParentValue == tValue || tValue == NULL )

                {

                // This attribute is inherited from parent, or not 

                // defined in parent

                if ( iDocument )

                    {

                    // Create a new Vector object and clone lArrayFix

                    tValue = iDocument->iMemoryManager->GetCssVectorObjectL( lArrayFix );

                    // Associate tValue with the current element

                    iCurrentElement->SetPresentationAttribute ( ( TInt8 ) aName,tValue );

                    }

                // tValue contains a copy of lArrayFix, hence lArrayFix is not needed

                // anymore. 

                // tValue is owned by the element.

                CleanupStack::PopAndDestroy( lArrayFix ); //cleanup

                }

            else

                {

                // stroke dash array was already present in the element

                // SetValueL function takes ownership of lArrayFix

                ((CVectorCssValueImpl*)tValue)->SetValueL ( lArrayFix );

                // No need to destroy lArrayFix as it is now owned 

                // by the element.

                CleanupStack::Pop( lArrayFix ); //cleanup

                }

			return ETrue;

			}

		else

			{

			return ETrue;

			}

		}

	else

		{

		return EFalse;

		}

	}

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

// TBool CSvgDecoder::DecodeSVGTAttributeL(const TUint16 aName)

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

TBool CSvgDecoder::DecodeSVGTAttributeL(const TUint16 aName)

	{

	if( (iCurrentElement->ElemID() == KSvgSvgElement) &&

      ( aName== KAtrWidth || aName== KAtrHeight ) )

		{

		TUint8 lFlag;

		iStream >> lFlag ;

		if (iIsFixPt)

		{

			TFloatFixPt lAtrValue;

			lAtrValue.iValue = iStream.ReadInt32L();

				// Flag is used to ckech whether height and width are percentage or not.

			if(lFlag)

			{

			    if(aName == KAtrWidth)

			    {

			        ((CSvgSvgElementImpl *)iCurrentElement)->iWidthInPercentage = ETrue;

			        ((CSvgSvgElementImpl *)iCurrentElement)->iWidthInUserCoordinate = lAtrValue;

			    }

			    else if(aName == KAtrHeight)

			    {

			        ((CSvgSvgElementImpl *)iCurrentElement)->iHeightInPercentage = ETrue;

			        ((CSvgSvgElementImpl *)iCurrentElement)->iHeightInUserCoordinate = lAtrValue;

			    }

			}

			else

			{

			    if(aName == KAtrWidth)

			    {

			        ((CSvgSvgElementImpl *)iCurrentElement)->iWidthInPercentage = EFalse;

			    }

			    else if(aName == KAtrHeight)

			    {

			        ((CSvgSvgElementImpl *)iCurrentElement)->iHeightInPercentage = EFalse;

			    }

			iCurrentElement->SetAttributeFloatL( (TInt)aName, lAtrValue );

			}

		}

		else

		{

			TReal32 lAtrValue;

			iStream >> lAtrValue;

				// Flag is used to ckech whether height and width are percentage or not.

			if(lFlag)

			{

			    if(aName == KAtrWidth)

			    {

			        ((CSvgSvgElementImpl *)iCurrentElement)->iWidthInPercentage = ETrue;

			        ((CSvgSvgElementImpl *)iCurrentElement)->iWidthInUserCoordinate = lAtrValue;  

			    }

			    else if (aName == KAtrHeight)

			    {

			        ((CSvgSvgElementImpl *)iCurrentElement)->iHeightInPercentage = ETrue;

			        ((CSvgSvgElementImpl *)iCurrentElement)->iHeightInUserCoordinate = lAtrValue;

			    }

			}