--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/svgtopt/SVG/SVGEngine/src/Svgdecoder.cpp Wed Nov 03 18:56:10 2010 +0200
@@ -0,0 +1,4422 @@
+/*
+* 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;
+ }
+
+ }
+ else
+ {
+ if(aName == KAtrWidth)
+ {
+ ((CSvgSvgElementImpl *)iCurrentElement)->iWidthInPercentage = EFalse;
+ }
+ else if(aName == KAtrHeight)
+ {
+ ((CSvgSvgElementImpl *)iCurrentElement)->iHeightInPercentage = EFalse;
+ }
+ iCurrentElement->SetAttributeFloatL( (TInt)aName, (TFloatFixPt)lAtrValue );
+ }
+ }
+
+ return ETrue;
+ }
+
+ if(iCurrentElement->ElemID() == KSvgTextElement)
+ {
+ if (aName== KAtrX || aName== KAtrY)
+ {
+ CArrayFixFlat<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
+
+ for(TInt8 i=0; i<lCount; i++)
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt lTemp;
+ lTemp.iValue = iStream.ReadInt32L();
+ lArrayFix->AppendL( lTemp );
+ }
+ else
+ {
+ TReal32 lTemp;
+ iStream >> lTemp ;
+ lArrayFix->AppendL( (TFloatFixPt) lTemp);
+ }
+
+ }
+
+ ((CSvgTextElementImpl*)iCurrentElement)->SetXYArray(aName,lArrayFix);
+ CleanupStack::Pop(lArrayFix); //cleanup
+ return ETrue;
+ }
+ }
+
+
+ if( aName<KSvgFloatAttrEndIndex ||
+ aName== KAtrFx ||
+ aName== KAtrFy ||
+ aName== KAtrOffset ||
+ aName== KAtrStopOpacity
+ )
+ {
+
+ return DecodeAttributeFloatL(aName);
+ }
+
+ else if(aName == KAtrK)
+ {
+ iCurrentElement->iReqAttrFlag =0;
+ return DecodeAttributeFloatL(aName);
+ }
+
+ else if( aName<= KSvgDesAttrEndIndex ||
+ aName== KAtrMedia ||
+ aName== KAtrTitle
+ )
+ {
+
+ return DecodeAttributeDesL(aName);
+ }
+ else if (aName== KAtrVolume)
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt lTemp;
+ lTemp.iValue = iStream.ReadInt32L();
+ TBuf<16> lTemp2;
+ _LIT(KAudioLevelFormat, "%f");
+ lTemp2.Format(KAudioLevelFormat, (float)lTemp );
+ //lTemp2.AppendNum((float)lTemp );
+ ((CSvgAudioElementImpl *)iCurrentElement)->SetAttributeL (_L("volume"),lTemp2);
+ }
+ else
+ {
+ TReal32 lTemp;
+ iStream >> lTemp;
+ TBuf<16> lTemp2;
+ _LIT(KAudioLevelFormat, "%f");
+ lTemp2.Format(KAudioLevelFormat, (float)lTemp );
+ //lTemp2.AppendNum(lTemp);
+ ((CSvgAudioElementImpl *)iCurrentElement)->SetAttributeL (_L("volume"),lTemp2);
+ }
+ return ETrue;
+ }
+ else if (aName== KAtrAudioLevel)
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt lTemp;
+ lTemp.iValue = iStream.ReadInt32L();
+ TBuf<16> lTemp2;
+ _LIT(KAudioLevelFormat, "%f");
+ lTemp2.Format(KAudioLevelFormat, (float)lTemp );
+ //lTemp2.AppendNum((float)lTemp );
+ ((CSvgAudioElementImpl *)iCurrentElement)->SetAttributeL (_L("audio-level"),lTemp2);
+ }
+ else
+ {
+ TReal32 lTemp;
+ iStream >> lTemp;
+ TBuf<16> lTemp2;
+ _LIT(KAudioLevelFormat, "%f");
+ lTemp2.Format(KAudioLevelFormat, (float)lTemp );
+ //lTemp2.AppendNum(lTemp);
+ ((CSvgAudioElementImpl *)iCurrentElement)->SetAttributeL (_L("audio-level"),lTemp2);
+ }
+ return ETrue;
+ }
+
+ switch( aName )
+ {
+ case KAtrType:
+ {
+ if(iCurrentElement->ElemID()== KSvgAnimateTransformElement)
+ {
+ if (iCurrentElement->iReqAttrFlag == KAtrSVGTrf)
+ {
+ iCurrentElement->iReqAttrFlag=KAtrAttributeName;
+ }
+ else
+ {
+ iCurrentElement->iReqAttrFlag= 0;
+ }
+ TUint8 lType, lSize;
+ iStream >> lType;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeType(lType);
+ iStream >> lSize;
+ ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetMatrixDataSize(lSize);
+ return ETrue;
+ }
+ else if(iCurrentElement->ElemID()== KSvgAudioElement)
+ {
+ TPtrC lPtr(DecodeTDesCLC());
+ ((CSvgAudioElementImpl*)iCurrentElement)->SetAttributeL(_L("type"),lPtr);
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+ else
+ {
+ return DecodeAttributeDesL(aName);
+ }
+ }
+
+ case KAtrCdata:
+ {
+ if ( iCurrentElement->ElemID() == KSvgTextElement )
+ {
+ // DecodeTDesCLC() allocates the string on the cleanup stack
+ // and advances the file pointer beyond the CData
+ // SetTextL() makes a copy of the CData in the text element.
+ ( ( CSvgTextElementImpl* )iCurrentElement )->SetTextL(
+ DecodeTDesCLC() );
+ }
+ else
+ {
+ // Skip the CData
+ DecodeTDesCLC();
+ }
+ // Free the CData allocated inside DecodeTDesCLC()
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+ case KAtrD:
+ case KAtrPoints:
+ {
+ iCurrentElement->iReqAttrFlag = 0;
+ return DecodeAttributePathL(aName);
+ }
+
+ case KAtrSpreadMethods:
+ case KAtrGradientUnits:
+ {
+ return DecodeAttributeIntL(aName);
+ }
+
+ case KAtrRotate:
+ {
+ // for AnimateMotion Element
+ if (iCurrentElement->ElemID()== KSvgAnimateMotionElement)
+ {
+ TInt16 lRotate;
+ iStream >> lRotate;
+ ((CSvgAnimateMotionElementImpl*)iCurrentElement)->SetAnimRotate(lRotate);
+ }
+
+ // For Text Element
+ else
+ {
+ TInt8 lCount;
+ CArrayFixFlat<TReal32>* lArray;
+ iStream >> lCount;
+ if(lCount)
+ {
+ lArray= new ( ELeave ) CArrayFixFlat<TReal32>( lCount );
+ CleanupStack::PushL(lArray); //cleanup
+ for (TInt i=0; i<lCount; i++)
+ {
+ TReal32 lTemp;
+ iStream >> lTemp;
+ lArray->AppendL((TReal32) lTemp);
+ }
+
+ if ( iCurrentElement->ElemID() == KSvgTextElement )
+ {
+ ((CSvgTextElementImpl*)iCurrentElement)->SetRotateArray (lArray);
+ }
+
+ CleanupStack::Pop(lArray); //cleanup
+ }
+ }
+
+ return ETrue;
+ }
+
+ case KAtrStopColor:
+ {
+ TUint32 lColor;
+ iStream >> lColor;
+ // Shift from XBGR to XRGB
+ if(!iIsRGB)
+ {
+ lColor = ( lColor & 0xFF000000) |
+ ( (lColor & 0x00FF0000) >> 16 ) |
+ ( lColor & 0x0000FF00 ) |
+ ( (lColor & 0x000000FF) << 16 );
+ }
+
+ if ( iCurrentElement->ElemID() == KSvgStopElement )
+ {
+ ((CSvgStopElementImpl*)iCurrentElement)->SetStopColorL(lColor);
+ }
+
+ return ETrue;
+ }
+
+ default:
+ {
+ return EFalse;
+ }
+ }
+ }
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeAnimationAttributeL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeAnimationAttributeL(const TUint16 aName)
+ {
+
+ if (aName== KAtrAttributeName)
+ {
+ TUint16 lAtrId;
+ TUint8 lType;
+ iStream >> lAtrId;
+
+ // For Animate Transform element
+ if (iCurrentElement->ElemID()== KSvgAnimateTransformElement)
+ {
+ // Attribute Id of the animate transform has been changed. For binary compatibility
+ if (lAtrId == KAtrTransform )
+ {
+ lAtrId= KAtrAnimateTransformAttrId;
+ }
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeId(lAtrId);
+
+ if (iCurrentElement->iReqAttrFlag == KAtrSVGTrf)
+ {
+ iCurrentElement->iReqAttrFlag=KAtrType;
+ }
+ else
+ {
+ iCurrentElement->iReqAttrFlag= 0;
+ }
+ }
+
+ //For other animation elements
+ else
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeId(lAtrId);
+ iCurrentElement->iReqAttrFlag= 0;
+ iStream >> lType;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeType(lType);
+ ((CSvgAnimationBase*)iCurrentElement)->GetAttrValueL();
+ }
+ return ETrue;
+ }
+
+ if (aName== KAtrBegin)
+ {
+ // Although discard element belongs to animation, the discard element isn't
+ // necessary inherited from giant AnimationBase, so handle attribute separately.
+ //
+ if ( iCurrentElement->ElemID() == KSvgDiscardElement /*||
+ iCurrentElement->ElemID() == KSvgMediaAnimationElement*/ )
+ {
+ return EFalse;
+ }
+
+ TInt8 lCheck, lCount;
+ iStream >> lCheck;
+ // Flag is used to check for Indefinite value.
+ if(lCheck)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAbsoluteBeginTime(KTimeIndefinite);
+ ((CSvgAnimationBase*)iCurrentElement)->SetBeginTime(KTimeIndefinite);
+ }
+ else
+ {
+ CArrayFixFlat<CSvgAnimationBase::TEventListItem>* lEventList;
+ RArray<TInt32>* lTimeList;
+ // event list
+ iStream >> lCount;
+ if (lCount)
+ {
+ lEventList= new (ELeave) CArrayFixFlat<CSvgAnimationBase::TEventListItem>(lCount);
+ }
+ else
+ {
+ lEventList= new (ELeave) CArrayFixFlat<CSvgAnimationBase::TEventListItem>(1);
+ }
+
+ CleanupStack::PushL(lEventList); //cleanup
+
+ for( TInt i=0; i<lCount; i++)
+ {
+ CSvgAnimationBase::TEventListItem lItem;
+ TInt32 lTime;
+ iStream >> lTime;
+ lItem.iTime= lTime;
+
+ TInt32 lOffset;
+ iStream >> lOffset;
+ lItem.iOffset= lOffset;
+
+ if (iIsFixPt)
+ {
+ TFloatFixPt temp;
+ temp.iValue = iStream.ReadInt32L();
+ lItem.iRepeatValue = (TReal32)temp;
+ }
+ else
+ {
+ TReal32 lValue;
+ iStream >> lValue;
+ lItem.iRepeatValue= lValue;
+ }
+
+
+ TPtrC lPtr(DecodeTDesCLC());
+ // check for the use of unique Id of the target element
+ if(lPtr == _L("unid"))
+ {
+ lItem.iTargetElement = (((CSvgAnimationBase*)iCurrentElement)->GetTargetElem());
+ lItem.iReferenceElemeId= NULL;
+ }
+ else
+ {
+ // get element by id and append its pointer.
+
+ // there can be an issue if the id is not found. in case of forward reference.
+ // for this we will store the id if it is not found at this time.
+ lItem.iTargetElement = (CSvgElementImpl*)iDocument->GetElementById( lPtr );
+ if( lItem.iTargetElement == NULL)
+ {
+ // this indicates that this is a forward reference in case of begin.
+
+ lItem.iReferenceElemeId = lPtr.AllocL();
+ }
+ else
+ {
+ // otherwise the element is found and we
+ // do not need to keep iReferenceElemeId so
+ // make it NULL;
+ lItem.iReferenceElemeId = NULL;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( 1 );
+
+ TUint16 lCode;
+ iStream >> lCode;
+ lItem.iAccessKeyCode= lCode;
+
+ TInt8 lEvent;
+ iStream >> lEvent;
+ lItem.iEvent= (TSvgEvent) lEvent;
+
+ switch(lItem.iEvent)
+ {
+ case ESvgEventKey:
+ case ESvgEventNone:
+ {
+ lItem.iTargetElement =NULL;
+ break;
+ }
+ }
+ lEventList->AppendL((CSvgAnimationBase::TEventListItem) lItem);
+ }
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetEventList(lEventList);
+ CleanupStack::Pop(lEventList); //cleanup
+
+ //begin time list
+ iStream >> lCount;
+ if (lCount)
+ {
+ lTimeList= new (ELeave) RArray<TInt32>(lCount);
+ }
+ else
+ {
+ lTimeList= new (ELeave) RArray<TInt32>(1);
+ }
+
+ // For proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->SetBeginTimeList(lTimeList);
+ lTimeList->AppendL(NULL);
+ lTimeList->Remove(0);
+
+ for( TInt i=0; i<lCount; i++)
+ {
+ TInt32 lTime;
+ iStream >> lTime;
+ lTimeList->AppendL( (TInt32) lTime);
+ }
+
+ TInt32 lTime;
+ iStream >> lTime;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAbsoluteBeginTime(lTime);
+ iStream >> lTime;
+ ((CSvgAnimationBase*)iCurrentElement)->SetBeginTime(lTime);
+
+
+ iStream >> lCheck;
+ // flag to ckeck Adding to the Reciever EventList
+ if(lCheck)
+ {
+ iDocument->AddToEventReceiverListL( iCurrentElement,
+ KSvgEventMaskExternalUI );
+ }
+ }
+ return ETrue;
+ }
+
+
+ if (aName== KAtrEnd) //End Time
+ {
+ TInt8 lCheck;
+ iStream >> lCheck;
+
+ // Flag is used to check for Indefinite value
+ if(lCheck)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetEndTime(KTimeIndefinite);
+ }
+ else
+ {
+ CArrayFixFlat<CSvgAnimationBase::TEventListItem>* lTimeList;
+ // event list
+
+ lTimeList= new (ELeave) CArrayFixFlat<CSvgAnimationBase::TEventListItem>(1);
+ CleanupStack::PushL(lTimeList); //cleanup
+
+ CSvgAnimationBase::TEventListItem lItem;
+ TInt8 lEvent;
+ iStream >> lEvent;
+ lItem.iEvent = (TSvgEvent) lEvent;
+
+ if (iIsFixPt)
+ {
+ TFloatFixPt temp;
+ temp.iValue = iStream.ReadInt32L();
+ lItem.iRepeatValue = (TReal32)temp;
+ }
+ else
+ {
+ TReal32 lValue;
+ iStream >> lValue;
+ lItem.iRepeatValue= lValue;
+ }
+
+
+ TPtrC lPtr( DecodeTDesCLC() );
+
+ if (lPtr == _L("unid") )
+ {
+ lItem.iTargetElement = ((CSvgAnimationBase*)iCurrentElement)->GetTargetElem();
+ lItem.iReferenceElemeId = NULL;
+ }
+ else
+ {
+ // get element by id and append its pointer.
+ lItem.iTargetElement = ( CSvgElementImpl * )
+ iDocument->GetElementById( lPtr );
+ if(lItem.iTargetElement == NULL)
+ {
+ lItem.iReferenceElemeId = lPtr.AllocL();
+ }
+ else
+ {
+ // Set the iEndReferenceElemeId to NULL:
+ lItem.iReferenceElemeId = NULL;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( 1 );
+
+ switch ( lItem.iEvent )
+ {
+ case ESvgEventKey:
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetEndTime(KTimeIndefinite ); // same as indefinite
+
+ TUint16 lCode;
+ iStream >> lCode;
+ lItem.iAccessKeyCode= lCode;
+ lItem.iTargetElement =NULL;
+ iDocument->AddToEventReceiverListL( iCurrentElement,
+ KSvgEventMaskExternalUI );
+ break;
+ }
+ case ESvgEventWallClock:
+ // not supported yet
+ break;
+ case ESvgEventNone:
+ {
+ TInt32 lTime;
+ iStream >> lTime;
+ lItem.iTime= lTime;
+ ((CSvgAnimationBase*)iCurrentElement)->AddEndTime(lTime);
+ lItem.iTargetElement =NULL;
+ break;
+ }
+ default:
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetEndTime( KTimeIndefinite ); // same as indifinite
+ TInt32 lOffset;
+ iStream >> lOffset;
+ lItem.iOffset= lOffset;
+
+ lItem.iTime = KTimeIndefinite;
+ iDocument->AddToEventReceiverListL( iCurrentElement,
+ KSvgEventMaskInternal );
+ }
+
+ }
+ lTimeList->AppendL( (CSvgAnimationBase::TEventListItem) lItem);
+ ((CSvgAnimationBase*)iCurrentElement)->SetEndTimeList( lTimeList);
+ CleanupStack::Pop(lTimeList); //cleanup
+
+ }
+
+ return ETrue;
+ }
+
+////////// for multiple end times
+
+ if (aName== KMultipleEndTime)
+ {
+ TInt8 lCount;
+
+ CArrayFixFlat<CSvgAnimationBase::TEventListItem>* lTimeList;
+ // event list
+ iStream >> lCount;
+ if (lCount)
+ {
+ lTimeList= new (ELeave) CArrayFixFlat<CSvgAnimationBase::TEventListItem>(lCount);
+ }
+ else
+ {
+ lTimeList= new (ELeave) CArrayFixFlat<CSvgAnimationBase::TEventListItem>(1);
+ }
+
+ CleanupStack::PushL(lTimeList); //cleanup
+
+ for( TInt i=0; i<lCount; i++)
+ {
+ CSvgAnimationBase::TEventListItem lItem;
+ TInt32 lTime;
+ iStream >> lTime;
+ lItem.iTime= lTime;
+
+ TInt32 lOffset;
+ iStream >> lOffset;
+ lItem.iOffset= lOffset;
+
+ if (iIsFixPt)
+ {
+ TFloatFixPt temp;
+ temp.iValue = iStream.ReadInt32L();
+ lItem.iRepeatValue = (TReal32)temp;
+ }
+ else
+ {
+ TReal32 lValue;
+ iStream >> lValue;
+ lItem.iRepeatValue= lValue;
+ }
+
+
+ TPtrC lPtr(DecodeTDesCLC());
+ // check for the use of unique Id of the target element
+ if(lPtr == _L("unid"))
+ {
+ lItem.iTargetElement = (((CSvgAnimationBase*)iCurrentElement)->GetTargetElem());
+ lItem.iReferenceElemeId= NULL;
+ }
+ else
+ {
+ // get element by id and append its pointer.
+ // there can be an issue if the id is not found. in case of forward reference.
+ // for this we will store the id if it is not found at this time.
+ lItem.iTargetElement = (CSvgElementImpl*)iDocument->GetElementById( lPtr );
+ if( lItem.iTargetElement == NULL)
+ {
+ // this indicates that this is a forward reference in case of begin.
+
+ lItem.iReferenceElemeId = lPtr.AllocL();
+ }
+ else
+ {
+ // otherwise the element is found and we
+ // do not need to keep iReferenceElemeId so
+ // make it NULL;
+ lItem.iReferenceElemeId = NULL;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( 1 );
+
+ TUint16 lCode;
+ iStream >> lCode;
+ lItem.iAccessKeyCode= lCode;
+
+ TInt8 lEvent;
+ iStream >> lEvent;
+ lItem.iEvent= (TSvgEvent) lEvent;
+
+ switch ( lItem.iEvent )
+ {
+ case ESvgEventKey:
+ lItem.iTargetElement =NULL;
+ ((CSvgAnimationBase*)iCurrentElement)->SetEndTime( KTimeIndefinite ); // same as indefinite
+
+ iDocument->AddToEventReceiverListL( iCurrentElement,
+ KSvgEventMaskExternalUI );
+ break;
+
+ case ESvgEventWallClock:
+ // not supported yet
+ break;
+
+ case ESvgEventNone:
+ lItem.iTargetElement =NULL;
+ // Simple Offset-value
+ ((CSvgAnimationBase*)iCurrentElement)->AddEndTime( lItem.iTime );
+
+ break;
+
+ default:
+ // <id>.<event> +/- <offeset>
+ ((CSvgAnimationBase*)iCurrentElement)->SetEndTime( KTimeIndefinite ); // same as indifinite
+
+ iDocument->AddToEventReceiverListL( iCurrentElement,
+ KSvgEventMaskInternal );
+ }
+
+ lTimeList->AppendL((CSvgAnimationBase::TEventListItem) lItem);
+ }
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetEndTimeList(lTimeList);
+ CleanupStack::Pop(lTimeList); //cleanup
+
+
+
+
+ return ETrue;
+ }
+
+
+ if (aName== KAtrDur)
+ {
+ TInt32 lTime;
+ TInt8 lCheck;
+ iStream >> lTime;
+ ((CSvgAnimationBase*)iCurrentElement)->SetDurationTime(lTime);
+ iStream >> lCheck;
+ // Flag is used to check for Indefinite value
+ if(lCheck)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetBeginTime(KTimeIndefinite);
+ }
+ return ETrue;
+ }
+
+ if (aName== KAtrFrom)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFlag();
+
+ //For Animate Transform element
+ if(iCurrentElement->ElemID()== KSvgAnimateTransformElement)
+ {
+ CSvgAnimateTransformElementImpl::TMatrixData lMatrix;
+
+ if (iIsFixPt)
+ {
+ for (TInt i=0; i<3; i++)
+ {
+ lMatrix.iData[i].iValue = iStream.ReadInt32L();
+ }
+ }
+ else
+ {
+ TReal32 lTemp;
+ for (TInt i=0; i<3; i++)
+ {
+ iStream >> lTemp;
+ lMatrix.iData[i]= (TFloatFixPt) lTemp;
+ }
+ }
+
+ ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetMatrixData(0,lMatrix);
+ }
+
+ // for other Animation elements
+ else
+ {
+
+ TUint8 lType;
+ iStream >>lType;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeType(lType);
+ switch ( lType )
+ {
+ case KSvgTypeOpacity:
+ case KSvgTypeLength:
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt lValue;
+ lValue.iValue = iStream.ReadInt32L();
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFloat(lValue);
+ }
+ else
+ {
+ TReal32 lValue;
+ iStream >> lValue;
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFloat((TFloatFixPt)lValue);
+ }
+
+ break;
+ }
+ case KSvgTypeList:
+ case KSvgTypePath:
+ {
+ CGfxGeneralPath* lPath;
+ DecodeAnimationPathL(lPath);
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromPathL(lPath);
+ break;
+ }
+ case KSvgTypeColor:
+ {
+ TInt32 lColor;
+ iStream >> lColor;
+ // Shift from XBGR to XRGB
+ if(!iIsRGB)
+ {
+ lColor = ( lColor & 0xFF000000) |
+ ( (lColor & 0x00FF0000) >> 16 ) |
+ ( lColor & 0x0000FF00 ) |
+ ( (lColor & 0x000000FF) << 16 );
+ }
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromInt(lColor);
+ break;
+ }
+ case KSvgTypeTextAnchor:
+ case KSvgTypeGradientUnits:
+ case KSvgTypeSpreadMethod:
+ case KSvgTypeInteger:
+ case KSvgTypeDisplay:
+ case KSvgTypeVisibility:
+ {
+ TInt32 lTemp;
+ iStream >> lTemp;
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromInt(lTemp);
+ break;
+ }
+
+ // viewBox attribute
+ case KSvgTypeViewBox:
+ {
+
+ if (iIsFixPt)
+ {
+ TGfxRectangle2D temp;
+ temp.iX.iValue = iStream.ReadInt32L();
+
+ temp.iY.iValue = iStream.ReadInt32L();
+ temp.iWidth.iValue = iStream.ReadInt32L();
+ temp.iHeight.iValue = iStream.ReadInt32L();
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromViewBox(temp);
+ }
+ else
+ {
+ TReal32 lValue;
+ TGfxRectangle2D temp;
+
+ this->iStream >> lValue;
+ temp.iX = (TFloatFixPt) lValue;
+ this->iStream >> lValue;
+ temp.iY = (TFloatFixPt) lValue;
+ this->iStream >> lValue;
+ temp.iWidth = (TFloatFixPt) lValue;
+ this->iStream >> lValue;
+ temp.iHeight = (TFloatFixPt) lValue;
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromViewBox(temp);
+ }
+ break;
+ }
+ }
+ }
+ return ETrue;
+ }
+
+ if (aName== KAtrTo)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetToFlag();
+
+ // For Animate Transform
+ if(iCurrentElement->ElemID()== KSvgAnimateTransformElement)
+ {
+ if( ((CSvgAnimationBase*)iCurrentElement)->GetFromFlag() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ }
+ CSvgAnimateTransformElementImpl::TMatrixData lMatrix;
+
+ if (iIsFixPt)
+ {
+ for (TInt i=0; i<3; i++)
+ {
+ lMatrix.iData[i].iValue = iStream.ReadInt32L();
+ }
+ }
+ else
+ {
+ TReal32 lTemp;
+ for (TInt i=0; i<3; i++)
+ {
+ iStream >> lTemp;
+ lMatrix.iData[i]= (TFloatFixPt) lTemp;
+ }
+ }
+
+ ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetMatrixData(1,lMatrix);
+ ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetAccumMatrix();
+ }
+
+ // for Other Animation Elements
+ else
+ {
+ TUint8 lType;
+ iStream >>lType;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeType(lType);
+ switch ( lType )
+ {
+ case KSvgTypeOpacity:
+ case KSvgTypeLength:
+ {
+
+ if (iIsFixPt)
+ {
+ TFloatFixPt lValue;
+ lValue.iValue = iStream.ReadInt32L();
+ ((CSvgAnimationBase*)iCurrentElement)->SetToFloat(lValue);
+ }
+ else
+ {
+ TReal32 lValue;
+ iStream >> lValue;
+ ((CSvgAnimationBase*)iCurrentElement)->SetToFloat((TFloatFixPt)lValue);
+ }
+
+ break;
+ }
+ case KSvgTypeList:
+ case KSvgTypePath:
+ {
+ CGfxGeneralPath* lPath;
+ DecodeAnimationPathL(lPath);
+ ((CSvgAnimationBase*)iCurrentElement)->SetToPath(lPath);
+ break;
+ }
+ case KSvgTypeColor:
+ {
+ TInt32 lColor;
+ iStream >> lColor;
+ // Shift from XBGR to XRGB
+ if(!iIsRGB)
+ {
+ lColor = ( lColor & 0xFF000000) |
+ ( (lColor & 0x00FF0000) >> 16 ) |
+ ( lColor & 0x0000FF00 ) |
+ ( (lColor & 0x000000FF) << 16 );
+ }
+ ((CSvgAnimationBase*)iCurrentElement)->SetToInt(lColor);
+ break;
+ }
+ case KSvgTypeTextAnchor:
+ case KSvgTypeGradientUnits:
+ case KSvgTypeSpreadMethod:
+ case KSvgTypeInteger:
+ case KSvgTypeDisplay:
+ case KSvgTypeVisibility:
+ {
+ TInt32 lTemp;
+ iStream >> lTemp;
+ ((CSvgAnimationBase*)iCurrentElement)->SetToInt(lTemp);
+ break;
+ }
+
+ // viewBox attribute
+ case KSvgTypeViewBox:
+ {
+ if (iIsFixPt)
+ {
+ TGfxRectangle2D temp;
+ temp.iX.iValue = iStream.ReadInt32L();
+ temp.iY.iValue = iStream.ReadInt32L();
+ temp.iWidth.iValue = iStream.ReadInt32L();
+ temp.iHeight.iValue = iStream.ReadInt32L();
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetToViewBox(temp);
+ }
+ else
+ {
+ TReal32 lValue;
+ TGfxRectangle2D temp;
+
+ this->iStream >> lValue;
+ temp.iX = (TFloatFixPt) lValue;
+ this->iStream >> lValue;
+ temp.iY = (TFloatFixPt) lValue;
+ this->iStream >> lValue;
+ temp.iWidth = (TFloatFixPt) lValue;
+ this->iStream >> lValue;
+ temp.iHeight = (TFloatFixPt) lValue;
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetToViewBox(temp);
+ }
+
+ break;
+ }
+
+ }
+ }
+ return ETrue;
+
+ }
+
+ if (aName== KAtrBy) //by
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetByFlag();
+
+ // For Animate Transform
+ if(iCurrentElement->ElemID()== KSvgAnimateTransformElement)
+ {
+ if( ((CSvgAnimationBase*)iCurrentElement)->GetFromFlag() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ }
+ CSvgAnimateTransformElementImpl::TMatrixData lMatrix;
+
+ if (iIsFixPt)
+ {
+ for (TInt i=0; i<3; i++)
+ {
+ lMatrix.iData[i].iValue = iStream.ReadInt32L();
+ }
+ }
+ else
+ {
+ TReal32 lTemp;
+ for (TInt i=0; i<3; i++)
+ {
+ iStream >> lTemp;
+ lMatrix.iData[i]= (TFloatFixPt) lTemp;
+ }
+ }
+
+ ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetMatrixData(1,lMatrix);
+ }
+
+ // for Other Animation Elements
+ else
+ {
+ TUint8 lType;
+ iStream >>lType;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeType(lType);
+ switch ( lType )
+ {
+ case KSvgTypeOpacity:
+ case KSvgTypeLength:
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt lValue;
+ lValue.iValue = iStream.ReadInt32L();
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetToFloat( lValue );
+ if( ((CSvgAnimationBase*)iCurrentElement)->GetFromFlag() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFlag();
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFloat((TFloatFixPt)0);
+ }
+ }
+ else
+ {
+ TReal32 lValue;
+ iStream >> lValue;
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetToFloat((TFloatFixPt)lValue);
+ if( ((CSvgAnimationBase*)iCurrentElement)->GetFromFlag() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFlag();
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFloat((TFloatFixPt)0);
+ }
+ }
+
+ break;
+ }
+ case KSvgTypeList:
+ case KSvgTypePath:
+ {
+ CGfxGeneralPath* lPath;
+ DecodeAnimationPathL(lPath);
+ ((CSvgAnimationBase*)iCurrentElement)->SetToPath(lPath);
+ break;
+ }
+
+ case KSvgTypeColor:
+ {
+ TInt32 lColor;
+ iStream >> lColor;
+ // Shift from XBGR to XRGB
+ if(!iIsRGB)
+ {
+ lColor = ( lColor & 0xFF000000) |
+ ( (lColor & 0x00FF0000) >> 16 ) |
+ ( lColor & 0x0000FF00 ) |
+ ( (lColor & 0x000000FF) << 16 );
+ }
+ ((CSvgAnimationBase*)iCurrentElement)->SetToInt(lColor);
+ if( ((CSvgAnimationBase*)iCurrentElement)->GetFromFlag() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromInt((TInt32)0);
+ }
+ break;
+ }
+ case KSvgTypeTextAnchor:
+ case KSvgTypeGradientUnits:
+ case KSvgTypeSpreadMethod:
+ case KSvgTypeInteger:
+ {
+ TInt32 lTemp;
+ iStream >> lTemp;
+ ((CSvgAnimationBase*)iCurrentElement)->SetToInt(lTemp);
+ if( ((CSvgAnimationBase*)iCurrentElement)->GetFromFlag() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFlag();
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromInt((TInt32)0);
+ }
+ break;
+ }
+
+ case KSvgTypeDisplay:
+ case KSvgTypeVisibility:
+ {
+ TInt32 lTemp;
+ iStream >> lTemp;
+ ((CSvgAnimationBase*)iCurrentElement)->SetToInt(lTemp);
+ break;
+ }
+
+ // viewBox attribute
+ case KSvgTypeViewBox:
+ {
+ if (iIsFixPt)
+ {
+ TGfxRectangle2D temp;
+ temp.iX.iValue = iStream.ReadInt32L();
+ temp.iY.iValue = iStream.ReadInt32L();
+ temp.iWidth.iValue = iStream.ReadInt32L();
+ temp.iHeight.iValue = iStream.ReadInt32L();
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetToViewBox(temp);
+ }
+ else
+ {
+ TReal32 lValue;
+ TGfxRectangle2D temp;
+
+ iStream >> lValue;
+ temp.iX = (TFloatFixPt) lValue;
+ iStream >> lValue;
+ temp.iY = (TFloatFixPt) lValue;
+ iStream >> lValue;
+ temp.iWidth = (TFloatFixPt) lValue;
+ iStream >> lValue;
+ temp.iHeight = (TFloatFixPt) lValue;
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetToViewBox(temp);
+ }
+
+ if( ((CSvgAnimationBase*)iCurrentElement)->GetFromFlag() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFlag();
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromViewBox
+ (TGfxRectangle2D( 0, 0, 0, 0 ) );
+ }
+ break;
+ }
+ }
+ }
+ return ETrue;
+
+ }
+
+
+ if (aName== KAtrValues) // values
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetFromFlag();
+ ((CSvgAnimationBase*)iCurrentElement)->SetValuesFlag();
+
+ // For Animate Transform
+ if(iCurrentElement->ElemID()== KSvgAnimateTransformElement)
+ {
+ TUint16 lCount;
+ RArray<CSvgAnimateTransformElementImpl::TMatrixData>* lValues= NULL;
+
+ iStream >>lCount;
+ if (lCount)
+ {
+ lValues= new (ELeave) RArray<CSvgAnimateTransformElementImpl::TMatrixData>(lCount);
+ }
+ else
+ {
+ lValues= new (ELeave) RArray<CSvgAnimateTransformElementImpl::TMatrixData>(1);
+ }
+
+ // for proper cleanup
+ ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetTransformValues(lValues);
+ CSvgAnimateTransformElementImpl::TMatrixData lMatrix1;
+ lValues->AppendL(lMatrix1);
+ lValues->Remove(0);
+
+ for (TInt i=0; i<lCount; i++)
+ {
+ CSvgAnimateTransformElementImpl::TMatrixData lMatrix;
+
+ if (iIsFixPt)
+ {
+ for (TInt i=0; i<3; i++)
+ {
+ lMatrix.iData[i].iValue = iStream.ReadInt32L();
+ }
+ }
+ else
+ {
+ TReal32 lTemp;
+ for (TInt i=0; i<3; i++)
+ {
+ iStream >> lTemp;
+ lMatrix.iData[i]= (TFloatFixPt) lTemp;
+ }
+ }
+
+ lValues->AppendL( (CSvgAnimateTransformElementImpl::TMatrixData) lMatrix);
+ }
+ if(iCurrentElement->ElemID()== KSvgAnimateTransformElement)
+ {
+ ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetAccumMatrix();
+ }
+ }
+
+
+ // For other Animation elements
+ else
+ {
+ TUint8 lType;
+ iStream >>lType;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAttributeType(lType);
+ switch ( lType )
+ {
+ case KSvgTypeOpacity:
+ case KSvgTypeLength:
+ {
+ RArray<TFloatFixPt>* lArray;
+ TUint16 lCount;
+ iStream >> lCount;
+ if (lCount)
+ {
+ lArray= new (ELeave) RArray<TFloatFixPt>(lCount);
+ }
+ else
+ {
+ lArray= new (ELeave) RArray<TFloatFixPt>(1);
+ }
+
+ // for proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->SetFloatValuesArray(lArray);
+ lArray->AppendL(NULL);
+ lArray->Remove(0);
+
+ TFloatFixPt lValueFix;
+ TReal32 lValueFloat;
+
+ for(TInt i=0; i<lCount; i++)
+ {
+
+ if(iIsFixPt)
+ {
+ lValueFix.iValue = iStream.ReadInt32L();
+ lArray->AppendL( lValueFix );
+ }
+ else
+ {
+ iStream >> lValueFloat;
+ lArray->AppendL((TFloatFixPt) lValueFloat);
+ }
+
+ }
+ break;
+ }
+ case KSvgTypeList:
+ case KSvgTypePath:
+ {
+ TUint16 lCount;
+ RPointerArray<CGfxGeneralPath>* lArray;
+ iStream >> lCount;
+ if (lCount)
+ {
+ lArray= new (ELeave) RPointerArray<CGfxGeneralPath>(lCount);
+ }
+ else
+ {
+ lArray= new (ELeave) RPointerArray<CGfxGeneralPath>(1);
+ }
+
+ // for proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->ResetFloatValuesArray();
+ ((CSvgAnimationBase*)iCurrentElement)->SetPathValuesArray(lArray);
+ lArray->AppendL(NULL);
+ lArray->Remove(0);
+ for(TInt i=0; i<lCount; i++)
+ {
+ CGfxGeneralPath* lPath;
+ DecodeAnimationPathL(lPath);
+ lArray->AppendL( (CGfxGeneralPath*)lPath );
+ }
+ break;
+ }
+
+ case KSvgTypeColor:
+ {
+ RArray<TInt32>* lArray;
+ TUint16 lCount;
+ iStream >> lCount;
+ if (lCount)
+ {
+ lArray= new (ELeave) RArray<TInt32>(lCount);
+ }
+ else
+ {
+ lArray= new (ELeave) RArray<TInt32>(1);
+ }
+
+ // for proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->ResetFloatValuesArray();
+ ((CSvgAnimationBase*)iCurrentElement)->SetIntValuesArray(lArray);
+ lArray->AppendL(NULL);
+ lArray->Remove(0);
+
+ for(TInt i=0; i<lCount; i++)
+ {
+ TInt32 lColor;
+ iStream >> lColor;
+ if(!iIsRGB)
+ {
+ lColor = ( lColor & 0xFF000000) |
+ ( (lColor & 0x00FF0000) >> 16 ) |
+ ( lColor & 0x0000FF00 ) |
+ ( (lColor & 0x000000FF) << 16 );
+ }
+ lArray->AppendL((TInt32) lColor);
+ }
+ break;
+ }
+
+ case KSvgTypeGradientUnits:
+ case KSvgTypeSpreadMethod:
+ case KSvgTypeInteger:
+ case KSvgTypeDisplay:
+ case KSvgTypeVisibility:
+ case KSvgTypeTextAnchor:
+ {
+ RArray<TInt32>* lArray;
+ TUint16 lCount;
+ iStream >> lCount;
+ if (lCount)
+ {
+ lArray= new (ELeave) RArray<TInt32>(lCount);
+ }
+ else
+ {
+ lArray= new (ELeave) RArray<TInt32>(1);
+ }
+
+ // for proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->ResetFloatValuesArray();
+ ((CSvgAnimationBase*)iCurrentElement)->SetIntValuesArray(lArray);
+ lArray->AppendL(NULL);
+ lArray->Remove(0);
+
+ for(TInt i=0; i<lCount; i++)
+ {
+ TInt32 lValue;
+ iStream >> lValue;
+ lArray->AppendL((TInt32) lValue);
+ }
+ break;
+ }
+
+ // viewBox
+ case KSvgTypeViewBox:
+ {
+ RArray<TGfxRectangle2D>* lArray;
+ TUint16 lCount;
+ iStream >> lCount;
+ if (lCount)
+ {
+ lArray= new (ELeave) RArray<TGfxRectangle2D>(lCount);
+ }
+ else
+ {
+ lArray= new (ELeave) RArray<TGfxRectangle2D>(1);
+ }
+ TGfxRectangle2D temp1;
+ // for proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->SetViewBoxValuesArray(lArray);
+ lArray->AppendL(temp1);
+ lArray->Remove(0);
+
+
+ TGfxRectangle2D temp;
+ TReal32 lValueFloat;
+ for(TInt i=0; i<lCount; i++)
+ {
+
+ if (iIsFixPt)
+ {
+ temp.iX.iValue = iStream.ReadInt32L();
+ temp.iY.iValue = iStream.ReadInt32L();
+ temp.iWidth.iValue = iStream.ReadInt32L();
+ temp.iHeight.iValue = iStream.ReadInt32L();
+
+ lArray->AppendL((TGfxRectangle2D) temp);
+ }
+ else
+ {
+ iStream >> lValueFloat;
+ temp.iX = (TFloatFixPt) lValueFloat;
+ iStream >> lValueFloat;
+ temp.iY = (TFloatFixPt) lValueFloat;
+ iStream >> lValueFloat;
+ temp.iWidth = (TFloatFixPt) lValueFloat;
+ iStream >> lValueFloat;
+ temp.iHeight = (TFloatFixPt) lValueFloat;
+
+ lArray->AppendL((TGfxRectangle2D) temp);
+ }
+ }
+ break;
+ }
+ }
+ }
+ return ETrue;
+
+ }
+
+ // Used to set the Fill attribute of Animation elements
+ if (aName== KAnimFreeze)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAnimFreeze();
+ return ETrue;
+ }
+
+ if (aName== KAtrRepeatDur)
+ {
+ TUint32 lDur;
+ iStream >> lDur;
+ ((CSvgAnimationBase*)iCurrentElement)->SetRepeatDuration(lDur);
+ return ETrue;
+ }
+
+ if (aName== KAtrRepeatCount)
+ {
+
+ if (iIsFixPt)
+ {
+ TFloatFixPt lCount;
+ lCount.iValue = iStream.ReadInt32L();
+ ((CSvgAnimationBase*)iCurrentElement)->SetRepeatCount(lCount.iValue);
+ }
+ else
+ {
+ TReal32 lCount;
+ iStream >> lCount;
+ ((CSvgAnimationBase*)iCurrentElement)->SetRepeatCount(lCount);
+ }
+
+ return ETrue;
+ }
+
+ if (aName== KAtrRestart)
+ {
+ TUint8 lMode;
+ iStream >> lMode;
+ ((CSvgAnimationBase*)iCurrentElement)->SetRestartMode((TRestartMode)lMode);
+ return ETrue;
+ }
+
+ if (aName== KAtrAccumulate)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAccumulate(KAccumSum);
+ return ETrue;
+ }
+
+ if (aName== KAtrAdditive)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ return ETrue;
+ }
+
+ if (aName== KAtrCalcMode)
+ {
+ TUint8 lMode;
+ iStream >> lMode;
+ ((CSvgAnimationBase*)iCurrentElement)->SetCalcMode((TAnimCalcMode) lMode);
+ return ETrue;
+ }
+
+ if (aName== KAtrKeyTimes)
+ {
+ TUint16 lCount;
+ RArray<CSvgAnimTimeController::TKeyTime>* lArray;
+ iStream >> lCount;
+ if (lCount)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetKeyTimeFlag();
+ lArray= new (ELeave) RArray<CSvgAnimTimeController::TKeyTime>(lCount);
+ }
+ else
+ {
+ lArray= new (ELeave) RArray<CSvgAnimTimeController::TKeyTime>(1);
+ }
+ CSvgAnimTimeController::TKeyTime lTime1;
+ // for proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->SetKeyTimeArray(lArray);
+ lArray->AppendL(lTime1);
+ lArray->Remove(0);
+
+ for (TInt i=0; i<lCount; i++)
+ {
+ TUint8 lTemp;
+ CSvgAnimTimeController::TKeyTime lTime;
+ iStream >> lTemp;
+ lTime.iX = (TUint16) (lTemp);
+ iStream >> lTemp;
+ lTime.iY = (TUint16) (lTemp);
+ lArray->AppendL( (CSvgAnimTimeController::TKeyTime) lTime);
+ }
+ return ETrue;
+ }
+
+ if (aName== KAtrKeySplines)
+ {
+ TUint16 lCount;
+ RArray<CSvgAnimTimeController::TKeyTime>* lArray;
+ RArray<TUint32>* lAnimArray;
+
+ // keyTime Array
+ iStream >> lCount;
+ if (lCount)
+ {
+ lArray= new (ELeave) RArray<CSvgAnimTimeController::TKeyTime>(lCount);
+ }
+ else
+ {
+ lArray= new (ELeave) RArray<CSvgAnimTimeController::TKeyTime>(1);
+ }
+ CSvgAnimTimeController::TKeyTime lTime1;
+ // for proper cleanup
+ ((CSvgAnimationBase*)iCurrentElement)->SetKeyTimeArray(lArray);
+ lArray->AppendL(lTime1);
+ lArray->Remove(0);
+ for (TInt i=0; i<lCount; i++)
+ {
+ TUint8 lTemp;
+ CSvgAnimTimeController::TKeyTime lTime;
+ iStream >> lTemp;
+ lTime.iX = (TUint16) (lTemp);
+ iStream >> lTemp;
+ lTime.iY = (TUint16) (lTemp);
+ lArray->AppendL( (CSvgAnimTimeController::TKeyTime) lTime);
+ }
+
+ //AnimTime Array
+ iStream >> lCount;
+ if (lCount)
+ {
+ lAnimArray = new (ELeave) RArray<TUint32>(lCount);
+ }
+ else
+ {
+ lAnimArray= new (ELeave) RArray<TUint32>(1);
+ }
+
+ ((CSvgAnimationBase*)iCurrentElement)->SetAnimTimeArray(lAnimArray);
+ lAnimArray->AppendL(NULL);
+ lAnimArray->Remove(0);
+
+ for (TInt i=0; i<lCount; i++)
+ {
+ TUint8 lTemp;
+ iStream >> lTemp;
+ lAnimArray->AppendL( (TUint32) lTemp);
+ }
+ return ETrue;
+ }
+
+
+ // Animate motion Element is handled here
+ if (aName== KAtrAnimateMotion)
+ {
+ DecodeAttributePathL(KAtrAnimateMotion);
+ TUint8 lFlag;
+ iStream >> lFlag;
+ if(lFlag == KAtrAdditiveSet)
+ {
+ iCurrentElement->iReqAttrFlag= 0;
+ ((CSvgAnimationBase*)iCurrentElement)->SetAdditive(KAdditiveSum);
+ return ETrue;
+ }
+ iCurrentElement->iReqAttrFlag= lFlag;
+ return ETrue;
+ }
+
+ if (aName== KAtrXlinkhref)
+ {
+ _LIT( KXlink, "xlink:href" );
+ TPtrC lPtr(DecodeTDesCLC());
+ CSvgMediaAnimationElementImpl* mediaElement = static_cast<CSvgMediaAnimationElementImpl*>(iCurrentElement);
+ mediaElement->SetAttributeL(KXlink, lPtr);
+ CleanupStack::PopAndDestroy(1);
+ return ETrue;
+ }
+
+ if( aName == KAtrSyncBehavior )
+ {
+ TUint8 syncBehavior;
+ iStream>>syncBehavior;
+ ((CSvgMediaElementBase*)iCurrentElement)->SetSyncBehavior( (TSvgSyncBehaviour) syncBehavior );
+ return ETrue;
+ }
+ else if( aName == KAtrSyncTolerance)
+ {
+ TUint8 syncTolerance;
+ iStream>>syncTolerance;
+ ((CSvgMediaElementBase*)iCurrentElement)->SetSyncTolerance( syncTolerance, EFalse );
+ return ETrue;
+ }
+ else if( aName == KAtrSyncMaster )
+ {
+ TUint8 syncMaster ;
+ iStream>>syncMaster ;
+ ((CSvgMediaElementBase*)iCurrentElement)->SetSyncMaster( syncMaster );
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeSvgElementAttributeL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeSvgElementAttributeL(const TUint16 aName)
+ {
+ if ( ( aName<= KSvgSVGAttrEndIndex) ||
+ ( aName == KAtrSyncBehaviorDefault ) || // To support backward compatibility
+ ( aName == KAtrSyncToleranceDefault ))
+ {
+
+ if (aName== KAtrViewBox)
+ {
+ TGfxRectangle2D lRect;
+
+ if (iIsFixPt)
+ {
+ lRect.iX.iValue = iStream.ReadInt32L();
+ lRect.iY.iValue = iStream.ReadInt32L();
+ lRect.iWidth.iValue = iStream.ReadInt32L();
+ lRect.iHeight.iValue = iStream.ReadInt32L();
+
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetViewBoxL(lRect);
+ }
+ else
+ {
+ TReal32 lTemp;
+
+ iStream >> lTemp;
+ lRect.iX= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lRect.iY= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lRect.iWidth= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lRect.iHeight= (TFloatFixPt) lTemp;
+
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetViewBoxL(lRect);
+ }
+ return ETrue;
+ }
+
+ if (aName== KAtrBaseProfile)
+ {
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetBaseProfileL(DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+ if (aName== KAtrVersion)
+ {
+
+ if (iIsFixPt)
+ {
+ TFloatFixPt lTemp;
+ lTemp.iValue = iStream.ReadInt32L();
+ TBuf<16> lTemp2;
+ lTemp2.AppendNum( (float)lTemp );
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetVersion (lTemp2);
+ }
+ else
+ {
+ TReal32 lTemp;
+ iStream >> lTemp;
+ TBuf<16> lTemp2;
+ lTemp2.AppendNum(lTemp);
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetVersion (lTemp2);
+ }
+
+ return ETrue;
+
+ /*
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetVersion (DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ */
+ }
+
+ if (aName== KAtrZoomAndPan)
+ {
+ TInt8 lTemp;
+ iStream >> lTemp;
+ TSvgZoomAndPanType lType= (TSvgZoomAndPanType) lTemp;
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetZoomAndPan(lType);
+ return ETrue;
+ }
+
+ if (aName== KAtrPreserveAspectRatio)
+ {
+ if (iCurrentElement->ElemID()== KSvgSvgElement)
+ {
+ TInt8 lTemp;
+ iStream >> lTemp;
+ TSvgPreserveAspectAlignType lAType= (TSvgPreserveAspectAlignType) lTemp;
+ iStream >> lTemp;
+ TSvgMeetOrSliceType lMType= (TSvgMeetOrSliceType) lTemp;
+ ((CSvgSvgElementImpl *)iCurrentElement)->SetPreserveAspectRatioL(lAType, lMType);
+ return ETrue;
+ }
+ else if(iCurrentElement->ElemID()== KSvgMediaAnimationElement)
+ {
+ TInt8 lTemp;
+ iStream >> lTemp;
+ TSvgPreserveAspectAlignType lAType= (TSvgPreserveAspectAlignType) lTemp;
+ iStream >> lTemp;
+ TSvgMeetOrSliceType lMType= (TSvgMeetOrSliceType) lTemp;
+ ((CSvgMediaAnimationElementImpl*)iCurrentElement)->SetPreserveAspectRatioL(lAType, lMType);
+ return ETrue;
+ }
+ else
+ {
+ ((CSvgImageElementImpl *)iCurrentElement)->SetParL(DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+ }
+
+ if( aName == KAtrSyncBehaviorDefault )
+ {
+ TUint8 syncBehaviorDefault;
+ iStream>>syncBehaviorDefault;
+ ((CSvgSvgElementImpl*)iCurrentElement)->SetSyncBehaviorDefault( (TSvgSyncBehaviour) syncBehaviorDefault );
+ return ETrue;
+ }
+ else if( aName == KAtrSyncToleranceDefault )
+ {
+ TUint8 syncToleranceDefault;
+ iStream>>syncToleranceDefault;
+ ((CSvgSvgElementImpl*)iCurrentElement)->SetSyncToleranceDefault( syncToleranceDefault );
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeLangSpaceAttributeL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeLangSpaceAttributeL(const TUint16 aName)
+ {
+ if (aName<= KSvgLangAttrEndIndex)
+ {
+
+ if (aName== KAtrXmlLang)
+ {
+ iCurrentElement->SetXMLLangL (DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+ if (aName== KAtrXmlSpace)
+ {
+ iCurrentElement->SetXMLSpaceL (DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeTransformAttributeL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeTransformAttributeL(const TUint16 aName)
+ {
+
+ if (aName== KAtrTransform)
+ {
+
+ if (iIsFixPt)
+ {
+ TUint32 lTemp1;
+ TGfxAffineTransform lTransform;
+
+ lTransform.iM00.iValue = iStream.ReadInt32L();
+ lTransform.iM01.iValue = iStream.ReadInt32L();
+ lTransform.iM02.iValue = iStream.ReadInt32L();
+ lTransform.iM10.iValue = iStream.ReadInt32L();
+ lTransform.iM11.iValue = iStream.ReadInt32L();
+ lTransform.iM12.iValue = iStream.ReadInt32L();
+ iStream >> lTemp1;
+ lTransform.iTransType= (TGfxTransformType) lTemp1;
+
+ iCurrentElement->SetTransformList(lTransform);
+ }
+ else
+ {
+ TReal32 lTemp;
+ TUint32 lTemp1;
+ TGfxAffineTransform lTransform;
+
+ iStream >> lTemp;
+ lTransform.iM00= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lTransform.iM01= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lTransform.iM02= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lTransform.iM10= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lTransform.iM11= (TFloatFixPt) lTemp;
+ iStream >> lTemp;
+ lTransform.iM12= (TFloatFixPt) lTemp;
+ iStream >> lTemp1;
+ lTransform.iTransType= (TGfxTransformType) lTemp1;
+
+ iCurrentElement->SetTransformList(lTransform);
+ }
+
+ return ETrue;
+ }
+
+ else if ( aName== KAtrGradientTransform)
+ {
+
+ if (iIsFixPt)
+ {
+ SVGReal lMatrix[2][3];
+
+ TFloatFixPt lTemp;
+ lTemp.iValue = iStream.ReadInt32L();
+ lMatrix[0][0]= lTemp.iValue;
+ lTemp.iValue = iStream.ReadInt32L();
+ lMatrix[0][1]= lTemp.iValue;
+ lTemp.iValue = iStream.ReadInt32L();
+ lMatrix[0][2]= lTemp.iValue;
+ lTemp.iValue = iStream.ReadInt32L();
+ lMatrix[1][0]= lTemp.iValue;
+ lTemp.iValue = iStream.ReadInt32L();
+ lMatrix[1][1]= lTemp.iValue;
+ lTemp.iValue = iStream.ReadInt32L();
+ lMatrix[1][2]= lTemp.iValue;
+
+ ((CSvgGradientElementImpl*)iCurrentElement)->SetGradientTransMatrix(lMatrix);
+ }
+ else
+ {
+ TReal32 lTemp;
+ SVGReal lMatrix[2][3];
+
+ iStream >> lTemp;
+ lMatrix[0][0]= (SVGReal) lTemp;
+ iStream >> lTemp;
+ lMatrix[0][1]= (SVGReal) lTemp;
+ iStream >> lTemp;
+ lMatrix[0][2]= (SVGReal) lTemp;
+ iStream >> lTemp;
+ lMatrix[1][0]= (SVGReal) lTemp;
+ iStream >> lTemp;
+ lMatrix[1][1]= (SVGReal) lTemp;
+ iStream >> lTemp;
+ lMatrix[1][2]= (SVGReal) lTemp;
+
+ ((CSvgGradientElementImpl*)iCurrentElement)->SetGradientTransMatrix(lMatrix);
+ }
+
+ return ETrue;
+ }
+
+
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeTestAttributeL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeTestAttributeL(const TUint16 aName)
+ {
+ if(aName<= KSvgTestAttrEndIndex)
+ {
+
+ if (
+ aName== KAtrRequiredFeatures ||
+ aName== KAtrRequiredExtensions ||
+ aName== KAtrSystemLanguage
+ )
+ {
+ CDesCArrayFlat* lFeatures;
+ TInt8 lCount;
+ iStream >> lCount;
+ if(lCount)
+ {
+ lFeatures= new ( ELeave ) CDesCArrayFlat( lCount );
+ }
+ else
+ {
+ lFeatures= new ( ELeave ) CDesCArrayFlat( 1 );
+ }
+
+ CleanupStack::PushL(lFeatures); //cleanup
+
+ for(TInt8 i=0; i<lCount; i++)
+ {
+ lFeatures->AppendL((const TDesC&)DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ }
+
+ iCurrentElement->CreateSvgTestL(aName); //instantiates iSvgTest
+ if (aName== KAtrRequiredFeatures)
+ {
+ iCurrentElement->SetRequiredFeatures (lFeatures);
+ }
+ else if (aName== KAtrRequiredExtensions)
+ {
+ iCurrentElement->SetRequiredExtensions (lFeatures);
+ }
+ else
+ {
+ iCurrentElement->SetSystemLanguage (lFeatures);
+ }
+
+ CleanupStack::Pop(lFeatures); //cleanup
+
+ return ETrue;
+ }
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeIdAndXmlAttributeL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeIdAndXmlAttributeL(const TUint16 aName)
+ {
+
+ if (aName== KAtrId)
+ {
+ iCurrentElement->SetIdandXmlbaseL( _L("id"), DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+ if (aName== KAtrXmlBase)
+ {
+ iCurrentElement->SetIdandXmlbaseL( _L("xml:base"), DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeUriRefAttributeL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeUriRefAttributeL(const TUint16 aName)
+ {
+ if (aName<= KSvgUriAttrEndIndex)
+ {
+ if (aName== KAtrXlinkhref)
+ {
+ // Although discard element belongs to animation, the discard element isn't
+ // necessary inherited from giant AnimationBase, so handle attribute separately.
+ //
+ if ( iCurrentElement->ElemID() == KSvgDiscardElement || iCurrentElement->ElemID() == KSvgMediaAnimationElement )
+ return EFalse;
+
+ TPtrC lPtr(DecodeTDesCLC());
+ /*Code modified for Forward refrence support in animation*/
+ iCurrentElement->SetUriRefDesL (aName, lPtr );
+ // For Animation Elements
+ if(iIsAnimElement)
+ {
+ CSvgElementImpl* lElement;
+ lElement= (CSvgElementImpl*) iDocument->GetElementById(lPtr);
+ if(lElement)
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetTarget(lElement);
+ }
+ else
+ {
+ if (!iAnimRefElementArray)
+ {
+ iAnimRefElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);
+ }
+ iAnimRefElementArray->AppendL((CSvgElementImpl*)iCurrentElement);
+ }
+
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+
+ //Only for Image Element
+ if (iCurrentElement->ElemID() == KSvgImageElement)
+ {
+ ((CSvgImageElementImpl*)iCurrentElement)->SetUriL(lPtr);
+ iImageElements.Append((CSvgImageElementImpl*)iCurrentElement);
+ }
+ CleanupStack::PopAndDestroy( 1 );
+
+ // setting reference element of use Element
+ if (iCurrentElement->ElemID() == KSvgUseElement)
+ {
+ if( ((CSvgUseElementImpl*)iCurrentElement)->SetRefElemById
+ (DecodeTDesCLC()) != KErrNone)
+ {
+ // if it is null reallocate the memeory again.
+ if (!iUseElementArray)
+ {
+ iUseElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);
+ }
+ iUseElementArray->AppendL((CSvgElementImpl*)iCurrentElement);
+ }
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+// for future animation element
+// else if (iCurrentElement->ElemID() == KSvgAnimationElement)
+// {
+// if( ((CSvgAnimationElementImpl*)iCurrentElement)->SetRefElemById
+// (DecodeTDesCLC()) == KErrNone)
+// {
+ // if it is null reallocate the memeory again.
+// if (!iAnimationElementArray)
+// {
+// iAnimationElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);
+// }
+// User::LeaveIfError(iAnimationElementArray->Append((CSvgElementImpl*)iCurrentElement));
+// }
+// CleanupStack::PopAndDestroy( 1 );
+// return ETrue;
+// }
+
+ // setting Path of Mpath element
+ if (iCurrentElement->ElemID() == KSvgMpathElement)
+ {
+ iCurrentElement->iReqAttrFlag =0;
+ TInt8 lCheck;
+ iStream >> lCheck;
+ // Flag is used to check the validity of reference element
+ if (lCheck)
+ {
+ ((CSvgMpathElementImpl*)iCurrentElement)->SetAttributePathByIdL(DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ }
+ }
+
+ return ETrue;
+ }
+
+ else if (aName== KAtrXlinkactuate ||
+ aName== KAtrXlinkarcrole ||
+ aName== KAtrXlinkrole ||
+ aName== KAtrXlinktitle ||
+ aName== KAtrXlinktype ||
+ aName== KAtrXlinkshow
+ )
+ {
+ iCurrentElement->SetUriRefDesL (aName, DecodeTDesCLC() );
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+ else
+ {
+ return EFalse;
+ }
+ }
+
+ else if (aName== KXlinkhrefImageEmbedded)
+ {
+ TPtrC lPtr(DecodeImageEmbeddedTDesCLC());
+
+ iCurrentElement->SetUriRefDesL (aName, lPtr );
+
+ //Only for Image Element
+ if (iCurrentElement->ElemID() == KSvgImageElement)
+ {
+ // Keep track of embedded images
+ iEmbeddedImagesCount++;
+ ((CSvgImageElementImpl*)iCurrentElement)->SetUriL(lPtr);
+ ((CSvgImageElementImpl*)iCurrentElement)->LoadUriL();
+ }
+ CleanupStack::PopAndDestroy( 2 );
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeDiscardAttributeL (const TUint16& aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeDiscardAttributeL (const TUint16& aName)
+ {
+ if ( iCurrentElement->ElemID() != KSvgDiscardElement )
+ return EFalse;
+
+ TInt8 lCheck;
+ TInt16 lTemp;
+
+ if (aName== KAtrBegin)
+ {
+ // Flag is used to check for SyncValue flag.
+ iStream >> lCheck;
+ if ( lCheck )
+ {
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetSyncValueDefined(ETrue);
+ }
+ else
+ {
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetSyncValueDefined(EFalse);
+ }
+
+ // Flag is used to check for EventValue flag.
+ iStream >> lCheck;
+ if ( lCheck )
+ {
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetEventValueDefined(ETrue);
+ }
+ else
+ {
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetEventValueDefined(EFalse);
+ }
+
+
+ // Flag is used to check for SyncElement's id.
+ iStream >> lCheck;
+ if ( lCheck )
+ {
+ TPtrC lPtr(DecodeTDesCLC());
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetBeginSyncElementId(lPtr);
+ CleanupStack::PopAndDestroy( 1 );
+ }
+
+
+ iStream >> lTemp;
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetAbsoluteBeginTime(lTemp);
+
+ iStream >> lTemp;
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetRefBeginTime(lTemp);
+
+ iStream >> lTemp;
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetKeyValue(lTemp);
+
+ iStream >> lTemp;
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetBeginReferenceEvent((TSvgEvent)lTemp);
+
+ }
+ else
+ if (aName== KAtrXlinkhref)
+ {
+ // Flag is used to check for HrefValue flag.
+ iStream >> lCheck;
+ if ( lCheck )
+ {
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetHrefValueDefined(ETrue);
+ TPtrC lPtr(DecodeTDesCLC());
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetTargetId(lPtr);
+ CleanupStack::PopAndDestroy( 1 );
+ }
+ else
+ ((CSvgDiscardElementImpl*)iCurrentElement)->SetHrefValueDefined(EFalse);
+
+ }
+
+ return ETrue;
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeAttributeFloatL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeAttributeFloatL(const TUint16 aName)
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt lTemp;
+ lTemp.iValue = iStream.ReadInt32L();
+ iCurrentElement->SetAttributeFloatL( (TInt)aName, lTemp );
+ }
+ else
+ {
+ TReal32 lTemp;
+ iStream >> lTemp;
+ iCurrentElement->SetAttributeFloatL( (TInt)aName, (TFloatFixPt)lTemp );
+ }
+
+ return ETrue;
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeAttributeIntL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeAttributeIntL(const TUint16 aName)
+ {
+ TInt8 lTemp;
+ iStream >> lTemp;
+ iCurrentElement->SetAttributeIntL( (TInt)aName, (TInt32)lTemp );
+ return ETrue;
+ }
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeAttributePathL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeAttributePathL(const TUint16 aName)
+ {
+ CGfxGeneralPath* lPath;
+ DecodeAnimationPathL(lPath);
+
+ iCurrentElement->SetAttributePathRef( (TInt)aName, lPath);
+
+ return ETrue;
+ }
+
+
+// --------------------------------------------------------------------------
+// void CSvgDecoder::DecodeAnimationPathL(CGfxGeneralPath*& aPath)
+// ---------------------------------------------------------------------------
+void CSvgDecoder::DecodeAnimationPathL(CGfxGeneralPath*& aPath)
+ {
+
+ aPath = CGfxGeneralPath::NewLC();
+
+ {
+ const TInt KLargePathTypeCount = 4*256;
+
+ TUint16 typeCount = 0;
+ iStream >> typeCount;
+
+ /******************************************************************/
+ // Path Type
+ /******************************************************************/
+ RArray<TUint32>* pathTypeArray = NULL;
+ // Put path-type-array to path to handle cleanup
+ if ( typeCount == 0 )
+ {
+ pathTypeArray = new (ELeave)RArray<TUint32>( 1 );
+ aPath->SetPointTypeArrayRef( pathTypeArray );
+ }
+ else
+ {
+ pathTypeArray = new (ELeave)RArray<TUint32>( typeCount );
+ aPath->SetPointTypeArrayRef( pathTypeArray );
+ }
+
+ // Occurs only for very large paths
+ if ( typeCount > KLargePathTypeCount )
+ {
+ TUint8* byteData = new (ELeave) TUint8[typeCount];
+ CleanupArrayDeletePushL( byteData );
+
+ iStream.ReadL( byteData, typeCount );
+
+ for ( TInt i = 0; i < typeCount; i++ )
+ {
+
+ if(byteData[i] == EGfxEncodedSegMoveTo)
+ {
+ byteData[i] = EGfxSegMoveTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegLineTo )
+ {
+ byteData[i] = EGfxSegLineTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegQuadTo)
+ {
+ byteData[i] = EGfxSegQuadTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegCubicTo)
+ {
+ byteData[i] = EGfxSegCubicTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegClose)
+ {
+ byteData[i] = EGfxSegClose;
+ }
+ // Path will close RArray if Leave occurs
+ pathTypeArray->AppendL( byteData[i] );
+ }
+ //Transfering ownership to Path
+ aPath->PathSegmentTypeArray(byteData);
+ aPath->Count(typeCount);
+ CleanupStack::Pop( 1 );
+ //delete [] byteData;
+ }
+ else
+ {
+ TUint8 *byteData = new (ELeave) TUint8[KLargePathTypeCount];
+ CleanupArrayDeletePushL( byteData );
+ iStream.ReadL( byteData, typeCount );
+ for ( TInt i = 0; i < typeCount; i++ )
+ {
+
+ if(byteData[i] == EGfxEncodedSegMoveTo)
+ {
+ byteData[i] = EGfxSegMoveTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegLineTo )
+ {
+ byteData[i] = EGfxSegLineTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegQuadTo)
+ {
+ byteData[i] = EGfxSegQuadTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegCubicTo)
+ {
+ byteData[i] = EGfxSegCubicTo;
+ }
+ else if(byteData[i] == EGfxEncodedSegClose)
+ {
+ byteData[i] = EGfxSegClose;
+ }
+ // Path will close RArray if Leave occurs
+ pathTypeArray->AppendL( byteData[i] );
+ }
+ aPath->PathSegmentTypeArray(byteData);
+ aPath->Count(typeCount);
+ CleanupStack::Pop( 1 );
+ }
+ }
+
+ /******************************************************************/
+ // Path Points
+ /******************************************************************/
+ {
+ const TInt KLargePathPointsCount = 256;
+
+ TUint16 valueCount = 0;
+ iStream >> valueCount;
+
+ RArray<TFloatFixPt>* pathPointsArray = NULL;
+
+ if ( valueCount == 0 )
+ {
+ pathPointsArray = new (ELeave)RArray<TFloatFixPt>( 1 );
+ aPath->SetPointCoordsArrayRef( pathPointsArray );
+ }
+ else
+ {
+ pathPointsArray = new (ELeave)RArray<TFloatFixPt>( valueCount );
+ aPath->SetPointCoordsArrayRef( pathPointsArray );
+ }
+
+ if ( valueCount > KLargePathPointsCount )
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt* fixedData = new (ELeave) TFloatFixPt[valueCount];
+ CleanupArrayDeletePushL( fixedData );
+
+ TInt byteCount = sizeof( TFloatFixPt ) * valueCount;
+ iStream.ReadL( (TUint8*)fixedData, byteCount );
+
+ for ( TInt i = 0; i < valueCount; i++ )
+ {
+ // Path will close RArray if Leave occurs
+ pathPointsArray->AppendL( fixedData[i] );
+ }
+
+ CleanupStack::Pop( 1 ); // fixedData
+ delete [] fixedData;
+ }
+ else
+ {
+ TReal32* real32Data = new (ELeave) TReal32[valueCount];
+ CleanupArrayDeletePushL( real32Data );
+
+ TInt byteCount = sizeof( TReal32 ) * valueCount;
+ iStream.ReadL( (TUint8*)real32Data, byteCount );
+
+ for ( TInt i = 0; i < valueCount; i++ )
+ {
+ // Path will close RArray if Leave occurs
+ pathPointsArray->AppendL( (TFloatFixPt)real32Data[i] );
+ }
+
+ CleanupStack::Pop( 1 ); // real32Data
+ delete [] real32Data;
+ }
+ }
+ else
+ {
+ if (iIsFixPt)
+ {
+ TFloatFixPt fixedData[KLargePathPointsCount];
+ TInt byteCount = sizeof( TFloatFixPt ) * valueCount;
+ iStream.ReadL( (TUint8*)fixedData, byteCount );
+
+ for ( TInt i = 0; i < valueCount; i++ )
+ {
+ pathPointsArray->AppendL( fixedData[i] );
+ }
+ }
+ else
+ {
+ TReal32 real32Data[KLargePathPointsCount];
+ TInt byteCount = sizeof( TReal32 ) * valueCount;
+ iStream.ReadL( (TUint8*)real32Data, byteCount );
+
+ for ( TInt i = 0; i < valueCount; i++ )
+ {
+ pathPointsArray->AppendL( (TFloatFixPt)real32Data[i] );
+ }
+ }
+ }
+
+ }
+
+ CleanupStack::Pop( 1 ); // aPath
+ }
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeAttributeDesL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeAttributeDesL(const TUint16 aName)
+ {
+ iCurrentElement->SetAttributeDesL ((TInt)aName, DecodeTDesCLC());
+ CleanupStack::PopAndDestroy( 1 );
+ return ETrue;
+ }
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeStringCssValueL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeStringCssValueL(const TUint16 aName)
+ {
+
+ CCssValue* tParentValue = NULL;
+ CCssValue* tValue = NULL;
+
+ iCurrentElement->FindProperty ((TInt8)aName,tValue);
+
+ TPtrC lPtr(DecodeTDesCLC());
+
+ if(iCurrentElement->ElemID() == KSvgFontfaceElement)
+ {
+ ((CSvgFontFaceElementImpl *)iCurrentElement)->SetFontFamilyL(lPtr);
+ }
+
+ if(iCurrentElement!= iRootElement)
+ {
+ iCurrentParentElement->FindProperty ((TInt8)aName,tParentValue);
+ }
+
+ if (tParentValue == tValue || tValue == NULL)
+ {
+
+ if (iDocument)
+ {
+ tValue = iDocument->iMemoryManager->GetCssStrObjectL( lPtr );
+ }
+
+
+
+ CleanupStack::PopAndDestroy( 1 );// cleanup : for lPtr
+ iCurrentElement->SetPresentationAttribute ((TInt8)aName,tValue);
+ }
+ else
+ {
+ ((CStrCssValueImpl*)tValue)->SetValueL ( lPtr );
+ CleanupStack::PopAndDestroy( 1 );
+ }
+
+ return ETrue;
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeIntCssValueL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeIntCssValueL(const TUint16 aName)
+ {
+
+ TInt32 lInt32;
+ iStream >> lInt32;
+
+ CCssValue* tParentValue = NULL;
+ CCssValue* tValue = NULL;
+
+ iCurrentElement->FindProperty ((TInt8)aName,tValue);
+
+ if(iCurrentElement!= iRootElement)
+ {
+ iCurrentParentElement->FindProperty ((TInt8)aName,tParentValue);
+ }
+
+ if (tParentValue == tValue || tValue == NULL)
+ {
+
+ if (iDocument)
+ {
+ tValue = iDocument->iMemoryManager->GetCssIntObjectL( (TInt)lInt32 );
+ }
+
+ iCurrentElement->SetPresentationAttribute ((TInt8)aName,tValue);
+ }
+ else
+ {
+ ((CIntCssValueImpl*)tValue)->SetValueL ((TInt)lInt32);
+ }
+
+ return ETrue;
+ }
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeFloatCssValueL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeFloatCssValueL(const TUint16 aName)
+ {
+
+ if (iIsFixPt)
+ {
+ TFloatFixPt lFixed;
+ lFixed.iValue = iStream.ReadInt32L();
+
+ CCssValue* tParentValue = NULL;
+ CCssValue* tValue = NULL;
+
+ iCurrentElement->FindProperty ((TInt8)aName,tValue);
+
+ if(iCurrentElement!= iRootElement)
+ {
+ iCurrentParentElement->FindProperty ((TInt8)aName,tParentValue);
+ }
+
+ if (tParentValue == tValue || tValue == NULL)
+ {
+ if (iDocument)
+ {
+ tValue = iDocument->iMemoryManager->GetCssFloatObjectL( lFixed );
+ }
+
+ iCurrentElement->SetPresentationAttribute ((TInt8)aName,tValue);
+ }
+ else
+ {
+ ((CFloatCssValueImpl*)tValue)->SetValueL ( lFixed );
+ }
+ }
+ else
+ {
+ TReal32 lFlt32;
+ iStream >> lFlt32;
+
+ CCssValue* tParentValue = NULL;
+ CCssValue* tValue = NULL;
+
+ iCurrentElement->FindProperty ((TInt8)aName,tValue);
+
+ if(iCurrentElement!= iRootElement)
+ {
+ iCurrentParentElement->FindProperty ((TInt8)aName,tParentValue);
+ }
+
+ if (tParentValue == tValue || tValue == NULL)
+ {
+ if (iDocument)
+ {
+ tValue = iDocument->iMemoryManager->GetCssFloatObjectL((TFloatFixPt)lFlt32);
+ }
+
+ iCurrentElement->SetPresentationAttribute ((TInt8)aName,tValue);
+ }
+ else
+ {
+ ((CFloatCssValueImpl*)tValue)->SetValueL ((TFloatFixPt)lFlt32);
+ }
+ }
+
+ return ETrue;
+ }
+
+
+// --------------------------------------------------------------------------
+// TBool CSvgDecoder::DecodeColorCssValueL(const TUint16 aName)
+// ---------------------------------------------------------------------------
+TBool CSvgDecoder::DecodeColorCssValueL(const TUint16 aName)
+ {
+ TUint32 lColor;
+ iStream >> lColor;
+
+ // Shift from XBGR to XRGB
+ if(!iIsRGB)
+ {
+ lColor = ( lColor & 0xFF000000) |
+ ( (lColor & 0x00FF0000) >> 16 ) |
+ ( lColor & 0x0000FF00 ) |
+ ( (lColor & 0x000000FF) << 16 );
+ }
+
+ CCssValue* tParentValue = NULL;
+ CCssValue* tValue = NULL;
+
+ iCurrentElement->FindProperty ((TInt8)aName,tValue);
+
+ if(iCurrentElement!= iRootElement)
+ {
+ iCurrentParentElement->FindProperty ((TInt8)aName,tParentValue);
+ }
+
+ if (tParentValue == tValue || tValue == NULL)
+ {
+ if ( iDocument )
+ {
+ tValue = iDocument->iMemoryManager->GetCssClrObjectL();
+
+ CleanupStack::PushL(tValue); //cleanup
+
+ ((CClrCssValueImpl*)tValue)->CloneRGBValueL (lColor);
+ iCurrentElement->SetPresentationAttribute ((TInt8)aName,tValue);
+ CleanupStack::Pop(tValue); //cleanup
+ }
+ }
+ else
+ {
+ ((CClrCssValueImpl*)tValue)->CloneRGBValueL (lColor);
+ }
+
+ return ETrue;
+ }
+
+
+
+// --------------------------------------------------------------------------
+// void CSvgDecoder::SetPaintValueL (CCssValue*& aValue)
+// ---------------------------------------------------------------------------
+void CSvgDecoder::SetPaintValueL (CCssValue*& aValue)
+ {
+ TUint8 lCheckGradient;
+ iStream >> lCheckGradient;
+
+ if( lCheckGradient)
+ {
+ ((CPaintCssValueImpl *)aValue)->SetUrlflag();
+ ((CPaintCssValueImpl *)aValue)->SetUrlIdL( DecodeTDesCLC() );
+ CleanupStack::PopAndDestroy( 1 );
+ }
+ else
+ {
+ TUint32 lColor;
+ iStream >> lColor;
+ // Shift from XBGR to ARGB
+ if(!iIsRGB)
+ {
+ lColor = ( lColor & 0xFF000000) |
+ ( (lColor & 0x00FF0000) >> 16 ) |
+ ( lColor & 0x0000FF00 ) |
+ ( (lColor & 0x000000FF) << 16 );
+ }
+ ((CPaintCssValueImpl *)aValue)->CloneRGBValueL (lColor);
+ }
+ }
+
+
+
+
+
+// ==========================================================================
+// Start Decoding
+// ==========================================================================
+CSvgElementImpl* CSvgDecoder::StartDecodingL(CSvgDocumentImpl *aDocument,
+ CSvgErrorImpl& aError )
+ {
+
+ iDocument= aDocument;
+
+ iSvgError = &aError;
+ aError.SetErrorCode( ESvgNoError );
+
+ TUint32 lValidBinary;
+ iStream >> lValidBinary;
+
+ if (lValidBinary != KBinaryFile &&
+ lValidBinary != KBinaryFile2 &&
+ lValidBinary != KBinaryFile3 &&
+ lValidBinary != KBinaryFile4)
+ {
+ iSvgError->SetErrorCode ( ESvgbFileNotValid );
+ iSvgError->SetDescription( _L( "Not a valid binary file." ) );
+ iSvgError->SetIsWarning( EFalse );
+ return NULL;
+ }
+
+ if (lValidBinary == KBinaryFile2)
+ {
+ iIsFixPt = ETrue;
+ iIsRGB = EFalse;
+ }
+
+ if (lValidBinary == KBinaryFile3)
+ {
+ iIsFixPt = ETrue;
+ iIsRGB = ETrue;
+ }
+
+ if(lValidBinary == KBinaryFile4)
+ {
+ iIsFixPt = EFalse;
+ iIsRGB = ETrue;
+ }
+
+ TUint8 lElemId;
+ TUint16 lAttrName;
+
+ MXmlElement* newElement;
+
+ iStream >> lElemId;
+ while (lElemId != KEndSvgFile)
+ {
+
+ // checks end of element
+ while (lElemId==KEndElemIndex)
+ {
+ if ( iCurrentParentElement != iRootElement )
+ {
+ // Depth is decreased, so the current parent should be one level up
+ iCurrentParentElement = ( CSvgElementImpl * )
+ iCurrentParentElement->ParentNode();
+ }
+
+ iStream >> lElemId;
+ }
+
+ // checks for Cdata
+ if (lElemId == KCDataPresent)
+ {
+ iCurrentElement= iCurrentParentElement;
+ DecodeAttributeL((TUint16)KAtrCdata);
+ iStream >> lElemId;
+ continue;
+ }
+
+
+
+ //checks end of file.
+ if (lElemId == KEndSvgFile)
+ {
+ break;
+ }
+
+
+ newElement = iDocument->CreateElementL( lElemId );
+
+ if( newElement == NULL)
+ {
+ User::Leave(KErrCorrupt);
+ }
+
+ iCurrentElement = ( CSvgElementImpl * ) newElement;
+
+
+ if ( lElemId == KSvgSvgElement && !iRootElement )
+ {
+ iRootElement = iCurrentElement;
+
+ //CleanupStack::PushL(iRootElement);
+ iDocument->AppendChildL( newElement );
+ //CleanupStack::Pop(iRootElement);
+
+ }
+ // for all other elements
+ else
+ {
+ iCurrentParentElement->AppendChildL( newElement );
+ }
+
+ // Setting target element for animations
+ if( iCurrentElement->IsAnimatedElement() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetTarget( iCurrentParentElement);
+ // For media elements do not set iIsAnimElement as
+ // the Xlink:Href is for external files rather
+ // than internal elements
+ if (!( iCurrentElement->ElemID() >= KSvgMediaElemsStartIndex &&
+ iCurrentElement->ElemID() <= KSvgMediaElemsEndIndex ) )
+ {
+ iIsAnimElement= ETrue;
+ }
+ }
+
+
+ iStream >> lAttrName;
+
+ // for attribute list.
+ while (lAttrName!= KStartNewElem)
+ {
+ DecodeAttributeL(lAttrName);
+ iStream >> lAttrName;
+ }
+ if( iCurrentElement->ElemID() == KSvgStopElement)
+ {
+ if( ((CSvgElementImpl*)iCurrentElement->ParentNode()) != NULL )
+ {
+ if((((((CSvgElementImpl*)iCurrentElement->ParentNode())->ElemID()) == KSvgRadialGradientElement) ||
+ ((((CSvgElementImpl*)iCurrentElement->ParentNode())->ElemID()) == KSvgLinearGradientElement) ) )
+ {
+ CSvgGradientElementImpl *parent = ((CSvgGradientElementImpl *)iCurrentElement->ParentNode());
+
+ if(parent)
+ {
+ // Initialize the offset value to 0 if its still -1.
+ TFloatFixPt lOffsetValue;
+ TFloatFixPt lDefaultOffsetValue(-1);
+ TBuf<6> lAttributeName;
+ TBuf<1> lValueBuffer;
+
+ lAttributeName.Append(OFFSET);
+ lValueBuffer.Append(ZEROVALUE);
+
+ ((CSvgStopElementImpl*)iCurrentElement)->GetOffset( lOffsetValue );
+
+ // Offset Value of -1 indicates that Offset Attribute is not declared in
+ // stop element.
+ if( lOffsetValue == lDefaultOffsetValue )
+ {
+ // Deliberately calling SetAttributeL in place of SetAttributeFloatL as the latter inturn
+ // calls UpdateOffsetValues which should be called on any Stop element once it is added to
+ // to the Stop element array Owned by parent Gradient element.
+ ((CSvgStopElementImpl*)iCurrentElement)->SetAttributeL( lAttributeName, lValueBuffer );
+ }
+
+ // The function not only adds the element in Stop element array but also
+ // adjusts the offset values of all the previously added elements such that
+ // each gradient offset value is greater than the previous gradient stop's
+ // offset value.It calls UpdateOffsetValues to adjust the values.
+ ((CSvgGradientElementImpl *)parent)->AddStopElementInArray((CSvgStopElementImpl*)iCurrentElement);
+ }
+ }
+ }
+ }
+
+
+ if (iCurrentElement->ElemID() == KSvgUseElement)
+ {
+ ((CSvgUseElementImpl *)iCurrentElement)->SetReferenceElementL();
+ }
+/* else if (iCurrentElement->ElemID() == KSvgAnimationElement)
+ {
+ ((CSvgAnimationElementImpl *)iCurrentElement)->SetReferenceElementL();
+ if(((CSvgAnimationElementImpl *)iCurrentElement)->RecursionVariable())
+ {
+ iSvgError->SetErrorCode( ESvgDocumentNotValid );
+ iSvgError->SetIsWarning( EFalse );
+ iSvgError->SetDescription( _L( "Invalid Document \n" ) );
+ iSvgError->AppendDescription( _L("Animation element in loop") );
+ return iRootElement;
+ }
+ }
+*/
+ if (iCurrentElement->HasAnyTests())
+ {
+ iReqFetAttSysArray->AppendL(iCurrentElement);
+ }
+
+ if (iCurrentElement->ElemID() == KSvgSwitchElement)
+ {
+ iSwitchElementArray->AppendL(iCurrentElement);
+ }
+
+ // For DOM reuse
+ if( iCurrentElement->IsAnimatedElement() )
+ {
+ ((CSvgAnimationBase*)iCurrentElement)->SetOriginalValues_DOMReuse() ;
+ iAnimationElementArray->AppendL(iCurrentElement);
+ }
+
+
+ if( iCurrentElement->ElemID() >= KSvgLinearGradientElement &&
+ iCurrentElement->ElemID() <= KSvgStopElement )
+ {
+ iCurrentElement->SetAttributeIntL(KCSS_ATTR_DISPLAY,0);
+ }
+
+ if ( iCurrentElement->ElemID() == KSvgMpathElement &&
+ iCurrentParentElement->ElemID() == KSvgAnimateMotionElement &&
+ iSvgError->ErrorCode() == ESvgMissingRequiredAttribute &&
+ iSvgError->IsWarning()
+ )
+
+
+ {
+ iSvgError->SetErrorCode( ESvgNoError );
+ // add to event receiver list will have only one copy
+ iDocument->AddToEventReceiverListL( iCurrentParentElement, KSvgEventMaskTimer );
+ }
+
+ CheckRequiredAttributesL( lElemId);
+ iIsAnimElement= EFalse;
+
+ iCurrentParentElement = iCurrentElement;
+
+ iStream >> lElemId;
+
+ }
+ //Load Images
+
+ TInt lImageElementCnt = iImageElements.Count();
+ TInt lTotalImagesCount = lImageElementCnt + iEmbeddedImagesCount;
+ iDocument->SetImageElementsCount(lTotalImagesCount);
+ for( TInt index = 0 ; index < lImageElementCnt ; index++)
+ {
+ iImageElements[index]->LoadUriL();
+ }
+
+ if(iUseElementArray)
+ {
+ // support for forward reference in use element
+ TInt lCount = iUseElementArray->Count();
+ TInt lIndex= 0;
+ while(lIndex < lCount)
+ {
+ TPtrC tPtr2 = ((CSvgElementImpl*)iUseElementArray->operator[](lIndex))->Href();
+ TInt Pos1= tPtr2.Locate('#');
+ HBufC* tBufC = HBufC::NewLC( tPtr2.Length() );
+ TPtr tPtr3 ( tBufC->Des() );
+ tPtr3.Copy( tPtr2 );
+ tPtr3.TrimAll();
+ // remove '#'
+ if(Pos1 != KErrNotFound)
+ {
+ tPtr3.Delete(Pos1,1);
+ }
+ if(((CSvgUseElementImpl *)iUseElementArray->operator[](lIndex))->SetRefElemById(tPtr3) != KErrNotFound)
+ {
+ ((CSvgUseElementImpl *)iUseElementArray->operator[](lIndex))->SetReferenceElementL();
+
+ }
+ lIndex++;
+ CleanupStack::PopAndDestroy( 1 );
+ }
+ }
+ // support for forward reference in use element
+ if(iAnimRefElementArray)
+ {
+ TInt lCount = iAnimRefElementArray->Count();
+ TInt lIndex= 0;
+ while(lIndex < lCount)
+ {
+ TPtrC tPtr2 = ((CSvgElementImpl*)iAnimRefElementArray->operator[](lIndex))->Href();
+ ((CSvgAnimationBase *)iAnimRefElementArray->operator[](lIndex))->SetRefElemById(tPtr2);
+ lIndex++;
+ }
+ }
+
+ // For Animation elements
+ if (iAnimationElementArray)
+ {
+ TInt lCount = iAnimationElementArray->Count();
+ TInt lIndex = 0;
+ while(lIndex < lCount)
+ {
+ ((CSvgAnimationBase *)iAnimationElementArray->operator[](lIndex))->CheckBeginTime();
+ lIndex ++;
+ }
+ }
+ // Reset iCurrentElement, as it is no longer used
+ iCurrentElement = NULL;
+ RemoveFalseElements();
+ RemoveFalseSwitchCases();
+
+ return iRootElement;
+ }
+
+
+
+// --------------------------------------------------------------------------
+// void CSvgDecoder::CheckRequiredAttributesL(const TUint8 aName )
+// ---------------------------------------------------------------------------
+void CSvgDecoder::CheckRequiredAttributesL(const TUint8 aName )
+ {
+
+
+ if( iCurrentElement->iReqAttrFlag != 0)
+
+ {
+
+ iSvgError->SetErrorCode( ESvgMissingRequiredAttribute );
+ iSvgError->SetIsWarning( ETrue );
+ iSvgError->SetDescription( _L( "Missing required attribute \"" ) );
+ switch(iCurrentElement->iReqAttrFlag)
+ {
+ case KSVG_PATH_ELEMFLAG:
+ iSvgError->AppendDescription( _L("d") );
+ break;
+ case KAtrWidth:
+ iSvgError->AppendDescription( _L("width") );
+ break;
+ case KAtrHeight:
+ iSvgError->AppendDescription( _L("height") );
+ break;
+ case KSVG_POLYLINE_ELEMFLAG:
+ iSvgError->AppendDescription( _L("points") );
+ break;
+ case KAtrRy:
+ iSvgError->AppendDescription( _L("Ry") );
+ break;
+ case KAtrRx:
+ iSvgError->AppendDescription( _L("Rx") );
+ break;
+ case KAtrSVGRec:
+ iSvgError->AppendDescription( _L("width") );
+ iSvgError->AppendDescription( _L( "\" and \"" ) );
+ iSvgError->AppendDescription(_L("height"));
+ break;
+ case KAtrSVGElp:
+ iSvgError->AppendDescription( _L("Rx") );
+ iSvgError->AppendDescription( _L( "\" and \"" ) );
+ iSvgError->AppendDescription(_L("Ry"));
+ break;
+ case KAtrSVGTrf:
+ iSvgError->AppendDescription( _L("attributeName") );
+ iSvgError->AppendDescription( _L( "\" and \"" ) );
+ iSvgError->AppendDescription(_L("type"));
+ break;
+ case KSVG_ANIMATE_ELEMFLAG:
+ iSvgError->AppendDescription( _L("attributeName") );
+ break;
+ case KSVG_CIRCLE_ELEMFLAG:
+ iSvgError->AppendDescription( _L("r") );
+ break;
+ case KSVG_HKERN_ELEMFLAG:
+ iSvgError->AppendDescription( _L("k") );
+ break;
+ case KAtrType:
+ iSvgError->AppendDescription( _L("type") );
+ break;
+ case KAtrXlinkhref:
+ iSvgError->AppendDescription (_L("Xlink:href"));
+ break;
+ case KAtrSVGAmo:
+ iSvgError->AppendDescription( _L("path") );
+ ((CSvgDocumentImpl*)iDocument)->RemoveFromEventReceiverList( iCurrentElement );
+ break;
+ case KAtrToBy:
+ iSvgError->AppendDescription( _L("to/by") );
+ ((CSvgDocumentImpl*)iDocument)->RemoveFromEventReceiverList( iCurrentElement );
+ break;
+ }
+ iSvgError->AppendDescription( _L( "\" for <" ) );
+ // access schema data to get the name of the attribute which is missing
+ // currently the error msg doesnt not report the name of the attribute
+
+ TBuf<20> lElemName = _L("svg");
+ ((CSvgDocumentImpl*)iDocument)->SchemaData()->GetSVGElementName(aName,lElemName);
+ iSvgError->AppendDescription( lElemName );
+ iSvgError->AppendDescription( _L( ">." ) );
+ // turn off element
+
+ ((CSvgElementImpl*)iCurrentElement)->SetTurnOff( ETrue );
+
+ ((CSvgElementImpl*)iCurrentElement)->SetPropertyL(KCSS_ATTR_DISPLAY,_L("none"));
+
+
+ }
+ }
+
+//---------------------------------------------------
+//Removal of elements that dont pass
+//required extensions, required features, and system language
+//requirements
+//switch statement is special case were only the first one
+//that passes these requirements will be used so toss the rest
+//---------------------------------------------------
+void CSvgDecoder::RemoveFalseElements()
+ {
+ if (iReqFetAttSysArray == NULL)
+ {
+ // Error Case
+ return;
+ }
+
+ //loop through the list of elements with required features, attributes, or sys language
+ TInt reqFetSysArrayCnt = iReqFetAttSysArray->Count();
+ while ( reqFetSysArrayCnt > 0 )
+ {
+ CSvgElementImpl* lCurElement = ( CSvgElementImpl* )
+ iReqFetAttSysArray->operator[]( reqFetSysArrayCnt - 1 );
+
+ if ( lCurElement != NULL )
+ {
+ CSvgElementImpl* lCurParent = ( CSvgElementImpl* )
+ lCurElement->ParentNode();
+
+ //just a normal element check it and remove it if it doesnt pass
+ TBool lResult = EFalse;
+ TRAPD( error, lResult = VerifyReqExReqFtrSysL( lCurElement ) );
+ if ( error == KErrNone && !lResult )
+ {
+ // Remove internal references to the element about to be
+ // removed
+ // This function would also remove the lCurElement from
+ // iReqFetAttSysArray.
+ RemoveInternalReferences( lCurElement );
+ //element doesnt have proper required extension, attributes, or system language
+ lCurParent->RemoveChild( lCurElement );
+ delete (CXmlElementImpl*)lCurElement;
+ lCurElement = NULL;
+ }
+ else
+ {
+ // Remove the last element from the array as it is processed
+ iReqFetAttSysArray->Remove( reqFetSysArrayCnt - 1 );
+ } // if ( error == KErrNone && !lResult )
+ }
+ else
+ {
+ // Remove the last element from the array as it is processed
+ iReqFetAttSysArray->Remove( reqFetSysArrayCnt - 1 );
+ } // if ( lCurElement != NULL )
+ // Update the count of elements in the array
+ reqFetSysArrayCnt = iReqFetAttSysArray->Count();
+ } // while ( reqFetSysArrayCnt > 0 )
+ // Clear the array as it is no longer required.
+ iReqFetAttSysArray->Reset();
+ }
+
+// --------------------------------------------------------------------------
+// void CSvgDecoder::RemoveFalseSwitchCases()
+// ---------------------------------------------------------------------------
+void CSvgDecoder::RemoveFalseSwitchCases()
+ {
+ if (iSwitchElementArray == NULL)
+ {
+ // Error Case
+ return;
+ }
+
+ TInt switchEleArrayCnt = iSwitchElementArray->Count();
+ while ( switchEleArrayCnt > 0 )
+ {
+ TBool foundTrue = EFalse;
+ CSvgElementImpl* curSwitchElem = ( CSvgElementImpl* )
+ iSwitchElementArray->operator[]( switchEleArrayCnt - 1 );
+
+ if ( curSwitchElem != NULL )
+ {
+ //get the first child...which is where the first
+ CSvgElementImpl* curCaseElem = (CSvgElementImpl*)curSwitchElem->FirstChild();
+
+ while ( curCaseElem != NULL )
+ {
+ CSvgElementImpl* nextCaseElem = (CSvgElementImpl*)curCaseElem->NextSibling();
+ // foundTrue is set to TRUE when an element whose test passes is found. The
+ // subsequent elements are to be removed.
+ if ( foundTrue )
+ {
+ // Remove internal references of the element from
+ // decoder's lists
+ RemoveInternalReferences( curCaseElem );
+ //already found the true case in the switch delete the rest
+ curSwitchElem->RemoveChild( curCaseElem );
+ delete ( CXmlElementImpl* )curCaseElem;
+ curCaseElem = NULL;
+ }
+ else
+ {
+ TBool lResult = EFalse;
+ TRAPD(error, lResult = VerifyReqExReqFtrSysL(curCaseElem));
+ if ( error == KErrNone && !lResult )
+ {
+ // Remove internal references of the element from
+ // decoder's lists
+ RemoveInternalReferences( curCaseElem );
+ //this element doesnt meet the switch requirements delete it and its children
+ curSwitchElem->RemoveChild(curCaseElem);
+ delete (CXmlElementImpl*)curCaseElem;
+ curCaseElem = NULL;
+ }
+ else
+ {
+ //one evaluated to true so keep it but go ahead and delete the rest in the switch
+ //should only be one child for switch in end
+ foundTrue = ETrue;
+ } // if ( error == KErrNone && !lResult )
+ } // if ( foundTrue )
+ // Proceed checking the next sibling
+ curCaseElem = nextCaseElem;
+ } // while ( curCaseElem != NULL )
+ } // if ( curSwitchElem != NULL )
+ // Remove the last switch element which was processed
+ iSwitchElementArray->Remove( switchEleArrayCnt - 1 );
+ // Update the count of the array
+ switchEleArrayCnt = iSwitchElementArray->Count();
+ } // while ( switchEleArrayCnt > 0 )
+ // Clear the array as it is no longer needed
+ iSwitchElementArray->Reset();
+ }
+
+//---------------------------------------------------
+//Check to see
+//required extensions, required features, and system language
+//requirements
+//---------------------------------------------------
+TBool CSvgDecoder::VerifyReqExReqFtrSysL( CSvgElementImpl* aElement )
+{
+ const CDesCArrayFlat* tempTestArray = NULL; // 'const' keyword added due to S60 (CW) build team recommendation
+
+ TBool doDraw = ETrue;
+
+ // First check for requiredExtensions
+ aElement->GetRequiredExtensions( tempTestArray );
+
+ if ( tempTestArray && tempTestArray->MdcaCount() )
+ {
+ // Check for all entries in requiredExtensions
+
+ TInt lCount = tempTestArray->MdcaCount();
+
+ for ( TInt i = 0; i < lCount; i++ )
+ {
+ TPtrC tmpPtr = tempTestArray->MdcaPoint( i );
+ if ( tmpPtr.Length() )
+ {
+ doDraw = EFalse;
+ break;
+ }
+ else if ( aElement->HasExtension( tmpPtr ) == EFalse )
+ {
+ doDraw = EFalse;
+ break;
+ }
+ }
+ }
+
+ // Second, check for requiredFeatures
+ aElement->GetRequiredFeatures( tempTestArray );
+ if ( tempTestArray && tempTestArray->MdcaCount() && doDraw)
+ {
+ // Check for all entries in requiredFeatures
+ TInt lCount = tempTestArray->MdcaCount();
+ for ( TInt i = 0; i < lCount; i++ )
+ {
+ TPtrC tmpPtr = tempTestArray->MdcaPoint( i );
+ if ( aElement->HasFeature( tmpPtr ) == EFalse )
+ {
+ doDraw = EFalse;
+ break;
+ }
+ }
+ }
+
+ TBufC<5> iSystemLanguage;
+ SystemLanguage( iSystemLanguage.Des() );
+
+ // Third, check for systemLanguage
+ // Future enhancement: System language doesnt need to be stored in seperate array indexes
+ // could have just stored it as one big string and use findf without the loop
+ aElement->GetSystemLanguage( tempTestArray );
+ TBool doDrawSystem = EFalse;
+ if ( tempTestArray && tempTestArray->MdcaCount() && doDraw)
+ {
+ TInt lCount = tempTestArray->MdcaCount();
+
+ for ( TInt i = 0; i < lCount; i++ )
+ {
+ TPtrC tmpPtr = tempTestArray->MdcaPoint( i );
+
+ if ( tmpPtr.FindF( iSystemLanguage ) >= 0 )
+ {
+ doDrawSystem = ETrue;
+ break;
+ }
+ }
+
+ if (doDrawSystem == EFalse)
+ {
+ doDraw = EFalse;
+ }
+ }
+
+ return doDraw;
+}
+
+// --------------------------------------------------------------------------
+// void CSvgDecoder::SystemLanguage( TPtr aValue )
+// ---------------------------------------------------------------------------
+void CSvgDecoder::SystemLanguage( TPtr aValue )
+ {
+ _LIT( KEn, "en" );
+ _LIT( KFr, "fr" );
+ _LIT( KDe, "de" );
+ _LIT( KEs, "es" );
+
+ _LIT( KAf, "af" );
+ _LIT( KAm, "am" );
+ _LIT( KAr, "ar" );
+ _LIT( KBg, "bg" );
+ _LIT( KBn, "bn" );
+ _LIT( KBo, "bo" );
+ _LIT( KCa, "ca" );
+ _LIT( KCs, "cs" );
+ _LIT( KCy, "cy" );
+ _LIT( KDa, "da" );
+ _LIT( KEl, "el" );
+ _LIT( KEt, "et" );
+ _LIT( KFa, "fa" );
+ _LIT( KFi, "fi" );
+ _LIT( KGa, "ga" );
+ _LIT( KGd, "gd" );
+ _LIT( KGu, "gu" );
+ _LIT( KHe, "he" );
+ _LIT( KHi, "hi" );
+ _LIT( KHu, "hu" );
+ _LIT( KHr, "hr" );
+ _LIT( KHy, "hy" );
+ _LIT( KId, "id" );
+ _LIT( KIs, "is" );
+ _LIT( KIt, "it" );
+ _LIT( KJa, "ja" );
+ _LIT( KKa, "ka" );
+ _LIT( KKk, "kk" );
+ _LIT( KKm, "km" );
+ _LIT( KKn, "kn" );
+ _LIT( KKo, "ko" );
+ _LIT( KLo, "lo" );
+ _LIT( KLt, "lt" );
+ _LIT( KLv, "lv" );
+ _LIT( KMk, "mk" );
+ _LIT( KMl, "ml" );
+ _LIT( KMn, "mn" );
+ _LIT( KMo, "mo" );
+ _LIT( KMr, "mr" );
+ _LIT( KMs, "ms" );
+ _LIT( KMy, "my" );
+ _LIT( KNo, "no" );
+ _LIT( KNl, "nl" );
+ _LIT( KPa, "pa" );
+ _LIT( KPl, "pl" );
+ _LIT( KPt, "pt" );
+ _LIT( KRo, "ro" );
+ _LIT( KRu, "ru" );
+ _LIT( KSi, "si" );
+ _LIT( KSk, "sk" );
+ _LIT( KSl, "sl" );
+ _LIT( KSo, "so" );
+ _LIT( KSr, "sr" );
+ _LIT( KSq, "sq" );
+ _LIT( KSv, "sv" );
+ _LIT( KSw, "sw" );
+ _LIT( KTa, "ta" );
+ _LIT( KTe, "te" );
+ _LIT( KTh, "th" );
+ _LIT( KTi, "ti" );
+ _LIT( KTk, "tk" );
+ _LIT( KTl, "tl" );
+ _LIT( KTr, "tr" );
+ _LIT( KUk, "uk" );
+ _LIT( KUr, "ur" );
+ _LIT( KVi, "vi" );
+ //_LIT( KZh, "zh" );
+ _LIT( KZu, "zu" );
+
+ _LIT( KEnB, "en-UK");
+ _LIT( KEnUS, "en-US");
+ _LIT( KZhTW, "zh-TW");
+ _LIT( KZhHK, "zh-HK");
+ _LIT( KZhCN, "zh-CN");
+ _LIT( KFrCA, "fr-CA");
+ _LIT( KPtBR, "pt-BR");
+ _LIT( KEnTW, "en-TW");
+ _LIT( KEnHK, "en-HK");
+ _LIT( KEnCN, "en-CN");
+ _LIT( KEnJP, "en-JP");
+ _LIT( KEnTH, "en-TH");
+ _LIT( KEsAR, "es-AR");
+ _LIT( KMsAP, "ms-AP");
+ _LIT( KEnAP, "en-AP" ); // KLangApacEnglish
+ _LIT( KIdAP, "id-AP" ); // KLangApacIndonesian
+ _LIT( KEu, "eu" ); // KLangBasque
+ _LIT( KGl, "gl" ); // KLangGalician
+
+ _LIT(KDefault, "qqqqq");
+
+ switch ( User::Language() )
+ {
+ case ELangTest:
+ aValue = KEn;
+ break;
+
+ case ELangEnglish:
+ aValue = KEnB;
+ break;
+ case ELangAmerican:
+ aValue = KEnUS;
+ break;
+ case ELangAustralian:
+ case ELangNewZealand:
+ case ELangCanadianEnglish:
+ case ELangSouthAfricanEnglish:
+ case ELangInternationalEnglish:
+ aValue = KEn;
+ break;
+
+ case ELangFrench:
+ case ELangSwissFrench:
+ case ELangBelgianFrench:
+ aValue = KFr;
+ break;
+
+ case ELangGerman:
+ case ELangAustrian:
+ case ELangSwissGerman:
+ aValue = KDe;
+ break;
+
+ case ELangSpanish:
+ case ELangInternationalSpanish:
+ aValue = KEs;
+ break;
+
+ case ELangLatinAmericanSpanish:
+ aValue = KEsAR;
+ break;
+
+ case ELangItalian:
+ case ELangSwissItalian:
+ aValue = KIt;
+ break;
+
+ case ELangSwedish:
+ case ELangFinlandSwedish:
+ aValue = KSv;
+ break;
+
+ case ELangDanish:
+ aValue = KDa;
+ break;
+
+ case ELangNorwegian:
+ case ELangNorwegianNynorsk:
+ aValue = KNo;
+ break;
+
+ case ELangFinnish:
+ aValue = KFi;
+ break;
+
+ case ELangBrazilianPortuguese:
+ aValue = KPtBR;
+ break;
+
+ case ELangPortuguese:
+ aValue = KPt;
+ break;
+
+ case ELangTurkish:
+ case ELangCyprusTurkish:
+ aValue = KTr;
+ break;
+
+ case ELangIcelandic:
+ aValue = KIs;
+ break;
+
+ case ELangRussian:
+ case ELangBelarussian:
+ aValue = KRu;
+ break;
+
+ case ELangHungarian:
+ aValue = KHu;
+ break;
+
+ case ELangDutch:
+ case ELangBelgianFlemish:
+ aValue = KNl;
+ break;
+
+ case ELangCzech:
+ aValue = KCs;
+ break;
+
+ case ELangSlovak:
+ aValue = KSk;
+ break;
+
+ case ELangPolish:
+ aValue = KPl;
+ break;
+
+ case ELangSlovenian:
+ aValue = KSl;
+ break;
+
+ case ELangPrcChinese:
+ aValue = KZhCN;
+ break;
+ case ELangTaiwanChinese:
+ aValue = KZhTW;
+ break;
+ case ELangHongKongChinese:
+ aValue = KZhHK;
+ break;
+
+ case ELangJapanese:
+ aValue = KJa;
+ break;
+
+ case ELangThai:
+ aValue = KTh;
+ break;
+
+ case ELangAfrikaans:
+ aValue = KAf;
+ break;
+
+ case ELangAlbanian:
+ aValue = KSq;
+ break;
+
+ case ELangAmharic:
+ aValue = KAm;
+ break;
+
+ case ELangArabic:
+ aValue = KAr;
+ break;
+
+ case ELangArmenian:
+ aValue = KHy;
+ break;
+
+ case ELangTagalog:
+ aValue = KTl;
+ break;
+
+ case ELangBengali:
+ aValue = KBn;
+ break;
+
+ case ELangBulgarian:
+ aValue = KBg;
+ break;
+
+ case ELangBurmese:
+ aValue = KMy;
+ break;
+
+ case ELangCatalan:
+ aValue = KCa;
+ break;
+
+ case ELangCroatian:
+ aValue = KHr;
+ break;
+
+ case ELangEstonian:
+ aValue = KEt;
+ break;
+
+ case ELangFarsi:
+ aValue = KFa;
+ break;
+
+ case ELangCanadianFrench:
+ aValue = KFrCA;
+ break;
+
+ case ELangScotsGaelic:
+ aValue = KGd;
+ break;
+
+ case ELangGeorgian:
+ aValue = KKa;
+ break;
+
+ case ELangGreek:
+ case ELangCyprusGreek:
+ aValue = KEl;
+ break;
+
+ case ELangGujarati:
+ aValue = KGu;
+ break;
+
+ case ELangHebrew:
+ aValue = KHe;
+ break;
+
+ case ELangHindi:
+ aValue = KHi;
+ break;
+
+ case ELangIndonesian:
+ aValue = KId;
+ break;
+
+ case ELangIrish:
+ aValue = KGa;
+ break;
+
+ case ELangKannada :
+ aValue = KKn;
+ break;
+
+
+ case ELangKazakh:
+ aValue = KKk;
+ break;
+
+ case ELangKhmer:
+ aValue = KKm;
+ break;
+
+ case ELangKorean:
+ aValue = KKo;
+ break;
+
+ case ELangLao:
+ aValue = KLo;
+ break;
+
+ case ELangLatvian:
+ aValue = KLv;
+ break;
+
+ case ELangLithuanian:
+ aValue = KLt;
+ break;
+
+ case ELangMacedonian:
+ aValue = KMk;
+ break;
+
+ case ELangMalay:
+ aValue = KMs;
+ break;
+
+ case ELangMalayalam:
+ aValue = KMl;
+ break;
+
+ case ELangMarathi:
+ aValue = KMr;
+ break;
+
+ case ELangMoldavian:
+ aValue = KMo;
+ break;
+
+ case ELangMongolian:
+ aValue = KMn;
+ break;
+
+ case ELangPunjabi:
+ aValue = KPa;
+ break;
+
+ case ELangRomanian:
+ aValue = KRo;
+ break;
+
+ case ELangSerbian:
+ aValue = KSr;
+ break;
+
+ case ELangSinhalese:
+ aValue = KSi;
+ break;
+
+ case ELangSomali:
+ aValue = KSo;
+ break;
+
+ case ELangSwahili:
+ aValue = KSw;
+ break;
+
+ case ELangTamil:
+ aValue = KTa;
+ break;
+
+ case ELangTelugu:
+ aValue = KTe;
+ break;
+
+ case ELangTibetan:
+ aValue = KBo;
+ break;
+
+ case ELangTigrinya:
+ aValue = KTi;
+ break;
+
+ case ELangTurkmen:
+ aValue = KTk;
+ break;
+
+ case ELangUkrainian:
+ aValue = KUk;
+ break;
+
+ case ELangUrdu:
+ aValue = KUr;
+ break;
+
+ case ELangVietnamese:
+ aValue = KVi;
+ break;
+
+ case ELangWelsh:
+ aValue = KCy;
+ break;
+
+ case ELangZulu:
+ aValue = KZu;
+ break;
+
+ // from \\epoc32\\include\\oem\\languages.hrh
+
+ case KLangTaiwanEnglish:
+ aValue = KEnTW;
+ break;
+
+ case KLangHongKongEnglish:
+ aValue = KEnHK;
+ break;
+
+ case KLangPrcEnglish:
+ aValue = KEnCN;
+ break;
+
+ case KLangJapaneseEnglish:
+ aValue = KEnJP;
+ break;
+
+ case KLangThaiEnglish:
+ aValue = KEnTH;
+ break;
+
+ case KLangApacMalay:
+ aValue = KMsAP;
+ break;
+
+ case KLangApacEnglish:
+ {
+ aValue = KEnAP;
+ break;
+ }
+ case KLangApacIndonesian:
+ {
+ aValue = KIdAP;
+ break;
+ }
+ case KLangBasque:
+ {
+ aValue = KEu;
+ break;
+ }
+ case KLangGalician:
+ {
+ aValue = KGl;
+ break;
+ }
+
+ // Cingular English
+ case 6154:
+ aValue = KEnUS;
+ break;
+
+ default:
+ aValue = KDefault;
+ break;
+ }
+ }
+
+// --------------------------------------------------------------------------
+// TInt CSvgDecoder::RemoveInternalReferences( CSvgElementImpl* )
+// ---------------------------------------------------------------------------
+void CSvgDecoder::RemoveInternalReferences( CSvgElementImpl* aElement )
+ {
+ // Remove the references of aElement in content handler's lists
+
+ // Use Elements
+ TInt lIndex = 0;
+ if ( aElement->ElemID() == KSvgUseElement )
+ {
+ lIndex = iUseElementArray->Find( aElement );
+ if ( lIndex != KErrNotFound )
+ {
+ iUseElementArray->Remove( lIndex );
+ }
+ }
+ else if ( aElement->ElemID() == KSvgSwitchElement )
+ {
+ // Switch Elements
+ lIndex = iSwitchElementArray->Find( aElement );
+ if ( lIndex != KErrNotFound )
+ {
+ iSwitchElementArray->Remove( lIndex );
+ }
+ }
+ else if ( aElement->IsAnimatedElement() )
+ {
+ // Animation elements include animate* elements, set,
+ // "animation", audio elements etc.
+ lIndex = iAnimationElementArray->Find( aElement );
+ if ( lIndex != KErrNotFound )
+ {
+ iAnimationElementArray->Remove( lIndex );
+ }
+ lIndex = iAnimRefElementArray->Find( aElement );
+ if ( lIndex != KErrNotFound )
+ {
+ iAnimRefElementArray->Remove( lIndex );
+ }
+ }
+ // Elements with test attributes - requiredFeatures,
+ // requiredExtensions, systemLanguage
+ lIndex = iReqFetAttSysArray->Find( aElement );
+ if ( lIndex != KErrNotFound )
+ {
+ iReqFetAttSysArray->Remove( lIndex );
+ }
+
+ // Remove Internal references of subtree elements as well
+ CSvgElementImpl* lChild = ( CSvgElementImpl* )aElement->FirstChild();
+ while ( lChild != NULL )
+ {
+ RemoveInternalReferences( lChild );
+ lChild = ( CSvgElementImpl* )lChild->NextSibling();
+ }
+
+ }