/*

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

#include "SVGElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGSchemaData.h"

#include "GfxAffineTransform.h"

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

//

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

CSvgCircleElementImpl* CSvgCircleElementImpl::NewL(  const TUint8 aElemID,

                                                    CSvgDocumentImpl* aDoc )

    {

    CSvgCircleElementImpl*  self    = new ( ELeave )

                                      CSvgCircleElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL( aElemID );

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgCircleElementImpl* CSvgCircleElementImpl::NewLC(  const TUint8 aElemID,

                                                     CSvgDocumentImpl* aDoc )

    {

    CSvgCircleElementImpl*  self    = new ( ELeave )

                                      CSvgCircleElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID );

    return self;

    }

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

//

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

void CSvgCircleElementImpl::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();

	iReqAttrFlag=KSVG_CIRCLE_ELEMFLAG;

    }

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

//

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

CSvgCircleElementImpl::~CSvgCircleElementImpl()

    {

	if ( iSvgStyleProperties )

		{

		iSvgStyleProperties->Close();

		delete iSvgStyleProperties;

		iSvgStyleProperties = NULL;

		}

    }

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

// From SVG DOM

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

//

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

TFloatFixPt CSvgCircleElementImpl::Cx()

    {

	#ifdef SVG_FLOAT_BUILD

		return iCircle.iX + (iCircle.iWidth * TFloatFixPt( 0.5f ) );

	#else

	return iCircle.iX + (iCircle.iWidth >> 1);

	#endif

    }

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

//

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

TFloatFixPt CSvgCircleElementImpl::Cy()

    {

	#ifdef SVG_FLOAT_BUILD

    return iCircle.iY + (iCircle.iHeight * .5f);

	#else

    return iCircle.iY + (iCircle.iHeight >> 1);

	#endif

    }

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

//

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

TFloatFixPt CSvgCircleElementImpl::R()

    {

	#ifdef SVG_FLOAT_BUILD

    return iCircle.iWidth * .5f;

	#else

    return iCircle.iWidth >> 1;

	#endif

    }

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

// SVG Implementation

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

//

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

void CSvgCircleElementImpl::SetCx( TFloatFixPt aCx )

    {

	#ifdef SVG_FLOAT_BUILD

    iCircle.iX = aCx - (iCircle.iWidth * .5f);

	#else

    iCircle.iX = aCx - (iCircle.iWidth >> 1);

	#endif

    }

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

//

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

void CSvgCircleElementImpl::SetCy( TFloatFixPt aCy )

    {

	#ifdef SVG_FLOAT_BUILD

    iCircle.iY = aCy - (iCircle.iHeight * .5f);

	#else

    iCircle.iY = aCy - (iCircle.iHeight >> 1);

	#endif

    }

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

//

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

void CSvgCircleElementImpl::SetR( TFloatFixPt aR )

    {

	#ifdef SVG_FLOAT_BUILD

    if (aR < TFloatFixPt(0))

        {

        aR = 0;

        }

    iCircle.iX += (iCircle.iWidth * TFloatFixPt(.5f)) - aR;

    iCircle.iWidth = aR * TFloatFixPt(2.0f);

    // Both x and width will be changed.

    iCircle.iY += (iCircle.iHeight * TFloatFixPt(.5f)) - aR;

    iCircle.iHeight = aR * TFloatFixPt(2.0f);

	#else

    if (aR < TFloatFixPt(0, ETrue))

        {

        aR = TFloatFixPt(0, ETrue);

        }

    iCircle.iX += (iCircle.iWidth >> 1) - aR;

    iCircle.iWidth = aR << 1;

    // Both x and width will be changed.

    iCircle.iY += (iCircle.iHeight >> 1) - aR;

    iCircle.iHeight = aR << 1;

	#endif

    }

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

// From MXmlElement

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

//

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

TInt CSvgCircleElementImpl::SetAttributeL( const TDesC& aName,

                                           const TDesC& aValue )

    {

	CSvgElementImpl::SetAttributeL(aName,aValue);

    return KErrNone;

    }

// From MXmlElementOpt

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

//

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

TInt CSvgCircleElementImpl::GetAttributeFloat( const TInt aNameId,

                                               TFloatFixPt& aValue )

    {

    switch ( aNameId )

        {

        case KAtrCx:

        case KAtrRefX:

        aValue = Cx();

        break;

        case KAtrCy:

        case KAtrRefY:

        aValue = Cy();

        break;

        case KAtrRadius:

        aValue = R();

        break;

        default:

        return CSvgElementImpl::GetAttributeFloat( aNameId, aValue );

        }

    return KErrNone;

    }

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

//

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

TInt CSvgCircleElementImpl::SetAttributeFloatL( const TInt aNameId,

                                                const TFloatFixPt aValue )

    {

    switch ( aNameId )

        {

        case KAtrCx:

        SetCx( aValue );

        break;

        case KAtrCy:

        SetCy( aValue );

        break;

        case KAtrRadius:

		SetR( aValue );

		iReqAttrFlag = 0;

		if ( WasTurnedOff() )

        {

        _LIT(KInline , "inline");

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

        // hence we can render it.

        CSvgElementImpl::SetPropertyL(KCSS_ATTR_DISPLAY, KInline);

        SetTurnOff( EFalse );

        }

		break;

        default:

        return CSvgElementImpl::SetAttributeFloatL( aNameId, aValue );

        }

    return KErrNone;

    }

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

// From CSvgElementImpl

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

//

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

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

    {

	TFloatFixPt lValue;

	this->GetAttributeFloat(KAtrRadius,lValue);

	if (lValue.iValue <= 0)

		{

		return ETrue;

		}

    this->DrawShapeL( aGc, iCircle, aElement );

    return ETrue;

    }

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

// Private

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

//

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

CSvgCircleElementImpl::CSvgCircleElementImpl( CSvgDocumentImpl* aDoc ) : iCircle( 0,

                                                                                  0,

                                                                                  0,

                                                                                  0 )

    {

	SetOwnerDocument(aDoc);

    }

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

//

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

void CSvgCircleElementImpl::GetBBox( TGfxRectangle2D& aBbox )

    {

    iCircle.GetBounds( GetCTM(), aBbox );

    }

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

//

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

void CSvgCircleElementImpl::GetUnscaledBBox( TGfxRectangle2D& aBbox )

    {

    TGfxAffineTransform identityTx;

    iCircle.GetBounds( identityTx, aBbox );

    }

// perform a deep clone of this object

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

//

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

MXmlElement* CSvgCircleElementImpl::CloneL(MXmlElement* aParentElement)

    {

	CSvgCircleElementImpl* newElement = CSvgCircleElementImpl::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 CSvgCircleElementImpl::CopyL( CSvgCircleElementImpl* aDestElement )

    {

   if(aDestElement)

	   	{

	    // copy iCircle items special to circle

	    aDestElement->iCircle.iX = this->iCircle.iX;

	    aDestElement->iCircle.iY = this->iCircle.iY;

	    aDestElement->iCircle.iWidth = this->iCircle.iWidth;

	    aDestElement->iCircle.iHeight = this->iCircle.iHeight;

	    // copy the reference to idoc (CSvgDocumentImpl)

	    aDestElement->iOwnerDocument = this->iOwnerDocument;

		// copy stuff from superclass

	    this->CSvgElementImpl::CopyL(aDestElement);

	    }

    }

void CSvgCircleElementImpl::Print( TBool aIsEncodeOn )

{

	if (!aIsEncodeOn)

	{

		#ifdef _DEBUG

		RDebug::Printf("<circle x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\">", (int)iCircle.iX, (int)iCircle.iY, (int)iCircle.iWidth, (int)iCircle.iHeight);

		#endif

	}

}