/*
* 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
// ==========================================================================
// ==========================================================================
// BEGIN CVectorCssValueImpl Memory Management
// ==========================================================================
// ==========================================================================
// CSvgMemoryManager::AllocateCssVectorBlockL
// ==========================================================================
void CSvgMemoryManager::AllocateCssVectorBlockL( )
{
//setup the new current block
iCurrentVectorObjectIndex = 0;
iCVectorCssValueImplArray = new ( ELeave ) CVectorCssValueImpl[KCssVectorBlockSize];
Mem::FillZ( iCVectorCssValueImplArray, sizeof(CVectorCssValueImpl)*KCssVectorBlockSize);
//put the new block into the larger tracking array.
iCVectorCssValueImplArrays.AppendL(iCVectorCssValueImplArray);
}
// ==========================================================================
// CSvgMemoryManager::GetCssVectorObject
// MAIN allocation block
// ==========================================================================
CVectorCssValueImpl* CSvgMemoryManager::GetCssVectorObjectL( const TDesC& aValue )
{
if ( !iCVectorCssValueImplArray || iCurrentVectorObjectIndex >= KCssVectorBlockSize )
{
//we have used all of the objects in the current array
//and need to allocate another one
AllocateCssVectorBlockL();
}
CVectorCssValueImpl* lVectorObject = &iCVectorCssValueImplArray[iCurrentVectorObjectIndex++];
lVectorObject->SetValueL(aValue);
return ( lVectorObject );
}
// ==========================================================================
// CSvgMemoryManager::GetCssVectorObject
// MAIN allocation block
// ==========================================================================
CVectorCssValueImpl* CSvgMemoryManager::GetCssVectorObjectL( CArrayFix<TFloatFixPt>* aValue )
{
if ( !iCVectorCssValueImplArray || iCurrentVectorObjectIndex >= KCssVectorBlockSize )
{
//we have used all of the objects in the current array
//and need to allocate another one
AllocateCssVectorBlockL();
}
CVectorCssValueImpl* lVectorObject = &iCVectorCssValueImplArray[iCurrentVectorObjectIndex++];
lVectorObject->CloneValueL(aValue);
return ( lVectorObject );
}
// ==========================================================================
// END OF CVectorCssValueImpl Memory Management
// ==========================================================================
void CSvgMemoryManager::Print()
{
#ifdef _DEBUG
RDebug::Printf("CSvgMemoryManager:: iCPaintCssValueImplArrays objects: %d",
(iCPaintCssValueImplArrays.Count() - 1) * KCssPaintBlockSize + iCurrentPaintObjectIndex);
RDebug::Printf("CSvgMemoryManager:: iCFloatCssValueImplArrays objects: %d",
(iCFloatCssValueImplArrays.Count() - 1) * KCssFloatBlockSize + iCurrentFloatObjectIndex);
RDebug::Printf("CSvgMemoryManager:: iCClrCssValueImplArrays objects: %d",
(iCClrCssValueImplArrays.Count() - 1) * KCssClrBlockSize + iCurrentClrObjectIndex);
RDebug::Printf("CSvgMemoryManager:: iCIntCssValueImplArrays objects: %d",
(iCIntCssValueImplArrays.Count() - 1) * KCssIntBlockSize + iCurrentIntObjectIndex);
RDebug::Printf("CSvgMemoryManager:: iCStrCssValueImplArrays objects: %d",
(iCStrCssValueImplArrays.Count() - 1) * KCssStrBlockSize + iCurrentStrObjectIndex);
RDebug::Printf("CSvgMemoryManager:: iCVectorCssValueImplArrays objects: %d",
(iCVectorCssValueImplArrays.Count() - 1) * KCssVectorBlockSize + iCurrentVectorObjectIndex);
#endif
}