|
1 /* |
|
2 * Copyright (c) 2002 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 // AKNBITMAPANIMATION.CPP |
|
19 // |
|
20 // Copyright (c) 1997-2001 Symbian Ltd. All rights reserved. |
|
21 // |
|
22 #include <barsread.h> |
|
23 #include <eikenv.h> |
|
24 #include <fbs.h> |
|
25 #include <AknBitmapAnimation.h> |
|
26 #include <bmpanconsts.h> |
|
27 #include <AknsUtils.h> |
|
28 #include <AknsItemDef.h> |
|
29 #include <AknIconUtils.h> |
|
30 #include <AknPanic.h> |
|
31 #include <AknUtils.h> |
|
32 |
|
33 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
34 #include <akntransitionutils.h> |
|
35 #include <avkondomainpskeys.h> |
|
36 #include <e32property.h> |
|
37 #endif |
|
38 |
|
39 // CONSTANTS |
|
40 |
|
41 // The value for this frame delay interval should be kept big |
|
42 // enough because otherwise the first and (only) frame of the animation |
|
43 // will not be shown at all by bitmap animation framework. |
|
44 // This value is used only in skin forward comparability purposes. |
|
45 const TInt KSkinForwardCompatibilityFrameDelayInterval = 1000; |
|
46 |
|
47 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
48 const TInt KWaitForUiEffectDelay = 50000; |
|
49 #endif |
|
50 |
|
51 RAknBitmapAnim::RAknBitmapAnim(RAnimDll& aAnimDll) |
|
52 : RBitmapAnim(aAnimDll) |
|
53 { |
|
54 } |
|
55 |
|
56 TInt RAknBitmapAnim::Stop() |
|
57 { |
|
58 return CommandReply(EBitmapAnimCommandStopAnimation); |
|
59 } |
|
60 |
|
61 void RAknBitmapAnim::StartAndKeepLastFrameL() |
|
62 { |
|
63 User::LeaveIfError(CommandReply(EBitmapAnimCommandStartAnimationAndKeepLastFrame)); |
|
64 } |
|
65 |
|
66 enum TInternalFlags |
|
67 { |
|
68 EInitialisationCompleted = 0x0001, |
|
69 EAnimationStarted = 0x0002, |
|
70 EAnimationFinished = 0x0004, |
|
71 EAnimationTimerStarted = 0x0008, |
|
72 EAnimationExcludeFramesFromCache = 0x0010, |
|
73 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
74 EWaitingForUiEffect = 0x0020, |
|
75 #endif |
|
76 EAnimationSingleFrame = 0x0040 |
|
77 }; |
|
78 |
|
79 enum TAknAnimationPanic |
|
80 { |
|
81 EAknPanicAnimationNoControlContext, |
|
82 EAknPanicAnimationNoRAnimation, |
|
83 EAknPanicAnimationNoWindow, |
|
84 EAknPanicAnimationMethodToBeRemoved |
|
85 }; |
|
86 |
|
87 GLDEF_C void Panic(TAknAnimationPanic aPanic) |
|
88 { |
|
89 _LIT(KPanicCat,"Animation"); |
|
90 User::Panic(KPanicCat, aPanic); |
|
91 } |
|
92 |
|
93 const TInt KConversionFromMillisecondsToMicroseconds = 1000; |
|
94 |
|
95 // |
|
96 // |
|
97 EXPORT_C CAknBitmapAnimation* CAknBitmapAnimation::NewL() |
|
98 { // static |
|
99 CAknBitmapAnimation* self=new(ELeave) CAknBitmapAnimation(); |
|
100 CleanupStack::PushL(self); |
|
101 self->ConstructL(); |
|
102 CleanupStack::Pop(); |
|
103 return self; |
|
104 } |
|
105 |
|
106 CAknBitmapAnimation::CAknBitmapAnimation() : |
|
107 iAnimDll(iEikonEnv->WsSession()), |
|
108 iAnimation(iAnimDll), |
|
109 iScaleModeFrames(EAspectRatioPreserved), |
|
110 iScaleModeBackgroundFrame(EAspectRatioPreserved) |
|
111 { |
|
112 } |
|
113 |
|
114 EXPORT_C CAknBitmapAnimation::~CAknBitmapAnimation() |
|
115 { |
|
116 CancelAnimation(); |
|
117 delete iTimer; |
|
118 iAnimation.Close(); |
|
119 delete iBitmapAnimData; |
|
120 iAnimDll.Close(); |
|
121 } |
|
122 |
|
123 EXPORT_C RBitmapAnim& CAknBitmapAnimation::Animation() |
|
124 { |
|
125 return iAnimation; |
|
126 } |
|
127 |
|
128 EXPORT_C CBitmapAnimClientData* CAknBitmapAnimation::BitmapAnimData() const |
|
129 { |
|
130 return iBitmapAnimData; |
|
131 } |
|
132 // |
|
133 // |
|
134 void CAknBitmapAnimation::ConstructL() |
|
135 { |
|
136 iBitmapAnimData = CBitmapAnimClientData::NewL(); |
|
137 _LIT(DllName, "Z:\\SYS\\BIN\\BMPANSRV.DLL"); |
|
138 User::LeaveIfError(iAnimDll.Load(DllName)); |
|
139 iTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
|
140 } |
|
141 // |
|
142 // |
|
143 |
|
144 void CAknBitmapAnimation::Draw(const TRect& /*aRect*/) const |
|
145 { |
|
146 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
147 CWindowGc& gc = SystemGc(); |
|
148 CWindowGc& coegc = iCoeEnv->SystemGc(); |
|
149 TBool hascustomgc = (&gc != &coegc); |
|
150 TInt frameCount( BitmapAnimData()->FrameArray().Count() ); |
|
151 if ( frameCount > 0 && ( ( iFlags & EAnimationStarted ) || iGainedFocus || |
|
152 hascustomgc ) ) |
|
153 { |
|
154 gc.Reset(); |
|
155 #else |
|
156 TInt frameCount( BitmapAnimData()->FrameArray().Count() ); |
|
157 if ( ( iFlags & EAnimationStarted ) || iGainedFocus ) |
|
158 { |
|
159 CWindowGc& gc=SystemGc(); |
|
160 gc.Reset(); |
|
161 #endif |
|
162 |
|
163 TInt endFrame = frameCount - 1; |
|
164 if (0 <= endFrame) |
|
165 { |
|
166 TPoint pos = BitmapAnimData()->FrameArray().At(endFrame)->Position(); |
|
167 pos += Position(); |
|
168 CFbsBitmap* bit = BitmapAnimData()->FrameArray().At(endFrame)->Bitmap(); |
|
169 CFbsBitmap* mask = BitmapAnimData()->FrameArray().At(endFrame)->Mask(); |
|
170 |
|
171 if (mask) |
|
172 { |
|
173 gc.BitBltMasked(pos,bit,TRect(TPoint(0,0),bit->SizeInPixels()),mask,ETrue); |
|
174 } |
|
175 else |
|
176 { |
|
177 gc.BitBlt(pos,bit,TRect(TPoint(0,0),bit->SizeInPixels())); |
|
178 } |
|
179 } |
|
180 } |
|
181 } |
|
182 |
|
183 |
|
184 void CAknBitmapAnimation::FocusChanged(TDrawNow /*aDrawNow*/) |
|
185 { |
|
186 if ( BitmapAnimData()->FrameArray().Count() == 1 ) |
|
187 { |
|
188 // focus loss and gain may cause the animation not to appear in |
|
189 // confirmation queries -> draw one frame animation also here |
|
190 if ( IsFocused() ) |
|
191 { |
|
192 DrawDeferred(); |
|
193 iGainedFocus = ETrue; |
|
194 } |
|
195 else |
|
196 { |
|
197 iGainedFocus = EFalse; |
|
198 } |
|
199 } |
|
200 } |
|
201 |
|
202 // ----------------------------------------------------------------------------- |
|
203 // CAknBitmapAnimation::ConstructFromSkinL |
|
204 // (documented in the header). |
|
205 // ----------------------------------------------------------------------------- |
|
206 // |
|
207 EXPORT_C TBool CAknBitmapAnimation::ConstructFromSkinL( |
|
208 const TAknsItemID& aItemID ) |
|
209 { |
|
210 TBool unknownPlayMode = EFalse; |
|
211 MAknsSkinInstance* skin = AknsUtils::SkinInstance(); |
|
212 if( !skin ) |
|
213 { |
|
214 User::Leave( KErrNotSupported ); |
|
215 } |
|
216 |
|
217 CAknsBmpAnimItemData* animData = static_cast<CAknsBmpAnimItemData*>( |
|
218 skin->CreateUncachedItemDataL( aItemID, EAknsITBmpAnim ) ); |
|
219 if( !animData ) |
|
220 { |
|
221 return EFalse; |
|
222 } |
|
223 CleanupStack::PushL( animData ); |
|
224 |
|
225 iBitmapAnimData->SetFrameInterval( animData->FrameInterval() ); |
|
226 |
|
227 CBitmapAnimClientData::TPlayMode playMode = static_cast<CBitmapAnimClientData::TPlayMode>(animData->PlayMode()); |
|
228 |
|
229 if (playMode != CBitmapAnimClientData::EPlay && |
|
230 playMode != CBitmapAnimClientData::ECycle && |
|
231 playMode != CBitmapAnimClientData::EBounce) |
|
232 { |
|
233 unknownPlayMode = ETrue; |
|
234 playMode = CBitmapAnimClientData::EPlay; |
|
235 |
|
236 if (!animData->FrameInterval()) |
|
237 { |
|
238 iBitmapAnimData->SetFrameInterval(KSkinForwardCompatibilityFrameDelayInterval); |
|
239 } |
|
240 } |
|
241 |
|
242 iBitmapAnimData->SetPlayMode(playMode); |
|
243 iBitmapAnimData->SetFlash( animData->Flash() ); |
|
244 iBitmapAnimData->ResetFrameArray(); |
|
245 |
|
246 TAknsBmpAnimFrameInfo* frameInfos = animData->FrameInfos(); |
|
247 |
|
248 TBool result = ETrue; |
|
249 |
|
250 TInt n = animData->NumberOfImages(); |
|
251 for( TInt i=0; i<n; i++ ) |
|
252 { |
|
253 CAknsBitmapItemData* bmpData = static_cast<CAknsBitmapItemData*>( |
|
254 skin->CreateUncachedItemDataL( animData->ImageIID( i ), EAknsITBitmap ) ); |
|
255 CleanupStack::PushL( bmpData ); |
|
256 |
|
257 if( bmpData ) |
|
258 { |
|
259 CBitmapFrameData* targetFrameData = CBitmapFrameData::NewL( |
|
260 bmpData->Bitmap() ); |
|
261 bmpData->SetBitmap( NULL ); // Detaches ownership |
|
262 |
|
263 if( bmpData->Type() == EAknsITMaskedBitmap ) |
|
264 { |
|
265 CAknsMaskedBitmapItemData* maskedData = |
|
266 static_cast<CAknsMaskedBitmapItemData*>( bmpData ); |
|
267 targetFrameData->SetMask( maskedData->Mask() ); |
|
268 maskedData->SetMask( NULL ); // Detaches ownership |
|
269 } |
|
270 |
|
271 if( frameInfos ) |
|
272 { |
|
273 // if the playmode is not recognized the frame interval should be set to -1 |
|
274 // this way the frame internal set on animation level takes precedence |
|
275 targetFrameData->SetInterval( (unknownPlayMode?-1:frameInfos[i].iTime) ); |
|
276 targetFrameData->SetPosition( TPoint( |
|
277 frameInfos[i].iPosX, frameInfos[i].iPosY ) ); |
|
278 } |
|
279 |
|
280 if( (i==n-1) && animData->LastFrameBackground() ) |
|
281 { |
|
282 iBitmapAnimData->SetBackgroundFrame( targetFrameData ); |
|
283 } |
|
284 else |
|
285 { |
|
286 CleanupStack::PushL( targetFrameData ); |
|
287 iBitmapAnimData->AppendFrameL( targetFrameData ); |
|
288 CleanupStack::Pop(); // targetFrameData |
|
289 } |
|
290 } |
|
291 else |
|
292 { |
|
293 result = EFalse; |
|
294 } |
|
295 |
|
296 CleanupStack::PopAndDestroy(); // bmpData |
|
297 } |
|
298 |
|
299 CleanupStack::PopAndDestroy(); // animData |
|
300 return result; |
|
301 } |
|
302 |
|
303 EXPORT_C void CAknBitmapAnimation::ConstructFromResourceL(TResourceReader& aReader) |
|
304 { |
|
305 // Read identifier byte. It may be used later to identify the used resource struct. |
|
306 TInt8 identifier = aReader.ReadInt8(); |
|
307 __ASSERT_DEBUG( identifier <= KAknBMPAnimVersion, Panic( EAknPanicNotSupported ) ); |
|
308 |
|
309 if (identifier == KAknBMPAnimVersion) |
|
310 { |
|
311 TAknsItemID iid; |
|
312 iid.Set( EAknsMajorAvkon, aReader.ReadInt32()); |
|
313 if (ConstructFromSkinL(iid)) |
|
314 { |
|
315 iBitmapAnimData->SetFrameInterval(aReader.ReadInt16()); |
|
316 iBitmapAnimData->SetPlayMode((CBitmapAnimClientData::TPlayMode)aReader.ReadInt16()); |
|
317 iBitmapAnimData->SetFlash(aReader.ReadInt8()); |
|
318 aReader.ReadTPtrC(); // filename |
|
319 aReader.ReadInt32(); // frames |
|
320 aReader.ReadInt32(); // background frame data |
|
321 if ( iBitmapAnimData->FrameArray().Count() == 1 ) |
|
322 { |
|
323 iFlags |= EAnimationSingleFrame; |
|
324 iFlags |= EInitialisationCompleted; |
|
325 } |
|
326 return; |
|
327 } |
|
328 } |
|
329 |
|
330 iBitmapAnimData->SetFrameInterval(aReader.ReadInt16()); |
|
331 iBitmapAnimData->SetPlayMode((CBitmapAnimClientData::TPlayMode)aReader.ReadInt16()); |
|
332 iBitmapAnimData->SetFlash(aReader.ReadInt8()); |
|
333 iBitmapAnimData->ResetFrameArray(); |
|
334 |
|
335 TFileName appName(aReader.ReadTPtrC()); // filename |
|
336 if (appName.Length()) |
|
337 { |
|
338 TInt err = CompleteWithAppPath(appName); |
|
339 if (err != KErrNotSupported) |
|
340 User::LeaveIfError(err); |
|
341 } |
|
342 |
|
343 // Start reading the data frames |
|
344 TInt listFrameLink=aReader.ReadInt32(); |
|
345 if (listFrameLink) |
|
346 { |
|
347 TResourceReader framesReader; |
|
348 iCoeEnv->CreateResourceReaderLC(framesReader, listFrameLink); |
|
349 const TInt count=framesReader.ReadInt16(); |
|
350 CBitmapFrameData* frameData = NULL; |
|
351 for (TInt ii=0;ii<count;++ii) |
|
352 { |
|
353 //read the frame data from resource |
|
354 frameData = CreateFrameDataFromResourceL(framesReader, appName, identifier); |
|
355 CleanupStack::PushL(frameData); |
|
356 iBitmapAnimData->AppendFrameL(frameData); |
|
357 CleanupStack::Pop(frameData); |
|
358 } |
|
359 CleanupStack::PopAndDestroy(); |
|
360 } |
|
361 // Start reading the background frame data |
|
362 TInt backgroundFrameLink=aReader.ReadInt32(); |
|
363 if (backgroundFrameLink) |
|
364 { |
|
365 TResourceReader framesReader; |
|
366 iCoeEnv->CreateResourceReaderLC(framesReader, backgroundFrameLink); |
|
367 const TInt count=framesReader.ReadInt16(); |
|
368 CBitmapFrameData* frameData = NULL; |
|
369 for (TInt ii=0;ii<count;++ii) |
|
370 { |
|
371 //read the background frame from resource |
|
372 frameData = CreateFrameDataFromResourceL(framesReader, appName, identifier); |
|
373 iBitmapAnimData->SetBackgroundFrame(frameData); |
|
374 } |
|
375 CleanupStack::PopAndDestroy(); |
|
376 } |
|
377 if ( iBitmapAnimData->FrameArray().Count() == 1 ) |
|
378 { |
|
379 iFlags |= EAnimationSingleFrame; |
|
380 iFlags |= EInitialisationCompleted; |
|
381 } |
|
382 } |
|
383 |
|
384 |
|
385 // |
|
386 // |
|
387 CBitmapFrameData* CAknBitmapAnimation::CreateFrameDataFromResourceL(TResourceReader& aFramesReader, |
|
388 const TDesC& aFileName, |
|
389 const TInt8 aVersion) |
|
390 { |
|
391 CBitmapFrameData* frameData = CBitmapFrameData::NewL(); |
|
392 CleanupStack::PushL(frameData); |
|
393 frameData->SetInterval(aFramesReader.ReadInt16()); |
|
394 TPoint position; |
|
395 position.iX = aFramesReader.ReadInt16(); |
|
396 position.iY = aFramesReader.ReadInt16(); |
|
397 frameData->SetPosition(position); |
|
398 const TInt bmpId = aFramesReader.ReadInt16(); |
|
399 const TInt maskId = aFramesReader.ReadInt16(); |
|
400 CFbsBitmap *bitmap, *mask; |
|
401 MAknsSkinInstance* skin = AknsUtils::SkinInstance(); |
|
402 |
|
403 if (bmpId >= 0 && maskId>= 0) |
|
404 { |
|
405 if (aVersion == KAknBMPAnimVersion) |
|
406 { |
|
407 TAknsItemID iid; |
|
408 TInt major = aFramesReader.ReadInt32(); |
|
409 TInt minor = aFramesReader.ReadInt32(); |
|
410 iid.Set( major, minor); |
|
411 AknsUtils::CreateIconLC(skin, iid, bitmap, mask, aFileName, bmpId, maskId); |
|
412 } |
|
413 else |
|
414 { |
|
415 AknIconUtils::CreateIconLC(bitmap, mask, aFileName, bmpId, maskId); |
|
416 } |
|
417 frameData->SetBitmap(bitmap); |
|
418 frameData->SetMask(mask); |
|
419 CleanupStack::Pop(2); // bitmap, mask |
|
420 } |
|
421 else if (bmpId >= 0) |
|
422 { |
|
423 bitmap = AknIconUtils::CreateIconL(aFileName, bmpId); |
|
424 frameData->SetBitmap(bitmap); |
|
425 } |
|
426 else |
|
427 { |
|
428 // Do nothing. Panic can also be considered here. |
|
429 } |
|
430 CleanupStack::Pop(frameData); //frameData |
|
431 return frameData; |
|
432 } |
|
433 |
|
434 // |
|
435 // |
|
436 EXPORT_C TInt CAknBitmapAnimation::CancelAnimation() |
|
437 { |
|
438 #ifdef _DEBUG |
|
439 RDebug::Print(_L("CAknBitmapAnimation::CancelAnimation instance:%x"),this); |
|
440 #endif //_DEBUG |
|
441 TInt err = 0; |
|
442 |
|
443 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
444 if(!(iFlags & EWaitingForUiEffect)) |
|
445 { |
|
446 #endif |
|
447 if ( ( iFlags & EAnimationStarted // callback completed |
|
448 || iFlags &EAnimationTimerStarted ) // animation is started, but callback not yet complete |
|
449 && !( iFlags & EAnimationSingleFrame ) ) |
|
450 { |
|
451 err = iAnimation.Stop(); |
|
452 } |
|
453 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
454 } |
|
455 iFlags &= ~EWaitingForUiEffect; |
|
456 #endif |
|
457 if (iTimer) |
|
458 { |
|
459 iTimer->Cancel(); |
|
460 iFlags &= ~EAnimationTimerStarted; |
|
461 } |
|
462 |
|
463 iFlags &= ~EAnimationStarted; |
|
464 return err; |
|
465 } |
|
466 |
|
467 // |
|
468 // |
|
469 void CAknBitmapAnimation::CompleteAnimationInitialisationL() |
|
470 { |
|
471 SetAnimationWindowL(); |
|
472 iAnimation.SetBitmapAnimDataL(*iBitmapAnimData); |
|
473 iAnimation.SetPositionL(iPosition); |
|
474 iFlags |= EInitialisationCompleted; |
|
475 } |
|
476 |
|
477 // |
|
478 // |
|
479 TBool CAknBitmapAnimation::IsInitialisationCompleted() |
|
480 { |
|
481 return iFlags&EInitialisationCompleted; |
|
482 } |
|
483 |
|
484 // |
|
485 // |
|
486 EXPORT_C TSize CAknBitmapAnimation::MinimumSize() |
|
487 { |
|
488 return iBitmapAnimData->Size(); |
|
489 } |
|
490 |
|
491 // |
|
492 // |
|
493 void CAknBitmapAnimation::PositionChanged() |
|
494 { |
|
495 if (IsInitialisationCompleted()) |
|
496 { |
|
497 TRAP_IGNORE(iAnimation.SetPositionL(iPosition)); |
|
498 } |
|
499 } |
|
500 |
|
501 // |
|
502 // |
|
503 void CAknBitmapAnimation::SetAnimationWindowL() |
|
504 { |
|
505 iAnimation.ConstructL(Window()); |
|
506 } |
|
507 |
|
508 // |
|
509 EXPORT_C void CAknBitmapAnimation::SetFrameIndexL(TInt aIndex) |
|
510 { |
|
511 if (!IsInitialisationCompleted()) |
|
512 CompleteAnimationInitialisationL(); |
|
513 if ( !( iFlags & EAnimationSingleFrame ) ) |
|
514 { |
|
515 iAnimation.DisplayFrameL(aIndex); |
|
516 } |
|
517 } |
|
518 |
|
519 // |
|
520 EXPORT_C void CAknBitmapAnimation::SetFrameIntervalL(TInt aFrameIntervalInMilliSeconds) |
|
521 { |
|
522 if (!IsInitialisationCompleted()) |
|
523 CompleteAnimationInitialisationL(); |
|
524 iAnimation.SetFrameIntervalL(aFrameIntervalInMilliSeconds); |
|
525 } |
|
526 // |
|
527 // |
|
528 void CAknBitmapAnimation::SizeChanged() |
|
529 { |
|
530 #ifdef _DEBUG |
|
531 RDebug::Print(_L("CAknBitmapAnimation::SizeChanged instance:%x"),this); |
|
532 #endif //_DEBUG |
|
533 // background frame needs also to be resized |
|
534 if (BitmapAnimData()->BackgroundFrame()) |
|
535 { |
|
536 CFbsBitmap* bit = BitmapAnimData()->BackgroundFrame()->Bitmap(); |
|
537 if (iFlags & EAnimationExcludeFramesFromCache) |
|
538 { |
|
539 AknIconUtils::ExcludeFromCache(bit); |
|
540 } |
|
541 AknIconUtils::SetSize(bit, Rect().Size(),iScaleModeBackgroundFrame); |
|
542 } |
|
543 |
|
544 TInt endFrame = BitmapAnimData()->FrameArray().Count()-1; |
|
545 for (TInt i=0;i<=endFrame;i++) |
|
546 { |
|
547 CFbsBitmap* bit = BitmapAnimData()->FrameArray().At(i)->Bitmap(); |
|
548 if (iFlags & EAnimationExcludeFramesFromCache) |
|
549 { |
|
550 AknIconUtils::ExcludeFromCache(bit); |
|
551 } |
|
552 AknIconUtils::SetSize(bit, Rect().Size(),iScaleModeFrames); |
|
553 } |
|
554 } |
|
555 |
|
556 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
557 LOCAL_C TInt WaitForUiEffect(TAny* aArg) |
|
558 { |
|
559 CAknBitmapAnimation* self = (CAknBitmapAnimation*)aArg; |
|
560 self->StartAnimationL(); |
|
561 return EFalse; |
|
562 } |
|
563 #endif |
|
564 |
|
565 // |
|
566 // |
|
567 EXPORT_C void CAknBitmapAnimation::StartAnimationL() |
|
568 { |
|
569 #ifdef _DEBUG |
|
570 RDebug::Print(_L("CAknBitmapAnimation::StartAnimationL instance:%x"),this); |
|
571 #endif //_DEBUG |
|
572 |
|
573 if ( iFlags & EAnimationSingleFrame ) |
|
574 { |
|
575 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
576 iFlags &= ~EWaitingForUiEffect; |
|
577 #endif |
|
578 iFlags |= EAnimationStarted; |
|
579 DrawDeferred(); |
|
580 return; |
|
581 } |
|
582 |
|
583 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
584 TInt redirectstatus = 0; |
|
585 RProperty::Get(KPSUidAvkonDomain, KAknTfxServerRedirectionStatus, redirectstatus ); |
|
586 TBool isredirected = (redirectstatus & ETfxScreenRedirected); |
|
587 |
|
588 // this is executed as long as transition is running, then the aknbitmapanimation |
|
589 // switches to "normal" mode and WaitForUiEffect callback isn't called anymore |
|
590 if( CAknTransitionUtils::GetData(EDontAnimateBitmaps) || isredirected ) |
|
591 { |
|
592 if( !(iFlags & EAnimationTimerStarted) && !( iFlags & EWaitingForUiEffect ) ) |
|
593 { |
|
594 iFlags |= EWaitingForUiEffect; |
|
595 TCallBack callback(WaitForUiEffect, this); |
|
596 iTimer->Cancel(); |
|
597 iTimer->Start(KWaitForUiEffectDelay, KWaitForUiEffectDelay, callback); |
|
598 } |
|
599 } |
|
600 else |
|
601 { |
|
602 iFlags &= ~EWaitingForUiEffect; |
|
603 #endif |
|
604 if (!IsInitialisationCompleted()) |
|
605 { |
|
606 CompleteAnimationInitialisationL(); |
|
607 } |
|
608 else |
|
609 { |
|
610 // Otherwise, update animation data since it may have changed |
|
611 iAnimation.SetBitmapAnimDataL(*iBitmapAnimData); |
|
612 // This call updates the cached background frame content for the animation. |
|
613 // It is also very important to call this function only after calling |
|
614 // iAnimation.SetBitmapAnimDataL() |
|
615 iAnimation.SetPositionL(iPosition); |
|
616 } |
|
617 iAnimation.StartAndKeepLastFrameL(); |
|
618 if (!(iFlags & EAnimationTimerStarted)) |
|
619 { // if animation timer has not started, start timer |
|
620 TCallBack callback(AnimationStartedCallback, this); |
|
621 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
622 iTimer->Cancel(); //when popup animations are enabled the timer might already be started |
|
623 #endif //RD_UI_TRANSITION_EFFECTS_POPUPS |
|
624 iTimer->Start(iBitmapAnimData->DurationInMilliSeconds()*KConversionFromMillisecondsToMicroseconds/2, 1/*just the once*/, callback); // a delay of half the animation time |
|
625 iFlags |= EAnimationTimerStarted; |
|
626 } |
|
627 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
628 } |
|
629 #endif |
|
630 } |
|
631 |
|
632 |
|
633 // ----------------------------------------------------------------------------- |
|
634 // CAknBitmapAnimation::SetScaleModeForAnimationFrames |
|
635 // ----------------------------------------------------------------------------- |
|
636 // |
|
637 EXPORT_C void CAknBitmapAnimation::SetScaleModeForAnimationFrames(TScaleMode aMode) |
|
638 { |
|
639 iScaleModeFrames = aMode; |
|
640 } |
|
641 |
|
642 // ----------------------------------------------------------------------------- |
|
643 // CAknBitmapAnimation::SetScaleModeForAnimationBackgroundFrame |
|
644 // ----------------------------------------------------------------------------- |
|
645 // |
|
646 EXPORT_C void CAknBitmapAnimation::SetScaleModeForAnimationBackgroundFrame(TScaleMode aMode) |
|
647 { |
|
648 iScaleModeBackgroundFrame = aMode; |
|
649 } |
|
650 |
|
651 // ----------------------------------------------------------------------------- |
|
652 // CAknBitmapAnimation::ExcludeAnimationFramesFromCache |
|
653 // ----------------------------------------------------------------------------- |
|
654 // |
|
655 EXPORT_C void CAknBitmapAnimation::ExcludeAnimationFramesFromCache() |
|
656 { |
|
657 iFlags |= EAnimationExcludeFramesFromCache; |
|
658 } |
|
659 |
|
660 TInt CAknBitmapAnimation::AnimationHasStarted(TBool aHasStarted) |
|
661 { |
|
662 if (aHasStarted) |
|
663 { |
|
664 iFlags |= EAnimationStarted; |
|
665 DrawDeferred(); |
|
666 } |
|
667 if (iTimer) |
|
668 |
|
669 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
670 if( !( iFlags & EWaitingForUiEffect ) ) |
|
671 { |
|
672 iTimer->Cancel(); |
|
673 } |
|
674 #else |
|
675 iTimer->Cancel(); |
|
676 #endif |
|
677 return KErrNone; |
|
678 } |
|
679 |
|
680 TInt CAknBitmapAnimation::AnimationStartedCallback(TAny* aPtr) |
|
681 { |
|
682 CAknBitmapAnimation* ptr = (CAknBitmapAnimation*)aPtr; |
|
683 return ptr->AnimationHasStarted(ETrue); |
|
684 } |
|
685 |
|
686 EXPORT_C void CAknBitmapAnimation::StartAnimationL( TBool aKeepLastFrame ) |
|
687 { |
|
688 #ifdef _DEBUG |
|
689 RDebug::Print(_L("CAknBitmapAnimation::StartAnimationL instance:%x"),this); |
|
690 #endif //_DEBUG |
|
691 |
|
692 if ( iFlags & EAnimationSingleFrame ) |
|
693 { |
|
694 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
695 iFlags &= ~EWaitingForUiEffect; |
|
696 #endif |
|
697 iFlags |= EAnimationStarted; |
|
698 DrawDeferred(); |
|
699 return; |
|
700 } |
|
701 |
|
702 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
703 TInt redirectstatus = 0; |
|
704 RProperty::Get(KPSUidAvkonDomain, KAknTfxServerRedirectionStatus, redirectstatus ); |
|
705 TBool isredirected = (redirectstatus & ETfxScreenRedirected); |
|
706 |
|
707 // this is executed as long as transition is running, then the aknbitmapanimation |
|
708 // switches to "normal" mode and WaitForUiEffect callback isn't called anymore |
|
709 if( CAknTransitionUtils::GetData(EDontAnimateBitmaps) || isredirected ) |
|
710 { |
|
711 if( !(iFlags & EAnimationTimerStarted) && !( iFlags & EWaitingForUiEffect ) ) |
|
712 { |
|
713 iFlags |= EWaitingForUiEffect; |
|
714 TCallBack callback(WaitForUiEffect, this); |
|
715 iTimer->Cancel(); |
|
716 iTimer->Start(KWaitForUiEffectDelay, KWaitForUiEffectDelay, callback); |
|
717 } |
|
718 } |
|
719 else |
|
720 { |
|
721 iFlags &= ~EWaitingForUiEffect; |
|
722 #endif |
|
723 if (!IsInitialisationCompleted()) |
|
724 { |
|
725 CompleteAnimationInitialisationL(); |
|
726 } |
|
727 else |
|
728 { |
|
729 // Otherwise, update animation data since it may have changed |
|
730 iAnimation.SetBitmapAnimDataL(*iBitmapAnimData); |
|
731 // This call updates the cached background frame content for the animation. |
|
732 // It is also very important to call this function only after calling |
|
733 // iAnimation.SetBitmapAnimDataL() |
|
734 iAnimation.SetPositionL(iPosition); |
|
735 } |
|
736 if( aKeepLastFrame ) |
|
737 { |
|
738 iAnimation.StartAndKeepLastFrameL(); |
|
739 } |
|
740 else |
|
741 { |
|
742 iAnimation.StartL(); |
|
743 } |
|
744 |
|
745 if (!(iFlags & EAnimationTimerStarted)) |
|
746 { // if animation timer has not started, start timer |
|
747 TCallBack callback(AnimationStartedCallback, this); |
|
748 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
749 iTimer->Cancel(); //when popup animations are enabled the timer might already be started |
|
750 #endif //RD_UI_TRANSITION_EFFECTS_POPUPS |
|
751 iTimer->Start(iBitmapAnimData->DurationInMilliSeconds()*KConversionFromMillisecondsToMicroseconds/2, 1/*just the once*/, callback); // a delay of half the animation time |
|
752 iFlags |= EAnimationTimerStarted; |
|
753 } |
|
754 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS |
|
755 } |
|
756 #endif |
|
757 } |