]> git.sesse.net Git - vlc/blob - modules/gui/macosx/embeddedwindow.m
macosx: added missing pl locks
[vlc] / modules / gui / macosx / embeddedwindow.m
1 /*****************************************************************************
2  * embeddedwindow.m: MacOS X interface module
3  *****************************************************************************
4  * Copyright (C) 2005-2008 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Benjamin Pracht <bigben at videolan dot org>
8  *          Felix Paul Kühne <fkuehne at videolan dot org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 /* DisableScreenUpdates, SetSystemUIMode, ... */
30 #import <QuickTime/QuickTime.h>
31
32 #import "intf.h"
33 #import "controls.h"
34 #import "vout.h"
35 #import "embeddedwindow.h"
36 #import "fspanel.h"
37
38 /*****************************************************************************
39  * VLCEmbeddedWindow Implementation
40  *****************************************************************************/
41
42 @implementation VLCEmbeddedWindow
43
44 - (void)awakeFromNib
45 {
46     [self setDelegate: self];
47
48     [o_btn_backward setToolTip: _NS("Rewind")];
49     [o_btn_forward setToolTip: _NS("Fast Forward")];
50     [o_btn_fullscreen setToolTip: _NS("Fullscreen")];
51     [o_btn_play setToolTip: _NS("Play")];
52     [o_slider setToolTip: _NS("Position")];
53
54     o_img_play = [NSImage imageNamed: @"play_embedded"];
55     o_img_pause = [NSImage imageNamed: @"pause_embedded"];
56     [self controlTintChanged];
57     [[NSNotificationCenter defaultCenter] addObserver: self
58                                              selector: @selector( controlTintChanged )
59                                                  name: NSControlTintDidChangeNotification
60                                                object: nil];
61
62     /* Useful to save o_view frame in fullscreen mode */
63     o_temp_view = [[NSView alloc] init];
64     [o_temp_view setAutoresizingMask:NSViewHeightSizable | NSViewWidthSizable];
65
66     o_fullscreen_window = nil;
67     o_fullscreen_anim1 = o_fullscreen_anim2 = nil;
68
69     /* Not fullscreen when we wake up */
70     [o_btn_fullscreen setState: NO];
71     b_fullscreen = NO;
72
73     [self setMovableByWindowBackground:YES];
74
75     [self setDelegate:self];
76
77     /* Make sure setVisible: returns NO */
78     [self orderOut:self];
79     b_window_is_invisible = YES;
80     videoRatio = NSMakeSize( 0., 0. );
81 }
82
83 - (void)controlTintChanged
84 {
85     BOOL b_playing = NO;
86     if( [o_btn_play alternateImage] == o_img_play_pressed )
87         b_playing = YES;
88     
89     if( [NSColor currentControlTint] == NSGraphiteControlTint )
90     {
91         o_img_play_pressed = [NSImage imageNamed: @"play_embedded_graphite"];
92         o_img_pause_pressed = [NSImage imageNamed: @"pause_embedded_graphite"];
93         [o_btn_backward setAlternateImage: [NSImage imageNamed: @"skip_previous_embedded_graphite"]];
94         [o_btn_forward setAlternateImage: [NSImage imageNamed: @"skip_forward_embedded_graphite"]];
95         [o_btn_fullscreen setAlternateImage: [NSImage imageNamed: @"fullscreen_graphite"]];
96     }
97     else
98     {
99         o_img_play_pressed = [NSImage imageNamed: @"play_embedded_blue"];
100         o_img_pause_pressed = [NSImage imageNamed: @"pause_embedded_blue"];
101         [o_btn_backward setAlternateImage: [NSImage imageNamed: @"skip_previous_embedded_blue"]];
102         [o_btn_forward setAlternateImage: [NSImage imageNamed: @"skip_forward_embedded_blue"]];
103         [o_btn_fullscreen setAlternateImage: [NSImage imageNamed: @"fullscreen_blue"]];
104     }
105     
106     if( b_playing )
107         [o_btn_play setAlternateImage: o_img_play_pressed];
108     else
109         [o_btn_play setAlternateImage: o_img_pause_pressed];
110 }
111
112 - (void)dealloc
113 {
114     [[NSNotificationCenter defaultCenter] removeObserver: self];
115     [o_img_play release];
116     [o_img_play_pressed release];
117     [o_img_pause release];
118     [o_img_pause_pressed release];
119     
120     [super dealloc];
121 }
122
123 - (void)setTime:(NSString *)o_arg_time position:(float)f_position
124 {
125     [o_time setStringValue: o_arg_time];
126     [o_slider setFloatValue: f_position];
127 }
128
129 - (void)playStatusUpdated:(int)i_status
130 {
131     if( i_status == PLAYING_S )
132     {
133         [o_btn_play setImage: o_img_pause];
134         [o_btn_play setAlternateImage: o_img_pause_pressed];
135         [o_btn_play setToolTip: _NS("Pause")];
136     }
137     else
138     {
139         [o_btn_play setImage: o_img_play];
140         [o_btn_play setAlternateImage: o_img_play_pressed];
141         [o_btn_play setToolTip: _NS("Play")];
142     }
143 }
144
145 - (void)setSeekable:(BOOL)b_seekable
146 {
147     [o_btn_forward setEnabled: b_seekable];
148     [o_btn_backward setEnabled: b_seekable];
149     [o_slider setEnabled: b_seekable];
150 }
151
152 - (BOOL)windowShouldZoom:(NSWindow *)sender toFrame:(NSRect)newFrame
153 {
154     [self setFrame: newFrame display: YES animate: YES];
155     return NO;
156 }
157
158 - (BOOL)windowShouldClose:(id)sender
159 {
160     playlist_t * p_playlist = pl_Hold( VLCIntf );
161
162     playlist_Stop( p_playlist );
163     vlc_object_release( p_playlist );
164     return YES;
165 }
166
167 - (NSView *)mainView
168 {
169     if (o_fullscreen_window)
170         return o_temp_view;
171     else
172         return o_view;
173 }
174
175 - (void)setVideoRatio:(NSSize)ratio
176 {
177     videoRatio = ratio;
178 }
179
180 - (NSSize)windowWillResize:(NSWindow *)window toSize:(NSSize)proposedFrameSize
181 {
182     if( videoRatio.height == 0. || videoRatio.width == 0. )
183         return proposedFrameSize;
184
185     NSRect viewRect = [o_view convertRect:[o_view bounds] toView: nil];
186     NSRect contentRect = [self contentRectForFrameRect:[self frame]];
187     float marginy = viewRect.origin.y + [self frame].size.height - contentRect.size.height;
188     float marginx = contentRect.size.width - viewRect.size.width;
189     proposedFrameSize.height = (proposedFrameSize.width - marginx) * videoRatio.height / videoRatio.width + marginy;
190
191     return proposedFrameSize;
192 }
193
194 /*****************************************************************************
195  * Fullscreen support
196  */
197
198 - (BOOL)isFullscreen
199 {
200     return b_fullscreen;
201 }
202
203 - (void)lockFullscreenAnimation
204 {
205     [o_animation_lock lock];
206 }
207
208 - (void)unlockFullscreenAnimation
209 {
210     [o_animation_lock unlock];
211 }
212
213 - (void)enterFullscreen
214 {
215     NSMutableDictionary *dict1, *dict2;
216     NSScreen *screen;
217     NSRect screen_rect;
218     NSRect rect;
219     vout_thread_t *p_vout = vlc_object_find( VLCIntf, VLC_OBJECT_VOUT, FIND_ANYWHERE );
220     BOOL blackout_other_displays = config_GetInt( VLCIntf, "macosx-black" );
221
222     screen = [NSScreen screenWithDisplayID:(CGDirectDisplayID)var_GetInteger( p_vout, "video-device" )]; 
223  
224     [self lockFullscreenAnimation];
225
226     if (!screen)
227     {
228         msg_Dbg( p_vout, "chosen screen isn't present, using current screen for fullscreen mode" );
229         screen = [self screen];
230     }
231     if (!screen)
232     {
233         msg_Dbg( p_vout, "Using deepest screen" );
234         screen = [NSScreen deepestScreen];
235     }
236
237     vlc_object_release( p_vout );
238
239     screen_rect = [screen frame];
240
241     [o_btn_fullscreen setState: YES];
242
243     [NSCursor setHiddenUntilMouseMoves: YES];
244  
245     if( blackout_other_displays )        
246         [screen blackoutOtherScreens];
247
248     /* Make sure we don't see the window flashes in float-on-top mode */
249     originalLevel = [self level];
250     [self setLevel:NSNormalWindowLevel];
251
252     /* Only create the o_fullscreen_window if we are not in the middle of the zooming animation */
253     if (!o_fullscreen_window)
254     {
255         /* We can't change the styleMask of an already created NSWindow, so we create an other window, and do eye catching stuff */
256
257         rect = [[o_view superview] convertRect: [o_view frame] toView: nil]; /* Convert to Window base coord */
258         rect.origin.x += [self frame].origin.x;
259         rect.origin.y += [self frame].origin.y;
260         o_fullscreen_window = [[VLCWindow alloc] initWithContentRect:rect styleMask: NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:YES];
261         [o_fullscreen_window setBackgroundColor: [NSColor blackColor]];
262         [o_fullscreen_window setCanBecomeKeyWindow: YES];
263
264         if (![self isVisible] || [self alphaValue] == 0.0 || MACOS_VERSION < 10.4f)
265         {
266             /* We don't animate if we are not visible or if we are running on
267              * Mac OS X <10.4 which doesn't support NSAnimation, instead we
268              * simply fade the display */
269             CGDisplayFadeReservationToken token;
270  
271             CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
272             CGDisplayFade( token, 0.5, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
273  
274             if ([screen isMainScreen])
275                 SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
276  
277             [[self contentView] replaceSubview:o_view with:o_temp_view];
278             [o_temp_view setFrame:[o_view frame]];
279             [o_fullscreen_window setContentView:o_view];
280
281             [o_fullscreen_window makeKeyAndOrderFront:self];
282             [o_fullscreen_window orderFront:self animate:YES];
283
284             [o_fullscreen_window setFrame:screen_rect display:YES];
285
286             CGDisplayFade( token, 0.3, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
287             CGReleaseDisplayFadeReservation( token);
288
289             /* Will release the lock */
290             [self hasBecomeFullscreen];
291
292             return;
293         }
294  
295         /* Make sure we don't see the o_view disappearing of the screen during this operation */
296         DisableScreenUpdates();
297         [[self contentView] replaceSubview:o_view with:o_temp_view];
298         [o_temp_view setFrame:[o_view frame]];
299         [o_fullscreen_window setContentView:o_view];
300         [o_fullscreen_window makeKeyAndOrderFront:self];
301         EnableScreenUpdates();
302     }
303
304     if (MACOS_VERSION < 10.4f)
305     {
306         /* We were already fullscreen nothing to do when NSAnimation
307          * is not supported */
308         [self unlockFullscreenAnimation];
309         return;
310     }
311
312     /* We are in fullscreen (and no animation is running) */
313     if (b_fullscreen)
314     {
315         /* Make sure we are hidden */
316         [super orderOut: self];
317         [self unlockFullscreenAnimation];
318         return;
319     }
320
321     if (o_fullscreen_anim1)
322     {
323         [o_fullscreen_anim1 stopAnimation];
324         [o_fullscreen_anim1 release];
325     }
326     if (o_fullscreen_anim2)
327     {
328         [o_fullscreen_anim2 stopAnimation];
329         [o_fullscreen_anim2 release];
330     }
331  
332     if ([screen isMainScreen])
333         SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
334
335     dict1 = [[NSMutableDictionary alloc] initWithCapacity:2];
336     dict2 = [[NSMutableDictionary alloc] initWithCapacity:3];
337
338     [dict1 setObject:self forKey:NSViewAnimationTargetKey];
339     [dict1 setObject:NSViewAnimationFadeOutEffect forKey:NSViewAnimationEffectKey];
340
341     [dict2 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
342     [dict2 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
343     [dict2 setObject:[NSValue valueWithRect:screen_rect] forKey:NSViewAnimationEndFrameKey];
344
345     /* Strategy with NSAnimation allocation:
346         - Keep at most 2 animation at a time
347         - leaveFullscreen/enterFullscreen are the only responsible for releasing and alloc-ing
348     */
349     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict1, nil]];
350     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict2, nil]];
351
352     [dict1 release];
353     [dict2 release];
354
355     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
356     [o_fullscreen_anim1 setDuration: 0.3];
357     [o_fullscreen_anim1 setFrameRate: 30];
358     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
359     [o_fullscreen_anim2 setDuration: 0.2];
360     [o_fullscreen_anim2 setFrameRate: 30];
361
362     [o_fullscreen_anim2 setDelegate: self];
363     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
364
365     [o_fullscreen_anim1 startAnimation];
366     /* fullscreenAnimation will be unlocked when animation ends */
367 }
368
369 - (void)hasBecomeFullscreen
370 {
371     [o_fullscreen_window makeFirstResponder: [[[VLCMain sharedInstance] getControls] voutView]];
372
373     [o_fullscreen_window makeKeyWindow];
374     [o_fullscreen_window setAcceptsMouseMovedEvents: TRUE];
375
376     /* tell the fspanel to move itself to front next time it's triggered */
377     [[[[VLCMain sharedInstance] getControls] getFSPanel] setVoutWasUpdated: (int)[[o_fullscreen_window screen] displayID]];
378
379     if([self isVisible])
380         [super orderOut: self];
381
382     [[[[VLCMain sharedInstance] getControls] getFSPanel] setActive: nil];
383
384     b_fullscreen = YES;
385     [self unlockFullscreenAnimation];
386 }
387
388 - (void)leaveFullscreen
389 {
390     [self leaveFullscreenAndFadeOut: NO];
391 }
392
393 - (void)leaveFullscreenAndFadeOut: (BOOL)fadeout
394 {
395     NSMutableDictionary *dict1, *dict2;
396     NSRect frame;
397
398     [self lockFullscreenAnimation];
399
400     b_fullscreen = NO;
401     [o_btn_fullscreen setState: NO];
402
403     /* We always try to do so */
404     [NSScreen unblackoutScreens];
405
406     /* Don't do anything if o_fullscreen_window is already closed */
407     if (!o_fullscreen_window)
408     {
409         [self unlockFullscreenAnimation];
410         return;
411     }
412
413     if (fadeout || MACOS_VERSION < 10.4f)
414     {
415         /* We don't animate if we are not visible or if we are running on
416         * Mac OS X <10.4 which doesn't support NSAnimation, instead we
417         * simply fade the display */
418         CGDisplayFadeReservationToken token;
419
420         CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval, &token);
421         CGDisplayFade( token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
422
423         [[[[VLCMain sharedInstance] getControls] getFSPanel] setNonActive: nil];
424         SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
425
426         /* Will release the lock */
427         [self hasEndedFullscreen];
428
429         /* Our window is hidden, and might be faded. We need to workaround that, so note it
430          * here */
431         b_window_is_invisible = YES;
432
433         CGDisplayFade( token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
434         CGReleaseDisplayFadeReservation( token);
435         return;
436     }
437
438     [self setAlphaValue: 0.0];
439     [self orderFront: self];
440
441     [[[[VLCMain sharedInstance] getControls] getFSPanel] setNonActive: nil];
442     SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
443
444     if (o_fullscreen_anim1)
445     {
446         [o_fullscreen_anim1 stopAnimation];
447         [o_fullscreen_anim1 release];
448     }
449     if (o_fullscreen_anim2)
450     {
451         [o_fullscreen_anim2 stopAnimation];
452         [o_fullscreen_anim2 release];
453     }
454
455     frame = [[o_temp_view superview] convertRect: [o_temp_view frame] toView: nil]; /* Convert to Window base coord */
456     frame.origin.x += [self frame].origin.x;
457     frame.origin.y += [self frame].origin.y;
458
459     dict2 = [[NSMutableDictionary alloc] initWithCapacity:2];
460     [dict2 setObject:self forKey:NSViewAnimationTargetKey];
461     [dict2 setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
462
463     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict2, nil]];
464     [dict2 release];
465
466     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
467     [o_fullscreen_anim2 setDuration: 0.3];
468     [o_fullscreen_anim2 setFrameRate: 30];
469
470     [o_fullscreen_anim2 setDelegate: self];
471
472     dict1 = [[NSMutableDictionary alloc] initWithCapacity:3];
473
474     [dict1 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
475     [dict1 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
476     [dict1 setObject:[NSValue valueWithRect:frame] forKey:NSViewAnimationEndFrameKey];
477
478     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict1, nil]];
479     [dict1 release];
480
481     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
482     [o_fullscreen_anim1 setDuration: 0.2];
483     [o_fullscreen_anim1 setFrameRate: 30];
484     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
485
486     /* Make sure o_fullscreen_window is the frontmost window */
487     [o_fullscreen_window orderFront: self];
488
489     [o_fullscreen_anim1 startAnimation];
490     /* fullscreenAnimation will be unlocked when animation ends */
491 }
492
493 - (void)hasEndedFullscreen
494 {
495     /* This function is private and should be only triggered at the end of the fullscreen change animation */
496     /* Make sure we don't see the o_view disappearing of the screen during this operation */
497     DisableScreenUpdates();
498     [o_view retain];
499     [o_view removeFromSuperviewWithoutNeedingDisplay];
500     [[self contentView] replaceSubview:o_temp_view with:o_view];
501     [o_view release];
502     [o_view setFrame:[o_temp_view frame]];
503     [self makeFirstResponder: o_view];
504     if ([self isVisible])
505         [super makeKeyAndOrderFront:self]; /* our version contains a workaround */
506     [o_fullscreen_window orderOut: self];
507     EnableScreenUpdates();
508
509     [o_fullscreen_window release];
510     o_fullscreen_window = nil;
511     [self setLevel:originalLevel];
512
513     [self unlockFullscreenAnimation];
514 }
515
516 - (void)animationDidEnd:(NSAnimation*)animation
517 {
518     NSArray *viewAnimations;
519
520     if ([animation currentValue] < 1.0)
521         return;
522
523     /* Fullscreen ended or started (we are a delegate only for leaveFullscreen's/enterFullscren's anim2) */
524     viewAnimations = [o_fullscreen_anim2 viewAnimations];
525     if ([viewAnimations count] >=1 &&
526         [[[viewAnimations objectAtIndex: 0] objectForKey: NSViewAnimationEffectKey] isEqualToString:NSViewAnimationFadeInEffect])
527     {
528         /* Fullscreen ended */
529         [self hasEndedFullscreen];
530     }
531     else
532     {
533         /* Fullscreen started */
534         [self hasBecomeFullscreen];
535     }
536 }
537
538 - (void)orderOut: (id)sender
539 {
540     [super orderOut: sender];
541
542     /* Make sure we leave fullscreen */
543     [self leaveFullscreenAndFadeOut: YES];
544 }
545
546 - (void)makeKeyAndOrderFront: (id)sender
547 {
548     /* Hack
549      * when we exit fullscreen and fade out, we may endup in
550      * having a window that is faded. We can't have it fade in unless we
551      * animate again. */
552
553     if(!b_window_is_invisible)
554     {
555         /* Make sure we don't do it too much */
556         [super makeKeyAndOrderFront: sender];
557         return;
558     }
559
560     [super setAlphaValue:0.0f];
561     [super makeKeyAndOrderFront: sender];
562
563     NSMutableDictionary * dict = [[[NSMutableDictionary alloc] initWithCapacity:2] autorelease];
564     [dict setObject:self forKey:NSViewAnimationTargetKey];
565     [dict setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
566
567     NSViewAnimation * anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
568
569     [anim setAnimationBlockingMode: NSAnimationNonblocking];
570     [anim setDuration: 0.1];
571     [anim setFrameRate: 30];
572
573     [anim startAnimation];
574     b_window_is_invisible = NO;
575
576     /* fullscreenAnimation will be unlocked when animation ends */
577 }
578
579
580
581 /* Make sure setFrame gets executed on main thread especially if we are animating.
582  * (Thus we won't block the video output thread) */
583 - (void)setFrame:(NSRect)frame display:(BOOL)display animate:(BOOL)animate
584 {
585     struct { NSRect frame; BOOL display; BOOL animate;} args;
586     NSData *packedargs;
587
588     args.frame = frame;
589     args.display = display;
590     args.animate = animate;
591
592     packedargs = [NSData dataWithBytes:&args length:sizeof(args)];
593
594     [self performSelectorOnMainThread:@selector(setFrameOnMainThread:)
595                     withObject: packedargs waitUntilDone: YES];
596 }
597
598 - (void)setFrameOnMainThread:(NSData*)packedargs
599 {
600     struct args { NSRect frame; BOOL display; BOOL animate; } * args = (struct args*)[packedargs bytes];
601
602     if( args->animate )
603     {
604         /* Make sure we don't block too long and set up a non blocking animation */
605         NSDictionary * dict = [NSDictionary dictionaryWithObjectsAndKeys:
606             self, NSViewAnimationTargetKey,
607             [NSValue valueWithRect:[self frame]], NSViewAnimationStartFrameKey,
608             [NSValue valueWithRect:args->frame], NSViewAnimationEndFrameKey, nil];
609
610         NSViewAnimation * anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict, nil]];
611
612         [anim setAnimationBlockingMode: NSAnimationNonblocking];
613         [anim setDuration: 0.4];
614         [anim setFrameRate: 30];
615         [anim startAnimation];
616     }
617     else {
618         [super setFrame:args->frame display:args->display animate:args->animate];
619     }
620
621 }
622 @end