/*

* 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 <e32base.h>

#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 (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

                {