|
1 /* |
|
2 * Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: SVG Implementation source file |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "SVGMemoryManager.h" |
|
20 #include "SVGPaintCssValueImpl.h" |
|
21 #include "SVGFloatCssValueImpl.h" |
|
22 #include "SVGIntCssValueImpl.h" |
|
23 #include "SVGStrCssValueImpl.h" |
|
24 #include "SVGVectorCssValueImpl.h" |
|
25 #include "SVGClrCssValueImpl.h" |
|
26 #include "SVGDocumentImpl.h" |
|
27 |
|
28 class CSvgElementImpl; |
|
29 |
|
30 const TUint CSvgMemoryManager::KCssPaintBlockSize = 20; |
|
31 const TUint CSvgMemoryManager::KCssFloatBlockSize = 20; |
|
32 const TUint CSvgMemoryManager::KCssIntBlockSize = 20; |
|
33 const TUint CSvgMemoryManager::KCssClrBlockSize = 20; |
|
34 const TUint CSvgMemoryManager::KCssStrBlockSize = 20; |
|
35 const TUint CSvgMemoryManager::KCssVectorBlockSize = 4; |
|
36 |
|
37 // ========================================================================== |
|
38 // Need method description |
|
39 // ========================================================================== |
|
40 CSvgMemoryManager* CSvgMemoryManager::NewL() |
|
41 { |
|
42 CSvgMemoryManager* self = new ( ELeave ) CSvgMemoryManager; |
|
43 CleanupStack::PushL( self ); |
|
44 self->ConstructL(); |
|
45 CleanupStack::Pop(); |
|
46 |
|
47 return self; |
|
48 } |
|
49 |
|
50 // ========================================================================== |
|
51 // Need method description |
|
52 // ========================================================================== |
|
53 CSvgMemoryManager* CSvgMemoryManager::NewLC() |
|
54 { |
|
55 CSvgMemoryManager* self = new ( ELeave ) CSvgMemoryManager; |
|
56 CleanupStack::PushL( self ); |
|
57 self->ConstructL(); |
|
58 |
|
59 return self; |
|
60 } |
|
61 |
|
62 // ========================================================================== |
|
63 // Need method description |
|
64 // ========================================================================== |
|
65 void CSvgMemoryManager::ConstructL() |
|
66 { |
|
67 } |
|
68 |
|
69 // ========================================================================== |
|
70 // Need method description |
|
71 // ========================================================================== |
|
72 CSvgMemoryManager::CSvgMemoryManager() : |
|
73 iCPaintCssValueImplArrays( 2 ), |
|
74 iCFloatCssValueImplArrays( 2 ), |
|
75 iCClrCssValueImplArrays( 2 ), |
|
76 iCIntCssValueImplArrays( 2 ), |
|
77 iCStrCssValueImplArrays( 2 ), |
|
78 iCVectorCssValueImplArrays( 1 ) |
|
79 { |
|
80 } |
|
81 |
|
82 // ========================================================================== |
|
83 // Need method description |
|
84 // ========================================================================== |
|
85 CSvgMemoryManager::~CSvgMemoryManager() |
|
86 { |
|
87 //delete all of the paint blocks |
|
88 TInt cPaintCSSValueImplArraysCnt = iCPaintCssValueImplArrays.Count(); |
|
89 for (TInt i=0; i < cPaintCSSValueImplArraysCnt; i++) |
|
90 { |
|
91 delete [] iCPaintCssValueImplArrays[i]; |
|
92 } |
|
93 iCPaintCssValueImplArrays.Close(); |
|
94 |
|
95 |
|
96 //delete all of the float blocks |
|
97 TInt cFloatValueImplArraysCnt = iCFloatCssValueImplArrays.Count(); |
|
98 for (TInt i=0; i < cFloatValueImplArraysCnt; i++) |
|
99 { |
|
100 delete [] iCFloatCssValueImplArrays[i]; |
|
101 } |
|
102 iCFloatCssValueImplArrays.Close(); |
|
103 |
|
104 //delete all of the clr blocks |
|
105 TInt cClrCssValueImplArraysCnt = iCClrCssValueImplArrays.Count(); |
|
106 for (TInt i=0; i < cClrCssValueImplArraysCnt; i++) |
|
107 { |
|
108 delete [] iCClrCssValueImplArrays[i]; |
|
109 } |
|
110 iCClrCssValueImplArrays.Close(); |
|
111 |
|
112 |
|
113 //delete all of the int blocks |
|
114 TInt cIntCssValueImplArraysCnt = iCIntCssValueImplArrays.Count(); |
|
115 for (TInt i=0; i < cIntCssValueImplArraysCnt; i++) |
|
116 { |
|
117 delete [] iCIntCssValueImplArrays[i]; |
|
118 } |
|
119 iCIntCssValueImplArrays.Close(); |
|
120 |
|
121 //delete all of the str blocks |
|
122 TInt cStrCssValueImplArraysCnt = iCStrCssValueImplArrays.Count(); |
|
123 for (TInt i=0; i < cStrCssValueImplArraysCnt; i++) |
|
124 { |
|
125 delete [] iCStrCssValueImplArrays[i]; |
|
126 } |
|
127 iCStrCssValueImplArrays.Close(); |
|
128 |
|
129 //delete all of the vector blocks |
|
130 TInt cVectorCssValueImplArraysCnt = iCVectorCssValueImplArrays.Count(); |
|
131 for (TInt i=0; i < cVectorCssValueImplArraysCnt; i++) |
|
132 { |
|
133 delete [] iCVectorCssValueImplArrays[i]; |
|
134 } |
|
135 iCVectorCssValueImplArrays.Close(); |
|
136 |
|
137 } |
|
138 |
|
139 // ========================================================================== |
|
140 // Need method description |
|
141 // ========================================================================== |
|
142 CCssValue* CSvgMemoryManager::CloneCssValueL(CCssValue* aCssValue ) |
|
143 { |
|
144 CCssValue* lCssValueCloned = NULL; |
|
145 |
|
146 //see if the value is in a paint block |
|
147 TInt cPaintCssValueImplArraysCnt = iCPaintCssValueImplArrays.Count(); |
|
148 for (TInt i=0; i < cPaintCssValueImplArraysCnt; i++) |
|
149 { |
|
150 CPaintCssValueImpl* aPaintBlock = iCPaintCssValueImplArrays[i]; |
|
151 if ((TInt)aCssValue >= (TInt)&aPaintBlock[0] && (TInt)aCssValue <= (TInt)&aPaintBlock[KCssPaintBlockSize]) |
|
152 { |
|
153 //aValue is a Paint clone it as such |
|
154 if ( ((CPaintCssValueImpl*)aCssValue)->iUrlId ) |
|
155 { |
|
156 lCssValueCloned = GetCssPaintObjectL(((CPaintCssValueImpl*)aCssValue)->iUrlId->Des(), |
|
157 ((CPaintCssValueImpl*)aCssValue)->iSvgElementImpl); |
|
158 } |
|
159 else |
|
160 { |
|
161 lCssValueCloned = GetCssPaintObjectL( ((CPaintCssValueImpl*)aCssValue)->iSvgElementImpl ); |
|
162 } |
|
163 |
|
164 MGfxPaint* value = ((CPaintCssValueImpl*)aCssValue)->Value(); |
|
165 |
|
166 if (value) |
|
167 { |
|
168 ((CPaintCssValueImpl*)lCssValueCloned)->CloneRGBValueL( value->GetColor() ); |
|
169 } |
|
170 |
|
171 return lCssValueCloned; |
|
172 } |
|
173 } |
|
174 |
|
175 //see if the value is in a float block |
|
176 TInt cFloatCssValueImplArraysCnt = iCFloatCssValueImplArrays.Count(); |
|
177 for (TInt i=0; i < cFloatCssValueImplArraysCnt; i++) |
|
178 { |
|
179 CFloatCssValueImpl* aFloatBlock = iCFloatCssValueImplArrays[i]; |
|
180 if ((TInt)aCssValue >= (TInt)&aFloatBlock[0] && (TInt)aCssValue <= (TInt)&aFloatBlock[KCssFloatBlockSize]) |
|
181 { |
|
182 //aValue is a Float clone it as such |
|
183 lCssValueCloned = GetCssFloatObjectL(((CFloatCssValueImpl*)aCssValue)->Value()); |
|
184 return lCssValueCloned; |
|
185 } |
|
186 } |
|
187 |
|
188 //see if the value is in a str block |
|
189 TInt cClrCssValueImplArraysCnt = iCClrCssValueImplArrays.Count(); |
|
190 for (TInt i=0; i < cClrCssValueImplArraysCnt; i++) |
|
191 { |
|
192 CClrCssValueImpl* aClrBlock = iCClrCssValueImplArrays[i]; |
|
193 if ((TInt)aCssValue >= (TInt)&aClrBlock[0] && (TInt)aCssValue <= (TInt)&aClrBlock[KCssClrBlockSize]) |
|
194 { |
|
195 //aValue is a Clr clone it as such |
|
196 lCssValueCloned = GetCssClrObjectL(); |
|
197 ((CClrCssValueImpl*)lCssValueCloned)->SetL((CClrCssValueImpl*)aCssValue); |
|
198 |
|
199 return lCssValueCloned; |
|
200 } |
|
201 } |
|
202 |
|
203 //see if the value is in an int block |
|
204 TInt cIntCssValueImplArraysCnt = iCIntCssValueImplArrays.Count(); |
|
205 for (TInt i=0; i < cIntCssValueImplArraysCnt; i++) |
|
206 { |
|
207 CIntCssValueImpl* aIntBlock = iCIntCssValueImplArrays[i]; |
|
208 if ((TInt)aCssValue >= (TInt)&aIntBlock[0] && (TInt)aCssValue <= (TInt)&aIntBlock[KCssIntBlockSize]) |
|
209 { |
|
210 //aValue is an Int clone it as such |
|
211 lCssValueCloned = GetCssIntObjectL(((CIntCssValueImpl*)aCssValue)->Value()); |
|
212 return lCssValueCloned; |
|
213 } |
|
214 } |
|
215 |
|
216 //see if the value is in a str block |
|
217 TInt cStrCssValueImplArraysCnt = iCStrCssValueImplArrays.Count(); |
|
218 for (TInt i=0; i < cStrCssValueImplArraysCnt; i++) |
|
219 { |
|
220 CStrCssValueImpl* aStrBlock = iCStrCssValueImplArrays[i]; |
|
221 if ((TInt)aCssValue >= (TInt)&aStrBlock[0] && (TInt)aCssValue <= (TInt)&aStrBlock[KCssStrBlockSize]) |
|
222 { |
|
223 //aValue is a string clone it as such |
|
224 //makes a copy of the string |
|
225 lCssValueCloned = GetCssStrObjectL(((CStrCssValueImpl*)aCssValue)->Value()); |
|
226 return lCssValueCloned; |
|
227 } |
|
228 } |
|
229 |
|
230 //see if the value is in a vector block |
|
231 TInt cVectorCssValueImplArraysCnt = iCVectorCssValueImplArrays.Count(); |
|
232 for (TInt i=0; i < cVectorCssValueImplArraysCnt; i++) |
|
233 { |
|
234 CVectorCssValueImpl* aVectorBlock = iCVectorCssValueImplArrays[i]; |
|
235 if ((TInt)aCssValue >= (TInt)&aVectorBlock[0] && (TInt)aCssValue <= (TInt)&aVectorBlock[KCssVectorBlockSize]) |
|
236 { |
|
237 //aValue is a vector clone it as such |
|
238 //makes a copy of the vector |
|
239 lCssValueCloned = GetCssVectorObjectL(((CVectorCssValueImpl*)aCssValue)->Value()); |
|
240 return lCssValueCloned; |
|
241 } |
|
242 } |
|
243 |
|
244 return NULL; |
|
245 } |
|
246 |
|
247 // ========================================================================== |
|
248 // BEGIN CIntCssValue Memory Management |
|
249 // ========================================================================== |
|
250 // ========================================================================== |
|
251 // CSvgMemoryManager::AllocateCssIntBlockL |
|
252 // ========================================================================== |
|
253 void CSvgMemoryManager::AllocateCssIntBlockL( ) |
|
254 { |
|
255 //setup the new current block |
|
256 iCurrentIntObjectIndex = 0; |
|
257 |
|
258 iCIntCssValueImplArray = new ( ELeave ) CIntCssValueImpl[KCssIntBlockSize]; |
|
259 |
|
260 //put the new block into the larger tracking array. |
|
261 iCIntCssValueImplArrays.AppendL(iCIntCssValueImplArray); |
|
262 |
|
263 } |
|
264 |
|
265 // ========================================================================== |
|
266 // CSvgMemoryManager::GetCssIntObject |
|
267 // MAIN allocation block |
|
268 // ========================================================================== |
|
269 CIntCssValueImpl* CSvgMemoryManager::GetCssIntObjectL( TInt aInitValue ) |
|
270 { |
|
271 if ( !iCIntCssValueImplArray || iCurrentIntObjectIndex >= KCssIntBlockSize ) |
|
272 { |
|
273 //we have used all of the objects in the current array |
|
274 //and need to allocate another one |
|
275 AllocateCssIntBlockL(); |
|
276 } |
|
277 CIntCssValueImpl* lIntObject = &iCIntCssValueImplArray[iCurrentIntObjectIndex++]; |
|
278 lIntObject->SetValueL(aInitValue); |
|
279 return ( lIntObject ); |
|
280 } |
|
281 |
|
282 // ========================================================================== |
|
283 // CSvgMemoryManager::GetCssIntObject |
|
284 // ========================================================================== |
|
285 CIntCssValueImpl* CSvgMemoryManager::GetCssIntObjectL( CIntCssValueImpl* aIntValue ) |
|
286 { |
|
287 return GetCssIntObjectL( aIntValue->Value() ); |
|
288 } |
|
289 |
|
290 // ========================================================================== |
|
291 // CSvgMemoryManager::GetCssIntObject |
|
292 // ========================================================================== |
|
293 CIntCssValueImpl* CSvgMemoryManager::GetCssIntObjectL( const TDesC& aValueString ) |
|
294 { |
|
295 CIntCssValueImpl* intObject = GetCssIntObjectL(); |
|
296 |
|
297 intObject->SetValueL(aValueString); |
|
298 |
|
299 return intObject; |
|
300 |
|
301 } |
|
302 // ========================================================================== |
|
303 // END OF CIntCssValue Memory Management |
|
304 // ========================================================================== |
|
305 |
|
306 // ========================================================================== |
|
307 // BEGIN CPaintCssValueImpl Memory Management |
|
308 // ========================================================================== |
|
309 // ========================================================================== |
|
310 // CSvgMemoryManager::AllocateCssPaintBlockL |
|
311 // ========================================================================== |
|
312 void CSvgMemoryManager::AllocateCssPaintBlockL() |
|
313 { |
|
314 //setup the new current block |
|
315 iCurrentPaintObjectIndex = 0; |
|
316 |
|
317 iCPaintCssValueImplArray = new ( ELeave ) CPaintCssValueImpl[KCssPaintBlockSize]; |
|
318 |
|
319 //may not need this as long as we always pass in initial values for paint |
|
320 //Mem::FillZ( iCPaintCssValueImplArray, sizeof(CPaintCssValueImpl)*KCssPaintBlockSize); |
|
321 |
|
322 //put the new block into the larger tracking array. |
|
323 iCPaintCssValueImplArrays.AppendL(iCPaintCssValueImplArray); |
|
324 |
|
325 } |
|
326 |
|
327 // ========================================================================== |
|
328 // CSvgMemoryManager::GetCssPaintObject |
|
329 // ========================================================================== |
|
330 CPaintCssValueImpl* CSvgMemoryManager::GetCssPaintObjectL( CSvgElementImpl* aElementImpl ) |
|
331 { |
|
332 if ( !iCPaintCssValueImplArray || iCurrentPaintObjectIndex >= KCssPaintBlockSize ) |
|
333 { |
|
334 //we have used all of the objects in the current array |
|
335 //and need to allocate another one |
|
336 AllocateCssPaintBlockL(); |
|
337 } |
|
338 |
|
339 CPaintCssValueImpl* lPaintObject = &iCPaintCssValueImplArray[iCurrentPaintObjectIndex++]; |
|
340 lPaintObject->SetElement(aElementImpl); |
|
341 return ( lPaintObject ); |
|
342 } |
|
343 |
|
344 // ========================================================================== |
|
345 // CSvgMemoryManager::GetCssPaintObject |
|
346 // ========================================================================== |
|
347 CPaintCssValueImpl* CSvgMemoryManager::GetCssPaintObjectL( const TDesC& aValue, CSvgElementImpl* aElementImpl) |
|
348 { |
|
349 CPaintCssValueImpl* lPaintObject = GetCssPaintObjectL(aElementImpl); |
|
350 |
|
351 CSvgElementImpl* lReferencedElement = NULL; |
|
352 // iUrlFlag is true means this paint is gradient. |
|
353 |
|
354 CSvgDocumentImpl *lDoc = (CSvgDocumentImpl *)aElementImpl->OwnerDocument(); |
|
355 |
|
356 if (lDoc) |
|
357 { |
|
358 lReferencedElement = ( CSvgElementImpl*)lDoc->GetElementById( aValue ); |
|
359 } |
|
360 |
|
361 if(lReferencedElement) |
|
362 { |
|
363 lPaintObject->SetUrlflag(); |
|
364 lPaintObject->SetUrlIdL(aValue); |
|
365 lPaintObject->iValue = lPaintObject->Value(); |
|
366 } |
|
367 else |
|
368 { |
|
369 lPaintObject->SetValueL(aValue); |
|
370 } |
|
371 return lPaintObject; |
|
372 } |
|
373 // ========================================================================== |
|
374 // END OF CPaintCssValueImpl Memory Management |
|
375 // ========================================================================== |
|
376 |
|
377 // ========================================================================== |
|
378 // BEGIN CFloatCssValueImpl Memory Management |
|
379 // ========================================================================== |
|
380 // ========================================================================== |
|
381 // CSvgMemoryManager::AllocateCssFloatBlockL |
|
382 // ========================================================================== |
|
383 void CSvgMemoryManager::AllocateCssFloatBlockL( ) |
|
384 { |
|
385 //setup the new current block |
|
386 iCurrentFloatObjectIndex = 0; |
|
387 |
|
388 iCFloatCssValueImplArray = new ( ELeave ) CFloatCssValueImpl[KCssFloatBlockSize]; |
|
389 |
|
390 //put the new block into the larger tracking array. |
|
391 iCFloatCssValueImplArrays.AppendL(iCFloatCssValueImplArray); |
|
392 |
|
393 } |
|
394 |
|
395 // ========================================================================== |
|
396 // CSvgMemoryManager::GetCssFloatObject |
|
397 // MAIN allocation block |
|
398 // ========================================================================== |
|
399 CFloatCssValueImpl* CSvgMemoryManager::GetCssFloatObjectL( float aFloat ) |
|
400 { |
|
401 if ( !iCFloatCssValueImplArray || iCurrentFloatObjectIndex >= KCssFloatBlockSize ) |
|
402 { |
|
403 //we have used all of the objects in the current array |
|
404 //and need to allocate another one |
|
405 AllocateCssFloatBlockL(); |
|
406 } |
|
407 |
|
408 CFloatCssValueImpl* lFloatObject = &iCFloatCssValueImplArray[iCurrentFloatObjectIndex++]; |
|
409 lFloatObject->SetValueL( aFloat ); |
|
410 return ( lFloatObject ); |
|
411 } |
|
412 |
|
413 // ========================================================================== |
|
414 // CSvgMemoryManager::GetCssIntObject |
|
415 // ========================================================================== |
|
416 CFloatCssValueImpl* CSvgMemoryManager::GetCssFloatObjectL( CFloatCssValueImpl* aFloatValue ) |
|
417 { |
|
418 return GetCssFloatObjectL( aFloatValue->Value() ); |
|
419 } |
|
420 |
|
421 // ========================================================================== |
|
422 // CSvgMemoryManager::GetCssFloatObject |
|
423 // ========================================================================== |
|
424 CFloatCssValueImpl* CSvgMemoryManager::GetCssFloatObjectL( const TDesC& aValueString ) |
|
425 { |
|
426 CFloatCssValueImpl* floatObject = GetCssFloatObjectL(); |
|
427 |
|
428 floatObject->SetValueL(aValueString); |
|
429 |
|
430 return floatObject; |
|
431 |
|
432 } |
|
433 // ========================================================================== |
|
434 // END OF CFloatCssValueImpl Memory Management |
|
435 // ========================================================================== |
|
436 |
|
437 // ========================================================================== |
|
438 // BEGIN CClrCssValueImpl Memory Management |
|
439 // ========================================================================== |
|
440 // ========================================================================== |
|
441 // CSvgMemoryManager::AllocateCssClrBlockL |
|
442 // ========================================================================== |
|
443 void CSvgMemoryManager::AllocateCssClrBlockL( ) |
|
444 { |
|
445 //setup the new current block |
|
446 iCurrentClrObjectIndex = 0; |
|
447 |
|
448 iCClrCssValueImplArray = new ( ELeave ) CClrCssValueImpl[KCssClrBlockSize]; |
|
449 |
|
450 //put the new block into the larger tracking array. |
|
451 iCClrCssValueImplArrays.AppendL(iCClrCssValueImplArray); |
|
452 |
|
453 } |
|
454 |
|
455 // ========================================================================== |
|
456 // CSvgMemoryManager::GetCssClrObject |
|
457 // MAIN allocation block |
|
458 // ========================================================================== |
|
459 CClrCssValueImpl* CSvgMemoryManager::GetCssClrObjectL( ) |
|
460 { |
|
461 if ( !iCClrCssValueImplArray || iCurrentClrObjectIndex >= KCssClrBlockSize ) |
|
462 { |
|
463 //we have used all of the objects in the current array |
|
464 //and need to allocate another one |
|
465 AllocateCssClrBlockL(); |
|
466 } |
|
467 |
|
468 CClrCssValueImpl* lClrObject = &iCClrCssValueImplArray[iCurrentClrObjectIndex++]; |
|
469 return ( lClrObject ); |
|
470 } |
|
471 |
|
472 // ========================================================================== |
|
473 // CSvgMemoryManager::GetCssClrObject |
|
474 // ========================================================================== |
|
475 CClrCssValueImpl* CSvgMemoryManager::GetCssClrObjectL( const TDesC& aValueString ) |
|
476 { |
|
477 CClrCssValueImpl* clrObject = GetCssClrObjectL(); |
|
478 |
|
479 clrObject->SetValueL(aValueString); |
|
480 |
|
481 return clrObject; |
|
482 |
|
483 } |
|
484 // ========================================================================== |
|
485 // END OF CClrCssValueImpl Memory Management |
|
486 // ========================================================================== |
|
487 |
|
488 // ========================================================================== |
|
489 // BEGIN CStrCssValueImpl Memory Management |
|
490 // ========================================================================== |
|
491 // ========================================================================== |
|
492 // CSvgMemoryManager::AllocateCssStrBlockL |
|
493 // ========================================================================== |
|
494 void CSvgMemoryManager::AllocateCssStrBlockL( ) |
|
495 { |
|
496 //setup the new current block |
|
497 iCurrentStrObjectIndex = 0; |
|
498 |
|
499 iCStrCssValueImplArray = new ( ELeave ) CStrCssValueImpl[KCssStrBlockSize]; |
|
500 |
|
501 //may not need this as long as we always pass in initial values for string |
|
502 Mem::FillZ( iCStrCssValueImplArray, sizeof(CStrCssValueImpl)*KCssStrBlockSize); |
|
503 |
|
504 //put the new block into the larger tracking array. |
|
505 iCStrCssValueImplArrays.AppendL(iCStrCssValueImplArray); |
|
506 |
|
507 } |
|
508 |
|
509 // ========================================================================== |
|
510 // CSvgMemoryManager::GetCssStrObject |
|
511 // MAIN allocation block |
|
512 // ========================================================================== |
|
513 CStrCssValueImpl* CSvgMemoryManager::GetCssStrObjectL( const TDesC& aValue ) |
|
514 { |
|
515 if ( !iCStrCssValueImplArray || iCurrentStrObjectIndex >= KCssStrBlockSize ) |
|
516 { |
|
517 //we have used all of the objects in the current array |
|
518 //and need to allocate another one |
|
519 AllocateCssStrBlockL(); |
|
520 } |
|
521 |
|
522 CStrCssValueImpl* lStrObject = &iCStrCssValueImplArray[iCurrentStrObjectIndex++]; |
|
523 lStrObject->SetValueL(aValue); |
|
524 return ( lStrObject ); |
|
525 } |
|
526 // ========================================================================== |
|
527 // END OF CStrCssValueImpl Memory Management |
|
528 // ========================================================================== |
|
529 |
|
530 // ========================================================================== |
|
531 // BEGIN CVectorCssValueImpl Memory Management |
|
532 // ========================================================================== |
|
533 // ========================================================================== |
|
534 // CSvgMemoryManager::AllocateCssVectorBlockL |
|
535 // ========================================================================== |
|
536 void CSvgMemoryManager::AllocateCssVectorBlockL( ) |
|
537 { |
|
538 //setup the new current block |
|
539 iCurrentVectorObjectIndex = 0; |
|
540 |
|
541 iCVectorCssValueImplArray = new ( ELeave ) CVectorCssValueImpl[KCssVectorBlockSize]; |
|
542 |
|
543 Mem::FillZ( iCVectorCssValueImplArray, sizeof(CVectorCssValueImpl)*KCssVectorBlockSize); |
|
544 |
|
545 //put the new block into the larger tracking array. |
|
546 iCVectorCssValueImplArrays.AppendL(iCVectorCssValueImplArray); |
|
547 |
|
548 } |
|
549 |
|
550 // ========================================================================== |
|
551 // CSvgMemoryManager::GetCssVectorObject |
|
552 // MAIN allocation block |
|
553 // ========================================================================== |
|
554 CVectorCssValueImpl* CSvgMemoryManager::GetCssVectorObjectL( const TDesC& aValue ) |
|
555 { |
|
556 if ( !iCVectorCssValueImplArray || iCurrentVectorObjectIndex >= KCssVectorBlockSize ) |
|
557 { |
|
558 //we have used all of the objects in the current array |
|
559 //and need to allocate another one |
|
560 AllocateCssVectorBlockL(); |
|
561 } |
|
562 |
|
563 CVectorCssValueImpl* lVectorObject = &iCVectorCssValueImplArray[iCurrentVectorObjectIndex++]; |
|
564 lVectorObject->SetValueL(aValue); |
|
565 return ( lVectorObject ); |
|
566 } |
|
567 |
|
568 // ========================================================================== |
|
569 // CSvgMemoryManager::GetCssVectorObject |
|
570 // MAIN allocation block |
|
571 // ========================================================================== |
|
572 CVectorCssValueImpl* CSvgMemoryManager::GetCssVectorObjectL( CArrayFix<TFloatFixPt>* aValue ) |
|
573 { |
|
574 if ( !iCVectorCssValueImplArray || iCurrentVectorObjectIndex >= KCssVectorBlockSize ) |
|
575 { |
|
576 //we have used all of the objects in the current array |
|
577 //and need to allocate another one |
|
578 AllocateCssVectorBlockL(); |
|
579 } |
|
580 |
|
581 CVectorCssValueImpl* lVectorObject = &iCVectorCssValueImplArray[iCurrentVectorObjectIndex++]; |
|
582 lVectorObject->CloneValueL(aValue); |
|
583 return ( lVectorObject ); |
|
584 } |
|
585 |
|
586 // ========================================================================== |
|
587 // END OF CVectorCssValueImpl Memory Management |
|
588 // ========================================================================== |
|
589 |
|
590 void CSvgMemoryManager::Print() |
|
591 { |
|
592 #ifdef _DEBUG |
|
593 RDebug::Printf("CSvgMemoryManager:: iCPaintCssValueImplArrays objects: %d", |
|
594 (iCPaintCssValueImplArrays.Count() - 1) * KCssPaintBlockSize + iCurrentPaintObjectIndex); |
|
595 RDebug::Printf("CSvgMemoryManager:: iCFloatCssValueImplArrays objects: %d", |
|
596 (iCFloatCssValueImplArrays.Count() - 1) * KCssFloatBlockSize + iCurrentFloatObjectIndex); |
|
597 RDebug::Printf("CSvgMemoryManager:: iCClrCssValueImplArrays objects: %d", |
|
598 (iCClrCssValueImplArrays.Count() - 1) * KCssClrBlockSize + iCurrentClrObjectIndex); |
|
599 RDebug::Printf("CSvgMemoryManager:: iCIntCssValueImplArrays objects: %d", |
|
600 (iCIntCssValueImplArrays.Count() - 1) * KCssIntBlockSize + iCurrentIntObjectIndex); |
|
601 RDebug::Printf("CSvgMemoryManager:: iCStrCssValueImplArrays objects: %d", |
|
602 (iCStrCssValueImplArrays.Count() - 1) * KCssStrBlockSize + iCurrentStrObjectIndex); |
|
603 RDebug::Printf("CSvgMemoryManager:: iCVectorCssValueImplArrays objects: %d", |
|
604 (iCVectorCssValueImplArrays.Count() - 1) * KCssVectorBlockSize + iCurrentVectorObjectIndex); |
|
605 #endif |
|
606 } |
|
607 |
|
608 |