diff -r 000000000000 -r d46562c3d99d svgtopt/SVG/SVGImpl/src/SVGElementImpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/svgtopt/SVG/SVGImpl/src/SVGElementImpl.cpp Thu Jan 07 16:19:02 2010 +0200 @@ -0,0 +1,3475 @@ +/* +* 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 Implementation source file + * +*/ + + +#if !defined(__E32BASE_H__) +#include +#endif + +#include "SVGElementImpl.h" +#include "SVGXmlElementImpl.h" + +#include "GfxAffineTransform.h" + +#include "SVGClrCssValueImpl.h" +#include "SVGPaintCssValueImpl.h" +#include "SVGIntCssValueImpl.h" +#include "SVGFloatCssValueImpl.h" +#include "SVGStrCssValueImpl.h" +#include "SVGVectorCssValueImpl.h" + +#include "SVGSchemaData.h" +#include "SVGAnimationBase.h" +#include "SVGLineElementImpl.h" +#include "SVGRectElementImpl.h" +#include "SVGCircleElementImpl.h" +#include "SVGMpathElementImpl.h" + +#include "SVGFontFaceElementImpl.h" + +#include "SVGDocumentImpl.h" +#include "SVGStringTokenizer.h" + +#include "SVGEngineImpl.h" +#include "SVGUseElementImpl.h" +#include "SVGAnimationElementImpl.h" +#include "SVGTokenizer.h" + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +CSvgElementImpl::~CSvgElementImpl() + { + if ( iId ) + { + delete iId; + iId = NULL; + } + + //need to remove from event list if it was an animation + + CSvgDocumentImpl* thisDocument = ( CSvgDocumentImpl* ) OwnerDocument(); + + if (thisDocument != NULL) + { + thisDocument->RemoveFromEventReceiverList(this); + } + + if ( iSvgTests ) + { + delete iSvgTests; + iSvgTests = NULL; + } + + if( iSvgLangSpace ) + { + delete iSvgLangSpace; + iSvgLangSpace = NULL; + } + + if ( iSvgTransformable ) + { + delete iSvgTransformable; + iSvgTransformable = NULL; + } + ResetReferenceAttrSet(); + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::StyleInParent(CSvgElementImpl* aElement, TInt aAttrIndex) + { + if(aElement != NULL) + { + CSvgElementImpl* lParentElement = (CSvgElementImpl*)aElement->ParentNode (); + while(lParentElement && (lParentElement->iSvgStyleProperties != NULL)) + { + if(!lParentElement) + return EFalse; + if (aElement->iSvgStyleProperties->operator[](aAttrIndex) == + lParentElement->iSvgStyleProperties->operator[](aAttrIndex)) + { + return ETrue; + } + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + } + return EFalse; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +CSvgElementImpl::CSvgElementImpl() : iAnimateTransformMatrixIndex(-1), + iSvgStyleProperties(NULL), + iAnimateMotionMatrixIndex( -1 ) + + { + SetAllAttributesAdded( ETrue ); + } + +void CSvgElementImpl::InitializeL( TUint8 aElemID) + { + CXmlElementImpl::InitializeL( aElemID ); + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::IsDrawable() + { + return ETrue; + } + +//***************************************************** +// +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::DrawShapeL( CGfx2dGc* aGc, + MGfxShape& aShape, + CSvgElementImpl* /*aElement */) + { + if ( !AreAllAttributesAdded() ) + { + return; + } + + // Paint is a special case. + // Paint must be reset locally + + SetGCL( aGc/*, aElement */); + + if( iSvgTransformable ) + { + aGc->SetTransform( GetCTM() ); + } + + aGc->DrawL( &aShape ); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::DrawShapeL( CGfx2dGc* aGc, CSvgElementImpl* /*aElement*/ ) + { + + SetGCL( aGc/*, aElement */); + + if(iSvgTransformable ) + { + aGc->SetTransform( GetCTM() ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::DrawL( CGfx2dGc* /* aGc */, + CSvgElementImpl* /* aElement */ ) + { + return ETrue; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +const TDesC* CSvgElementImpl::Id() + { + return iId; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetIdandXmlbaseL( const TDesC& aPropertyName, + const TDesC& aValue ) + { + _LIT( KId, "id" ); + if ( aPropertyName == KId) + { + delete iId; + iId = NULL; + iId = aValue.AllocL(); + } + else + { + return EFalse; + } + return ETrue; + } + +// --------------------------------------------------------------------------- +// +// This method might leave with KErrNoMemory. +// --------------------------------------------------------------------------- +MXmlElement* CSvgElementImpl::AppendChildL( MXmlElement* aNewChild, TBool aIsJSR226Element ) + { + + CXmlElementImpl::AppendChildL( aNewChild ); + + if ( aNewChild && (((CSvgElementImpl *)aNewChild)->ElemID() != KSvgSvgElement) ) + { + TInt err = KErrNone; + + if (!aIsJSR226Element) + { + err = ((CSvgElementImpl *)aNewChild)->InitSvgStyleProperties(); + } + else + { + // Error return needs to be checked + ((CSvgElementImpl*)aNewChild)->InitAllSvgStyleProperties((CSvgElementImpl*)aNewChild); + } + if (err != KErrNone) + #ifdef _Debug + RDebug::Print(_L("CSvgElementImpl::AppendChildL[%x]: memory when append child"), this); + #endif //_Debug + User::Leave(err); + } + + + return aNewChild; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- + +TInt CSvgElementImpl::SetAttributeL( const TDesC& aName , + const TDesC& aValue ) + { + + + if ( SetTransform( aName, aValue ) || + SetIdandXmlbaseL( aName, aValue ) || + SetLangSpaceAttributeL( aName, aValue ) || + SetTestAttributeL( aName, aValue ) + ) + { + return KErrNone; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::RemoveAttribute( const TInt aAttrId ) + { + if( iSvgStyleProperties && aAttrId < iSvgStyleProperties->Count() ) + { + CCssValue *lCurrentCssPointer = iSvgStyleProperties->operator[](aAttrId); + CCssValue *lParentCssPointer = NULL ; + + CSvgElementImpl* lParentElement = (CSvgElementImpl*)iParentNode; + while(lParentElement && (lParentElement->iSvgStyleProperties == NULL)) + { + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + + if ( lParentElement ) + { + FindProperty( (TInt8)aAttrId, lParentCssPointer, ( CSvgElementImpl * )lParentElement ); + } + + iSvgStyleProperties->operator[](aAttrId) = lParentCssPointer; + PropagateToChildren( lCurrentCssPointer,lParentCssPointer, aAttrId ); + } + return KErrNone; + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- + +void CSvgElementImpl::SetPresentationAttribute( const TInt8 aPropertyId, + CCssValue*& aCssValue ) + + { + if( iSvgStyleProperties && aPropertyId < iSvgStyleProperties->Count() ) + { + iSvgStyleProperties->operator[](aPropertyId) = aCssValue; + } + + } + +// --------------------------------------------------------------------------- +// This method sets a property value that takes a float +// The switch statement can be expanded to add more attributes +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::SetPropertyFloatL( const TInt& aAttrId, + TReal32 aValue) + { + CSvgDocumentImpl* doc = ( CSvgDocumentImpl* ) OwnerDocument(); + + if (!doc) + { + return EFalse; + } + + TInt position = aAttrId; + + + CSvgElementImpl* lParentElement = (CSvgElementImpl*)iParentNode; + while(lParentElement && (lParentElement->iSvgStyleProperties == NULL)) + { + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + + switch ( position ) + { + case KCSS_ATTR_STROKE_OPACITY: + case KCSS_ATTR_FILL_OPACITY: + case KCSS_ATTR_GROUP_OPACITY: + { + TFloatFixPt KZero; + TFloatFixPt KOne( KFloatFixOne ); + TFloatFixPt opacityValue = aValue; + if (opacityValue < KZero) + { + opacityValue = KZero; + } + else if (opacityValue > KOne) + { + opacityValue = KOne; + } + CFloatCssValueImpl* tParentValue = NULL; + CFloatCssValueImpl* tValue = (CFloatCssValueImpl *)(iSvgStyleProperties->operator[](position)); + + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CFloatCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssFloatObjectL( opacityValue ); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( opacityValue ); + } + } + break; + default: + return EFalse; + + } + + return ETrue; + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- + +TBool CSvgElementImpl::SetPropertyL( const TInt& aAttrId, + const TDesC& aValue) + { + _LIT( KInherit, "inherit" ); + + CSvgDocumentImpl* doc = ( CSvgDocumentImpl* ) OwnerDocument(); + + if (!doc) + { + return EFalse; + } + + CSvgSchemaData* lSchemaData = doc->SchemaData(); + + TInt position = aAttrId; + + + if( (aValue == KInherit) || (iSvgStyleProperties == NULL)) + { + return ETrue; + } + + CSvgElementImpl* lParentElement = (CSvgElementImpl*)iParentNode; + while(lParentElement && (lParentElement->iSvgStyleProperties == NULL)) + { + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + + + switch ( position ) + { + + case KCSS_ATTR_FILL: + //fill + { + CPaintCssValueImpl* tParentValue = NULL; + CPaintCssValueImpl* tValue = (CPaintCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CPaintCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssPaintObjectL(aValue, this); + + + if ( tValue->IsDefaultSet() ) + { + // if default color is set, check see if parent has one + if ( lParentElement ) + { + tParentValue = (CPaintCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + + if ( tParentValue != NULL ) + { + iSvgStyleProperties->operator[](position) = tParentValue; + break; + } + + } + else + { + iSvgStyleProperties->operator[](position) = tValue; + } + } + else + { + tValue->SetValueL( aValue ); + } + + break; + + } + case KCSS_ATTR_STROKE_OPACITY: + case KCSS_ATTR_FILL_OPACITY: + case KCSS_ATTR_GROUP_OPACITY: + { + TFloatFixPt KZero; + TFloatFixPt KOne( KFloatFixOne ); + TFloatFixPt opacityValue; + if ( TFloatFixPt::ConvertString( aValue, opacityValue ) == KErrNone ) + { + if (aValue.Locate('%') != KErrNotFound) + { + //if a percentage + opacityValue = opacityValue / TFloatFixPt(100); + } + } + else + { + opacityValue = KOne; + } + + if (opacityValue < KZero) + opacityValue = KZero; + else if (opacityValue > KOne) + opacityValue = KOne; + + CFloatCssValueImpl* tParentValue = NULL; + CFloatCssValueImpl* tValue = (CFloatCssValueImpl *)(iSvgStyleProperties->operator[](position)); + + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CFloatCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssFloatObjectL(opacityValue); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( opacityValue ); + } + } + break; + + case KCSS_ATTR_STROKE: + case KCSS_ATTR_COLOR: + { + + CClrCssValueImpl* tParentValue = NULL; + CClrCssValueImpl* tValue = (CClrCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CClrCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssClrObjectL( aValue ); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( aValue ); + } + + break; + + } + case KCSS_ATTR_VISIBILITY: + // visibility + { + TPtrC lVal; + if ( aValue == _L( "visible" ) ) + { + lVal.Set( _L( "0" ) ); + } + else if ( aValue == _L( "hidden" ) ) + { + lVal.Set( _L( "1" ) ); + } + else if ( aValue == _L( "collapse" ) ) + { + lVal.Set( _L( "3" ) ); + } + + CIntCssValueImpl* tParentValue = NULL; + CIntCssValueImpl* tValue = (CIntCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CIntCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssIntObjectL( lVal ); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( lVal ); + } + } + break; + + case KCSS_ATTR_DISPLAY: + // display + { + + TPtrC lVal; + if ( aValue == _L( "inline" ) ) + { + lVal.Set( _L( "0" ) ); + } + else if ( aValue == _L( "none" ) ) + { + lVal.Set( _L( "16" ) ); + } + + CIntCssValueImpl* tParentValue = NULL; + CIntCssValueImpl* tValue = (CIntCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CIntCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssIntObjectL( lVal ); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( lVal ); + } + + break; + } + case KCSS_ATTR_FONTSTYLE: + // font-style + { + TInt i; + + i = lSchemaData->FindFontStyle(aValue); + + TBufC<12> buf; + TPtr lVal ( buf.Des() ); + _LIT( KFixptFormat, "%d" ); + lVal.Format( KFixptFormat, i ); + + CIntCssValueImpl* tParentValue = NULL; + CIntCssValueImpl* tValue = (CIntCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CIntCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssIntObjectL( lVal ); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( lVal ); + } + } + break; + case KCSS_ATTR_FONTWEIGHT: + // font-weight + { + + TInt i; + i = lSchemaData->FindFontWeightEnum(aValue); + TBufC<12> buf; + TPtr lVal ( buf.Des() ); + _LIT( KFixptFormat, "%d" ); + lVal.Format( KFixptFormat, i ); + + CIntCssValueImpl* tParentValue = NULL; + CIntCssValueImpl* tValue = (CIntCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CIntCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + + tValue = doc->iMemoryManager->GetCssIntObjectL( lVal ); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( lVal ); + } + } + break; + + case KCSS_ATTR_FONTFAMILY: + if( ElemID() == KSvgFontfaceElement ) + { + ((CSvgFontFaceElementImpl *)this)->SetFontFamilyL(aValue); + } + + case KCSS_ATTR_STROKE_LINECAP: + case KCSS_ATTR_STROKE_LINEJOIN: + case KCSS_ATTR_FILLRULE: + { + CStrCssValueImpl* tParentValue = NULL; + CStrCssValueImpl* tValue = (CStrCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CStrCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssStrObjectL( aValue ); + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( aValue ); + } + } + break; + case KCSS_ATTR_STROKE_DASHARRAY: + { + + CVectorCssValueImpl* tParentValue = NULL; + CVectorCssValueImpl* tValue = (CVectorCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CVectorCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssVectorObjectL( aValue ); + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( aValue ); + } + + if(tValue) + { + CArrayFix* lDashArray = tValue->Value(); + TFloatFixPt lSum( 0 ); + TUint numElem = lDashArray->Count(); + // Iterate through the array to check whether the sum of elements + // of the dash array is non-zero. + for (TUint arrCount = 0; arrCount < numElem; arrCount++) + { + lSum = lSum + lDashArray->At(arrCount); + } + // If the sum is zero then, the behaviour should be similar to "none" i.e. no dashing applied. + if ( lSum == TFloatFixPt( 0 ) ) + { + iSvgStyleProperties->operator[](position)= NULL; + + + // Not deleting the tValue as this would be freed in the + // destructor of CSvgMemoryManager + } + } + + } + break; + case KCSS_ATTR_STROKEWIDTH: + { + // stroke-width can not be negative + TReal32 strokeWidth; + TPtrC remainder; + TBool validValue = TTokenizer::ParseDecimal( aValue, strokeWidth, remainder ); + + // Check for valid number characters and no characters following + // and must be non-negative + if ( !validValue || strokeWidth < 0.0f ) + { + strokeWidth = 1.0f; + } + /* + "1pt" equals "1.25px" (and therefore 1.25 user units) + "1pc" equals "15px" (and therefore 15 user units) + "1mm" would be "3.543307px" (3.543307 user units) + "1cm" equals "35.43307px" (and therefore 35.43307 user units) + "1in" equals "90px" (and therefore 90 user units) + */ + else if ( remainder.Length() > 0 ) + { + if ( remainder == _L("px") ) + { + // do nothing + } + if ( remainder == _L("pt") ) + { + strokeWidth *= 1.25f; + } + else if ( remainder == _L("pc") ) + { + strokeWidth *= 15.0f; + } + else if ( remainder == _L("mm") ) + { + strokeWidth *= 3.543307f; + } + else if ( remainder == _L("cm") ) + { + strokeWidth *= 35.43307f; + } + else if ( remainder == _L("in") ) + { + strokeWidth *= 90.0f; + } + else + { + strokeWidth = 1.0f; + } + } + + CFloatCssValueImpl* tParentValue = NULL; + CFloatCssValueImpl* tValue = (CFloatCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CFloatCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssFloatObjectL( strokeWidth ); + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( strokeWidth ); + } + } + break; + + case KCSS_ATTR_FONTSIZE: + case KCSS_ATTR_STROKE_DASHOFFSET: + case KCSS_ATTR_STROKE_MITERLIMIT: + { + CFloatCssValueImpl* tParentValue = NULL; + CFloatCssValueImpl* tValue = (CFloatCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CFloatCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssFloatObjectL(aValue); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( aValue ); + } + } + break; + case KCSS_ATTR_TEXTANCHOR: + //text-anchor + { + + TInt i; + + i = lSchemaData->FindTextAnchorEnum(aValue); + + TBufC<12> buf; + TPtr lVal ( buf.Des() ); + _LIT( KFixptFormat, "%d" ); + lVal.Format( KFixptFormat, i ); + + CIntCssValueImpl* tParentValue = NULL; + CIntCssValueImpl* tValue = (CIntCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CIntCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssIntObjectL( lVal ); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( lVal ); + } + } + break; + case KCSS_ATTR_TEXTDECORATION: + //text-decoration + { + + TInt i; + i = lSchemaData->FindTextDecorationEnum(aValue); + TBufC<12> buf; + TPtr lVal ( buf.Des() ); + _LIT( KFixptFormat, "%d" ); + lVal.Format( KFixptFormat, i ); + + CIntCssValueImpl* tParentValue = NULL; + CIntCssValueImpl* tValue = (CIntCssValueImpl *)(iSvgStyleProperties->operator[](position)); + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CIntCssValueImpl *) + (lParentElement->iSvgStyleProperties->operator[](position)); + } + if (tParentValue == tValue || tValue == NULL) + { + tValue = doc->iMemoryManager->GetCssIntObjectL(lVal); + + iSvgStyleProperties->operator[](position) = tValue; + } + else + { + tValue->SetValueL( lVal ); + } + } + break; + + default: + return EFalse; + + } + + return ETrue; + + } + + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::SetTransform( const TDesC& aAttributeName, + const TDesC& aValue ) + { + + if( iSvgTransformable == NULL ) + { + return EFalse; + } + + // If this attribute is not transform attribute, return immediately. + _LIT( KTransform, "transform" ); + if ( aAttributeName != KTransform ) + return EFalse; + + TLex input ( aValue ); + TReal32 M00, M10, M01, M11, M02, M12; + TGfxAffineTransform tempTransform; + MSvgTransformList* trList; + + iSvgTransformable->GetTransform( trList ); + TGfxAffineTransform originalTransform = trList->GetItem( 0 ); + + _LIT( KMatrixP, "matrix(" ); + _LIT( KTranslateP, "translate(" ); + _LIT( KScaleP, "scale(" ); + _LIT( KRotateP, "rotate(" ); + _LIT( KSkewxP, "skewX(" ); + _LIT( KSkewyP, "skewY(" ); + + while ( !( input.Eos() ) ) + { + input.Mark(); + input.SkipCharacters(); + TPtrC token = input.MarkedToken(); // then extract token + + if ( token == KMatrixP ) + { + input.SkipSpace(); if ( input.Val( M00, '.' ) != KErrNone ) return EFalse; + input.SkipSpace(); if ( input.Val( M10, '.' ) != KErrNone ) return EFalse; + input.SkipSpace(); if ( input.Val( M01, '.' ) != KErrNone ) return EFalse; + input.SkipSpace(); if ( input.Val( M11, '.' ) != KErrNone ) return EFalse; + input.SkipSpace(); if ( input.Val( M02, '.' ) != KErrNone ) return EFalse; + input.SkipSpace(); if ( input.Val( M12, '.' ) != KErrNone ) return EFalse; + + //check to make sure the user isn't setting in scale of 0 because that can never be undone + //they probably just mean that they don't want to scale + /* if (M00 == 0) + { + M00 = 1; + } + if (M11 == 0) + { + M11 = 1; + }*/ + + tempTransform.SetTransform( M00, M10, M01, M11, M02, M12 ); + originalTransform.Concatenate( tempTransform ); + trList->ReplaceItem( originalTransform, 0 ); + } + else if ( token == KTranslateP ) + { + // parse tx + input.SkipSpace(); + if ( input.Val( M00, '.' ) != KErrNone ) return EFalse; + + // parse ty + input.SkipSpace(); + if ( input.Val( M10, '.' ) != KErrNone ) M10 = 0.0; + + // set translate + TFloatFixPt fixM00 ( M00 ); + TFloatFixPt fixM10 ( M10 ); + originalTransform.Translate( fixM00, fixM10 ); + trList->ReplaceItem( originalTransform, 0 ); + } + else if ( token == KScaleP ) + { + input.SkipSpace(); + if(input.Peek().IsDigit() || (input.Peek() == '-') || (input.Peek() == '.')) + { + if ( input.Val( M00, TChar('.') ) != KErrNone ) + return EFalse; + } + else + { + M00 = 1.0; + } + input.SkipSpace(); + // If only one value is given then both scale values are set to that value + if ( input.Eos() || input.Peek() == ')' ) + { + M11 = M00; + } + else + { + if(input.Peek().IsDigit() || (input.Peek() == '-') || (input.Peek() == '.')) + { + if ( input.Val( M11, TChar('.')) != KErrNone ) + return EFalse; + } + else + { + M11 = 1.0; + } + } + originalTransform.Scale( M00, M11 ); + trList->ReplaceItem( originalTransform, 0 ); + } + else if ( token == KRotateP ) + { + // parse r + input.SkipSpace(); + if ( input.Val( M00, '.' ) != KErrNone ) return EFalse; + // parse cx + input.SkipSpace(); + if ( input.Val( M01, '.' ) == KErrNone ) + { + // parse cy + input.SkipSpace(); + if ( input.Val( M10, '.' ) != KErrNone ) return EFalse; + M00 = M00 * KGradiansPerDegree; // Convert to Radians + originalTransform.Rotate( M00, TFloatFixPt(M01), TFloatFixPt(M10) ); + trList->ReplaceItem( originalTransform, 0 ); + } + else + { + M00 = M00 * KGradiansPerDegree; // Convert to Radians + originalTransform.Rotate( M00 ); + trList->ReplaceItem( originalTransform, 0 ); + } + } + else if ( token == KSkewxP ) + { + input.SkipSpace(); if ( input.Val( M00, '.' ) != KErrNone ) return EFalse; + M00 = M00 * KGradiansPerDegree; // Convert to Radians + originalTransform.Shear( M00, 0.0f ); + trList->ReplaceItem( originalTransform, 0 ); + } + else if ( token == KSkewyP ) + { + input.SkipSpace(); if ( input.Val( M00, '.' ) != KErrNone ) return EFalse; + M00 = M00 * KGradiansPerDegree; // Convert to Radians + originalTransform.Shear( 0.0f, M00 ); + trList->ReplaceItem( originalTransform, 0 ); + } + + // Skip close paranthesis + input.SkipSpace(); + input.Mark(); + input.MarkedToken(); // then extract token + } + return ETrue; + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TSvgColor* CSvgElementImpl::CurrentColor() + { + + + if( iSvgStyleProperties ) + { + CCssValue* lColorValue = NULL; + lColorValue = iSvgStyleProperties->operator[](KCSS_ATTR_COLOR); + + if ( lColorValue && + ( ( CClrCssValueImpl * ) lColorValue )->Value() && + ( ( TSvgColor*)(( CClrCssValueImpl * ) lColorValue )->Value())->GetColor() != KSvgCurrentColor + ) + { + // current color found and useful, return it + return ( TSvgColor*)(( CClrCssValueImpl * ) lColorValue )->Value(); + } + else + { + // current color found, but it is "currentColor" + // find the real color from searching parents + + if ( iParentNode ) + { + return ( ( CSvgElementImpl * ) iParentNode )->CurrentColor(); + } + } + } + else + { + if ( iParentNode ) + { + return ( ( CSvgElementImpl * ) iParentNode )->CurrentColor(); + } + } + return NULL; + } + +void CSvgElementImpl::InitAllSvgStyleProperties(CSvgElementImpl* aElement) +{ + if (aElement && aElement->ParentNode()) + { + aElement->InitSvgJSRStyleProperties((CSvgElementImpl*)aElement->ParentNode()); + } + + if (aElement && aElement->iSvgStyleProperties && aElement->iSvgStyleProperties->Count() == KCSS_MAX_ATTR) + { + CSvgElementImpl* lChildElement = (CSvgElementImpl*)aElement->FirstChild(); + + if ( lChildElement ) + { + InitAllSvgStyleProperties( lChildElement ); + } + + CSvgElementImpl* lSiblingElement = (CSvgElementImpl*)aElement->NextSibling(); + + if ( lSiblingElement ) + { + InitAllSvgStyleProperties( lSiblingElement ); + } + } +} + +void CSvgElementImpl::InitSvgJSRStyleProperties(CSvgElementImpl* aParentElement) +{ + if ( iSvgStyleProperties && iSvgStyleProperties->Count() == KCSS_MAX_ATTR ) + { + //JSR226 ELEMENT CREATION WILL COME TO THIS + // any non NULL values in the iSvgStyleProperties array should be kept and + // the NULL ones should be replaced by the parent values + + if( aParentElement && aParentElement->iSvgStyleProperties) + { + TInt count = aParentElement->iSvgStyleProperties->Count(); + for ( TInt i = 0; i < count; i++ ) + { + CCssValue* lCssValue = aParentElement->iSvgStyleProperties->operator[]( i ); + CCssValue* thisCssValue = this->iSvgStyleProperties->operator[]( i ); + + if( lCssValue && !thisCssValue ) + { + // the parent had a property but we just had NULL, so lets inherit the parent property + (*iSvgStyleProperties)[i] = lCssValue; + } + else + { + //this element must have a new value of its own in it so leave it alone + } + } + } + } +} + +TInt CSvgElementImpl::InitSvgStyleProperties( ) + { + // all styles from all elements for the normal engine + // flow will be setup in this function + + TInt err(KErrNone); + + if( iSvgStyleProperties && iSvgStyleProperties->Count() == 0 ) + { + //NORMAL ENGINE ELEMENT CREATION... + CSvgElementImpl* lParentElement = (CSvgElementImpl*)iParentNode; + while(lParentElement && ((lParentElement->iSvgStyleProperties == NULL) || (lParentElement->iSvgStyleProperties->Count() == 0)) ) + { + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + + if( lParentElement ) + { + TInt count = lParentElement->iSvgStyleProperties->Count(); + for ( TInt i = 0; i < count; i++ ) + { + CCssValue* lCssValue = lParentElement->iSvgStyleProperties->operator[]( i ); + err = iSvgStyleProperties->Insert(lCssValue,i); + if (err) + return err; + } + } + } + + return err; +} + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- + +void CSvgElementImpl::FindProperty( const TInt8 aPropertyId, + CCssValue*& aCssValue, + CSvgElementImpl* aElement ) + + { + if (aElement != NULL) + aElement->FindProperty(aPropertyId, aCssValue); + else + FindProperty(aPropertyId, aCssValue); + } + +void CSvgElementImpl::FindProperty( const TInt8 aPropertyId, + CCssValue*& aCssValue) + + { + if( iSvgStyleProperties && iSvgStyleProperties->Count() > aPropertyId) + { + aCssValue = iSvgStyleProperties->operator[](aPropertyId); + } + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::SetTransform( MSvgTransformList*& aTransformList ) + { + if( !iSvgTransformable ) + { + // iSvgTransformable should not be NULL (created by subclass) + TRAP_IGNORE( iSvgTransformable = CSvgTransformableImpl::NewL() ); + } + + if( iSvgTransformable ) + { + iSvgTransformable->SetTransform( aTransformList ); + } + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::GetTransform( MSvgTransformList*& aTransformList ) + { + if( !iSvgTransformable ) + { + // iSvgTransformable should not be NULL (created by subclass) + TRAP_IGNORE( iSvgTransformable = CSvgTransformableImpl::NewL() ); + } + + if( iSvgTransformable ) + { + iSvgTransformable->GetTransform( aTransformList ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +const TGfxAffineTransform& CSvgElementImpl::GetCTM() + { + if( !iSvgTransformable ) + { + // iSvgTransformable should not be NULL (created by subclass) + TRAP_IGNORE( iSvgTransformable = CSvgTransformableImpl::NewL() ); + } + return( iSvgTransformable->GetCTM() ); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::SetCTM( TGfxAffineTransform& aTr ) + { + if( !iSvgTransformable ) + { + // iSvgTransformable should not be NULL (created by subclass) + TRAP_IGNORE( iSvgTransformable = CSvgTransformableImpl::NewL() ); + } + + if( iSvgTransformable ) + { + iSvgTransformable->SetCTM( aTr ); + } + else + { + #ifdef _DEBUG + RDebug::Printf("CSvgElementImpl::SetCTM element %d wasnt transformable CTM not set", this->ElemID()); + #endif + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::SetGCL( CGfx2dGc* aGc) + { + + + TSvgColor* lStroke = NULL; + MGfxPaint* lFill = NULL; + TGfxStroke lStrokeC; + TFloatFixPt lStrokeWidth = 1; + TPtrC lFillRule; // Should be a defined constant for nonzero + TPtrC lSLinecap; // Should be a defined constant for linecap + TPtrC lSLinejoin; // Should be a defined constant for linejoin + TInt lFontStyle = -1; // Should be a defined constant for fontstyle + TFloatFixPt lFontSize = 10; // Should be a defined constant for fontstyle + TInt lFontWeight = -1; // Should be a defined constant for fontweight + TInt lTextanchor = -1; + TInt lTextDecoration = -1; + TFloatFixPt lDashOffset = 0; + TFloatFixPt lSMiterlimit; // Should be a defined constant for strokemiterlimit + CArrayFix* lDasharray = NULL; + + CCssValue* lCssValue = NULL; + + // Get fill color + + FindProperty( KCSS_ATTR_FILL, lCssValue); + if ( lCssValue ) + { + // Currently only TSvgColor is represented by PaintCssValue + // It will be extended to handle CGfxTexturePaint and CGfxGradientPaint + lFill = ( ( CPaintCssValueImpl * ) lCssValue )->Value(); + // Set fill color + if(lFill) + { + if (lFill->GetColor() == KSvgCurrentColor ) + { + + lFill = CurrentColor(); + if (lFill && lFill->GetColor() != KGfxColorNull ) + { + aGc->SetPaint( lFill ); + + } + else + { + aGc->SetPaint( NULL ); + } + } + else if (lFill->GetColor() != KGfxColorNull ) + { + aGc->SetPaint( lFill ); + } + else + { + aGc->SetPaint( NULL ); + } + } + else + { + aGc->SetPaint( NULL ); + } + } + else + { + TSvgColor black ( 0 ); + aGc->SetPaint( &black ); + } + + // this is just regular opacity which needs to be an entire elements opacity + // Opacity set using stroke and fill opacity + CCssValue* lOpacityCssValue = NULL; + FindProperty( KCSS_ATTR_GROUP_OPACITY, lOpacityCssValue); + if ( lOpacityCssValue && ( ((CFloatCssValueImpl*)lOpacityCssValue)->Value() < TFloatFixPt(1) ) ) + { + aGc->SetStrokeOpacity( ( ( CFloatCssValueImpl * ) lOpacityCssValue )->Value() ); + aGc->SetFillOpacity( ( ( CFloatCssValueImpl * ) lOpacityCssValue )->Value() ); + } + + lCssValue = NULL; + FindProperty( KCSS_ATTR_STROKE_OPACITY, lCssValue); + if ( lCssValue ) + { + TFloatFixPt lValue = ( ( CFloatCssValueImpl * ) lCssValue )->Value(); + aGc->SetStrokeOpacity( lValue ); + } + else + { + aGc->SetStrokeOpacity(1); + } + + lCssValue = NULL; + FindProperty( KCSS_ATTR_FILL_OPACITY, lCssValue); + if ( lCssValue ) + { + TFloatFixPt lValue = ( ( CFloatCssValueImpl * ) lCssValue )->Value(); + aGc->SetFillOpacity( lValue ); + } + else + { + aGc->SetFillOpacity(1); + } + + // Get stroke color + lCssValue = NULL; + FindProperty( KCSS_ATTR_STROKE, lCssValue); + + if ( lCssValue ) + { + lStroke = ( ( CClrCssValueImpl * ) lCssValue )->Value(); + // Set stroke color + if ( lStroke && lStroke->GetColor () == KSvgCurrentColor ) + { + lStroke = CurrentColor(); + if(lStroke) + { + aGc->SetForegroundColor( *lStroke ); + } + } + else if ( lStroke ) + { + aGc->SetForegroundColor( *lStroke ); + } + } + + // Get stroke-width + lCssValue = NULL; + FindProperty( KCSS_ATTR_STROKEWIDTH, lCssValue); + + if ( lCssValue ) + { + lStrokeWidth = ( ( CFloatCssValueImpl * ) lCssValue )->Value(); + if (lStrokeWidth <= TFloatFixPt(0)) + { + lStrokeC.SetStrokeWidth( TFloatFixPt(0) ); + } + else + { + // Set stroke-width + lStrokeC.SetStrokeWidth( lStrokeWidth ); + } + } + + // Get and set fill-rule + lCssValue = NULL; + FindProperty( KCSS_ATTR_FILLRULE, lCssValue); + + if ( lCssValue ) + { + lFillRule.Set( ( ( CStrCssValueImpl * ) lCssValue )->Value() ); + if ( lFillRule == _L("evenodd" ) )// evenodd + { + aGc->SetWindingRule( EGfxWindEvenOdd ); + } + else if ( lFillRule == _L("nonzero") ) + { + aGc->SetWindingRule( EGfxWindNonZero ); + } + } + + // Get and set stroke-linecap + lCssValue = NULL; + FindProperty( KCSS_ATTR_STROKE_LINECAP, lCssValue); + + if ( lCssValue ) + { + lSLinecap.Set( ( ( CStrCssValueImpl * ) lCssValue )->Value() ); + + if (lSLinecap == _L("butt")) + { + lStrokeC.SetCapType( EGfxCapButt ); + } + else if (lSLinecap == _L("round")) + { + lStrokeC.SetCapType( EGfxCapRound ); + } + else if (lSLinecap == _L("square")) + { + lStrokeC.SetCapType( EGfxCapSquare ); + } + } + + lCssValue = NULL; + FindProperty( KCSS_ATTR_STROKE_LINEJOIN, lCssValue); + + if ( lCssValue ) + { + lSLinejoin.Set( ( ( CStrCssValueImpl * ) lCssValue )->Value() ); + + if (lSLinejoin == _L("miter")) + { + lStrokeC.SetJoinType( EGfxJoinMiter ); + } + else if (lSLinejoin == _L("round")) + { + lStrokeC.SetJoinType( EGfxJoinRound ); + } + else if (lSLinejoin == _L("bevel")) + { + lStrokeC.SetJoinType( EGfxJoinBevel ); + } + } + + + lCssValue = NULL; + + FindProperty( KCSS_ATTR_STROKE_DASHOFFSET, lCssValue); + if ( lCssValue ) + { + lDashOffset = ( ( CFloatCssValueImpl * ) lCssValue )->Value(); + // Set dashoffset into GC + aGc->SetDashOffset( lDashOffset ); + } + + // Get and set stroke-dasharray + lCssValue = NULL; + FindProperty( KCSS_ATTR_STROKE_DASHARRAY, lCssValue); + if ( lCssValue ) + { + ( ( CVectorCssValueImpl * ) lCssValue )->Value( lDasharray ); + // Set stroke-dasharray into GC + aGc->SetDashArrayL( lDasharray ); + } + + // get and set stroke-miterlimit + lCssValue = NULL; + FindProperty( KCSS_ATTR_STROKE_MITERLIMIT, lCssValue); + + if ( lCssValue ) + { + lSMiterlimit = ( ( CFloatCssValueImpl * ) lCssValue )->Value(); + + lStrokeC.SetMiterLimit(lSMiterlimit); + } + + if( iElemID == KSvgTextAreaElement || iElemID == KSvgTextElement) + { + lCssValue = NULL; + FindProperty( KCSS_ATTR_FONTSIZE, lCssValue); + + if ( lCssValue ) + { + lFontSize = ( ( CFloatCssValueImpl * ) lCssValue )->Value(); + + #ifdef SVG_FLOAT_BUILD + if(lFontSize <= TFloatFixPt ( 0 ) ) + { + lFontSize = TFloatFixPt ( 10 ); + } + #else + if(lFontSize <= TFloatFixPt ( 0,ETrue ) ) + lFontSize = TFloatFixPt ( 10 ); + #endif + aGc->SetFontSize( lFontSize ); + } + + lCssValue = NULL; + FindProperty( KCSS_ATTR_FONTSTYLE, lCssValue); + + if ( lCssValue ) + { + lFontStyle = ( ( CIntCssValueImpl * ) lCssValue )->Value(); + aGc->SetFontStyle( lFontStyle ); + } + + // Get and set font-weight + lCssValue = NULL; + FindProperty( KCSS_ATTR_FONTWEIGHT, lCssValue); + + if ( lCssValue ) + { + lFontWeight = ( ( CIntCssValueImpl * ) lCssValue )->Value(); + aGc->SetFontWeight( lFontWeight ); + } + + // Get and set text-anchor + lCssValue = NULL; + FindProperty( KCSS_ATTR_TEXTANCHOR, lCssValue); + + if ( lCssValue ) + { + lTextanchor = ( ( CIntCssValueImpl * ) lCssValue )->Value(); + aGc->SetTextanchor( lTextanchor ); + } + + // Get and set text-decoration + lCssValue = NULL; + FindProperty( KCSS_ATTR_TEXTDECORATION, lCssValue); + + if ( lCssValue ) + { + lTextDecoration = ( ( CIntCssValueImpl * ) lCssValue )->Value(); + aGc->SetTextDecoration( lTextDecoration ); + } + } + // Sset the stroke into the graphics library now that we are done + aGc->SetStroke( lStrokeC ); + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::UpdateCTM( ) +{ + CSvgDocumentImpl* lDocument = (CSvgDocumentImpl*)(this->OwnerDocument()); + + if ( !lDocument ) + { + return; + } + + TInt lElementId = this->ElemID(); + if( this->IsTransformable() ) + { + MSvgTransformList* trList; + + // Current delta transformation due to animation, etc. + TGfxAffineTransform localUserSpace; + // Element's CTM + TGfxAffineTransform lCurrentTM; + + + // we do not need this for the radial and linear Gradient Element. + // + if ( this != lDocument->RootElement() + && !(lElementId == KSvgLinearGradientElement + || lElementId == KSvgRadialGradientElement )) + + { + CSvgElementImpl* lParentEl = ( CSvgElementImpl* )this->ParentNode(); + while (lParentEl && !(lParentEl->IsTransformable()) ) + { + lParentEl = ( CSvgElementImpl* )lParentEl->ParentNode(); + } + if( lParentEl ) + { + lCurrentTM = lParentEl->GetCTM(); + } + } + + this->GetTransform( trList ); + localUserSpace = trList->Consolidate( IsOverwriteTransforms() ); + lCurrentTM.Concatenate( localUserSpace ); + + if(lElementId == KSvgUseElement) + { + lCurrentTM.Translate(((CSvgUseElementImpl *)this)->X(),((CSvgUseElementImpl *)this)->Y() ); + } + /* else if(lElementId == KSvgAnimationElement) + { + lCurrentTM.Translate(((CSvgAnimationElementImpl *)this)->X(),((CSvgAnimationElementImpl *)this)->Y() ); + }*/ + else if ( lElementId == KSvgSvgElement ) + { + // Viewbox + CSvgSvgElementImpl* tmpSvgEl = ( CSvgSvgElementImpl* ) + this; + TGfxRectangle2D tmpRect ( tmpSvgEl->X(), + tmpSvgEl->Y(), + tmpSvgEl->Width(), + tmpSvgEl->Height() ); + + // Add stop for bogus viewports being set if the SVG element hasn't been set + // from the Java side. + if (tmpRect.iWidth >= TFloatFixPt(0) && tmpRect.iHeight >= TFloatFixPt(0)) + { + tmpSvgEl->SetWindowViewportTrans( tmpRect, lCurrentTM ); + } + + } + + this->SetCTM( lCurrentTM ); + } + + CSvgElementImpl*lNewElement = ( CSvgElementImpl* ) + this->FirstChild(); + while ( lNewElement != NULL ) + { + lNewElement->UpdateCTM(); + lNewElement = ( CSvgElementImpl * ) lNewElement->NextSibling(); + } +} + + + + + +// ******************************************************* + +// --------------------------------------------------------------------------- +// From MSvgTests +// --------------------------------------------------------------------------- +void CSvgElementImpl::GetRequiredFeatures( const CDesCArrayFlat*& aRequiredFeatures ) + { + if( iSvgTests ) + { + iSvgTests->GetRequiredFeatures( aRequiredFeatures ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::GetRequiredExtensions( const CDesCArrayFlat*& aRequiredExtensions ) + { + if( iSvgTests ) + { + iSvgTests->GetRequiredExtensions( aRequiredExtensions ); + } + } + +// --------------------------------------------------------------------------- +// returns false if system language was empty string +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::GetSystemLanguage( const CDesCArrayFlat*& aSystemLanguage ) + { + if( iSvgTests ) + { + return (iSvgTests->GetSystemLanguage( aSystemLanguage )); + } + + return ETrue; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::HasExtension( const TDesC& aExtension ) + { + if( iSvgTests ) + { + return iSvgTests->HasExtension( aExtension ); + } + return EFalse; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::HasAnyTests( ) + { + if( iSvgTests ) + { + return iSvgTests->HasAnyTests( ); + } + return EFalse; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::HasFeature( const TDesC& aFeature ) + { + if( iSvgTests ) + { + return iSvgTests->HasFeature( aFeature ); + } + return EFalse; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::SetTestAttributeL( const TDesC& aPropertyName, + const TDesC& aValue ) + { + + _LIT( KRequiredFeatures, "requiredFeatures" ); + _LIT( KRequiredExtensions, "requiredExtensions" ); + _LIT( KSystemLanguage, "systemLanguage" ); + + if (aPropertyName == KRequiredFeatures || aPropertyName == KRequiredExtensions || aPropertyName == KSystemLanguage) + { + if (!iSvgTests) + { + iSvgTests = CSvgTestsImpl::NewL(); + } + + return iSvgTests->SetTestAttributeL( aPropertyName, aValue ); + } + + return EFalse; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::CreateSvgTestL(const TUint16 aAttrName) +{ + if (aAttrName == KAtrRequiredFeatures || aAttrName == KAtrRequiredExtensions || aAttrName == KAtrSystemLanguage) + { + if (!iSvgTests) + { + iSvgTests = CSvgTestsImpl::NewL(); + } + } +} +// ******************************************************* +// --------------------------------------------------------------------------- +// From MSvgLangSpace.h +// --------------------------------------------------------------------------- +const TDesC& CSvgElementImpl::XMLLang() + { + if( iSvgLangSpace ) + { + return iSvgLangSpace->XMLLang(); + } + else + { + return KNullDesC; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetXMLLangL( const TDesC& aXMLLang ) + { + if( iSvgLangSpace ) + { + iSvgLangSpace->SetXMLLangL( aXMLLang ); + } + return KErrNone; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +const TDesC& CSvgElementImpl::XMLSpace() + { + if( iSvgLangSpace ) + { + return iSvgLangSpace->XMLSpace(); + } + else + { + return KNullDesC; + } + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetXMLSpaceL( const TDesC& aXMLSpace ) + { + if( iSvgLangSpace ) + { + iSvgLangSpace->SetXMLSpaceL( aXMLSpace ); + } + return KErrNone; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::SetLangSpaceAttributeL( const TDesC& aPropertyName, + const TDesC& aValue ) +{ + _LIT( KXMLLang, "xml:lang" ); + _LIT( KXMLSpace, "xml:space" ); + + if (aPropertyName == KXMLLang || aPropertyName == KXMLSpace) + { + if (!iSvgLangSpace) + { + iSvgLangSpace = CSvgLangSpaceImpl::NewL(); + } + + return iSvgLangSpace->SetLangSpaceAttributeL( aPropertyName, aValue ); + } + else + { + return EFalse; + } +} + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::SetXlinkAttributeL( const TDesC& aPropertyName, + const TDesC& aValue ) + { + if( iSvgUriReferenceImpl ) + { + return iSvgUriReferenceImpl->SetXlinkAttributeL( aPropertyName, aValue ); + } + else + { + return EFalse; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +const TDesC& CSvgElementImpl::Href() + { + if( iSvgUriReferenceImpl ) + { + return iSvgUriReferenceImpl->Href(); + } + return KNullDesC; + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TDesC* CSvgElementImpl::HrefPointer() + { + if( iSvgUriReferenceImpl ) + { + return iSvgUriReferenceImpl->HrefPointer(); + } + return NULL; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- + +const TDesC& CSvgElementImpl::XlinkShow() + { + if(iSvgUriReferenceImpl ) + { + return iSvgUriReferenceImpl->XlinkShow(); + } + return KNullDesC; + } + + +// ******************************************************* +// From MSvgEventReceiver +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::ReceiveEventL( MSvgEvent* aEvent, const TUint16 aSubEventMask ) + { + CSvgEngineImpl* engine = ( ( CSvgDocumentImpl* ) OwnerDocument() )->Engine(); + + // Accepts Internal event and mouse events + switch ( aEvent->EventType() ) + { + case ESvgEngineInternalEvent: + break; + case ESvgEngineEventMouseDown: + case ESvgEngineEventMouseUp: + case ESvgEngineEventMouseMove: + { + // Check if pointer is inside of the element + MSvgUiMouseEvent* mevent = ( MSvgUiMouseEvent* ) aEvent; + //TGfxRectangle2D p(mevent->X(), mevent->Y(), 0,0); + TGfxPoint2D p ( mevent->X(), mevent->Y() ); + TGfxRectangle2D bbox; + TInt32 lVisible; + TInt32 lDisplay; + this->GetAttributeIntL(KCSS_ATTR_VISIBILITY,lVisible); + this->GetAttributeIntL(KCSS_ATTR_DISPLAY,lDisplay); + GetBBox( bbox ); + if ( bbox.Contains( p ) && lDisplay != 16 && lVisible == 0 ) + { + // Invoke internal event + switch ( aEvent->EventType() ) + { + case ESvgEngineEventMouseDown: + { + TSvgInternalEvent evt ( ESvgEventMousedown, + ( CSvgElementImpl* ) + this ); + engine->ProcessEventL( + ( CSvgDocumentImpl* )OwnerDocument(), &evt ); + SetMouseDown( ETrue ); + } + break; + case ESvgEngineEventMouseUp: + { + TSvgInternalEvent evt ( ESvgEventMouseup, + ( CSvgElementImpl* ) + this ); + engine->ProcessEventL( + ( CSvgDocumentImpl* )OwnerDocument(), &evt ); + + if ( IsMouseDown() ) + { + // Check the aSubEventMask to know which event + // has occured + if(CanGenerateInternalEvent(aSubEventMask,ESvgEventActivate)) + { + + TSvgInternalEvent evt1 ( + ESvgEventActivate, + ( CSvgElementImpl* )this ); + + engine->ProcessEventL( + ( CSvgDocumentImpl* ) OwnerDocument(), + &evt1 ); + } + if ( CanGenerateInternalEvent(aSubEventMask,ESvgEventClick)) + { + + TSvgInternalEvent evt ( + ESvgEventClick, + ( CSvgElementImpl* )this ); + + engine->ProcessEventL( + ( CSvgDocumentImpl* ) OwnerDocument(), + &evt ); + + } + } + SetMouseDown( EFalse ); + } + break; + case ESvgEngineEventMouseMove: + { + + engine->NotifyElementActivatedLinkEntered(this); + + if ( CanGenerateInternalEvent(aSubEventMask,ESvgEventMousemove) ) + { + + TSvgInternalEvent evt1( + ESvgEventMousemove, + ( CSvgElementImpl* )this ); + engine->ProcessEventL( + ( CSvgDocumentImpl* ) OwnerDocument(), + &evt1 ); + } + + if ( !IsMouseIn() ) + { + + engine->NotifyInteractiveElementEntered(this); + + // Check the aSubEventMask to know which event + // has occured + if ( CanGenerateInternalEvent(aSubEventMask,ESvgEventMouseover) ) + { + + TSvgInternalEvent evt ( + ESvgEventMouseover, + ( CSvgElementImpl* )this ); + engine->ProcessEventL( + ( CSvgDocumentImpl* ) OwnerDocument(), + &evt ); + } + + if ( CanGenerateInternalEvent(aSubEventMask,ESvgEventFocusin) ) + { + + TSvgInternalEvent evt2 ( + ESvgEventFocusin, + ( CSvgElementImpl* )this ); + + engine->ProcessEventL( + ( CSvgDocumentImpl* ) OwnerDocument(), + &evt2 ); + + } + } + SetMouseIn( ETrue ); + } + break; + default: + break; + } + } + else + { + engine->NotifyElementActivatedLinkExited(this); + + + // if state was 'mouse down'then reset the state + SetMouseDown( EFalse ); + + // if state was 'mouse in' and event is ESvgEngineEventMouseMove, + // invoke mouseout event + + //MouseMove: in case of scrolling over a element focusOut events must + // be generated + + //MouseDown: In touch cases, if you tap on a element and then tap outside + // then a focusout event must be generated + if ( IsMouseIn() && + (aEvent->EventType() == ESvgEngineEventMouseMove || aEvent->EventType() == ESvgEngineEventMouseDown ) + ) + { + + // Check the aSubEventMask to know whether any valid bit + // is set + if(engine->Document()->IsValidSubEventMask(aSubEventMask)) + { + engine->NotifyInteractiveElementExited(this); + } + if ( CanGenerateInternalEvent( + aSubEventMask,ESvgEventMouseout ) ) + { + TSvgInternalEvent mouseOutEvent ( + ESvgEventMouseout, this ); + engine->ProcessEventL( + ( CSvgDocumentImpl* ) OwnerDocument(), + &mouseOutEvent ); + } + if ( CanGenerateInternalEvent( + aSubEventMask,ESvgEventFocusout)) + { + TSvgInternalEvent focusOutEvent ( + ESvgEventFocusout, this ); + engine->ProcessEventL( + ( CSvgDocumentImpl* ) OwnerDocument(), + &focusOutEvent ); + } + } + SetMouseIn( EFalse ); + } + } + break; + default: + break; + } + + return EFalse; + } + + // ******************************************************* +// From MSvgEventReceiver +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TBool CSvgElementImpl::ReceiveEventL( MSvgEvent* /*aEvent*/ ) + { + // Dummy implementation + return EFalse; + } + + + + +// ******************************************************* +// From MXmlElementOpt +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::GetAttributeIntL( const TInt aNameId, TInt32& aValue ) + { + + + CCssValue* lCssValue = NULL; + + + if( aNameId == KAtrAnimMotionMatrixIndex ) + { + aValue = AnimateMotionMatrixIndexL(); + } + else if(aNameId== KAtrAnimTransformMatrixIndex) + { + aValue = AnimateTransformMatrixIndexL(); + } + else + { + if( (aNameId >= KCSS_MAX_ATTR || aNameId < 0)) + { + return KErrInvalidAttribute; + } + + if (iSvgStyleProperties == NULL ) + { + //if the style properties havent been set then just get a default one to be safe + GetDefaultAttributeL(aNameId, lCssValue); + } + else + { + lCssValue = iSvgStyleProperties->operator[](aNameId); + } + + if( lCssValue ) + { + aValue = (( CIntCssValueImpl* )lCssValue)->Value(); + + if( aNameId == KCSS_ATTR_FILL ) + { + + MGfxPaint* lPaintValue = (MGfxPaint *)((( CPaintCssValueImpl* )lCssValue)->Value()); + if(lPaintValue && lPaintValue->GetColor()== KSvgCurrentColor) + { + lPaintValue = CurrentColor(); + aValue = lPaintValue->GetColor(); + } + else if(lPaintValue) + { + aValue = lPaintValue->GetColor(); + } + else + { + return KErrNoAttribute; + } + } + else if(aNameId == KCSS_ATTR_STROKE || aNameId == KCSS_ATTR_COLOR) + { + TSvgColor *lColorValue = (( CClrCssValueImpl* )lCssValue)->Value(); + if(lColorValue) + { + aValue = lColorValue->GetColor(); + } + else + { + return KErrNoAttribute; + } + } + return KErrNone; + } + else + { + return KErrNoAttribute; + } + } + return KErrNone; + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetAttributeIntL( const TInt aNameId, + const TInt32 aValue ) + { + + + CSvgDocumentImpl* doc = ( CSvgDocumentImpl* ) OwnerDocument(); + + if (!doc) + { + return KErrNoAttribute; + } + + if( aNameId >= KCSS_MAX_ATTR || (iSvgStyleProperties == NULL)) + { + return KErrNoAttribute; + } + + CSvgElementImpl* lParentElement = (CSvgElementImpl*)ParentNode (); + while(lParentElement && (lParentElement->iSvgStyleProperties == NULL)) + { + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + switch(aNameId) + { + case KCSS_ATTR_FILL: + { + CPaintCssValueImpl* tValue = (CPaintCssValueImpl *)(iSvgStyleProperties->operator[](aNameId)); + CPaintCssValueImpl* tParentValue = NULL ; + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CPaintCssValueImpl *)(lParentElement->iSvgStyleProperties->operator[](aNameId)); + } + + if( tParentValue == tValue || tValue == NULL) //Not Yet set + { + tValue = doc->iMemoryManager->GetCssPaintObjectL(); + + CCssValue* oldValue = iSvgStyleProperties->operator[](aNameId); + PropagateToChildren( oldValue, tValue, aNameId ); + iSvgStyleProperties->operator[](aNameId) = tValue; + } + tValue->SetValueL( aValue ); + + break; + } + case KCSS_ATTR_STROKE: + case KCSS_ATTR_COLOR: + { + + CClrCssValueImpl* tValue = (CClrCssValueImpl *)(iSvgStyleProperties->operator[](aNameId)); + CClrCssValueImpl* tParentValue = NULL ; + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CClrCssValueImpl *)(lParentElement->iSvgStyleProperties->operator[](aNameId)); + } + + if( tParentValue == tValue || tValue == NULL) //Not Yet set + { + tValue = doc->iMemoryManager->GetCssClrObjectL(); + + CCssValue* oldValue = iSvgStyleProperties->operator[](aNameId); + PropagateToChildren( oldValue, tValue, aNameId ); + iSvgStyleProperties->operator[](aNameId) = tValue; + } + tValue->SetValueL( aValue ); + + break; + } + default: + { + CIntCssValueImpl* tValue = (CIntCssValueImpl *)(iSvgStyleProperties->operator[](aNameId)); + if( tValue != NULL && tValue->Value() == aValue ) + { + return KErrNone; + } + CIntCssValueImpl* tParentValue = NULL ; + if( this != doc->RootElement() && lParentElement ) + { + tParentValue = (CIntCssValueImpl *)(lParentElement->iSvgStyleProperties->operator[](aNameId)); + } + + if( tParentValue == tValue || tValue == NULL) //Not Yet set + { + tValue = doc->iMemoryManager->GetCssIntObjectL(); + + CCssValue* oldValue = iSvgStyleProperties->operator[](aNameId); + PropagateToChildren( oldValue, tValue, aNameId ); + iSvgStyleProperties->operator[](aNameId) = tValue; + + } + if( lParentElement && aValue == KInherit ) + { + tParentValue = (CIntCssValueImpl *)(lParentElement->iSvgStyleProperties->operator[](aNameId)); + (*iSvgStyleProperties)[aNameId]= tParentValue; + } + else + { + tValue->SetValueL( aValue ); + } + + break; + + } + } + return KErrNoAttribute; + + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::GetAttributeFloat( const TInt aNameId, TFloatFixPt& aValue ) + { + + CCssValue* lCssValue = NULL; + if((aNameId < KCSS_MAX_ATTR) && iSvgStyleProperties ) + { + lCssValue = iSvgStyleProperties->operator[](aNameId); + if( lCssValue ) + { + aValue = (( CFloatCssValueImpl * )lCssValue)->Value(); + return KErrNone; + } + else + { + TRAPD(err, GetDefaultAttributeL(aNameId, lCssValue)); + if (err) + { + #ifdef _DEBUG + RDebug::Printf("CSvgElementImpl::GetAttributeFloat: Error trapped=%d", err); + #endif + return KErrNoAttribute; + } + aValue = (( CFloatCssValueImpl * )lCssValue)->Value(); + return KErrNone; + } + } + return KErrNoAttribute; + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetAttributeFloatL( const TInt aNameId, + const TFloatFixPt aValue ) + { + CSvgDocumentImpl* doc = ( CSvgDocumentImpl* ) OwnerDocument(); + + if (!doc) + { + return KErrNoAttribute; + } + + if(aNameId < KCSS_MAX_ATTR && iSvgStyleProperties) + { + CSvgElementImpl* lParentElement = (CSvgElementImpl*)ParentNode (); + while(lParentElement && (lParentElement->iSvgStyleProperties == NULL)) + { + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + + + CFloatCssValueImpl* tValue = (CFloatCssValueImpl *)(iSvgStyleProperties->operator[](aNameId)); + CFloatCssValueImpl* tParentValue = NULL ; + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CFloatCssValueImpl *)(lParentElement->iSvgStyleProperties->operator[](aNameId)); + + } + + if( tParentValue == tValue || tValue == NULL) //Not Yet set + { + tValue = doc->iMemoryManager->GetCssFloatObjectL(); + + + CCssValue* oldValue = iSvgStyleProperties->operator[](aNameId); + PropagateToChildren( oldValue, tValue, aNameId ); + + iSvgStyleProperties->operator[](aNameId) = tValue; + } + return tValue->SetValueL( aValue ); + + } + return KErrNoAttribute; + + } + + +void CSvgElementImpl::GetSvgStylePropertiesArray( RPointerArray*& aSvgStyleProperties) + { + aSvgStyleProperties = iSvgStyleProperties; + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::GetAttributePath( const TInt /* aNameId */, + CGfxGeneralPath*& /* aValue */ ) + { + return KErrNoAttribute; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetAttributePathL( const TInt /*aNameId */, + CGfxGeneralPath* /* aValue */ ) + { + return KErrNoAttribute; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetAttributePathRef( const TInt /*aNameId */, + CGfxGeneralPath*& /* aValue */ ) + { + return KErrNoAttribute; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::GetAttributeDes( const TInt aNameId, TPtrC16& aValue ) + { + CCssValue* lCssValue = NULL; + + if(aNameId < KCSS_MAX_ATTR && iSvgStyleProperties) + { + lCssValue = iSvgStyleProperties->operator[](aNameId); + if( lCssValue ) + { + aValue.Set( (( CStrCssValueImpl * )lCssValue)->Value() ); + return KErrNone; + + } + else + { + TBool defaultAttr = EFalse; + TRAPD(err, defaultAttr = GetDefaultAttributeL(aNameId, lCssValue)); + if (err) + { + #ifdef _DEBUG + RDebug::Printf("CSvgElementImpl::GetAttributeDes: Error trapped=%d", err); + #endif + return KErrNoAttribute; + } + + if (defaultAttr && lCssValue) + { + aValue.Set( (( CStrCssValueImpl * )lCssValue)->Value() ); + return KErrNone; + } + return KErrNoAttribute; + } + } + // This is added for JSR API's and this is helpful for testing of the JSR API's + if(aNameId == KAtrId) + { + if( Id() ) + { + aValue.Set( *Id() ); + return KErrNone; + } + } + return KErrNoAttribute; + + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +TInt CSvgElementImpl::SetAttributeDesL( const TInt aNameId, + const TDesC& aValue ) + { + CSvgDocumentImpl* doc = ( CSvgDocumentImpl* ) OwnerDocument(); + + if (!doc) + { + return KErrNoAttribute; + } + + if(aNameId < KCSS_MAX_ATTR && iSvgStyleProperties) + { + + CSvgElementImpl* lParentElement = (CSvgElementImpl*)ParentNode (); + while(lParentElement && (lParentElement->iSvgStyleProperties == NULL)) + { + lParentElement = (CSvgElementImpl*)lParentElement->ParentNode (); + } + + CStrCssValueImpl* tValue = (CStrCssValueImpl *)(iSvgStyleProperties->operator[](aNameId)); + CStrCssValueImpl* tParentValue = NULL ; + if( this != doc->RootElement() && lParentElement) + { + tParentValue = (CStrCssValueImpl *)(lParentElement->iSvgStyleProperties->operator[](aNameId)); + } + + if( tParentValue == tValue || tValue == NULL) //Not Yet set + { + tValue = doc->iMemoryManager->GetCssStrObjectL(KNullDesC); + + + CCssValue* oldValue = iSvgStyleProperties->operator[](aNameId); + PropagateToChildren( oldValue, tValue, aNameId ); + + iSvgStyleProperties->operator[](aNameId) = tValue; + + } + return tValue->SetValueL( aValue ); + + } + // the following code is added to modify the Id. This might be needed for the JSR API's + if(aNameId == KAtrId) + { + delete iId; + iId = NULL; + iId = aValue.AllocL(); + return KErrNone; + } + return KErrNoAttribute; + + + } + +// --------------------------------------------------------------------------- +// Internal public method (public but not exported) +// --------------------------------------------------------------------------- +TInt32 CSvgElementImpl::AnimateMotionMatrixIndexL() + { + if ( iAnimateMotionMatrixIndex < 0 && iSvgTransformable ) + { + TGfxAffineTransform ident; + MSvgTransformList* trList; + this->GetTransform( trList ); + trList->AppendItemL( ident, ETrue, ETrue ); // Set identity transform + iAnimateMotionMatrixIndex = ( TInt16 ) ( trList->NumberOfItems() - 1 );// Keep index in list for this anim element + } + + return iAnimateMotionMatrixIndex; + } +TInt32 CSvgElementImpl::AnimateTransformMatrixIndexL() + { + if ( iAnimateTransformMatrixIndex < 0 && iSvgTransformable ) + { + TGfxAffineTransform ident; + MSvgTransformList* trList; + this->GetTransform( trList ); + trList->AppendItemL( ident, ETrue, 2); // Set identity transform + iAnimateTransformMatrixIndex = trList->NumberOfItems() - 1;// Keep index in list for this anim element */ + } + + return iAnimateTransformMatrixIndex; + } +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::GetBBox( TGfxRectangle2D& /*aBbox*/ ) + { + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::GetUnscaledBBox( TGfxRectangle2D& /*aBbox*/ ) + { + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +void CSvgElementImpl::ResetReferenceElementL() + { + } + +// --------------------------------------------------------------------------- +// perform a deep clone of this object +// --------------------------------------------------------------------------- +MXmlElement* CSvgElementImpl::CloneL(MXmlElement*) + { + return NULL; + } + +// --------------------------------------------------------------------------- +// copy the contents of this object to the passed object +// this method assumes that the passed object has already been +// created using the proper NewL method. +// --------------------------------------------------------------------------- +void CSvgElementImpl::CopyL( CSvgElementImpl* aDestElement ) + { + + if(aDestElement) + { + + if( iSvgStyleProperties ) + { + aDestElement->iSvgStyleProperties->Reset(); + + CloneSvgStylePropertiesL(aDestElement,(CSvgElementImpl *)(aDestElement->ParentNode())); + } + + + // copy iSvgTransformable (CSvgTransformableImpl) + if( iSvgTransformable ) + { + if ( aDestElement->iSvgTransformable != NULL ) + { + delete aDestElement->iSvgTransformable; + aDestElement->iSvgTransformable = NULL; + } + aDestElement->iSvgTransformable = this->iSvgTransformable->CloneL(); + } + + // copy iSvgTests (CSvgTestImpl) + if( iSvgTests ) + { + if ( aDestElement->iSvgTests != NULL ) + { + delete aDestElement->iSvgTests; + aDestElement->iSvgTests = NULL; + } + aDestElement->iSvgTests = this->iSvgTests->CloneL(); + } + + // copy iSvgUriReferenceImpl (CSvgUriReferenceImpl) + if( iSvgUriReferenceImpl ) + { + if ( aDestElement->iSvgUriReferenceImpl != NULL ) + { + delete aDestElement->iSvgUriReferenceImpl; + aDestElement->iSvgUriReferenceImpl = NULL; + } + aDestElement->iSvgUriReferenceImpl = this->iSvgUriReferenceImpl->CloneL(); + } + + // copy iSvgLangSpace (CSvgLangSpaceImpl) + if( iSvgLangSpace ) + { + if ( aDestElement->iSvgLangSpace != NULL ) + { + delete aDestElement->iSvgLangSpace; + aDestElement->iSvgLangSpace = NULL; + } + aDestElement->iSvgLangSpace = this->iSvgLangSpace->CloneL(); + } + + // copy Id (iId) + if( iId ) + { + aDestElement->SetAttributeDesL( KAtrId, *iId ); + } + + // copy stuff from superclass + this->CXmlElementImpl::CopyL(aDestElement); + } + + } + +void CSvgElementImpl::PropagateToChildren( CCssValue *oldValue, CCssValue *newValue, const TInt aNameId ) + { + CSvgElementImpl *lChild = (CSvgElementImpl *)FirstChild(); + + while(lChild) + { + if( lChild->iSvgStyleProperties ) + { + if( lChild->iSvgStyleProperties->operator[](aNameId) == oldValue) + { + lChild->iSvgStyleProperties->operator[](aNameId) = newValue; + if( lChild->FirstChild() ) + { + lChild = (CSvgElementImpl *)lChild->FirstChild(); + continue; + } + + } + } + else + { + if( lChild->FirstChild() ) + { + lChild = (CSvgElementImpl *)lChild->FirstChild(); + continue; + } + } + + + if( lChild->NextSibling() ) + { + lChild = (CSvgElementImpl *)lChild->NextSibling(); + } + else + { + lChild = (CSvgElementImpl *)lChild->ParentNode(); + while( lChild != this && lChild->NextSibling() == NULL ) + { + lChild = (CSvgElementImpl *)lChild->ParentNode(); + } + if( lChild == this ) + { + lChild = NULL ; + } + else + { + lChild = (CSvgElementImpl *)(lChild->NextSibling()); + } + } + } + } + +void CSvgElementImpl::CloneSvgStylePropertiesL( CSvgElementImpl* aNewChild, CSvgElementImpl* aParentElement) + { + + CSvgDocumentImpl* doc = (CSvgDocumentImpl*)OwnerDocument(); + + if (!doc) + { + return; + } + + if( iSvgStyleProperties ) + { + TInt count = iSvgStyleProperties->Count(); + CSvgElementImpl* lTmpParent = (CSvgElementImpl*)ParentNode (); + while(lTmpParent && (lTmpParent->iSvgStyleProperties == NULL)) + { + lTmpParent = (CSvgElementImpl*)lTmpParent->ParentNode (); + } + + RPointerArray*lSvgStyleProperties = NULL; + + ( ( CSvgElementImpl * ) aNewChild )->GetSvgStylePropertiesArray( lSvgStyleProperties ); + + CSvgElementImpl* lTmpCloneParent = aParentElement; + while(lTmpCloneParent && (lTmpCloneParent->iSvgStyleProperties == NULL)) + { + lTmpCloneParent = (CSvgElementImpl*)lTmpCloneParent->ParentNode (); + } + + for ( TInt i = 0; i < count; i++ ) + { + if( lTmpParent && (lTmpParent->iSvgStyleProperties->operator[]( i ) == iSvgStyleProperties->operator[]( i )) ) + { + CCssValue* lCssValue = NULL; + if( lTmpCloneParent ) + { + lCssValue = lTmpCloneParent->iSvgStyleProperties->operator[]( i ); + } + lSvgStyleProperties->InsertL(lCssValue,i); + } + else + { + + CCssValue* lCssValue = (iSvgStyleProperties->operator[]( i )); + + //CLONING VALUES THROUGH MEMORY MANAGER + + CCssValue* lCssValueCloned = doc->iMemoryManager->CloneCssValueL(lCssValue); + + lSvgStyleProperties->InsertL(lCssValueCloned,i); + } + } + } + } + +void CSvgElementImpl::ResetReferenceAttrSet() + { + if( iAnimateAttrSet ) + { + iAnimateAttrSet->Close(); + delete iAnimateAttrSet; + iAnimateAttrSet = NULL ; + } + } + + +// functions for encoding + +void CSvgElementImpl::SetTransformList(TGfxAffineTransform& aTr) + { + if( iSvgTransformable ) + { + iSvgTransformable->SetTransformList(aTr); + } + } + + +void CSvgElementImpl::SetRequiredFeatures( CDesCArrayFlat*& aRequiredFeatures ) + { + if( iSvgTests ) + { + iSvgTests->SetRequiredFeatures (aRequiredFeatures); + } + } + +void CSvgElementImpl::SetRequiredExtensions( CDesCArrayFlat*& aRequiredExtensions ) + { + if( iSvgTests ) + { + iSvgTests->SetRequiredExtensions (aRequiredExtensions); + } + } + +void CSvgElementImpl::SetSystemLanguage( CDesCArrayFlat*& aSystemLanguage ) + { + if( iSvgTests ) + { + iSvgTests->SetSystemLanguage (aSystemLanguage); + } + } + +TBool CSvgElementImpl::IsTransformable() + { + if( iSvgTransformable ) + return ETrue; + else + return EFalse; + } +TInt CSvgElementImpl::SetUriRefDesL( const TUint16 aNameId, + const TDesC& aValue ) + { + if( iSvgUriReferenceImpl ) + { + return iSvgUriReferenceImpl->SetUriRefDesL(aNameId, aValue); + } + return (TInt) EFalse; + } +void CSvgElementImpl::Reset(MSvgEvent* /*aEvent*/) + { + + } + +void CSvgElementImpl::ReInitializeAnimation() +{ + +} + +CGfxGeneralPath* CSvgElementImpl::GetPathAttribute(TInt /*aAttributeId*/) +{ + return NULL; +} +void CSvgElementImpl::SetPathAttribute(TInt /*aSvgAttrId*/, CGfxGeneralPath* /*aPathHandle*/) +{ + +} + +//this element has an animation associated with it +TBool CSvgElementImpl::HasAnimation() +{ + if (iHasAnimationBase) + { + return ETrue; + } + + return EFalse; +} + +void CSvgElementImpl::SetIsAnimating( TBool aBool ) +{ + if ( aBool ) + { + iBooleanFlags = iBooleanFlags | KAnimatingBit; + } + else + { + iBooleanFlags = iBooleanFlags & ~KAnimatingBit; + } +} + +TBool CSvgElementImpl::IsAnimating() +{ + return iBooleanFlags & KAnimatingBit; +} + +void CSvgElementImpl::SetTurnOff( TBool aBool ) +{ + if ( aBool ) + { + iBooleanFlags = iBooleanFlags | KWasTurnedOffBit; + } + else + { + iBooleanFlags = iBooleanFlags & ~KWasTurnedOffBit; + } +} + +TBool CSvgElementImpl::WasTurnedOff() +{ + return iBooleanFlags & KWasTurnedOffBit; +} + +void CSvgElementImpl::SetOverwriteTransforms( TBool aBool ) +{ + if ( aBool ) + { + iBooleanFlags = iBooleanFlags | KOverwriteTransformsBit; + } + else + { + iBooleanFlags = iBooleanFlags & ~KOverwriteTransformsBit; + } +} + +TBool CSvgElementImpl::IsOverwriteTransforms() +{ + return iBooleanFlags & KOverwriteTransformsBit; +} + +void CSvgElementImpl::SetAllAttributesAdded( TBool aBool ) +{ + if ( aBool ) + { + iBooleanFlags = iBooleanFlags | KAllAttributesAddedBit; + } + else + { + iBooleanFlags = iBooleanFlags & ~KAllAttributesAddedBit; + } +} + +TBool CSvgElementImpl::AreAllAttributesAdded() +{ + return iBooleanFlags & KAllAttributesAddedBit; +} + +void CSvgElementImpl::SetMouseDown( TBool aBool ) +{ + if ( aBool ) + { + iBooleanFlags = iBooleanFlags | KMouseDownBit; + } + else + { + iBooleanFlags = iBooleanFlags & ~KMouseDownBit; + } +} + +TBool CSvgElementImpl::IsMouseDown() +{ + return iBooleanFlags & KMouseDownBit; +} + +void CSvgElementImpl::SetMouseIn( TBool aBool ) +{ + if ( aBool ) + { + iBooleanFlags = iBooleanFlags | KMouseInBit; + } + else + { + iBooleanFlags = iBooleanFlags & ~KMouseInBit; + } +} + +TBool CSvgElementImpl::IsMouseIn() +{ + return iBooleanFlags & KMouseInBit; +} + +void CSvgElementImpl::DeactivateAnimation() +{ +} + +TBool CSvgElementImpl::DoAnimProcL(MSvgEvent* /*aEvent*/) +{ +return ETrue; +} +void CSvgElementImpl ::PointToParent(const TInt aAttrId) +{ + //this method doesnt look too good to me. + //especially since the OldPointer that is getting passed + //to PropagateToChildren is NULL + + if(aAttrId < KCSS_MAX_ATTR && iSvgStyleProperties) + { + CSvgElementImpl* lTmpParent = (CSvgElementImpl*)ParentNode (); + if(lTmpParent) + { + if(iSvgStyleProperties->operator[]( aAttrId ) != lTmpParent->iSvgStyleProperties->operator[](aAttrId )) + { + + //store the old value. + CCssValue *OldPointer = iSvgStyleProperties->operator[]( aAttrId ); + + //this deletion is no longer needed as the memory manager is in charge of this now + + // set the pointer + iSvgStyleProperties->operator[]( aAttrId ) = lTmpParent->iSvgStyleProperties->operator[](aAttrId ); + + // update the child pointers to the previous values. + PropagateToChildren(OldPointer, lTmpParent->iSvgStyleProperties->operator[](aAttrId ), aAttrId ); + } + } + } +} +TBool CSvgElementImpl::IsInherited(const TInt aAttrId) +{ +if(aAttrId < KCSS_MAX_ATTR && iSvgStyleProperties) + { + CSvgElementImpl* lTmpParent = (CSvgElementImpl*)ParentNode (); + if(lTmpParent && lTmpParent->iSvgStyleProperties) + { + return (iSvgStyleProperties->operator[]( aAttrId ) == lTmpParent->iSvgStyleProperties->operator[](aAttrId )); + } + } +return EFalse; +} + +//probably dont need this anymore +void CSvgElementImpl::InitSvgStylePropertiesWithNullL() +{ + for( int i=0; i < KCSS_MAX_ATTR; i++ ) + { + User::LeaveIfError( iSvgStyleProperties->Append( NULL ) ); + } +} + +TBool CSvgElementImpl::IsVisible() +{ + if ( !AreAllAttributesAdded() ) + { + return EFalse; + } + + TInt32 visbilityValue = -1; + TInt lReturnValue = KErrGeneral; + TRAPD(err, lReturnValue = this->GetAttributeIntL( KCSS_ATTR_VISIBILITY, visbilityValue )); + if (err) + { + #ifdef _DEBUG + RDebug::Printf("CSvgElementImpl::IsVisible() GetAttributeIntL error"); + #endif + } + + return ( ( lReturnValue == KErrNone) && (visbilityValue == 0) ); +} + +void CSvgElementImpl::PrintStyleProperties( ) +{ + //prints all of the style properties out that this element has ahold of + + #ifdef _DEBUG + if (!iSvgStyleProperties) + { + RDebug::Printf("CSvgElementImpl::PrintStyleProperties[%x]: NO STYLES FOUND", this); + return; + } + + RDebug::Printf("----STYLES---"); + for (TInt i=0; iCount(); i++) + { + switch (i) + { + case 0: + RDebug::Printf("fill=\""); + break; + case 22: + RDebug::Printf("fill-opacity=\""); + break; + case 23: + RDebug::Printf("stroke-opacity=\""); + break; + case 1: + RDebug::Printf("stroke=\""); + break; + case 2: + RDebug::Printf("stroke-width=\""); + break; + case 3: + RDebug::Printf("visibility=\""); + break; + case 4: + RDebug::Printf("font-family=\""); + break; + case 5: + RDebug::Printf("font-size=\""); + break; + case 6: + RDebug::Printf("font-style=\""); + break; + case 7: + RDebug::Printf("font-weight=\""); + break; + case 8: + RDebug::Printf("stroke-dasharray=\""); + break; + case 9: + RDebug::Printf("display=\""); + break; + case 10: + RDebug::Printf("fill-rule=\""); + break; + case 11: + RDebug::Printf("stroke-linecap=\""); + break; + case 12: + RDebug::Printf("stroke-linejoin=\""); + break; + case 13: + RDebug::Printf("stroke-dashoffset=\""); + break; + case 14: + RDebug::Printf("stroke-miterlimit=\""); + break; + case 15: + RDebug::Printf("color=\""); + break; + case 16: + RDebug::Printf("text-anchor=\""); + break; + case 17: + RDebug::Printf("text-decoration=\""); + break; + case 18: + RDebug::Printf("color-interpolation=\""); + break; + case 19: + RDebug::Printf("color-rendering=\""); + break; + case 20: + RDebug::Printf("letter-spacing=\""); + break; + case 21: + RDebug::Printf("word-spacing=\""); + break; + case 24: //THIS SHOULD BE = KSS_MAX_ATTR + RDebug::Printf("group-opacity=\""); + break; + default: + RDebug::Printf("UNKNOWN STYLE FOUND!!"); + break; + } + + if ( iSvgStyleProperties->operator[]( i ) ) + { + iSvgStyleProperties->operator[]( i )->Print(); + RDebug::Printf("\""); + } + else + { + //that style was empty + RDebug::Printf("EMPTY!!\"", i); + } + } + RDebug::Printf("---END OF STYLES---"); + + #endif + +} + +TBool CSvgElementImpl::GetDefaultAttributeL( const TInt aNameId, CCssValue*& aValue ) +{ + CSvgDocumentImpl* lDocument = (CSvgDocumentImpl*)OwnerDocument(); + + if (!lDocument) + { + return EFalse; + } + + CSvgElementImpl* lRootElement = (CSvgElementImpl*)(lDocument->RootElement()); + + if (lRootElement) + { + RPointerArray*lSvgStyleProperties = NULL; + + lRootElement->GetSvgStylePropertiesArray(lSvgStyleProperties); + + if (lSvgStyleProperties && lSvgStyleProperties->operator[](aNameId) != NULL ) + { + aValue = (CCssValue*)lSvgStyleProperties->operator[](aNameId); + return ETrue; + } + } + + switch( aNameId ) + { + // Initilaise Svg Element with default values + case KCSS_ATTR_FILL: + { + CPaintCssValueImpl* lPaintObject = lDocument->iMemoryManager->GetCssPaintObjectL(_L("black"),(CSvgElementImpl *)this); + + iSvgStyleProperties->InsertL(lPaintObject, KCSS_ATTR_FILL ); + } + case KCSS_ATTR_FILL_OPACITY: + { + CFloatCssValueImpl* lFloatObject5 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1")); + + iSvgStyleProperties->InsertL(lFloatObject5,KCSS_ATTR_FILL_OPACITY); + } + break; + + case KCSS_ATTR_STROKE_OPACITY: + { + CFloatCssValueImpl* lFloatObject6 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1")); + + iSvgStyleProperties->InsertL(lFloatObject6,KCSS_ATTR_STROKE_OPACITY); + } + break; + + case KCSS_ATTR_STROKE: + { + CClrCssValueImpl* lClrObject = lDocument->iMemoryManager->GetCssClrObjectL(_L("none")); + + iSvgStyleProperties->InsertL(lClrObject, KCSS_ATTR_STROKE); + } + break; + + case KCSS_ATTR_STROKEWIDTH: + { + CFloatCssValueImpl* lFloatObject = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1")); + + iSvgStyleProperties->InsertL(lFloatObject, KCSS_ATTR_STROKEWIDTH); + } + break; + + case KCSS_ATTR_VISIBILITY: + { + CIntCssValueImpl* lIntObject = lDocument->iMemoryManager->GetCssIntObjectL(_L("0")); + + iSvgStyleProperties->InsertL(lIntObject,KCSS_ATTR_VISIBILITY); + } + break; + + case KCSS_ATTR_FONTFAMILY: + { + iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_FONTFAMILY); + } + break; + + case KCSS_ATTR_FONTSIZE: + { + CFloatCssValueImpl* lFloatObject2 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("10")); + + iSvgStyleProperties->InsertL(lFloatObject2 ,KCSS_ATTR_FONTSIZE); + } + break; + + case KCSS_ATTR_FONTSTYLE: + { + CIntCssValueImpl* lIntObject2 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0")); + + iSvgStyleProperties->InsertL(lIntObject2,KCSS_ATTR_FONTSTYLE); + } + break; + + case KCSS_ATTR_FONTWEIGHT: + { + CIntCssValueImpl* lIntObject3 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0")); + + iSvgStyleProperties->InsertL(lIntObject3,KCSS_ATTR_FONTWEIGHT); + } + break; + + case KCSS_ATTR_STROKE_DASHARRAY: + { + iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_STROKE_DASHARRAY); + } + break; + + case KCSS_ATTR_DISPLAY: + { + //set default to inline + CIntCssValueImpl* lIntObject4 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0")); + + iSvgStyleProperties->InsertL(lIntObject4,KCSS_ATTR_DISPLAY); + } + break; + + case KCSS_ATTR_FILLRULE: + { + CStrCssValueImpl* lStrObject1 = lDocument->iMemoryManager->GetCssStrObjectL(_L("nonzero")); + + iSvgStyleProperties->InsertL(lStrObject1,KCSS_ATTR_FILLRULE); + } + break; + + case KCSS_ATTR_STROKE_LINECAP: + { + CStrCssValueImpl* lStrObject2 = lDocument->iMemoryManager->GetCssStrObjectL(_L("butt")); + + iSvgStyleProperties->InsertL(lStrObject2,KCSS_ATTR_STROKE_LINECAP); + } + break; + + case KCSS_ATTR_STROKE_LINEJOIN: + { + CStrCssValueImpl* lStrObject3 = lDocument->iMemoryManager->GetCssStrObjectL(_L("miter")); + + iSvgStyleProperties->InsertL(lStrObject3,KCSS_ATTR_STROKE_LINEJOIN); + } + break; + + case KCSS_ATTR_STROKE_DASHOFFSET: + { + CFloatCssValueImpl* lFloatObject3 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("0")); + + iSvgStyleProperties->InsertL(lFloatObject3,KCSS_ATTR_STROKE_DASHOFFSET); + } + break; + + case KCSS_ATTR_STROKE_MITERLIMIT: + { + CFloatCssValueImpl* lFloatObject4 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("4")); + + iSvgStyleProperties->InsertL(lFloatObject4,KCSS_ATTR_STROKE_MITERLIMIT); + } + break; + + case KCSS_ATTR_COLOR: + { + CClrCssValueImpl* lClrObject4 = lDocument->iMemoryManager->GetCssClrObjectL(_L("black")); + + iSvgStyleProperties->InsertL(lClrObject4,KCSS_ATTR_COLOR); + } + break; + + case KCSS_ATTR_TEXTANCHOR: + { + CIntCssValueImpl* lIntObject5 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0")); + + iSvgStyleProperties->InsertL(lIntObject5,KCSS_ATTR_TEXTANCHOR); + } + break; + + case KCSS_ATTR_TEXTDECORATION: + { + CIntCssValueImpl* lIntObject6 = lDocument->iMemoryManager->GetCssIntObjectL(_L("-1")); + + iSvgStyleProperties->InsertL(lIntObject6,KCSS_ATTR_TEXTDECORATION); + } + break; + + case KCSS_ATTR_COLORINTERPOLATION: + { + iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_COLORINTERPOLATION); + } + break; + + case KCSS_ATTR_COLORRENDERING: + { + iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_COLORRENDERING); + } + break; + + case KCSS_ATTR_LETTERSPACING: + { + iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_LETTERSPACING); + } + break; + + case KCSS_ATTR_WORDSPACING: + { + iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_WORDSPACING); + } + break; + + case KCSS_ATTR_GROUP_OPACITY: + { + CFloatCssValueImpl* lFloatObject7 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1")); + + iSvgStyleProperties->InsertL(lFloatObject7,KCSS_ATTR_GROUP_OPACITY); + } + break; + + default: + { + //don't know the element + return EFalse; + } + } + + aValue = (CCssValue*)iSvgStyleProperties->operator[](aNameId); + return ETrue; +} + +TFloatFixPt CSvgElementImpl::GetCurrentScale( ) +{ + const TGfxAffineTransform& ctm = GetCTM(); + //GET THE SCALE FACTOR FROM THE CURRENT ELEMENT + TGfxPoint2D ep( 1, 0 ), org( 2, 0 ); + ctm.Transform( &ep, & ep, 1 ); + ctm.Transform( &org, & org, 1 ); + ep.iX -= org.iX; + ep.iY -= org.iY; + + TFloatFixPt scale = TFloatFixPt::Sqrt( ep.iX * ep.iX + ep.iY * ep.iY ); + // adjust for rounding error when rotated (and not scaled) + if ( scale < TFloatFixPt(1.0f) && scale > TFloatFixPt(0.998f) ) + { + scale = TFloatFixPt(1.0f); + } + + return scale; +} + + +//ALL animated element types must be listed here +TBool CSvgElementImpl::IsAnimatedElement( ) +{ + return ( iElemID == KSvgAnimateElement || + iElemID == KSvgAnimateColorElement || + iElemID == KSvgAnimateMotionElement || + iElemID == KSvgAnimateTransformElement || + iElemID == KSvgSetElement || + //iElemID == KSvgDiscardElement || //discard has a begin but doesn't inherit from animationbase? + iElemID == KSvgAudioElement || + iElemID == KSvgMediaAnimationElement ); +} + +TBool CSvgElementImpl::CanGenerateInternalEvent(TUint16 aSubEventmask, TSvgEvent aEvent) + { + TUint16 tmp=aSubEventmask; + switch(aEvent) + { + case ESvgEventActivate: + tmp= tmp & ESvgInteractiveEventActivate; + break; + case ESvgEventClick: + tmp = tmp & ESvgInteractiveEventClick; + break; + case ESvgEventMouseover: + tmp = tmp & ESvgInteractiveEventMouseover; + break; + case ESvgEventMousemove: + tmp = tmp & ESvgInteractiveEventMousemove; + break; + case ESvgEventFocusin: + tmp = tmp & ESvgInteractiveEventFocusin; + break; + case ESvgEventMouseout: + tmp = tmp & ESvgInteractiveEventMouseout; + break; + case ESvgEventFocusout: + tmp = tmp & ESvgInteractiveEventFocusout; + break; + default: + tmp=0; + } + if(tmp) + { + return ETrue; + } + else + { + return EFalse; + } + } +TBool CSvgElementImpl::IsSVGEnginePaused() +{ + CSvgEngineImpl* lEngine = ( ( CSvgDocumentImpl* ) OwnerDocument() )->Engine(); + return ( lEngine->IsSVGEnginePaused() ); + +}