|
1 /* |
|
2 * Copyright (c) 2008 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: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #include "HuiFxEngine.h" |
|
21 #include "HuiFxEffectParser.h" |
|
22 #include "HuiFxEffect.h" |
|
23 #include "HuiFxEffectCache.h" |
|
24 #include <uiacceltk/HuiEnv.h> |
|
25 #include <uiacceltk/HuiStatic.h> |
|
26 #include <uiacceltk/HuiUtil.h> |
|
27 #include <bautils.h> |
|
28 #include <uiacceltk/HuiDisplay.h> |
|
29 |
|
30 #if 0 |
|
31 _LIT(cache1, "C:\\Data\\drop_shadow.fxml"); |
|
32 const TDesC *cache_array[]={ &cache1 }; |
|
33 TInt cache_array_size = sizeof(cache_array)/sizeof(cache_array[0]); |
|
34 #endif |
|
35 |
|
36 EXPORT_C void CHuiFxEngine::ConstructL(THuiFxEngineType aEngineType) |
|
37 { |
|
38 iType = aEngineType; |
|
39 iBuffersInUse = 0; |
|
40 #ifdef HUIFX_RBCACHE_ENABLED |
|
41 iBuffersInCache = 0; |
|
42 // critical to be initialised to zeros: zero indicates an empty entry in array. |
|
43 memset(iBufferCache, '\0', sizeof(iBufferCache)); |
|
44 #endif |
|
45 #ifdef HUIFX_EFFECTCACHE_ENABLED |
|
46 iCache = CHuiFxEffectCache::NewL(); |
|
47 |
|
48 #if 0 |
|
49 // Preloading cache items |
|
50 for(int i=0;i<cache_array_size;i++) |
|
51 { |
|
52 const TDesC *filename = cache_array[i]; |
|
53 if (!BaflUtils::FileExists( CHuiStatic::FsSession(), *filename )) |
|
54 { |
|
55 continue; |
|
56 } |
|
57 CHuiFxEffect *effect = NULL; |
|
58 TRect extRectI; |
|
59 TRect *extRect = &extRectI; |
|
60 CHuiFxEffectCacheEffectNode *node = new(ELeave) CHuiFxEffectCacheEffectNode(*filename, effect, 0, extRect, this); |
|
61 CleanupStack::PushL(node); |
|
62 iCache->FindOrCreateL(node); // moves ownership |
|
63 CleanupStack::Pop(); |
|
64 //delete effect; // no need for this effect. |
|
65 } |
|
66 #endif |
|
67 #endif |
|
68 CHuiStatic::Env().AddMemoryLevelObserver(this); |
|
69 } |
|
70 |
|
71 EXPORT_C TBool CHuiFxEngine::FxmlUsesInput1(const TDesC &aFileName) |
|
72 { |
|
73 #ifdef HUIFX_EFFECTCACHE_ENABLED |
|
74 return iCache->FxmlUsesInput1(aFileName); |
|
75 #endif |
|
76 #ifndef HUIFX_EFFECTCACHE_ENABLED |
|
77 return EFalse; |
|
78 #endif |
|
79 } |
|
80 |
|
81 EXPORT_C void CHuiFxEngine::RegisterEffectL(const TDesC &aFileName) |
|
82 { |
|
83 #ifdef HUIFX_EFFECTCACHE_ENABLED |
|
84 const TDesC *filename = &aFileName; |
|
85 if (!BaflUtils::FileExists( CHuiStatic::FsSession(), *filename )) |
|
86 { |
|
87 return; |
|
88 } |
|
89 CHuiFxEffect *effect = NULL; |
|
90 TRect extRectI; |
|
91 TRect *extRect = &extRectI; |
|
92 CHuiFxEffectCacheEffectNode *node = new(ELeave) CHuiFxEffectCacheEffectNode(*filename, effect, 0, extRect, this); |
|
93 CleanupStack::PushL(node); |
|
94 iCache->CreateL(node); // moves ownership |
|
95 CleanupStack::Pop(); |
|
96 #endif |
|
97 } |
|
98 |
|
99 #ifdef HUIFX_EFFECTCACHE_ENABLED |
|
100 EXPORT_C void CHuiFxEngine::UnRegisterEffectL(const TDesC &aFileName) |
|
101 { |
|
102 MHuiFxEffectCacheNode *node = iCache->FindDup(aFileName); |
|
103 if (node) |
|
104 iCache->UnUse(node); |
|
105 #else |
|
106 EXPORT_C void CHuiFxEngine::UnRegisterEffectL(const TDesC &) |
|
107 { |
|
108 #endif |
|
109 } |
|
110 |
|
111 EXPORT_C void CHuiFxEngine::LoadEffectL( |
|
112 const TDesC& aFileName, |
|
113 CHuiFxEffect*& aEffect, |
|
114 MHuiEffectable* aVisual, |
|
115 #ifndef HUIFX_EFFECTCACHE_ENABLED |
|
116 TRect* extRect, |
|
117 #else |
|
118 TRect*, |
|
119 #endif |
|
120 MAlfGfxEffectObserver* aEffectEndObserver, |
|
121 TInt aHandle, |
|
122 TInt aFlags ) |
|
123 { |
|
124 #ifdef HUIFX_TRACE |
|
125 RDebug::Print(_L("CHuiFxEngine::LoadEffectL - %S, 0x%x, 0x%x"),&aFileName, aVisual, aEffect ); |
|
126 #endif |
|
127 if (aFileName.Length() == 0) |
|
128 { |
|
129 User::Leave( KErrNotFound); |
|
130 } |
|
131 //TODO: reuse parser? |
|
132 if( aEffect != NULL ) User::Leave( KErrGeneral ); |
|
133 #ifndef HUIFX_EFFECTCACHE_ENABLED |
|
134 iExtRect = TRect(); // clear the extrect |
|
135 if ( extRect ) |
|
136 { |
|
137 iExtRect = *extRect; |
|
138 } |
|
139 CHuiFxEffectParser* parser = CHuiFxEffectParser::NewL( *this, aVisual ); |
|
140 CleanupStack::PushL( parser ); |
|
141 parser->SetEffectEndObserver( aEffectEndObserver, aHandle ); |
|
142 parser->SetEffectFlags( aFlags ); |
|
143 // Parsing is asychronous, but we are not waiting for it to end. |
|
144 // CHuiFxEffectParser will take care of everything, and CHuiVisual |
|
145 // will kill the parser when parsing is finished or cancelled. |
|
146 aVisual->SetEffectParser( parser ); // ownership transferred |
|
147 CleanupStack::Pop( parser ); |
|
148 parser->ParseL( aFileName, iExtRect ); |
|
149 #endif |
|
150 #ifdef HUIFX_EFFECTCACHE_ENABLED |
|
151 CHuiFxEffectCacheEffectNode *node = new (ELeave) CHuiFxEffectCacheEffectNode(aFileName, aEffect, aVisual, &iExtRect, this); |
|
152 node->SetEffectEndObserver( aEffectEndObserver, aHandle ); |
|
153 aFlags |= KHuiFxDelayRunUntilFirstFrameHasBeenDrawn; |
|
154 node->SetEffectFlags( aFlags ); |
|
155 CleanupStack::PushL(node); |
|
156 iCache->FindOrCreateL(node); // takes ownership |
|
157 CleanupStack::Pop(); |
|
158 #endif |
|
159 } |
|
160 |
|
161 EXPORT_C void CHuiFxEngine::LoadGroupEffectL( |
|
162 const TDesC& aFileName, |
|
163 CHuiFxEffect*& aEffect, |
|
164 MHuiEffectable* aVisual, |
|
165 TInt aGroup, |
|
166 #ifndef HUIFX_EFFECTCACHE_ENABLED |
|
167 TRect* extRect, |
|
168 #else |
|
169 TRect*, |
|
170 #endif |
|
171 MAlfGfxEffectObserver* aEffectEndObserver, |
|
172 TInt aHandle, |
|
173 TInt aFlags ) |
|
174 { |
|
175 #ifdef HUIFX_TRACE |
|
176 RDebug::Print(_L("CHuiFxEngine::LoadEffectL - %S, 0x%x, 0x%x"),&aFileName, aVisual, aEffect ); |
|
177 #endif |
|
178 if (aFileName.Length() == 0) |
|
179 { |
|
180 User::Leave( KErrNotFound); |
|
181 } |
|
182 //TODO: reuse parser? |
|
183 if( aEffect != NULL ) User::Leave( KErrGeneral ); |
|
184 #ifndef HUIFX_EFFECTCACHE_ENABLED |
|
185 iExtRect = TRect(); // clear the extrect |
|
186 if ( extRect ) |
|
187 { |
|
188 iExtRect = *extRect; |
|
189 } |
|
190 CHuiFxEffectParser* parser = CHuiFxEffectParser::NewL( *this, aVisual ); |
|
191 CleanupStack::PushL( parser ); |
|
192 parser->SetEffectEndObserver( aEffectEndObserver, aHandle ); |
|
193 parser->SetEffectFlags( aFlags ); |
|
194 // Parsing is asychronous, but we are not waiting for it to end. |
|
195 // CHuiFxEffectParser will take care of everything, and CHuiVisual |
|
196 // will kill the parser when parsing is finished or cancelled. |
|
197 aVisual->SetEffectParser( parser ); // ownership transferred |
|
198 CleanupStack::Pop( parser ); |
|
199 parser->ParseL( aFileName, iExtRect ); |
|
200 #endif |
|
201 #ifdef HUIFX_EFFECTCACHE_ENABLED |
|
202 CHuiFxEffectCacheEffectNode *node = new (ELeave) CHuiFxEffectCacheEffectNode(aFileName, aEffect, aVisual, &iExtRect, this); |
|
203 node->SetEffectEndObserver( aEffectEndObserver, aHandle ); |
|
204 if (aGroup != KErrNotFound) |
|
205 { |
|
206 aFlags |= KHuiFxWaitGroupSyncronization; |
|
207 node->SetEffectGroup(aGroup); |
|
208 } |
|
209 aFlags |= KHuiFxDelayRunUntilFirstFrameHasBeenDrawn; |
|
210 node->SetEffectFlags( aFlags ); |
|
211 |
|
212 CleanupStack::PushL(node); |
|
213 iCache->FindOrCreateL(node); // takes ownership |
|
214 CleanupStack::Pop(); |
|
215 #endif |
|
216 } |
|
217 EXPORT_C CHuiFxEngine::~CHuiFxEngine() |
|
218 { |
|
219 iActiveEffects.ResetAndDestroy(); |
|
220 iActiveEffects.Close(); |
|
221 #ifdef HUIFX_EFFECTCACHE_ENABLED |
|
222 delete iCache; |
|
223 #endif |
|
224 CHuiStatic::Env().RemoveMemoryLevelObserver(this); |
|
225 } |
|
226 |
|
227 EXPORT_C void CHuiFxEngine::Release() |
|
228 { |
|
229 ASSERT(iBuffersInUse == 0); |
|
230 #ifdef HUIFX_TRACE |
|
231 RDebug::Print(_L("CHuiFxEngine::Release - 0x%x"),this); |
|
232 #endif |
|
233 #ifdef HUIFX_RBCACHE_ENABLED |
|
234 int freedBuffers = 0; |
|
235 for(int i = 0; i < CACHE_SIZE; i++) |
|
236 { |
|
237 CHuiFxRenderbuffer *entry = iBufferCache[i]; |
|
238 if(entry) |
|
239 { |
|
240 ReleaseNativeRenderbuffer(entry); |
|
241 iBufferCache[i] = 0; |
|
242 freedBuffers++; |
|
243 } |
|
244 } |
|
245 // there should be as many freed buffers as there were free buffers. |
|
246 ASSERT(freedBuffers == iBuffersInCache); |
|
247 #endif |
|
248 } |
|
249 |
|
250 EXPORT_C void CHuiFxEngine::RestoreL() |
|
251 { |
|
252 #ifdef HUIFX_TRACE |
|
253 RDebug::Print(_L("CHuiFxEngine::RestoreL - 0x%x "), this); |
|
254 #endif |
|
255 #ifdef HUIFX_RBCACHE_ENABLED |
|
256 memset(iBufferCache, '\0', sizeof(iBufferCache)); |
|
257 iBuffersInCache = 0; |
|
258 #endif |
|
259 iBuffersInUse = 0; |
|
260 } |
|
261 |
|
262 void CHuiFxEngine::NotifyEffectEndObservers() |
|
263 { |
|
264 for ( TInt i = iActiveEffects.Count() - 1; i >= 0; i-- ) |
|
265 { |
|
266 CHuiFxEffect* effect = iActiveEffects[i]; |
|
267 if (!effect->Changed()) |
|
268 { |
|
269 effect->NotifyEffectEndObserver(); |
|
270 } |
|
271 } |
|
272 } |
|
273 |
|
274 EXPORT_C void CHuiFxEngine::AdvanceTime(TReal32 aElapsedTime) |
|
275 { |
|
276 // TODO: Can we do anything about all this polling? |
|
277 TInt i; |
|
278 TBool refreshRequired = EFalse; |
|
279 #ifdef HUIFX_TRACE |
|
280 RDebug::Print(_L("CHuiFxEngine::AdvanceTime - 0x%x "), this); |
|
281 #endif |
|
282 // Go through the list in reverse order. |
|
283 // If the effect has ended, and has the callback set, |
|
284 // the effect will be removed, and will no longer be part of iActiveEffects set. |
|
285 // We must check if the effect is still in our list, but the indices change |
|
286 // if something is removed from the middle of the list |
|
287 for ( i = iActiveEffects.Count() - 1; i >= 0; i-- ) |
|
288 { |
|
289 CHuiFxEffect* effect = iActiveEffects[i]; |
|
290 if (effect->Changed()) |
|
291 { |
|
292 refreshRequired = ETrue; |
|
293 } |
|
294 if ( i < iActiveEffects.Count() && effect == iActiveEffects[i] && !(effect->EffectFlags() & KHuiFxWaitGroupSyncronization)) |
|
295 { |
|
296 // The effect is still in its place, it did not go away yet |
|
297 effect->AdvanceTime(aElapsedTime); |
|
298 } |
|
299 } |
|
300 |
|
301 if (refreshRequired) |
|
302 { |
|
303 #ifdef HUIFX_TRACE |
|
304 RDebug::Print(_L("CHuiFxEngine::AdvanceTime - manually continue refresh ")); |
|
305 #endif |
|
306 CHuiStatic::Env().ContinueRefresh(); |
|
307 } |
|
308 } |
|
309 |
|
310 EXPORT_C void CHuiFxEngine::AddEffectL(CHuiFxEffect* aEffect) |
|
311 { |
|
312 #ifdef HUIFX_TRACE |
|
313 RDebug::Print(_L("CHuiFxEngine::AddEffectL - 0x%x "), aEffect); |
|
314 #endif // #ifdef HUIFX_TRACE |
|
315 |
|
316 iActiveEffects.AppendL(aEffect); |
|
317 } |
|
318 |
|
319 EXPORT_C void CHuiFxEngine::RemoveEffect(CHuiFxEffect* aEffect) |
|
320 { |
|
321 #ifdef HUIFX_TRACE |
|
322 RDebug::Print(_L("CHuiFxEngine::RemoveEffect - 0x%x "), aEffect); |
|
323 #endif |
|
324 TInt i = iActiveEffects.Find(aEffect); |
|
325 if (i >= 0) |
|
326 { |
|
327 iActiveEffects.Remove(i); |
|
328 } |
|
329 } |
|
330 |
|
331 EXPORT_C TReal32 CHuiFxEngine::GetReferenceValue(THuiFxReferencePoint aPoint) |
|
332 { |
|
333 #ifdef HUIFX_TRACE |
|
334 RDebug::Print(_L("CHuiFxEngine::GetReferenceValue - %d "), aPoint); |
|
335 #endif |
|
336 switch (aPoint) |
|
337 { |
|
338 case EReferencePointDisplayWidth: |
|
339 case EReferencePointDisplayRight: |
|
340 { |
|
341 CHuiDisplay* display = &CHuiStatic::Env().PrimaryDisplay(); |
|
342 return display->VisibleArea().Size().iWidth; // was DefaultRenderbuffer()->Size().iWidth |
|
343 } |
|
344 case EReferencePointDisplayHeight: |
|
345 case EReferencePointDisplayBottom: |
|
346 { |
|
347 CHuiDisplay* display = &CHuiStatic::Env().PrimaryDisplay(); |
|
348 return display->VisibleArea().Size().iHeight; // was DefaultRenderbuffer()->Size().iHeight |
|
349 } |
|
350 default: |
|
351 break; |
|
352 } |
|
353 // display left and top return 0 |
|
354 return 0.0f; |
|
355 } |
|
356 |
|
357 EXPORT_C THuiFxEngineType CHuiFxEngine::EngineType() |
|
358 { |
|
359 return iType; |
|
360 } |
|
361 |
|
362 EXPORT_C CHuiFxRenderbuffer* CHuiFxEngine::AcquireRenderbuffer(const TSize& aDesiredSize) |
|
363 { |
|
364 return AcquireRenderbuffer(aDesiredSize, ETrue); |
|
365 } |
|
366 |
|
367 CHuiFxRenderbuffer* CHuiFxEngine::AcquireRenderbuffer(const TSize& aDesiredSize, TBool aAllowLarger) |
|
368 { |
|
369 CHuiFxRenderbuffer *buffer = 0; |
|
370 #ifdef HUIFX_TRACE |
|
371 RDebug::Print(_L("CHuiFxEngine::AcquireRenderbuffer - w: %d h: %d "), aDesiredSize.iWidth, aDesiredSize.iHeight); |
|
372 #endif |
|
373 |
|
374 #ifdef HUIFX_RBCACHE_ENABLED |
|
375 if(!IsCacheEmpty()) |
|
376 { |
|
377 buffer = LookupFreeRenderbuffer(aDesiredSize, aAllowLarger); |
|
378 } |
|
379 |
|
380 if(buffer == 0) // no free or no suitable buffer available --- create new |
|
381 { |
|
382 #endif |
|
383 buffer = AcquireNativeRenderbuffer(aDesiredSize); |
|
384 #ifdef HUIFX_RBCACHE_ENABLED |
|
385 if(!IsCacheEmpty()) |
|
386 { |
|
387 #ifdef HUIFX_TRACE |
|
388 RDebug::Print(_L("CHuiFxEngine::AcquireRenderbuffer() --- no suitable buffer found from cache even if it is populated. Needed buffer size: %dx%d"), aDesiredSize.iWidth, aDesiredSize.iHeight); |
|
389 #endif |
|
390 } |
|
391 } |
|
392 else |
|
393 { |
|
394 buffer->SetPosition(TPoint(0,0)); |
|
395 buffer->EnableBackground(EFalse); |
|
396 buffer->PrepareForReuse(aDesiredSize); // clean up the buffer |
|
397 } |
|
398 #endif |
|
399 iBuffersInUse++; |
|
400 #ifdef HUIFX_TRACE |
|
401 RDebug::Print(_L("CHuiFxEngine::AcquireRenderbuffer - buffer 0x%x "), buffer); |
|
402 #endif |
|
403 return (CHuiFxRenderbuffer *)buffer; |
|
404 } |
|
405 |
|
406 // try to find a reusable buffer from iFreeBufferList |
|
407 #ifdef HUIFX_RBCACHE_ENABLED |
|
408 |
|
409 CHuiFxRenderbuffer* CHuiFxEngine::LookupFreeRenderbuffer(const TSize& aDesiredSize, TBool aAllowLarger) |
|
410 { |
|
411 #ifdef HUIFX_TRACE |
|
412 RDebug::Print(_L("CHuiFxEngine::LookupFreeRenderbuffer - w: %d h: %d "), aDesiredSize.iWidth, aDesiredSize.iHeight); |
|
413 #endif |
|
414 #ifdef _DEBUG |
|
415 const int preFreeBuffers = iBuffersInCache; |
|
416 #endif |
|
417 CHuiFxRenderbuffer *buffer = 0; |
|
418 int i; |
|
419 |
|
420 for(i = 0; i < CACHE_SIZE; i++) |
|
421 { |
|
422 if(iBufferCache[i]) |
|
423 { |
|
424 const TSize& bufferSize = iBufferCache[i]->Size(); |
|
425 |
|
426 if (aAllowLarger) |
|
427 { |
|
428 if ((aDesiredSize.iHeight <= bufferSize.iHeight) && (aDesiredSize.iWidth <= bufferSize.iWidth)) |
|
429 { |
|
430 buffer = iBufferCache[i]; |
|
431 iBufferCache[i] = 0; // mark entry as empty |
|
432 iBuffersInCache--; |
|
433 break; // we've found a suitable buffer |
|
434 } |
|
435 } |
|
436 else |
|
437 { |
|
438 if ((aDesiredSize.iHeight == bufferSize.iHeight) && (aDesiredSize.iWidth == bufferSize.iWidth)) |
|
439 { |
|
440 buffer = iBufferCache[i]; |
|
441 iBufferCache[i] = 0; // mark entry as empty |
|
442 iBuffersInCache--; |
|
443 break; // we've found a suitable buffer |
|
444 } |
|
445 |
|
446 } |
|
447 } |
|
448 } |
|
449 |
|
450 // sanity check |
|
451 ASSERT(((buffer != 0) ? (preFreeBuffers == iBuffersInCache + 1) : (preFreeBuffers == iBuffersInCache))); |
|
452 |
|
453 #ifdef HUIFX_TRACE |
|
454 RDebug::Print(_L("CHuiFxEngine::LookupFreeRenderbuffer - buffer 0x%x "), buffer); |
|
455 #endif |
|
456 return buffer; |
|
457 } |
|
458 #endif |
|
459 |
|
460 EXPORT_C void CHuiFxEngine::ReleaseRenderbuffer(CHuiFxRenderbuffer* aBuffer) |
|
461 { |
|
462 #ifdef HUIFX_TRACE |
|
463 RDebug::Print(_L("CHuiFxEngine::ReleaseRenderbuffer - buffer: 0x%x "), aBuffer); |
|
464 #endif |
|
465 ASSERT((aBuffer) && (iBuffersInUse > 0)); |
|
466 |
|
467 #ifdef HUIFX_RBCACHE_ENABLED |
|
468 if(iLowGraphicsMemoryMode || IsCacheFull()) |
|
469 { |
|
470 #ifdef HUIFX_TRACE |
|
471 RDebug::Print(_L("CHuiFxEngine::ReleaseRenderbuffer() --- Renderbuffer cache full! Suspectible for memory fragmentation! Cache size is %d entries."), CACHE_SIZE); |
|
472 #endif |
|
473 #endif |
|
474 ReleaseNativeRenderbuffer(aBuffer); |
|
475 aBuffer = 0; |
|
476 #ifdef HUIFX_RBCACHE_ENABLED |
|
477 } |
|
478 else |
|
479 { |
|
480 InsertFreeRenderbuffer(aBuffer); |
|
481 } |
|
482 #endif |
|
483 iBuffersInUse--; |
|
484 } |
|
485 |
|
486 #ifdef HUIFX_RBCACHE_ENABLED |
|
487 void CHuiFxEngine::InsertFreeRenderbuffer(CHuiFxRenderbuffer* aBuffer) |
|
488 { |
|
489 #ifdef HUIFX_TRACE |
|
490 RDebug::Print(_L("CHuiFxEngine::InsertFreeRenderbuffer - buf: 0x%x "), aBuffer); |
|
491 #endif |
|
492 #ifdef _DEBUG |
|
493 const int preiFreeBuffers = iBuffersInCache; |
|
494 #endif |
|
495 |
|
496 ASSERT((aBuffer) && (!IsCacheFull())); |
|
497 |
|
498 for(int i = 0; i < CACHE_SIZE; i++) |
|
499 { |
|
500 if(iBufferCache[i] == 0) |
|
501 { |
|
502 iBufferCache[i] = aBuffer; |
|
503 iBuffersInCache++; |
|
504 aBuffer = 0; |
|
505 break; |
|
506 } |
|
507 } |
|
508 |
|
509 ASSERT((aBuffer == 0) && (preiFreeBuffers + 1 == iBuffersInCache)); // we have actually inserted the aBuffer into iFreeBufferList successfully? |
|
510 } |
|
511 |
|
512 inline TBool CHuiFxEngine::IsCacheEmpty() const |
|
513 { |
|
514 #ifdef HUIFX_TRACE |
|
515 RDebug::Print(_L("CHuiFxEngine::IsCacheEmpty - %d "), (iBuffersInCache == 0)); |
|
516 #endif |
|
517 if(iBuffersInCache == 0) |
|
518 { |
|
519 return ETrue; |
|
520 } |
|
521 else |
|
522 { |
|
523 return EFalse; |
|
524 } |
|
525 } |
|
526 |
|
527 inline TBool CHuiFxEngine::IsCacheFull() const |
|
528 { |
|
529 #ifdef HUIFX_TRACE |
|
530 RDebug::Print(_L("CHuiFxEngine::IsCacheFull - %d "), (iBuffersInCache == CACHE_SIZE)); |
|
531 #endif |
|
532 if(iBuffersInCache == CACHE_SIZE) |
|
533 { |
|
534 return ETrue; |
|
535 } |
|
536 else |
|
537 { |
|
538 return EFalse; |
|
539 } |
|
540 } |
|
541 #endif |
|
542 |
|
543 EXPORT_C void CHuiFxEngine::EnableLowMemoryState(TBool /*aEnable*/) |
|
544 { |
|
545 // deprecated |
|
546 } |
|
547 |
|
548 EXPORT_C void CHuiFxEngine::SetMemoryLevel(THuiMemoryLevel aLevel) |
|
549 { |
|
550 iLowGraphicsMemoryMode = aLevel; |
|
551 if(iLowGraphicsMemoryMode) // != Normal |
|
552 { |
|
553 ClearCache(); |
|
554 } |
|
555 } |
|
556 |
|
557 EXPORT_C void CHuiFxEngine::Composite(CHuiGc& /*aGc*/, CHuiFxRenderbuffer& /*aSource*/, const TPoint& /*aTargetPoint*/, TBool /*aOpaque*/, TInt /*aAlpha*/) |
|
558 { |
|
559 // Default implementation does nothing |
|
560 } |
|
561 |
|
562 TInt CHuiFxEngine::LowMemoryState() |
|
563 { |
|
564 return iLowGraphicsMemoryMode; |
|
565 } |
|
566 |
|
567 TBool CHuiFxEngine::HasActiveEffects() const |
|
568 { |
|
569 return iActiveEffects.Count() > 0; |
|
570 } |
|
571 |
|
572 void CHuiFxEngine::ClearCache() |
|
573 { |
|
574 // Release cached render targets from effects |
|
575 for (TInt j=0; j<iActiveEffects.Count();j++) |
|
576 { |
|
577 iActiveEffects[j]->ReleaseCachedRenderTarget(); |
|
578 } |
|
579 |
|
580 if(IsCacheEmpty()) |
|
581 { |
|
582 return; |
|
583 } |
|
584 else |
|
585 { |
|
586 //clear cache |
|
587 for(TInt i = 0; i < CACHE_SIZE; i++) |
|
588 { |
|
589 if(iBufferCache[i] != 0) |
|
590 { |
|
591 ReleaseNativeRenderbuffer(iBufferCache[i]); |
|
592 iBufferCache[i] = 0; |
|
593 iBuffersInCache--; |
|
594 } |
|
595 } |
|
596 } |
|
597 |
|
598 ASSERT(iBuffersInCache == 0); |
|
599 } |
|
600 |
|
601 EXPORT_C void CHuiFxEngine::BeginGroupEffect(TInt aGroup) |
|
602 { |
|
603 TInt index = iActiveEffectGroups.Find(aGroup); |
|
604 if (index == KErrNotFound) |
|
605 { |
|
606 iActiveEffectGroups.Append(aGroup); |
|
607 } |
|
608 else |
|
609 { |
|
610 // group already exists |
|
611 } |
|
612 } |
|
613 |
|
614 EXPORT_C TInt CHuiFxEngine::ActiveGroupEffect() |
|
615 { |
|
616 if (iActiveEffectGroups.Count() > 0) |
|
617 { |
|
618 return iActiveEffectGroups[iActiveEffectGroups.Count()-1]; |
|
619 } |
|
620 else |
|
621 { |
|
622 return KErrNotFound; |
|
623 } |
|
624 } |
|
625 |
|
626 EXPORT_C void CHuiFxEngine::StartGroupEffect(TInt aGroup) |
|
627 { |
|
628 TInt index = iActiveEffectGroups.Find(aGroup); |
|
629 if (index != KErrNotFound) |
|
630 { |
|
631 iActiveEffectGroups.Remove(index); |
|
632 |
|
633 for ( TInt i = iActiveEffects.Count() - 1; i >= 0; i-- ) |
|
634 { |
|
635 CHuiFxEffect* effect = iActiveEffects[i]; |
|
636 TInt flags = effect->EffectFlags(); |
|
637 if ((flags & KHuiFxWaitGroupSyncronization) && (effect->GroupId() == aGroup)) |
|
638 { |
|
639 flags &= ~KHuiFxWaitGroupSyncronization; |
|
640 effect->SetEffectFlags(flags); |
|
641 } |
|
642 } |
|
643 } |
|
644 } |