/*

* 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 "SVGSvgElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGEngineImpl.h"

#include "SVGSchemaData.h"

#include "SVGClrCssValueImpl.h"

#include "SVGPaintCssValueImpl.h"

#include "SVGIntCssValueImpl.h"

#include "SVGFloatCssValueImpl.h"

#include "SVGStrCssValueImpl.h"

#include "SVGVectorCssValueImpl.h"

#include "SVGPathElementImpl.h"

#include "SVGAnimTimingParser.h"

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

//

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

CSvgSvgElementImpl* CSvgSvgElementImpl::NewL(  const TUint8 aElemID,

                                              CSvgDocumentImpl* aDoc )

    {

    CSvgSvgElementImpl* self    = new ( ELeave ) CSvgSvgElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID);

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgSvgElementImpl* CSvgSvgElementImpl::NewLC(  const TUint8 aElemID,

                                               CSvgDocumentImpl* aDoc )

    {

    CSvgSvgElementImpl* self    = new ( ELeave ) CSvgSvgElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL( aElemID);

    return self;

    }

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

//

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

void CSvgSvgElementImpl::ConstructL( const TUint8 aElemID )

    {

    CSvgElementImpl::InitializeL( aElemID );

    iSvgStyleProperties = new(ELeave) RPointerArray<CCssValue>(KCSS_MAX_ATTR);

	CSvgDocumentImpl* lDocument = (CSvgDocumentImpl*)OwnerDocument();

	if (!lDocument)

	return;

    // This is required to allocate buffer up to granularity so that the

    // following Insert calls cannot leave.

    User::LeaveIfError( iSvgStyleProperties->Append( NULL ) );

    iSvgStyleProperties->Remove( 0 );

    iSvgTransformable = CSvgTransformableImpl::NewL();

    // Initilaise Svg Element with default values

    CPaintCssValueImpl* lPaintObject = lDocument->iMemoryManager->GetCssPaintObjectL( _L("black"),(CSvgElementImpl *)this );

    iSvgStyleProperties->InsertL(lPaintObject,KCSS_ATTR_FILL);

	CClrCssValueImpl* lClrObject = lDocument->iMemoryManager->GetCssClrObjectL(_L("none"));

    iSvgStyleProperties->InsertL(lClrObject,KCSS_ATTR_STROKE);

	CFloatCssValueImpl* lFloatObject = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1"));

    iSvgStyleProperties->InsertL(lFloatObject,KCSS_ATTR_STROKEWIDTH);

    //set default to visible

    CIntCssValueImpl* lIntObject = lDocument->iMemoryManager->GetCssIntObjectL(_L("0"));

    iSvgStyleProperties->InsertL(lIntObject,KCSS_ATTR_VISIBILITY);

    iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_FONTFAMILY);

	CFloatCssValueImpl* lFloatObject2 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("10"));

    iSvgStyleProperties->InsertL(lFloatObject2,KCSS_ATTR_FONTSIZE);

	CIntCssValueImpl* lIntObject2 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0"));

    iSvgStyleProperties->InsertL(lIntObject2,KCSS_ATTR_FONTSTYLE);

	CIntCssValueImpl* lIntObject3 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0"));

    iSvgStyleProperties->InsertL(lIntObject3,KCSS_ATTR_FONTWEIGHT);

    iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_STROKE_DASHARRAY);

    //set default to inline

    CIntCssValueImpl* lIntObject4 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0"));

    iSvgStyleProperties->InsertL(lIntObject4,KCSS_ATTR_DISPLAY);

	CStrCssValueImpl* lStrObject1 = lDocument->iMemoryManager->GetCssStrObjectL(_L("nonzero"));

    iSvgStyleProperties->InsertL(lStrObject1,KCSS_ATTR_FILLRULE);

	CStrCssValueImpl* lStrObject2 = lDocument->iMemoryManager->GetCssStrObjectL(_L("butt"));

    iSvgStyleProperties->InsertL(lStrObject2,KCSS_ATTR_STROKE_LINECAP);

	CStrCssValueImpl* lStrObject3 = lDocument->iMemoryManager->GetCssStrObjectL(_L("miter"));

    iSvgStyleProperties->InsertL(lStrObject3,KCSS_ATTR_STROKE_LINEJOIN);

	CFloatCssValueImpl* lFloatObject3 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("0"));

    iSvgStyleProperties->InsertL(lFloatObject3,KCSS_ATTR_STROKE_DASHOFFSET);

	CFloatCssValueImpl* lFloatObject4 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("4"));

    iSvgStyleProperties->InsertL(lFloatObject4,KCSS_ATTR_STROKE_MITERLIMIT);

	CClrCssValueImpl* lClrObject2 = lDocument->iMemoryManager->GetCssClrObjectL(_L("black"));

    iSvgStyleProperties->InsertL(lClrObject2,KCSS_ATTR_COLOR);

	CIntCssValueImpl* lIntObject5 = lDocument->iMemoryManager->GetCssIntObjectL(_L("0"));

    iSvgStyleProperties->InsertL(lIntObject5,KCSS_ATTR_TEXTANCHOR);

	CIntCssValueImpl* lIntObject6 = lDocument->iMemoryManager->GetCssIntObjectL(_L("-1"));

    iSvgStyleProperties->InsertL(lIntObject6,KCSS_ATTR_TEXTDECORATION);

    //default value is indeterminate at this point

    iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_COLORINTERPOLATION);

    iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_COLORRENDERING);

    iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_LETTERSPACING);

    iSvgStyleProperties->InsertL(NULL,KCSS_ATTR_WORDSPACING);

	CFloatCssValueImpl* lFloatObject5 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1"));

    iSvgStyleProperties->InsertL(lFloatObject5,KCSS_ATTR_FILL_OPACITY);

	CFloatCssValueImpl* lFloatObject6 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1"));

    iSvgStyleProperties->InsertL(lFloatObject6,KCSS_ATTR_STROKE_OPACITY);

	CFloatCssValueImpl* lFloatObject7 = lDocument->iMemoryManager->GetCssFloatObjectL(_L("1"));

    iSvgStyleProperties->InsertL(lFloatObject7,KCSS_ATTR_GROUP_OPACITY);

    iViewBoxImpl = CSvgFitToViewBoxImpl::NewL();

    iBaseProfile = HBufC::NewL( 0 );

    iVersion = HBufC::NewL( 0 );

    SetBaseProfileL(_L("tiny"));

    SetVersion(_L("1.1"));

	iWidthInUserCoordinate = 100;

	iHeightInUserCoordinate= 100;

    }

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

//

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

CSvgSvgElementImpl::~CSvgSvgElementImpl()

    {

    if (iContent)

    {

	delete iContent;

	iContent = NULL;

    }

    if ( iViewBoxImpl )

        {

        delete iViewBoxImpl;

        iViewBoxImpl = NULL;

        }

    if ( iBaseProfile )

        {

        delete iBaseProfile;

        iBaseProfile = NULL;

        }

    if ( iVersion )

    	{

    	delete iVersion;

    	iVersion = NULL;

        }

    if ( iSvgStyleProperties )

        {

        iSvgStyleProperties->Close();

        delete iSvgStyleProperties;

        iSvgStyleProperties = NULL;

        }

    }

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

//

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

CSvgSvgElementImpl::CSvgSvgElementImpl( CSvgDocumentImpl* aDoc ) : iZoomAndPan( ESvgZoomAndPanMagnify ),

                                                                   iWidth(100),

                                                                   iHeight(100),

                                                                   iWidthInPercentage(ETrue),

                                                                   iHeightInPercentage(ETrue),

                                                                   iIsWidthSet(EFalse),

                                                                   iIsHeightSet(EFalse)

    {

    SetOwnerDocument(aDoc);

    // Obtain the default sync behaviour/tolerance from the document

    if ( aDoc )

        {

        iSyncBehaviorDefault = aDoc->SyncBehaviorDefault();

        iSyncToleranceDefault = aDoc->SyncToleranceDefault();

        }    

    }

// *******************************************************

// From SVG DOM

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

//

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

TFloatFixPt CSvgSvgElementImpl::X()

    {

    return iX;

    }

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

//

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

TFloatFixPt CSvgSvgElementImpl::Y()

    {

    return iY;

    }

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

//

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

TFloatFixPt CSvgSvgElementImpl::Width()

    {

    return iWidth;

    }

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

//

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

TFloatFixPt CSvgSvgElementImpl::Height()

    {

    return iHeight;

    }

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

// Accessor funciton for SyncBehaviorDefault value

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

TSvgSyncBehaviour CSvgSvgElementImpl::SyncBehaviorDefault()

    {

    return iSyncBehaviorDefault;

    }

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

// Accessor funciton for SyncBehaviorDefault value

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

TUint32 CSvgSvgElementImpl::SyncToleranceDefault()

    {

    return iSyncToleranceDefault;

    }

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

//

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

MXmlElement* CSvgSvgElementImpl::GetElementById( const TDesC& /* aElementId */ )

    {

    return ( CSvgElementImpl * ) NULL;

    }

// *******************************************************

// SVG Implementation

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

//

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

void CSvgSvgElementImpl::SetWidth( TFloatFixPt aWidth )

    {

    iWidth = aWidth;

    }

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

//

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

void CSvgSvgElementImpl::SetHeight( TFloatFixPt aHeight )

    {

    iHeight = aHeight;

    }

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

//

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

// *******************************************************

// From MXmlElement

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

//

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

EXPORT_C TInt CSvgSvgElementImpl::GetAttribute( const TDesC& aName,

                                                TDes& aValue )

    {

    _LIT( KTmpWidth, "width" );

    _LIT( KTmpHeight, "height" );

    if ( aName == KTmpWidth )

        {

        TFloatFixPt  width;

        GetAttributeFloat( KAtrWidth, width );

	#ifdef SVG_FLOAT_BUILD

        TFloatFixPt::GetString( width, aValue );

	#else

        width.GetString( aValue );

	#endif

        }

    else if ( aName == KTmpHeight )

        {

        TFloatFixPt  height;

        GetAttributeFloat( KAtrHeight, height );

	#ifdef SVG_FLOAT_BUILD

        TFloatFixPt::GetString( height, aValue );

	#else

        height.GetString( aValue );

	#endif

        }

    return KErrNone;

    }

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

//

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

TInt CSvgSvgElementImpl::SetAttributeL( const TDesC& aName,

                                        const TDesC& aValue )

    {

    CSvgElementImpl::SetAttributeL(aName,aValue);

    // Encapsulates both viewBox and preserveAspectRatio attributes.

    if ( iViewBoxImpl->SetViewBoxL( aName, aValue ) )

        {

        return KErrNone;

        }

    _LIT( KTmpBaseProfile, "baseProfile" );

    _LIT( KTmpVersion, "version" );

    _LIT( KTmpZoomAndPan, "zoomAndPan" );

    _LIT( KTmpDisable, "disable" );

    _LIT( KTmpMagnify, "magnify" );

    _LIT( KNameSpace, "xmlns" );

    _LIT( KSvgNameSpace, "http://www.w3.org/2000/svg" );

    _LIT( KTmpSyncBehaviorDefault, "syncBehaviorDefault" );

    _LIT( KTmpSyncToleranceDefault,"syncToleranceDefault" );

    TLex    input   ( aValue );

    if ( aName == KTmpBaseProfile )

        {

        SetBaseProfileL( aValue );

        }

    else if ( aName == KTmpVersion )

        {

        //if (input.Val( tmpFloat, '.' ) == KErrNone)

        SetVersion( aValue );

        }

    else if ( aName == KTmpZoomAndPan )

        {

        if ( aValue == KTmpDisable )

            iZoomAndPan = ESvgZoomAndPanDisable;

        else if ( aValue == KTmpMagnify )

            iZoomAndPan = ESvgZoomAndPanMagnify;

        }

    else if ( aName == KNameSpace && aValue != KSvgNameSpace )

        {

        if ( iOwnerDocument )

            {

            _LIT( KMsg, "Invalid <svg> namespace: " );

            ((CSvgDocumentImpl*)iOwnerDocument)->SetError( KErrNotFound, KMsg, aValue );

            }

        }

    else if ( aName == KTmpSyncBehaviorDefault )

        {

        SetSyncBehaviorDefault( aValue );

        }

    else if ( aName == KTmpSyncToleranceDefault )

        {

        SetSyncToleranceDefault( aValue );

        }

    return KErrNone;

    }

// *******************************************************

// From MXmlElementOpt

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

//

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

TInt CSvgSvgElementImpl::GetAttributeFloat( const TInt aNameId, TFloatFixPt& aValue )

    {

    switch ( aNameId )

        {

        case KAtrX:

        aValue = X();

        break;

        case KAtrY:

        aValue = Y();

        break;

        case KAtrWidth:

        aValue = Width();

        break;

        case KAtrHeight:

        aValue = Height();

        break;

        default:

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

//

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

        return CSvgElementImpl::GetAttributeFloat( aNameId, aValue );

        }

    return KErrNone;

    }

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

//

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

TInt CSvgSvgElementImpl::SetAttributeFloatL( const TInt aNameId,

                                             const TFloatFixPt aValue )

    {

    TGfxRectangle2D lViewBox;

    switch ( aNameId )

        {

        case KAtrX:

        iX = aValue;

        break;

        case KAtrY:

        iY = aValue;

        break;

        case KAtrWidth:

        iWidth = aValue;

        if(!iIsWidthSet) // make sure that this is set only once

	        {

	        iWidthInUserCoordinate = (TReal32)aValue;

	        iIsWidthSet = ETrue;

	        }

        break;

        case KAtrHeight:

        iHeight = aValue;

        if(!iIsHeightSet ) // make sure that this is set only once

	        {

	        iHeightInUserCoordinate = (TReal32)aValue;

	        iIsHeightSet= ETrue;

	        }

        break;

        default:

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

//

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

        return CSvgElementImpl::SetAttributeFloatL( aNameId, aValue );

        }

    return KErrNone;

    }

// *******************************************************

// From CSvgElementImpl

// perform a deep clone of this object

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

//

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

MXmlElement* CSvgSvgElementImpl::CloneL(MXmlElement* aParentElement)

    {

    CSvgSvgElementImpl* retValue = CSvgSvgElementImpl::NewL(this->ElemID(),  ((CSvgDocumentImpl*)iOwnerDocument));

    CleanupStack::PushL(retValue);

    retValue->iParentNode = aParentElement;

    // *** have base class copy what it needs to

    this->CopyL(retValue);

    // *** copy iViewBoxImpl

    if (this->iViewBoxImpl != NULL)

        {

        if (retValue->iViewBoxImpl != NULL)

        {

			delete retValue->iViewBoxImpl;

			retValue->iViewBoxImpl= NULL;

		}

        retValue->iViewBoxImpl = this->iViewBoxImpl->CloneL();

        }

    // *** copy iBaseProfile

    if (retValue->iBaseProfile != NULL)

        {

        delete retValue->iBaseProfile;