/*

* 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

 *

*/

#include "SVGMemoryManager.h"

#include "SVGPaintCssValueImpl.h"

#include "SVGFloatCssValueImpl.h"

#include "SVGIntCssValueImpl.h"

#include "SVGStrCssValueImpl.h"

#include "SVGVectorCssValueImpl.h"

#include "SVGClrCssValueImpl.h"

#include "SVGDocumentImpl.h"

class CSvgElementImpl;

const TUint CSvgMemoryManager::KCssPaintBlockSize  = 20;

const TUint CSvgMemoryManager::KCssFloatBlockSize  = 20;

const TUint CSvgMemoryManager::KCssIntBlockSize    = 20;

const TUint CSvgMemoryManager::KCssClrBlockSize    = 20;

const TUint CSvgMemoryManager::KCssStrBlockSize    = 20;

const TUint CSvgMemoryManager::KCssVectorBlockSize = 4;

// ==========================================================================

// Need method description

// ==========================================================================

CSvgMemoryManager* CSvgMemoryManager::NewL()

    {

    CSvgMemoryManager*   self    = new ( ELeave ) CSvgMemoryManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// ==========================================================================

// Need method description

// ==========================================================================

CSvgMemoryManager* CSvgMemoryManager::NewLC()

    {

    CSvgMemoryManager*   self    = new ( ELeave ) CSvgMemoryManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ==========================================================================

// Need method description

// ==========================================================================

void CSvgMemoryManager::ConstructL()

    {

    }

// ==========================================================================

// Need method description

// ==========================================================================

CSvgMemoryManager::CSvgMemoryManager() :

    iCPaintCssValueImplArrays( 2 ),

    iCFloatCssValueImplArrays( 2 ),

    iCClrCssValueImplArrays( 2 ),

    iCIntCssValueImplArrays( 2 ),

    iCStrCssValueImplArrays( 2 ),

    iCVectorCssValueImplArrays( 1 )

    {

    }

// ==========================================================================

// Need method description

// ==========================================================================

CSvgMemoryManager::~CSvgMemoryManager()

    {

    //delete all of the paint blocks

    TInt cPaintCSSValueImplArraysCnt = iCPaintCssValueImplArrays.Count();

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

        {

        delete [] iCPaintCssValueImplArrays[i];

        }

    iCPaintCssValueImplArrays.Close();

    //delete all of the float blocks

    TInt cFloatValueImplArraysCnt = iCFloatCssValueImplArrays.Count();

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

        {

        delete [] iCFloatCssValueImplArrays[i];

        }

    iCFloatCssValueImplArrays.Close();

    //delete all of the clr blocks

    TInt cClrCssValueImplArraysCnt = iCClrCssValueImplArrays.Count();

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

        {

        delete [] iCClrCssValueImplArrays[i];

        }

    iCClrCssValueImplArrays.Close();

    //delete all of the int blocks

    TInt cIntCssValueImplArraysCnt = iCIntCssValueImplArrays.Count();

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

        {

        delete [] iCIntCssValueImplArrays[i];

        }

    iCIntCssValueImplArrays.Close();

    //delete all of the str blocks

    TInt cStrCssValueImplArraysCnt = iCStrCssValueImplArrays.Count();

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

        {

        delete [] iCStrCssValueImplArrays[i];

        }

    iCStrCssValueImplArrays.Close();

    //delete all of the vector blocks

    TInt cVectorCssValueImplArraysCnt = iCVectorCssValueImplArrays.Count();

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

        {

        delete [] iCVectorCssValueImplArrays[i];

        }

    iCVectorCssValueImplArrays.Close();

    }

// ==========================================================================

// Need method description

// ==========================================================================

CCssValue* CSvgMemoryManager::CloneCssValueL(CCssValue* aCssValue )

{

    CCssValue* lCssValueCloned = NULL;

    //see if the value is in a paint block

    TInt cPaintCssValueImplArraysCnt = iCPaintCssValueImplArrays.Count();

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

    {

        CPaintCssValueImpl* aPaintBlock = iCPaintCssValueImplArrays[i];

        if ((TInt)aCssValue >= (TInt)&aPaintBlock[0] && (TInt)aCssValue <= (TInt)&aPaintBlock[KCssPaintBlockSize])

        {

            //aValue is a Paint clone it as such

            if ( ((CPaintCssValueImpl*)aCssValue)->iUrlId )

            {

                lCssValueCloned = GetCssPaintObjectL(((CPaintCssValueImpl*)aCssValue)->iUrlId->Des(),

                    ((CPaintCssValueImpl*)aCssValue)->iSvgElementImpl);

   			}

   			else

   			{

   				lCssValueCloned = GetCssPaintObjectL( ((CPaintCssValueImpl*)aCssValue)->iSvgElementImpl );

   			}

   			MGfxPaint* value = ((CPaintCssValueImpl*)aCssValue)->Value();

   			if (value)

   			{

   				((CPaintCssValueImpl*)lCssValueCloned)->CloneRGBValueL( value->GetColor() );

   			}

            return lCssValueCloned;

        }

    }

    //see if the value is in a float block

    TInt cFloatCssValueImplArraysCnt = iCFloatCssValueImplArrays.Count();

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

    {

        CFloatCssValueImpl* aFloatBlock = iCFloatCssValueImplArrays[i];

        if ((TInt)aCssValue >= (TInt)&aFloatBlock[0] && (TInt)aCssValue <= (TInt)&aFloatBlock[KCssFloatBlockSize])

        {

            //aValue is a Float clone it as such

            lCssValueCloned = GetCssFloatObjectL(((CFloatCssValueImpl*)aCssValue)->Value());

            return lCssValueCloned;

        }

    }

    //see if the value is in a str block

    TInt cClrCssValueImplArraysCnt = iCClrCssValueImplArrays.Count();

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

    {

        CClrCssValueImpl* aClrBlock = iCClrCssValueImplArrays[i];

        if ((TInt)aCssValue >= (TInt)&aClrBlock[0] && (TInt)aCssValue <= (TInt)&aClrBlock[KCssClrBlockSize])

        {

            //aValue is a Clr clone it as such

            lCssValueCloned = GetCssClrObjectL();

            ((CClrCssValueImpl*)lCssValueCloned)->SetL((CClrCssValueImpl*)aCssValue);

            return lCssValueCloned;

        }

    }

    //see if the value is in an int block

    TInt cIntCssValueImplArraysCnt = iCIntCssValueImplArrays.Count();

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

    {

        CIntCssValueImpl* aIntBlock = iCIntCssValueImplArrays[i];

        if ((TInt)aCssValue >= (TInt)&aIntBlock[0] && (TInt)aCssValue <= (TInt)&aIntBlock[KCssIntBlockSize])

        {

            //aValue is an Int clone it as such

            lCssValueCloned = GetCssIntObjectL(((CIntCssValueImpl*)aCssValue)->Value());

            return lCssValueCloned;

        }

    }

    //see if the value is in a str block

    TInt cStrCssValueImplArraysCnt = iCStrCssValueImplArrays.Count();

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

    {

        CStrCssValueImpl* aStrBlock = iCStrCssValueImplArrays[i];

        if ((TInt)aCssValue >= (TInt)&aStrBlock[0] && (TInt)aCssValue <= (TInt)&aStrBlock[KCssStrBlockSize])

        {

            //aValue is a string clone it as such

            //makes a copy of the string

            lCssValueCloned = GetCssStrObjectL(((CStrCssValueImpl*)aCssValue)->Value());

            return lCssValueCloned;

        }

    }

    //see if the value is in a vector block

    TInt cVectorCssValueImplArraysCnt = iCVectorCssValueImplArrays.Count();

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

    {

        CVectorCssValueImpl* aVectorBlock = iCVectorCssValueImplArrays[i];

        if ((TInt)aCssValue >= (TInt)&aVectorBlock[0] && (TInt)aCssValue <= (TInt)&aVectorBlock[KCssVectorBlockSize])

        {

            //aValue is a vector clone it as such

            //makes a copy of the vector

            lCssValueCloned = GetCssVectorObjectL(((CVectorCssValueImpl*)aCssValue)->Value());

            return lCssValueCloned;

        }

   	}

   	return NULL;

}

// ==========================================================================

// BEGIN CIntCssValue Memory Management

// ==========================================================================

// ==========================================================================

// CSvgMemoryManager::AllocateCssIntBlockL

// ==========================================================================

void CSvgMemoryManager::AllocateCssIntBlockL( )

{

    //setup the new current block

    iCurrentIntObjectIndex = 0;

    iCIntCssValueImplArray = new ( ELeave ) CIntCssValueImpl[KCssIntBlockSize];

    //put the new block into the larger tracking array.

    iCIntCssValueImplArrays.AppendL(iCIntCssValueImplArray);

}

// ==========================================================================

// CSvgMemoryManager::GetCssIntObject

// MAIN allocation block

// ==========================================================================

CIntCssValueImpl* CSvgMemoryManager::GetCssIntObjectL( TInt aInitValue )

{

        if ( !iCIntCssValueImplArray || iCurrentIntObjectIndex >= KCssIntBlockSize )

        {

          //we have used all of the objects in the current array

            //and need to allocate another one

            AllocateCssIntBlockL();

        }

        CIntCssValueImpl* lIntObject = &iCIntCssValueImplArray[iCurrentIntObjectIndex++];

		lIntObject->SetValueL(aInitValue);

		return ( lIntObject );

}

// ==========================================================================

// CSvgMemoryManager::GetCssIntObject

// ==========================================================================

CIntCssValueImpl* CSvgMemoryManager::GetCssIntObjectL( CIntCssValueImpl* aIntValue )

{

	return GetCssIntObjectL( aIntValue->Value() );

}

// ==========================================================================

// CSvgMemoryManager::GetCssIntObject

// ==========================================================================

CIntCssValueImpl* CSvgMemoryManager::GetCssIntObjectL( const TDesC& aValueString )

{

	CIntCssValueImpl* intObject = GetCssIntObjectL();

	intObject->SetValueL(aValueString);

	return intObject;

}

// ==========================================================================

// END OF CIntCssValue Memory Management

// ==========================================================================

// ==========================================================================

// BEGIN CPaintCssValueImpl Memory Management

// ==========================================================================

// ==========================================================================

// CSvgMemoryManager::AllocateCssPaintBlockL

// ==========================================================================

void CSvgMemoryManager::AllocateCssPaintBlockL()

{

    //setup the new current block

    iCurrentPaintObjectIndex = 0;

    iCPaintCssValueImplArray = new ( ELeave ) CPaintCssValueImpl[KCssPaintBlockSize];

	//may not need this as long as we always pass in initial values for paint

	//Mem::FillZ( iCPaintCssValueImplArray, sizeof(CPaintCssValueImpl)*KCssPaintBlockSize);

    //put the new block into the larger tracking array.

    iCPaintCssValueImplArrays.AppendL(iCPaintCssValueImplArray);

}

// ==========================================================================

// CSvgMemoryManager::GetCssPaintObject

// ==========================================================================

CPaintCssValueImpl* CSvgMemoryManager::GetCssPaintObjectL( CSvgElementImpl* aElementImpl )

    {

        if ( !iCPaintCssValueImplArray || iCurrentPaintObjectIndex >= KCssPaintBlockSize )

        {

          //we have used all of the objects in the current array

            //and need to allocate another one

            AllocateCssPaintBlockL();

        }

		CPaintCssValueImpl* lPaintObject = &iCPaintCssValueImplArray[iCurrentPaintObjectIndex++];

		lPaintObject->SetElement(aElementImpl);

		return ( lPaintObject );

	}

// ==========================================================================

// CSvgMemoryManager::GetCssPaintObject

// ==========================================================================

CPaintCssValueImpl* CSvgMemoryManager::GetCssPaintObjectL( const TDesC& aValue, CSvgElementImpl* aElementImpl)

{

	CPaintCssValueImpl* lPaintObject  = GetCssPaintObjectL(aElementImpl);

    CSvgElementImpl* lReferencedElement = NULL;

   	// iUrlFlag is true means this paint is gradient.

   	CSvgDocumentImpl *lDoc = (CSvgDocumentImpl *)aElementImpl->OwnerDocument();

   	if (lDoc)

   		{

       	lReferencedElement = ( CSvgElementImpl*)lDoc->GetElementById( aValue );

   		}

	if(lReferencedElement)

		{

		lPaintObject->SetUrlflag();

		lPaintObject->SetUrlIdL(aValue);

		lPaintObject->iValue = lPaintObject->Value();

		}

	else

		{

		lPaintObject->SetValueL(aValue);

		}

	return lPaintObject;

}

// ==========================================================================

// END OF CPaintCssValueImpl Memory Management

// ==========================================================================

// ==========================================================================

// BEGIN CFloatCssValueImpl Memory Management

// ==========================================================================

// ==========================================================================

// CSvgMemoryManager::AllocateCssFloatBlockL

// ==========================================================================

void CSvgMemoryManager::AllocateCssFloatBlockL( )

{

    //setup the new current block

    iCurrentFloatObjectIndex = 0;

    iCFloatCssValueImplArray = new ( ELeave ) CFloatCssValueImpl[KCssFloatBlockSize];

    //put the new block into the larger tracking array.

    iCFloatCssValueImplArrays.AppendL(iCFloatCssValueImplArray);

}

// ==========================================================================

// CSvgMemoryManager::GetCssFloatObject

// MAIN allocation block

// ==========================================================================

CFloatCssValueImpl* CSvgMemoryManager::GetCssFloatObjectL( float aFloat )

    {

        if ( !iCFloatCssValueImplArray || iCurrentFloatObjectIndex >= KCssFloatBlockSize )

        {

          //we have used all of the objects in the current array

            //and need to allocate another one

            AllocateCssFloatBlockL();

        }

		CFloatCssValueImpl* lFloatObject = &iCFloatCssValueImplArray[iCurrentFloatObjectIndex++];

		lFloatObject->SetValueL( aFloat );

		return ( lFloatObject );

	}

// ==========================================================================

// CSvgMemoryManager::GetCssIntObject

// ==========================================================================

CFloatCssValueImpl* CSvgMemoryManager::GetCssFloatObjectL( CFloatCssValueImpl* aFloatValue )

{

	return GetCssFloatObjectL( aFloatValue->Value() );

}

// ==========================================================================

// CSvgMemoryManager::GetCssFloatObject

// ==========================================================================

CFloatCssValueImpl* CSvgMemoryManager::GetCssFloatObjectL( const TDesC& aValueString )

{

	CFloatCssValueImpl* floatObject = GetCssFloatObjectL();

	floatObject->SetValueL(aValueString);

	return floatObject;

}

// ==========================================================================

// END OF CFloatCssValueImpl Memory Management

// ==========================================================================

// ==========================================================================

// BEGIN CClrCssValueImpl Memory Management

// ==========================================================================

// ==========================================================================

// CSvgMemoryManager::AllocateCssClrBlockL

// ==========================================================================

void CSvgMemoryManager::AllocateCssClrBlockL( )

{

    //setup the new current block

    iCurrentClrObjectIndex = 0;

    iCClrCssValueImplArray = new ( ELeave ) CClrCssValueImpl[KCssClrBlockSize];

    //put the new block into the larger tracking array.

    iCClrCssValueImplArrays.AppendL(iCClrCssValueImplArray);

}

// ==========================================================================

// CSvgMemoryManager::GetCssClrObject

// MAIN allocation block

// ==========================================================================

CClrCssValueImpl* CSvgMemoryManager::GetCssClrObjectL( )

    {

        if ( !iCClrCssValueImplArray || iCurrentClrObjectIndex >= KCssClrBlockSize )

        {

          //we have used all of the objects in the current array

            //and need to allocate another one

            AllocateCssClrBlockL();

        }

		CClrCssValueImpl* lClrObject = &iCClrCssValueImplArray[iCurrentClrObjectIndex++];

		return ( lClrObject );

	}

// ==========================================================================

// CSvgMemoryManager::GetCssClrObject

// ==========================================================================

CClrCssValueImpl* CSvgMemoryManager::GetCssClrObjectL( const TDesC& aValueString )

{

	CClrCssValueImpl* clrObject = GetCssClrObjectL();

	clrObject->SetValueL(aValueString);

	return clrObject;

}

// ==========================================================================

// END OF CClrCssValueImpl Memory Management

// ==========================================================================

// ==========================================================================

// BEGIN CStrCssValueImpl Memory Management

// ==========================================================================

// ==========================================================================

// CSvgMemoryManager::AllocateCssStrBlockL

// ==========================================================================

void CSvgMemoryManager::AllocateCssStrBlockL( )

{

    //setup the new current block

    iCurrentStrObjectIndex = 0;

    iCStrCssValueImplArray = new ( ELeave ) CStrCssValueImpl[KCssStrBlockSize];

	//may not need this as long as we always pass in initial values for string

    Mem::FillZ( iCStrCssValueImplArray, sizeof(CStrCssValueImpl)*KCssStrBlockSize);

    //put the new block into the larger tracking array.

    iCStrCssValueImplArrays.AppendL(iCStrCssValueImplArray);

}

// ==========================================================================

// CSvgMemoryManager::GetCssStrObject

// MAIN allocation block

// ==========================================================================

CStrCssValueImpl* CSvgMemoryManager::GetCssStrObjectL( const TDesC& aValue )

    {

        if ( !iCStrCssValueImplArray || iCurrentStrObjectIndex >= KCssStrBlockSize )

        {

          //we have used all of the objects in the current array

            //and need to allocate another one

            AllocateCssStrBlockL();

        }

		CStrCssValueImpl* lStrObject = &iCStrCssValueImplArray[iCurrentStrObjectIndex++];

		lStrObject->SetValueL(aValue);

		return ( lStrObject );

	}

// ==========================================================================

// END OF CStrCssValueImpl Memory Management

// ==========================================================================