|
1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #ifndef __GFXTRANSEFFECT_H__ |
|
17 #define __GFXTRANSEFFECT_H__ |
|
18 |
|
19 #include <e32def.h> // IMPORT_C |
|
20 #include <e32std.h> // T types |
|
21 #include <vwsdef.h> // TVwsViewId |
|
22 |
|
23 // forwards for standard Symbian classes used |
|
24 class CCoeControl; |
|
25 |
|
26 /** |
|
27 MGfxTransEffectObserver |
|
28 Observer class for watching for when a transition is finished. |
|
29 |
|
30 @publishedPartner |
|
31 @released |
|
32 */ |
|
33 class MGfxTransEffectObserver |
|
34 { |
|
35 public: |
|
36 /** |
|
37 Called when a transition is finished |
|
38 |
|
39 TransitionFinished will not be called if the transition fails. Depending on engine implementation |
|
40 TransitionFinished might be called after or during the GfxTransEffect::End() call |
|
41 */ |
|
42 virtual void TransitionFinished(const CCoeControl* aControl, TUint aAction) = 0; |
|
43 }; |
|
44 |
|
45 /** |
|
46 GfxTransEffect |
|
47 |
|
48 A generic interface used by transition-enabled controls and implemented by the transition engine vendor |
|
49 @publishedPartner |
|
50 @released |
|
51 */ |
|
52 class GfxTransEffect |
|
53 { |
|
54 public: |
|
55 //@{ |
|
56 /** |
|
57 Registration and Deregistration of transition-able controls |
|
58 |
|
59 The transition engine needs to associate internal data and state with the transition-able controls in the client thread. |
|
60 Each control that is transition-able needs to register with the transition engine. An ideal place to register is during |
|
61 control construction. |
|
62 |
|
63 Registration associates a logical class of transitions with the control instance. It allows the transition effects associated |
|
64 with listbox events to be different from those associated with dialogs closing. Standard UIDs shall be defined as required |
|
65 to identify logical transitionable-control classes. |
|
66 |
|
67 If you register a simple view or control, the control represents the foreground and an implicit background is registered too if |
|
68 required. |
|
69 |
|
70 If you register an N-Layered control, the component layers shall be implicitly registered. Change to the layers (including the |
|
71 adding, removing and reordering of layers) shall be detected by the @c GfxTransEffect::Begin() automagically. |
|
72 |
|
73 Controls that are not registered with the transition engine shall be ignored. Specifically, the @c Begin() function shall |
|
74 do nothing and the @c End() function shall invoke a @c CCoeControl::DrawNow() |
|
75 |
|
76 */ |
|
77 |
|
78 /** |
|
79 register the type of a view |
|
80 |
|
81 Associates a view with a logical type; example types might include DETAILVIEW etc. |
|
82 |
|
83 A transitionable view is not n-layered. The transition engine may split it into two layers - |
|
84 a background and a foreground - to allow effects (e.g. animation) to happen between the two. Or |
|
85 it may consider it a single, flat layer. |
|
86 |
|
87 Warning: Views that are not registered shall not have transitions associated with them |
|
88 |
|
89 @param aKey a view |
|
90 @param aView the view-id to associate view |
|
91 @param aType the classification of the view; standard UIDs shall be reserved for base views, detail views etc |
|
92 */ |
|
93 IMPORT_C static void Register(const CCoeControl* aKey,const TVwsViewId &aView,TUid aType); |
|
94 |
|
95 /** |
|
96 register the type of a control |
|
97 |
|
98 Associates a control with a logical type; example types might include LISTBOX, MENUPAGE etc. |
|
99 |
|
100 A transitionable control probably contains an implicit zero layer - it's background. This is gathered if the @c MCoeControlBackground is set |
|
101 If the control is @c aNLayered, then each child is considered a separate layer (in strict order they are returned, last returned being topmost). |
|
102 Otherwise, a single foreground layer is assumed. |
|
103 |
|
104 Warning: Controls that are not registered will not have any transition associated with them |
|
105 |
|
106 @param aKey the address of the control used to coordinate the transitions |
|
107 @param aType the classification of the control; standard UIDs shall be reserved for listboxes, menupanes, tab groups, building blocks etc |
|
108 @param aNLayered does the control consist of more than two layers? |
|
109 */ |
|
110 IMPORT_C static void Register(const CCoeControl* aKey,TUid aType,TBool aNLayered = EFalse); |
|
111 |
|
112 /** |
|
113 tests whether a control is registered or not |
|
114 |
|
115 This does not test if the control is a layer within a registered N-Layered control |
|
116 |
|
117 @param aKey the address of the control used to coordinate the transitions |
|
118 @return ETrue if the control is registered, else EFalse |
|
119 */ |
|
120 IMPORT_C static TBool IsRegistered(const CCoeControl* aKey); |
|
121 |
|
122 /** |
|
123 Deregister a control or view |
|
124 |
|
125 Controls might often register themselves during their construction. |
|
126 This function provides the facility to undo that for the application programmer. |
|
127 |
|
128 Controls that are not registered shall not have transitions associated with them. |
|
129 |
|
130 Deregistration of a control currently under transition (between begin and end) will abort the transition. |
|
131 |
|
132 @param aKey the address of the control to be deregistered |
|
133 */ |
|
134 IMPORT_C static void Deregister(const CCoeControl* aKey); |
|
135 //@} |
|
136 |
|
137 //@{ |
|
138 /** |
|
139 Transition Hints |
|
140 |
|
141 Often the implementation of a transition-able control (or control that represents a layer within that control) shall be |
|
142 able to hint things to the transition effects engine that assist the transition effects engine in dealing with that control |
|
143 efficiently. |
|
144 |
|
145 Hints are just that: advice to the transition engine, which the transition engine may ignore if appropriate. |
|
146 |
|
147 Additional hints might be added in the future, or specific to a particular class of control. |
|
148 */ |
|
149 |
|
150 /** |
|
151 generic flags for @c SetHints() |
|
152 |
|
153 Implicit background layers have default flags of @c EStatic|EOpaque |
|
154 |
|
155 Foreground layers have default flags of @c EDynamic|ETransparent |
|
156 |
|
157 N-Layered controls have default flags of @c EDynamic|ETransparent - which is used to as the default for their child layers - |
|
158 even if they have an implicit background layer with default background layer flags. |
|
159 */ |
|
160 enum |
|
161 { |
|
162 EDynamic = 0x00000000, //< needs constant recalculating by the client |
|
163 EStatic = 0x00000001, //< unlikely to change (unless @c Invalidate() d) and therefore a good candidate for caching the contents of; opposite to @c EDynamic |
|
164 ETransparent = 0x00000000, //< needs to be drawn to a @c CBitmapContext that supports alpha |
|
165 EOpaque = 0x00000002, //< does not need alpha; opposite to @c ETransparent |
|
166 ENone = ~0 //< used if flags are retrieved for a control that is not registered |
|
167 }; |
|
168 |
|
169 /** |
|
170 sets the flags for a control |
|
171 |
|
172 If you @c SetHints on an N-Layered control, you shall be setting those same hints upon all component layers of that control; |
|
173 this is probably not what you intend to do. |
|
174 |
|
175 @param aControl the address of the control to associate the flags with; it is either registered, or a layer of a registered N-Layered control |
|
176 @param aFlags the new flags |
|
177 */ |
|
178 IMPORT_C static void SetHints(const CCoeControl* aControl,TUint aFlags); |
|
179 |
|
180 /** |
|
181 retrieves the flags for a control |
|
182 |
|
183 If you @c GetHints on an N-Layered control, you shall be retrieving the default settings for that control and it's layers. |
|
184 If individual layers have had @c SetHints called explicitly, they may not have the same flags as their parent. |
|
185 |
|
186 @param aControl the address of the control that the flags are associated with; it is either registered, or a layer of a registered N-Layered control |
|
187 @return @c ENone if the control is not registered, otherwise the flags |
|
188 */ |
|
189 IMPORT_C static TUint GetHints(const CCoeControl* aControl); |
|
190 |
|
191 IMPORT_C static void SetHints(const CCoeControl* aControl,TUid aLayerType); |
|
192 |
|
193 /** |
|
194 informs the engine that any cached graphical representation of a control that it might have made is now out of date |
|
195 |
|
196 controls flagged as @c EStatic may have bitmaps cached unless resized (although repositioning probably doesn't affect their cache) |
|
197 or an explicit call to @c Invalidate(). |
|
198 |
|
199 If you @c Invalidate() a registered N-Layered control, only its background layer will be invalidated |
|
200 |
|
201 @param aControl the address of the control to be invalidated; it is either registered, or a layer of a registered N-Layered control |
|
202 */ |
|
203 IMPORT_C static void Invalidate(const CCoeControl* aControl); |
|
204 //@} |
|
205 |
|
206 //@{ |
|
207 /** |
|
208 Transition Demarcations |
|
209 |
|
210 Sometimes an inter-window transition has an demarcation - e.g. a detail view 'zoom out' of the selected list box item, or a popup occur from a pointer press. The |
|
211 new window may not know where it is coming from, but the window losing focus might. This hint might help make the two transitions appear synchronised |
|
212 and connected. |
|
213 |
|
214 The demarcation can be set for a window losing focus/visibility and for a window gaining focus/visibility, or both at once. |
|
215 |
|
216 Non-TVwsViewId demarcation operations are applied to the inner-most @c Begin() block for this control; they panic if the control is not currently in transition |
|
217 (unless the transition engine is not able to comply) |
|
218 |
|
219 For a window gaining focus/visibility, the demarcation represents the begin-point for the transition. |
|
220 For a window losing focus/visibility, the demarcation infact represents the end-point for the transition. |
|
221 */ |
|
222 |
|
223 /** |
|
224 set the demarcation point of a transition |
|
225 |
|
226 Useful if the window losing focus and the window gaining focus are both in the same thread. |
|
227 |
|
228 @param aControl the address of the control to set the demarcation for; it is either registered, or a layer of a registered N-Layered control |
|
229 @param aDemarcation the point at from which the transition ought begin or end |
|
230 */ |
|
231 IMPORT_C static void SetDemarcation(const CCoeControl* aControl,const TPoint &aDemarcation); |
|
232 |
|
233 /** |
|
234 set the demarcation point of a transition using a @c TVwsViewId |
|
235 |
|
236 Useful if the window losing focus and the window gaining focus are not necessarily in the same thread |
|
237 |
|
238 @param aView the view id of the window |
|
239 @param aDemarcation the point from which the transition ought begin or end |
|
240 */ |
|
241 IMPORT_C static void SetDemarcation(const TVwsViewId &aView,const TPoint &aDemarcation); |
|
242 |
|
243 /** |
|
244 set the demarcation rectangle of a transition |
|
245 |
|
246 Useful if the control losing focus and the control gaining focus are both in the same thread |
|
247 |
|
248 @param aControl the address of the control to set the demarcation for; it is either registered, or a layer of a registered N-Layered control |
|
249 @param aDemarcation the rectangle from which the transition ought begin or end |
|
250 */ |
|
251 IMPORT_C static void SetDemarcation(const CCoeControl* aControl,const TRect &aDemarcation); |
|
252 |
|
253 /** |
|
254 set the demarcation rectangle of a transition using a @c TVwsViewId |
|
255 |
|
256 Useful if the window losing focus and the window gaining focus are not necessarily in the same thread |
|
257 |
|
258 @param aView the view id of the window |
|
259 @param aDemarcation the rectangle from which the transition ought begin or end |
|
260 */ |
|
261 IMPORT_C static void SetDemarcation(const TVwsViewId &aView,const TRect &aDemarcation); |
|
262 |
|
263 /** |
|
264 set the demarcation rectangle from the client rectangle of another control for a transition |
|
265 |
|
266 Useful if the control losing focus and the control gaining focus are both in the same thread |
|
267 |
|
268 @param aControl the address of the control to set the demarcation for; it is either registered, or a layer of a registered N-Layered control |
|
269 @param aSrc the control to use as the source; this control need not be registered |
|
270 @param aDemarcation the client rectangle of @c aSrc from which the transition ought begin or end |
|
271 */ |
|
272 IMPORT_C static void SetDemarcation(const CCoeControl* aControl,const CCoeControl* aSrc,const TRect &aDemarcation); |
|
273 |
|
274 /** |
|
275 set the demarcation rectangle from the client rectangle of a control for a transition using a @c TVwsViewId |
|
276 |
|
277 Useful if the window losing focus and the window gaining focus are not necessarily in the same thread |
|
278 |
|
279 @param aView the view id of the window, possibly owned by another thread |
|
280 @param aSrc the control in the current thread to use as the source; this control need not be registered |
|
281 @param aDemarcation the client rectangle of @c aSrc from which the transition ought begin or end |
|
282 */ |
|
283 IMPORT_C static void SetDemarcation(const TVwsViewId &aView,const CCoeControl* aSrc,const TRect &aDemarcation); |
|
284 //@} |
|
285 |
|
286 //@{ |
|
287 /** |
|
288 Effecting Transitions |
|
289 |
|
290 Actions that affect the visual representation of a control and that might have a transition associated with them are wrapped between |
|
291 @c Begin() and @c End() calls. |
|
292 |
|
293 @c Begin() and @c End() calls can be nested. It is up to the engine to decide whether to have sub-stages in transition effects or to |
|
294 flatten the transitions into a single transition. @c Begin() and @c End() calls must be matched and cannot be overlapped. |
|
295 */ |
|
296 |
|
297 /** |
|
298 generic transition event identifiers |
|
299 |
|
300 Additional events might be added in the future, or specific to a particular class of control |
|
301 */ |
|
302 enum |
|
303 { |
|
304 EOpen, |
|
305 EClose, |
|
306 EVisible, |
|
307 EInvisible, |
|
308 EGainFocus, |
|
309 ELoseFocus, |
|
310 EForegroundChange, |
|
311 EBackgroundChange, |
|
312 EInternalStateChange //< not an implicit @c Invalidate() ! You still have to invalidate a control or it's component layers manually |
|
313 }; |
|
314 |
|
315 /** |
|
316 begins a transition |
|
317 |
|
318 Provides an opportunity for the engine to capture the 'before' state of the control and its layers. |
|
319 |
|
320 Code between a @c Begin and it's matching @c End cannot leave. In those circumstances, use @c BeginLC instead. |
|
321 |
|
322 @param aKey the address of the control to begin transition |
|
323 @param aAction a hint as to the type of transition to perform, e.g. EGainFocus |
|
324 */ |
|
325 IMPORT_C static void Begin(const CCoeControl* aKey,TUint aAction); |
|
326 |
|
327 /** |
|
328 begins a transition in a leave-safe way |
|
329 |
|
330 Provides an opportunity for the engine to capture the 'before' state of the control and its layers. |
|
331 |
|
332 Places a special TCleanupItem onto the cleanup-stack so that subsequent code before the next @c End can leave. |
|
333 In the event of a leave, the transition shall be implicitly aborted and the corresponding @c End should not be called. |
|
334 |
|
335 This means that code within the @c BeginLC and the matching @c End cannot unbalance the cleanup stack, however. |
|
336 |
|
337 @c BeginLC shall only leave if it the push of the TCleanupItem fails (in which case code is typically in a bad way anyway). |
|
338 It shall not leave if there are insufficient resources to coordinate a transition. |
|
339 |
|
340 @param aKey the address of the control to begin transition |
|
341 @param aAction a hint as to the type of transition to perform, e.g. EGainFocus |
|
342 */ |
|
343 IMPORT_C static void BeginLC(const CCoeControl* aKey,TUint aAction); |
|
344 |
|
345 /** |
|
346 ends a transition |
|
347 |
|
348 Transition effects might not occur until the engine has seen both the 'before' and 'after' state of the control. |
|
349 |
|
350 End() should match the inner-most Begin() or BeginLC() block. |
|
351 If it doesn't, the client will try find a matching begin on a higher nesting level. |
|
352 If found, the 'unmatched' Begin calls lower in the nesting chain will be discarded. |
|
353 If not found, the End will be ignored. |
|
354 |
|
355 @param aKey the address of the registered control to end transition |
|
356 */ |
|
357 IMPORT_C static void End(const CCoeControl* aKey); |
|
358 |
|
359 /** |
|
360 notify the engine of an external state (change). |
|
361 |
|
362 Some transitions might need a notification of when an external state has been reached. |
|
363 Then this function can be used. |
|
364 The state information and the optional data is send unmodified to the engine, and has to be supported |
|
365 by the specific engine implementation. |
|
366 |
|
367 @param aState the state that has been reached. |
|
368 @param aArg optional argument data. |
|
369 */ |
|
370 IMPORT_C static void NotifyExternalState(TInt aState, const TDesC8* aArg = NULL); |
|
371 |
|
372 /** |
|
373 terminate a specific transition |
|
374 |
|
375 An aborted transition must not subsequently be ended. |
|
376 |
|
377 The call is ignored if @c aKey does not match the inner-most @c Begin |
|
378 |
|
379 @param aKey the address of the registered control to abort transition |
|
380 */ |
|
381 IMPORT_C static void Abort(const CCoeControl* aKey); |
|
382 |
|
383 /** |
|
384 terminate all effects for this client |
|
385 |
|
386 @c Abort() shall terminate all non-complete transitions. It may also signal the cancellation of logically-complete yet still under-animation |
|
387 transitions. |
|
388 |
|
389 Subsequent calls to @c Begin() shall begin a fresh transition set. Calls to @c End() and @c Abort() before the next @c Begin() shall |
|
390 not panic. |
|
391 */ |
|
392 IMPORT_C static void Abort(); |
|
393 |
|
394 /** |
|
395 terminate all effects for this client |
|
396 |
|
397 Aborts all non-complete transitions and may signal the cancellation of underway transitions. |
|
398 |
|
399 Subsequent calls to @c Begin() shall not begin a fresh transition set. |
|
400 */ |
|
401 IMPORT_C static void Disable(); |
|
402 |
|
403 /** |
|
404 enable transition effects |
|
405 */ |
|
406 IMPORT_C static void Enable(); |
|
407 |
|
408 /** |
|
409 query if the transition engine is available and enabled for this client |
|
410 |
|
411 This is no guarentee that the transition engine has resources to render transitions. |
|
412 */ |
|
413 IMPORT_C static TBool IsEnabled(); |
|
414 |
|
415 |
|
416 |
|
417 /** |
|
418 Sets the demarcation rectangle for the controls end position. |
|
419 |
|
420 This call will override the controls actual position at End. |
|
421 |
|
422 @param aControl the address of the control to set the demarcation for; it is either registered, or a layer of a registered N-Layered control |
|
423 @param aDemarcation the rectangle to which the transition will end |
|
424 */ |
|
425 IMPORT_C static void SetEndDemarcation(const CCoeControl* aControl, const TRect& aDemarcation); |
|
426 |
|
427 /** |
|
428 Sets the demarcation rectangle for the controls begin position. |
|
429 |
|
430 This call will override the controls actual position at Begin. |
|
431 |
|
432 @param aControl the address of the control to set the demarcation for; it is either registered, or a layer of a registered N-Layered control |
|
433 @param aDemarcation the rectangle from which the transition will begin |
|
434 */ |
|
435 IMPORT_C static void SetBeginDemarcation(const CCoeControl* aControl, const TRect& aDemarcation); |
|
436 |
|
437 /** |
|
438 Begins a new transition group |
|
439 |
|
440 Used to group several independent transitions to be executed synchronized. |
|
441 Begin/End calls between calls to BeginGroup and EndGroup will be queued and transitioned on the call to EndGroup. |
|
442 All calls to Begin must be followed by a corresponding call to End before EndGroup is called. |
|
443 |
|
444 @return an integer ID that indentifies the group. |
|
445 */ |
|
446 IMPORT_C static TInt BeginGroup(); //returns an id for the group. |
|
447 |
|
448 /** |
|
449 Ends a transition group. |
|
450 |
|
451 Ends a transition group and starts the grouped transitions. |
|
452 |
|
453 @param aGroupId the ID of the group. |
|
454 */ |
|
455 IMPORT_C static void EndGroup(TInt aGroupId); |
|
456 |
|
457 /** |
|
458 associates arbitrary data with a transition. |
|
459 |
|
460 The data is given the supplied aType id and applied to the inner-most Begin block. |
|
461 The descriptors data must be valid until End has been called. |
|
462 |
|
463 @param aType the type identifier of the data |
|
464 @param aData the data to supply. |
|
465 */ |
|
466 IMPORT_C static void SetTransitionData(TUint aType, const TDesC8& aData); |
|
467 |
|
468 //Support for non-CCoeControl transitions. |
|
469 |
|
470 /** |
|
471 Used to register a Draw Item Control. |
|
472 |
|
473 A Draw Item Control is a flat coecontrol that has graphic parts that are transioned independently. For example a listbox with listbox items. The client is informed of the independent parts while drawing the coecontrol using BeginDrawItem and EndDrawItem. |
|
474 |
|
475 @param aControl the control |
|
476 @param aType Type of item. Used by transition engine to assign proper behaviour. |
|
477 */ |
|
478 IMPORT_C static void RegisterDrawItemControl(const CCoeControl* aControl, TUid aType); |
|
479 |
|
480 |
|
481 /** |
|
482 Used to mark the start of an individual Draw Item in a Draw Item Control. |
|
483 |
|
484 BeginDrawItem and EndDrawItem should be called in the Draw Item Controls Draw() function, to identify wich drawing commands that belong to wich individual Draw Item. The draw commands supplied between BeginDrawItem and EndDrawItem will be treated as an individual participant bitmap in the transition. |
|
485 All draw commands not within Begin/EndDrawItem calls will be drawn treated as part of the coecontrol and not as an individual Draw Item. |
|
486 |
|
487 Note that aFromRect:s and aToRect:s provided in the Draw corrensponding to the end state of a transition has priority over the begin state |
|
488 |
|
489 @param aControl the control |
|
490 @param aId Unique id to match subitems between CCoeControl begin- and end states. |
|
491 @param aType Type of item. Used by transition engine to assign proper behaviour. |
|
492 @param aDrawRect This is the rect within the CCoeControl where the item is drawn. |
|
493 @param aFromRect Optional: This rectangle will be used as "begin demarcation" if used. |
|
494 @param aToRect Optional: This rectangle will be used as "end demarcation" if used. |
|
495 */ |
|
496 IMPORT_C static void BeginDrawItem(const CCoeControl* aControl, TUint aId, TUid aType,TRect &aDrawRect,const TRect* aFromRect, const TRect* aToRect); |
|
497 |
|
498 |
|
499 /** |
|
500 Used to mark the end of an individual Draw Item in a Draw Item Control. |
|
501 |
|
502 @param aControl the control |
|
503 */ |
|
504 IMPORT_C static void EndDrawItem(const CCoeControl* aControl); |
|
505 |
|
506 /** |
|
507 starts a full screen transition effect. |
|
508 |
|
509 Begins a full screen effect. |
|
510 Depending on the type of effect, it might start immediatly, or at the corresponding End call. |
|
511 |
|
512 @param aAction Effect identifier |
|
513 @param aEffectArea the part of the framebuffer to be affected |
|
514 */ |
|
515 IMPORT_C static void BeginFullScreen(TUint aAction, const TRect &aEffectArea); |
|
516 |
|
517 |
|
518 /** |
|
519 starts a full screen transition effect. |
|
520 |
|
521 Begins a full screen effect. |
|
522 Depending on the type of effect, it might start immediatly, or at the corresponding End call. |
|
523 This variant takes a type and a descriptor with extra parameters to the transition. These can typically be a position on the screen from wich the full screen effect should originate. |
|
524 |
|
525 @param aAction Effect identifier |
|
526 @param aEffectArea the part of the framebuffer to be affected |
|
527 @param aType the type of the parameters. |
|
528 @param aParam the parameters. |
|
529 */ |
|
530 IMPORT_C static void BeginFullScreen(TUint aAction, const TRect &aEffectArea, TUint aType, const TDesC8& aParams); |
|
531 |
|
532 /** |
|
533 Marks the end point for a full screen effect. |
|
534 |
|
535 Tells the transition engine that the wserv framebuffer should contain the desired end state of a fullscreen effect. |
|
536 For some effects this point might be when the transition actually start. |
|
537 */ |
|
538 IMPORT_C static void EndFullScreen(); |
|
539 |
|
540 /** |
|
541 aborts a full screen effect. |
|
542 |
|
543 Aborts any ongoing full screen effect. |
|
544 */ |
|
545 IMPORT_C static void AbortFullScreen(); |
|
546 |
|
547 /** |
|
548 Sets a transition observer |
|
549 |
|
550 The observer recieves callbacks when transitions are finished. |
|
551 @param aObserver The observer that will be notified. NULL means that no observer will be called. |
|
552 */ |
|
553 IMPORT_C static void SetTransitionObserver(MGfxTransEffectObserver* aObserver); |
|
554 |
|
555 //@} |
|
556 |
|
557 |
|
558 // |
|
559 }; |
|
560 #endif // __GFXTRANSEFFECT_H__ |