--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/svgtopt/SVG/SVGImpl/src/SVGMemoryManager.cpp Thu Jan 07 16:19:02 2010 +0200
@@ -0,0 +1,608 @@
+/*
+* 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
+}
+
+