diff -r 000000000000 -r 88edb906c587 svgtopt/SVG/SVGEngine/src/Svgdecoder.cpp --- /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 +#include +#include +#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 + +_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 (1); + iUseElementArray->Reset(); + + iAnimRefElementArray = new (ELeave)RPointerArray (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 (1); + iUseElementArray->Reset(); + + iAnimRefElementArray = new (ELeave)RPointerArray (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 (1); + iSwitchElementArray->Reset(); + + // Arrays added to reset event listeners for animation element + iAnimationElementArray = new (ELeave)RPointerArray (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 (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* lArrayFix; + TInt8 lCount; + iStream >> lCount; + if (lCount) + { + lArrayFix= new ( ELeave ) CArrayFixFlat( lCount ); + } + else + { + lArrayFix= new ( ELeave ) CArrayFixFlat( 1 ); + } + + CleanupStack::PushL(lArrayFix); //cleanup + + TFloatFixPt lTempFix; + TReal32 lTempReal; + + for(TInt8 i=0; iAppendL( 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* lArrayFix; + TInt8 lCount; + iStream >> lCount; + if (lCount) + { + lArrayFix= new ( ELeave ) CArrayFixFlat( lCount ); + } + else + { + lArrayFix= new ( ELeave ) CArrayFixFlat( 1 ); + } + + CleanupStack::PushL(lArrayFix); //cleanup + + for(TInt8 i=0; iAppendL( lTemp ); + } + else + { + TReal32 lTemp; + iStream >> lTemp ; + lArrayFix->AppendL( (TFloatFixPt) lTemp); + } + + } + + ((CSvgTextElementImpl*)iCurrentElement)->SetXYArray(aName,lArrayFix); + CleanupStack::Pop(lArrayFix); //cleanup + return ETrue; + } + } + + + if( aNameiReqAttrFlag =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* lArray; + iStream >> lCount; + if(lCount) + { + lArray= new ( ELeave ) CArrayFixFlat( lCount ); + CleanupStack::PushL(lArray); //cleanup + for (TInt i=0; i> 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* lEventList; + RArray* lTimeList; + // event list + iStream >> lCount; + if (lCount) + { + lEventList= new (ELeave) CArrayFixFlat(lCount); + } + else + { + lEventList= new (ELeave) CArrayFixFlat(1); + } + + CleanupStack::PushL(lEventList); //cleanup + + for( TInt i=0; i> 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(lCount); + } + else + { + lTimeList= new (ELeave) RArray(1); + } + + // For proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->SetBeginTimeList(lTimeList); + lTimeList->AppendL(NULL); + lTimeList->Remove(0); + + for( TInt i=0; i> 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* lTimeList; + // event list + + lTimeList= new (ELeave) CArrayFixFlat(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* lTimeList; + // event list + iStream >> lCount; + if (lCount) + { + lTimeList= new (ELeave) CArrayFixFlat(lCount); + } + else + { + lTimeList= new (ELeave) CArrayFixFlat(1); + } + + CleanupStack::PushL(lTimeList); //cleanup + + for( TInt i=0; i> 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: + // . +/- + ((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* lValues= NULL; + + iStream >>lCount; + if (lCount) + { + lValues= new (ELeave) RArray(lCount); + } + else + { + lValues= new (ELeave) RArray(1); + } + + // for proper cleanup + ((CSvgAnimateTransformElementImpl*)iCurrentElement)->SetTransformValues(lValues); + CSvgAnimateTransformElementImpl::TMatrixData lMatrix1; + lValues->AppendL(lMatrix1); + lValues->Remove(0); + + for (TInt i=0; i> 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* lArray; + TUint16 lCount; + iStream >> lCount; + if (lCount) + { + lArray= new (ELeave) RArray(lCount); + } + else + { + lArray= new (ELeave) RArray(1); + } + + // for proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->SetFloatValuesArray(lArray); + lArray->AppendL(NULL); + lArray->Remove(0); + + TFloatFixPt lValueFix; + TReal32 lValueFloat; + + for(TInt i=0; iAppendL( lValueFix ); + } + else + { + iStream >> lValueFloat; + lArray->AppendL((TFloatFixPt) lValueFloat); + } + + } + break; + } + case KSvgTypeList: + case KSvgTypePath: + { + TUint16 lCount; + RPointerArray* lArray; + iStream >> lCount; + if (lCount) + { + lArray= new (ELeave) RPointerArray(lCount); + } + else + { + lArray= new (ELeave) RPointerArray(1); + } + + // for proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->ResetFloatValuesArray(); + ((CSvgAnimationBase*)iCurrentElement)->SetPathValuesArray(lArray); + lArray->AppendL(NULL); + lArray->Remove(0); + for(TInt i=0; iAppendL( (CGfxGeneralPath*)lPath ); + } + break; + } + + case KSvgTypeColor: + { + RArray* lArray; + TUint16 lCount; + iStream >> lCount; + if (lCount) + { + lArray= new (ELeave) RArray(lCount); + } + else + { + lArray= new (ELeave) RArray(1); + } + + // for proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->ResetFloatValuesArray(); + ((CSvgAnimationBase*)iCurrentElement)->SetIntValuesArray(lArray); + lArray->AppendL(NULL); + lArray->Remove(0); + + for(TInt i=0; i> 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* lArray; + TUint16 lCount; + iStream >> lCount; + if (lCount) + { + lArray= new (ELeave) RArray(lCount); + } + else + { + lArray= new (ELeave) RArray(1); + } + + // for proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->ResetFloatValuesArray(); + ((CSvgAnimationBase*)iCurrentElement)->SetIntValuesArray(lArray); + lArray->AppendL(NULL); + lArray->Remove(0); + + for(TInt i=0; i> lValue; + lArray->AppendL((TInt32) lValue); + } + break; + } + + // viewBox + case KSvgTypeViewBox: + { + RArray* lArray; + TUint16 lCount; + iStream >> lCount; + if (lCount) + { + lArray= new (ELeave) RArray(lCount); + } + else + { + lArray= new (ELeave) RArray(1); + } + TGfxRectangle2D temp1; + // for proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->SetViewBoxValuesArray(lArray); + lArray->AppendL(temp1); + lArray->Remove(0); + + + TGfxRectangle2D temp; + TReal32 lValueFloat; + for(TInt i=0; iAppendL((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* lArray; + iStream >> lCount; + if (lCount) + { + ((CSvgAnimationBase*)iCurrentElement)->SetKeyTimeFlag(); + lArray= new (ELeave) RArray(lCount); + } + else + { + lArray= new (ELeave) RArray(1); + } + CSvgAnimTimeController::TKeyTime lTime1; + // for proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->SetKeyTimeArray(lArray); + lArray->AppendL(lTime1); + lArray->Remove(0); + + for (TInt i=0; i> lTemp; + lTime.iX = (TUint16) (lTemp); + iStream >> lTemp; + lTime.iY = (TUint16) (lTemp); + lArray->AppendL( (CSvgAnimTimeController::TKeyTime) lTime); + } + return ETrue; + } + + if (aName== KAtrKeySplines) + { + TUint16 lCount; + RArray* lArray; + RArray* lAnimArray; + + // keyTime Array + iStream >> lCount; + if (lCount) + { + lArray= new (ELeave) RArray(lCount); + } + else + { + lArray= new (ELeave) RArray(1); + } + CSvgAnimTimeController::TKeyTime lTime1; + // for proper cleanup + ((CSvgAnimationBase*)iCurrentElement)->SetKeyTimeArray(lArray); + lArray->AppendL(lTime1); + lArray->Remove(0); + for (TInt i=0; i> 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(lCount); + } + else + { + lAnimArray= new (ELeave) RArray(1); + } + + ((CSvgAnimationBase*)iCurrentElement)->SetAnimTimeArray(lAnimArray); + lAnimArray->AppendL(NULL); + lAnimArray->Remove(0); + + for (TInt i=0; i> 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(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; iAppendL((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 (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 (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 (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* pathTypeArray = NULL; + // Put path-type-array to path to handle cleanup + if ( typeCount == 0 ) + { + pathTypeArray = new (ELeave)RArray( 1 ); + aPath->SetPointTypeArrayRef( pathTypeArray ); + } + else + { + pathTypeArray = new (ELeave)RArray( 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* pathPointsArray = NULL; + + if ( valueCount == 0 ) + { + pathPointsArray = new (ELeave)RArray( 1 ); + aPath->SetPointCoordsArrayRef( pathPointsArray ); + } + else + { + pathPointsArray = new (ELeave)RArray( 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(); + } + + }