/*

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

#include "GfxGeneralPath.h"

#include "SVGDocumentImpl.h"

#include "SVGSchemaData.h"

#include "SVGPathDataParser.h"

_LIT( D, "d" );

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

//

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

CSvgPathElementImpl* CSvgPathElementImpl::NewL(  const TUint8 aElemID,

                                                CSvgDocumentImpl* aDoc )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aElemID );

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgPathElementImpl::~CSvgPathElementImpl()

    {

    if(iShape)

		{

		delete iShape;

		iShape = NULL;

        }

	if(iSvgStyleProperties)

		{

		iSvgStyleProperties->Close();

		delete iSvgStyleProperties;

		iSvgStyleProperties = NULL;

		}

    }

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

// From MXmlElement

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

//

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

TInt CSvgPathElementImpl::SetAttributeL( const TDesC& aName,

                                         const TDesC& aValue )

    {

	CSvgElementImpl::SetAttributeL(aName,aValue);

    if ( aName == D )

        {

        iReqAttrFlag = 0;

        TSvgPathDataParser::ParsePathData( aValue, iShape );

        // verify path starts with move command

        RArray<TUint32>* typeArray = iShape->PointTypeArray();

        if ( !typeArray || ( typeArray->Count() > 0 && (*typeArray)[0] != EGfxSegMoveTo ) )

            {

            if ( iOwnerDocument )

                {

                _LIT( msg1, "Missing 'move to segment' in <path>" );

                _LIT(msg2, "");

                ((CSvgDocumentImpl*)iOwnerDocument)->SetError( KErrNotFound, msg1, msg2 );

                }

            }

        }

	if (( ((CSvgElementImpl*)iParentNode) != NULL && ((CSvgElementImpl*)iParentNode)->ElemID() == KSvgGlyphElement ) && ( aName == D) )

	    {

       ((CSvgElementImpl*)iParentNode)->SetAttributeL(aName,aValue);

	    }

    return KErrNone;

    }

// From MXmlElementOpt

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

//

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

TInt CSvgPathElementImpl::GetAttributeFloat( const TInt aNameId,

                                             TFloatFixPt& aValue )

    {

    switch ( aNameId )

        {

        case KAtrRefX:

        aValue = iShape->PointCoordsArray()[0];

        break;

        case KAtrRefY:

        aValue = iShape->PointCoordsArray()[1];

        break;

        default:

        return CSvgElementImpl::GetAttributeFloat( aNameId, aValue );

        }

    return KErrNone;

    }

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

//

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

TInt CSvgPathElementImpl::GetAttributePath( const TInt aNameId,

                                            CGfxGeneralPath*& aValue )

    {

    if ( aNameId == KAtrData )

        {

        aValue = iShape;

        }

    else

        {

        aValue = NULL;

        return KErrNoAttribute;

        }

    return KErrNone;

    }

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

//

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

TInt CSvgPathElementImpl::SetAttributePathL( const TInt aNameId,

                                             CGfxGeneralPath* aValue )

    {

    if ( aNameId == KAtrData )

        {

        // copy aValue into iShape not just reassign pointers - that will cause memory leak

        // copy when CGfxGeneralPath implements a copy method

        iShape->SetPointTypeArrayL( aValue->PointTypeArray() );

        iShape->SetPointCoordsArrayL( aValue->PointCoordsArrayAll() );

        if( WasTurnedOff() )

			{

			// turn it on. this means all the required attributes Are present and

			// hence we can render it.

			_LIT(KInline , "inline");

			CSvgElementImpl::SetPropertyL(KCSS_ATTR_DISPLAY, KInline);

			SetTurnOff( EFalse );

			}

        }

    else

        {

        return KErrNoAttribute;

        }

    return KErrNone;

    }

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

//

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

TInt CSvgPathElementImpl::SetAttributePathRef( const TInt aNameId,

                                              CGfxGeneralPath*&  aValue  )

    {

    if ( aNameId == KAtrData )

        {

	    if(iShape)

			{

			delete iShape;

			iShape= NULL;

			}

		iShape= aValue;

		if (( ((CSvgElementImpl*)iParentNode) != NULL && ((CSvgElementImpl*)iParentNode)->ElemID() == KSvgGlyphElement ) && ( aNameId == KAtrD) )

		    {

            ((CSvgElementImpl*)iParentNode)->SetPathAttribute(aNameId,aValue);

		    }

        }

    else

        {

        return KErrNoAttribute;

        }

    return KErrNone;

    }

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

//

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

TBool CSvgPathElementImpl::DrawL( CGfx2dGc* aGc, CSvgElementImpl* aElement )

    {

    this->DrawShapeL( aGc, *iShape, aElement );

    return ETrue;

    }

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

//

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

void CSvgPathElementImpl::ConstructL(  const TUint8 aElemID )

    {

    CSvgElementImpl::InitializeL( aElemID );

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

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

    iSvgStyleProperties->Remove( 0 );

    iSvgTransformable = CSvgTransformableImpl::NewL();

    iShape = CGfxGeneralPath::NewL();

	iReqAttrFlag=KSVG_PATH_ELEMFLAG;

    }

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

//

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

CSvgPathElementImpl::CSvgPathElementImpl( CSvgDocumentImpl* aDoc )

    {

	SetOwnerDocument(aDoc);

    }

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

//

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

void CSvgPathElementImpl::GetBBox( TGfxRectangle2D& aBbox )

    {

    if (!iShape || iShape->PointTypeArray()->Count() == 0)

    {

    	// The D attribute has not been set yet

    	return;

    }

    iShape->GetBounds( GetCTM(), aBbox );

    }

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

//

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

void CSvgPathElementImpl::GetUnscaledBBox( TGfxRectangle2D& aBbox )

    {

    	if (!iShape || iShape->PointTypeArray()->Count() == 0)

    	{

    	// The D attribute has not been set yet

    	return;

    	}

    TGfxAffineTransform identityTx;

    iShape->GetBounds( identityTx, aBbox );

    }

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

// perform a deep clone of this object

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

MXmlElement* CSvgPathElementImpl::CloneL(MXmlElement* aParentElement)

    {

    // create new polyline

	CSvgPathElementImpl* newElement = CSvgPathElementImpl::NewL( this->ElemID(), ((CSvgDocumentImpl*)iOwnerDocument) );

	CleanupStack::PushL(newElement);

	newElement->iParentNode = aParentElement;

    // copy everything over

    this->CopyL(newElement);

	CleanupStack::Pop();

    return newElement;

    }

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

// perform a deep copy of this object

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

void CSvgPathElementImpl::CopyL( CSvgPathElementImpl* aDestElement )

    {

    if(aDestElement)

	    {

	    // copy stuff from superclass

	    this->CSvgElementImpl::CopyL(aDestElement);

	    // copy iShape

        RArray<TUint32>* lTypes = this->iShape->PointTypeArray();

        RArray<TFloatFixPt>* lCoords = this->iShape->PointCoordsArrayAll();

        aDestElement->iShape->SetPointTypeArrayL(lTypes);

        aDestElement->iShape->SetPointCoordsArrayL(lCoords);

	    // copy the reference to idoc (CSvgDocumentImpl)

	    aDestElement->iOwnerDocument = this->iOwnerDocument;

	    }

    }

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

//

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

CGfxGeneralPath* CSvgPathElementImpl::GetPathAttribute(TInt aAttributeId)

{

	if(aAttributeId == KAtrD)

		{

		return iShape;

		}

	return NULL;

}

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

//

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

void CSvgPathElementImpl::SetPathAttribute(TInt aAttributeId, CGfxGeneralPath* aPathHandle)

{

	if(aAttributeId == KAtrD)

		{

		if(iShape != aPathHandle)

			{

			delete iShape;

			iShape = aPathHandle;

			}

		}

}

void CSvgPathElementImpl::Print( TBool aIsEncodeOn )

{

	if (!aIsEncodeOn)

	{

	#ifdef _DEBUG

	RArray<TUint32>* lTypes = this->iShape->PointTypeArray();

	RArray<TFloatFixPt>* lCoords = this->iShape->PointCoordsArrayAll();

	if (lTypes->Count() != lCoords->Count())

	{

		RDebug::Printf("Invalid path points and types didnt match", this);

		return;

	}

	RDebug::Printf("<path d=\"", this);

	TInt lTypesCnt = lTypes->Count();

	for (TInt i=0; i < lTypesCnt; i++)

	{

		RDebug::Printf("%c ", lTypes->operator[]( i ));

		RDebug::Printf("%d ", (int)(lCoords->operator[]( i )));

	}

	RDebug::Printf(" z\">", this);

	#endif

	}

}