c78e19ea445aaa3153dcd12cf3a0d57ef22ea929
[vlc.git] / modules / gui / macosx / MainWindow.m
1 /*****************************************************************************
2  * MainWindow.h: MacOS X interface module
3  *****************************************************************************
4  * Copyright (C) 2002-2011 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Felix Paul K├╝hne <fkuehne -at- videolan -dot- org>
8  *          Jon Lech Johansen <jon-vl@nanocrew.net>
9  *          Christophe Massiot <massiot@via.ecp.fr>
10  *          Derk-Jan Hartman <hartman at videolan.org>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 #import "CompatibilityFixes.h"
28 #import "MainWindow.h"
29 #import "intf.h"
30 #import "CoreInteraction.h"
31 #import "AudioEffects.h"
32 #import "MainMenu.h"
33 #import "open.h"
34 #import "controls.h" // TODO: remove me
35 #import "SideBarItem.h"
36 #import <vlc_playlist.h>
37 #import <vlc_aout_intf.h>
38 #import <vlc_url.h>
39 #import <vlc_strings.h>
40 #import <vlc_services_discovery.h>
41
42 @implementation VLCMainWindow
43 static VLCMainWindow *_o_sharedInstance = nil;
44
45 + (VLCMainWindow *)sharedInstance
46 {
47     return _o_sharedInstance ? _o_sharedInstance : [[self alloc] init];
48 }
49
50 #pragma mark -
51 #pragma mark Initialization
52
53 - (id)init
54 {
55     if( _o_sharedInstance)
56     {
57         [self dealloc];
58         return _o_sharedInstance;
59     }
60     else
61     {
62         o_fspanel = [[VLCFSPanel alloc] init];
63         _o_sharedInstance = [super init];
64     }
65
66     return _o_sharedInstance;
67 }
68
69 - (id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)styleMask
70                   backing:(NSBackingStoreType)backingType defer:(BOOL)flag
71 {
72 //     styleMask ^= NSTexturedBackgroundWindowMask;
73
74     self = [super initWithContentRect:contentRect styleMask:styleMask //& ~NSTitledWindowMask
75                               backing:backingType defer:flag];
76
77     [[VLCMain sharedInstance] updateTogglePlaylistState];
78
79     /* we want to be moveable regardless of our style */
80     [self setMovableByWindowBackground: YES];
81
82     /* we don't want this window to be restored on relaunch */
83     if (OSX_LION)
84         [self setRestorable:NO];
85
86     return self;
87 }
88
89 - (BOOL)performKeyEquivalent:(NSEvent *)o_event
90 {
91     /* We indeed want to prioritize Cocoa key equivalent against libvlc,
92      so we perform the menu equivalent now. */
93     if([[NSApp mainMenu] performKeyEquivalent:o_event])
94         return TRUE;
95
96     return [[VLCMain sharedInstance] hasDefinedShortcutKey:o_event] || [(VLCControls *)[[VLCMain sharedInstance] controls] keyEvent:o_event];
97 }
98
99 - (void)dealloc
100 {
101     config_PutInt( VLCIntf->p_libvlc, "volume", i_lastShownVolume );
102     [o_sidebaritems release];
103     [super dealloc];
104 }
105
106 - (void)awakeFromNib
107 {
108     /* setup the styled interface */
109     b_dark_interface = config_GetInt( VLCIntf, "macosx-interfacestyle" );
110     b_nativeFullscreenMode = config_GetInt( VLCIntf, "macosx-nativefullscreenmode" );
111     i_lastShownVolume = -1;
112
113     [o_play_btn setToolTip: _NS("Play/Pause")];
114     [o_bwd_btn setToolTip: _NS("Backward")];
115     [o_fwd_btn setToolTip: _NS("Forward")];
116     [o_stop_btn setToolTip: _NS("Stop")];
117     [o_playlist_btn setToolTip: _NS("Show/Hide Playlist")];
118     [o_repeat_btn setToolTip: _NS("Repeat")];
119     [o_shuffle_btn setToolTip: _NS("Shuffle")];
120     [o_effects_btn setToolTip: _NS("Effects")];
121     [o_fullscreen_btn setToolTip: _NS("Toggle Fullscreen mode")];
122     [[o_search_fld cell] setPlaceholderString: _NS("Search")];
123     [o_volume_sld setToolTip: _NS("Volume")];
124     [o_volume_down_btn setToolTip: _NS("Mute")];
125     [o_volume_up_btn setToolTip: _NS("Full Volume")];
126     [o_time_sld setToolTip: _NS("Position")];
127     [o_dropzone_btn setTitle: _NS("Open media...")];
128     [o_dropzone_lbl setStringValue: _NS("Drop media here")];
129
130     if (!b_dark_interface) {
131         [o_bottombar_view setImage: [NSImage imageNamed:@"bottom-background"]];
132         [o_bwd_btn setImage: [NSImage imageNamed:@"back"]];
133         [o_bwd_btn setAlternateImage: [NSImage imageNamed:@"back-pressed"]];
134         o_play_img = [[NSImage imageNamed:@"play"] retain];
135         o_play_pressed_img = [[NSImage imageNamed:@"play-pressed"] retain];
136         o_pause_img = [[NSImage imageNamed:@"pause"] retain];
137         o_pause_pressed_img = [[NSImage imageNamed:@"pause-pressed"] retain];
138         [o_fwd_btn setImage: [NSImage imageNamed:@"forward"]];
139         [o_fwd_btn setAlternateImage: [NSImage imageNamed:@"forward-pressed"]];
140         [o_stop_btn setImage: [NSImage imageNamed:@"stop"]];
141         [o_stop_btn setAlternateImage: [NSImage imageNamed:@"stop-pressed"]];
142         [o_playlist_btn setImage: [NSImage imageNamed:@"playlist"]];
143         [o_playlist_btn setAlternateImage: [NSImage imageNamed:@"playlist-pressed"]];
144         o_repeat_img = [[NSImage imageNamed:@"repeat"] retain];
145         o_repeat_pressed_img = [[NSImage imageNamed:@"repeat-pressed"] retain];
146         o_repeat_all_img  = [[NSImage imageNamed:@"repeat-all"] retain];
147         o_repeat_all_pressed_img = [[NSImage imageNamed:@"repeat-all-pressed"] retain];
148         o_repeat_one_img = [[NSImage imageNamed:@"repeat-one"] retain];
149         o_repeat_one_pressed_img = [[NSImage imageNamed:@"repeat-one-pressed"] retain];
150         o_shuffle_img = [[NSImage imageNamed:@"shuffle"] retain];
151         o_shuffle_pressed_img = [[NSImage imageNamed:@"shuffle-pressed"] retain];
152         o_shuffle_on_img = [[NSImage imageNamed:@"shuffle-blue"] retain];
153         o_shuffle_on_pressed_img = [[NSImage imageNamed:@"shuffle-blue-pressed"] retain];
154         [o_time_sld_left_view setImage: [NSImage imageNamed:@"progression-track-wrapper-left"]];
155         [o_time_sld_middle_view setImage: [NSImage imageNamed:@"progression-track-wrapper-middle"]];
156         [o_time_sld_right_view setImage: [NSImage imageNamed:@"progression-track-wrapper-right"]];
157         [o_volume_down_btn setImage: [NSImage imageNamed:@"volume-low"]];
158         [o_volume_track_view setImage: [NSImage imageNamed:@"volume-slider-track"]];
159         [o_volume_up_btn setImage: [NSImage imageNamed:@"volume-high"]];
160         if (OSX_LION && b_nativeFullscreenMode)
161         {
162             [o_effects_btn setImage: [NSImage imageNamed:@"effects-one-button"]];
163             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-one-button-blue"]];
164         }
165         else
166         {
167             [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons"]];
168             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed"]];
169         }
170         [o_fullscreen_btn setImage: [NSImage imageNamed:@"fullscreen-double-buttons"]];
171         [o_fullscreen_btn setAlternateImage: [NSImage imageNamed:@"fullscreen-double-buttons-pressed"]];
172         [o_time_sld_fancygradient_view loadImagesInDarkStyle:NO];
173     }
174     else
175     {
176         /* TODO: we also need to change the window style here... */
177         [o_bottombar_view setImage: [NSImage imageNamed:@"bottom-background_dark"]];
178         [o_bwd_btn setImage: [NSImage imageNamed:@"back_dark"]];
179         [o_bwd_btn setAlternateImage: [NSImage imageNamed:@"back-pressed_dark"]];
180         o_play_img = [[NSImage imageNamed:@"play_dark"] retain];
181         o_play_pressed_img = [[NSImage imageNamed:@"play-pressed_dark"] retain];
182         o_pause_img = [[NSImage imageNamed:@"pause_dark"] retain];
183         o_pause_pressed_img = [[NSImage imageNamed:@"pause-pressed_dark"] retain];
184         [o_fwd_btn setImage: [NSImage imageNamed:@"forward_dark"]];
185         [o_fwd_btn setAlternateImage: [NSImage imageNamed:@"forward-pressed_dark"]];
186         [o_stop_btn setImage: [NSImage imageNamed:@"stop_dark"]];
187         [o_stop_btn setAlternateImage: [NSImage imageNamed:@"stop-pressed_dark"]];
188         [o_playlist_btn setImage: [NSImage imageNamed:@"playlist_dark"]];
189         [o_playlist_btn setAlternateImage: [NSImage imageNamed:@"playlist-pressed_dark"]];
190         o_repeat_img = [[NSImage imageNamed:@"repeat_dark"] retain];
191         o_repeat_pressed_img = [[NSImage imageNamed:@"repeat-pressed_dark"] retain];
192         o_repeat_all_img  = [[NSImage imageNamed:@"repeat-all-blue_dark"] retain];
193         o_repeat_all_pressed_img = [[NSImage imageNamed:@"repeat-all-blue-pressed_dark"] retain];
194         o_repeat_one_img = [[NSImage imageNamed:@"repeat-one-blue_dark"] retain];
195         o_repeat_one_pressed_img = [[NSImage imageNamed:@"repeat-one-blue-pressed_dark"] retain];
196         o_shuffle_img = [[NSImage imageNamed:@"shuffle_dark"] retain];
197         o_shuffle_pressed_img = [[NSImage imageNamed:@"shuffle-pressed_dark"] retain];
198         o_shuffle_on_img = [[NSImage imageNamed:@"shuffle-blue_dark"] retain];
199         o_shuffle_on_pressed_img = [[NSImage imageNamed:@"shuffle-blue-pressed_dark"] retain];
200         [o_time_fld setTextColor: [NSColor colorWithCalibratedRed:229.0 green:229.0 blue:229.0 alpha:100.0]];
201         [o_time_sld_left_view setImage: [NSImage imageNamed:@"progression-track-wrapper-left_dark"]];
202         [o_time_sld_middle_view setImage: [NSImage imageNamed:@"progression-track-wrapper-middle_dark"]];
203         [o_time_sld_right_view setImage: [NSImage imageNamed:@"progression-track-wrapper-right_dark"]];
204         [o_volume_down_btn setImage: [NSImage imageNamed:@"volume-low_dark"]];
205         [o_volume_track_view setImage: [NSImage imageNamed:@"volume-slider-track_dark"]];
206         [o_volume_up_btn setImage: [NSImage imageNamed:@"volume-high_dark"]];
207         if (OSX_LION && b_nativeFullscreenMode)
208         {
209             [o_effects_btn setImage: [NSImage imageNamed:@"effects-one-button_dark"]];
210             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-one-button-blue_dark"]];
211         }
212         else
213         {
214             [o_effects_btn setImage: [NSImage imageNamed:@"effects-double-buttons_dark"]];
215             [o_effects_btn setAlternateImage: [NSImage imageNamed:@"effects-double-buttons-pressed_dark"]];            
216         }
217         [o_fullscreen_btn setImage: [NSImage imageNamed:@"fullscreen-double-buttons_dark"]];
218         [o_fullscreen_btn setAlternateImage: [NSImage imageNamed:@"fullscreen-double-buttons-pressed_dark"]];
219         [o_time_sld_fancygradient_view loadImagesInDarkStyle:YES];
220     }
221     [o_repeat_btn setImage: o_repeat_img];
222     [o_repeat_btn setAlternateImage: o_repeat_pressed_img];
223     [o_shuffle_btn setImage: o_shuffle_img];
224     [o_shuffle_btn setAlternateImage: o_shuffle_pressed_img];
225     [o_play_btn setImage: o_play_img];
226     [o_play_btn setAlternateImage: o_play_pressed_img];
227
228     /* interface builder action */
229     [self setDelegate: self];
230     [self setExcludedFromWindowsMenu: YES];
231     // Set that here as IB seems to be buggy
232     [self setContentMinSize:NSMakeSize(500., 288.)];
233     [self setTitle: _NS("VLC media player")];
234     [o_playlist_btn setEnabled:NO];
235     [o_video_view setFrame: [o_split_view frame]];
236     o_temp_view = [[NSView alloc] init];
237     [o_temp_view setAutoresizingMask:NSViewHeightSizable | NSViewWidthSizable];
238     [o_dropzone_view setFrame: [o_playlist_table frame]];
239     [o_left_split_view setFrame: [o_sidebar_view frame]];
240     if (OSX_LION && b_nativeFullscreenMode)
241     {
242         [self setCollectionBehavior: NSWindowCollectionBehaviorFullScreenPrimary];
243         NSRect frame;
244         float f_width = [o_fullscreen_btn frame].size.width;
245
246         #define moveItem( item ) \
247         frame = [item frame]; \
248         frame.origin.x = f_width + frame.origin.x; \
249         [item setFrame: frame]
250
251         moveItem( o_effects_btn );
252         moveItem( o_volume_up_btn );
253         moveItem( o_volume_sld );
254         moveItem( o_volume_track_view );
255         moveItem( o_volume_down_btn );
256         moveItem( o_time_fld );
257         moveItem( o_time_sld_right_view );
258         #undef moveItem
259
260         #define enlargeItem( item ) \
261         frame = [item frame]; \
262         frame.size.width = f_width + frame.size.width; \
263         [item setFrame: frame]
264
265         enlargeItem( o_time_sld );
266         enlargeItem( o_progress_bar );
267         enlargeItem( o_time_sld_middle_view );
268         enlargeItem( o_time_sld_fancygradient_view );
269         #undef enlargeItem
270
271         [o_fullscreen_btn removeFromSuperviewWithoutNeedingDisplay];
272     }
273
274     /* create the sidebar */
275     o_sidebaritems = [[NSMutableArray alloc] init];
276     SideBarItem *libraryItem = [SideBarItem itemWithTitle:_NS("LIBRARY") identifier:@"library"];
277     SideBarItem *playlistItem = [SideBarItem itemWithTitle:_NS("Playlist") identifier:@"playlist"];
278     [playlistItem setIcon: [NSImage imageNamed:@"document-music-playlist"]];
279     SideBarItem *mycompItem = [SideBarItem itemWithTitle:_NS("MY COMPUTER") identifier:@"mycomputer"];
280     SideBarItem *devicesItem = [SideBarItem itemWithTitle:_NS("DEVICES") identifier:@"devices"];
281     SideBarItem *lanItem = [SideBarItem itemWithTitle:_NS("LOCAL NETWORK") identifier:@"localnetwork"];
282     SideBarItem *internetItem = [SideBarItem itemWithTitle:_NS("INTERNET") identifier:@"internet"];
283
284     /* SD subnodes, inspired by the Qt4 intf */
285     char **ppsz_longnames;
286     int *p_categories;
287     char **ppsz_names = vlc_sd_GetNames( pl_Get( VLCIntf ), &ppsz_longnames, &p_categories );
288     if (!ppsz_names)
289         msg_Err( VLCIntf, "no sd item found" ); //TODO
290     char **ppsz_name = ppsz_names, **ppsz_longname = ppsz_longnames;
291     int *p_category = p_categories;
292     NSMutableArray *internetItems = [[NSMutableArray alloc] init];
293     NSMutableArray *devicesItems = [[NSMutableArray alloc] init];
294     NSMutableArray *lanItems = [[NSMutableArray alloc] init];
295     NSMutableArray *mycompItems = [[NSMutableArray alloc] init];
296     NSString *o_identifier;
297     for (; *ppsz_name; ppsz_name++, ppsz_longname++, p_category++)
298     {
299         o_identifier = [NSString stringWithCString: *ppsz_name encoding: NSUTF8StringEncoding];
300         o_identifier = [[o_identifier componentsSeparatedByString:@"{"] objectAtIndex:0];
301         switch (*p_category) {
302             case SD_CAT_INTERNET:
303                 {
304                     [internetItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
305                     if (!strncmp( *ppsz_name, "podcast", 7 ))
306                         [[internetItems lastObject] setIcon: [NSImage imageNamed:@"film-cast"]];
307                     else
308                         [[internetItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
309                 }
310                 break;
311             case SD_CAT_DEVICES:
312                 {
313                     [devicesItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
314                     [[devicesItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
315                 }
316                 break;
317             case SD_CAT_LAN:
318                 {
319                     [lanItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
320                     [[lanItems lastObject] setIcon: [NSImage imageNamed:@"network-cloud"]];
321                 }
322                 break;
323             case SD_CAT_MYCOMPUTER:
324                 {
325                     [mycompItems addObject: [SideBarItem itemWithTitle: [NSString stringWithCString: *ppsz_longname encoding: NSUTF8StringEncoding] identifier: o_identifier]];
326                     if (!strncmp( *ppsz_name, "video_dir", 9 ))
327                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"film"]];
328                     else if (!strncmp( *ppsz_name, "audio_dir", 9 ))
329                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"music-beam"]];
330                     else if (!strncmp( *ppsz_name, "picture_dir", 11 ))
331                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"picture"]];
332                     else
333                         [[mycompItems lastObject] setIcon: [NSImage imageNamed:@"NSApplicationIcon"]];
334                 }
335                 break;
336             default:
337                 msg_Warn( VLCIntf, "unknown SD type found, skipping (%s)", *ppsz_name );
338                 break;
339         }
340
341         free( *ppsz_name );
342         free( *ppsz_longname );
343     }
344     [mycompItem setChildren: [NSArray arrayWithArray: mycompItems]];
345     [devicesItem setChildren: [NSArray arrayWithArray: devicesItems]];
346     [lanItem setChildren: [NSArray arrayWithArray: lanItems]];
347     [internetItem setChildren: [NSArray arrayWithArray: internetItems]];
348     [mycompItems release];
349     [devicesItems release];
350     [lanItems release];
351     [internetItems release];
352     free( ppsz_names );
353     free( ppsz_longnames );
354     free( p_categories );
355
356     [libraryItem setChildren: [NSArray arrayWithObject: playlistItem]];
357     [o_sidebaritems addObject: libraryItem];
358     if ([mycompItem hasChildren])
359         [o_sidebaritems addObject: mycompItem];
360     if ([devicesItem hasChildren])
361         [o_sidebaritems addObject: devicesItem];
362     if ([lanItem hasChildren])
363         [o_sidebaritems addObject: lanItem];
364     if ([internetItem hasChildren])
365         [o_sidebaritems addObject: internetItem];
366
367     [o_sidebar_view reloadData];
368     [o_sidebar_view selectRowIndexes:[NSIndexSet indexSetWithIndex:0] byExtendingSelection:YES];
369 }
370
371 #pragma mark -
372 #pragma mark Button Actions
373
374 - (IBAction)play:(id)sender
375 {
376     [[VLCCoreInteraction sharedInstance] play];
377 }
378
379 - (void)resetPreviousButton
380 {
381     if (([NSDate timeIntervalSinceReferenceDate] - last_bwd_event) >= 0.35) {
382         // seems like no further event occured, so let's switch the playback item
383         [[VLCCoreInteraction sharedInstance] previous];
384         just_triggered_previous = NO;
385     }
386 }
387
388 - (void)resetBackwardSkip
389 {
390     // the user stopped skipping, so let's allow him to change the item
391     if (([NSDate timeIntervalSinceReferenceDate] - last_bwd_event) >= 0.35)
392         just_triggered_previous = NO;
393 }
394
395 - (IBAction)bwd:(id)sender
396 {
397     if(!just_triggered_previous)
398     {
399         just_triggered_previous = YES;
400         [self performSelector:@selector(resetPreviousButton)
401                    withObject: NULL
402                    afterDelay:0.40];
403     }
404     else
405     {
406         if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) > 0.12 )
407         {
408             // we just skipped 3 "continous" events, otherwise we are too fast
409             [[VLCCoreInteraction sharedInstance] backward];
410             last_bwd_event = [NSDate timeIntervalSinceReferenceDate];
411             [self performSelector:@selector(resetBackwardSkip)
412                        withObject: NULL
413                        afterDelay:0.40];
414         }
415     }
416 }
417
418 - (void)resetNextButton
419 {
420     if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) >= 0.35) {
421         // seems like no further event occured, so let's switch the playback item
422         [[VLCCoreInteraction sharedInstance] next];
423         just_triggered_next = NO;
424     }
425 }
426
427 - (void)resetForwardSkip
428 {
429     // the user stopped skipping, so let's allow him to change the item
430     if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) >= 0.35)
431         just_triggered_next = NO;
432 }
433
434 - (IBAction)fwd:(id)sender
435 {
436    if(!just_triggered_next)
437     {
438         just_triggered_next = YES;
439         [self performSelector:@selector(resetNextButton)
440                    withObject: NULL
441                    afterDelay:0.40];
442     }
443     else
444     {
445         if (([NSDate timeIntervalSinceReferenceDate] - last_fwd_event) > 0.12 )
446         {
447             // we just skipped 3 "continous" events, otherwise we are too fast
448             [[VLCCoreInteraction sharedInstance] forward];
449             last_fwd_event = [NSDate timeIntervalSinceReferenceDate];
450             [self performSelector:@selector(resetForwardSkip)
451                        withObject: NULL
452                        afterDelay:0.40];
453         }
454     }
455 }
456
457 - (IBAction)stop:(id)sender
458 {
459     [[VLCCoreInteraction sharedInstance] stop];
460 }
461
462 - (IBAction)togglePlaylist:(id)sender
463 {
464     if (!b_nonembedded)
465     {
466         if ([o_video_view isHidden] && [o_playlist_btn isEnabled]) {
467             [o_split_view setHidden: YES];
468             [o_video_view setHidden: NO];
469         }
470         else
471         {
472             [o_video_view setHidden: YES];
473             [o_split_view setHidden: NO];
474         }
475     }
476     else
477     {
478         [o_split_view setHidden: NO];
479         [o_playlist_table setHidden: NO];
480         [o_video_view setHidden: ![[VLCMain sharedInstance] activeVideoPlayback]];
481     }
482 }
483
484 - (void)setRepeatOne
485 {
486     [o_repeat_btn setImage: o_repeat_one_img];
487     [o_repeat_btn setAlternateImage: o_repeat_one_pressed_img];   
488 }
489
490 - (void)setRepeatAll
491 {
492     [o_repeat_btn setImage: o_repeat_all_img];
493     [o_repeat_btn setAlternateImage: o_repeat_all_pressed_img];
494 }
495
496 - (void)setRepeatOff
497 {
498     [o_repeat_btn setImage: o_repeat_img];
499     [o_repeat_btn setAlternateImage: o_repeat_pressed_img];
500 }
501
502 - (IBAction)repeat:(id)sender
503 {
504     vlc_value_t looping,repeating;
505     intf_thread_t * p_intf = VLCIntf;
506     playlist_t * p_playlist = pl_Get( p_intf );
507
508     var_Get( p_playlist, "repeat", &repeating );
509     var_Get( p_playlist, "loop", &looping );
510
511     if( !repeating.b_bool && !looping.b_bool )
512     {
513         /* was: no repeating at all, switching to Repeat One */
514         [[VLCCoreInteraction sharedInstance] repeatOne];
515         [self setRepeatOne];
516     }
517     else if( repeating.b_bool && !looping.b_bool )
518     {
519         /* was: Repeat One, switching to Repeat All */
520         [[VLCCoreInteraction sharedInstance] repeatAll];
521         [self setRepeatAll];
522     }
523     else
524     {
525         /* was: Repeat All or bug in VLC, switching to Repeat Off */
526         [[VLCCoreInteraction sharedInstance] repeatOff];
527         [self setRepeatOff];
528     }
529 }
530
531 - (void)setShuffle
532 {
533     bool b_value;
534     playlist_t *p_playlist = pl_Get( VLCIntf );
535     b_value = var_GetBool( p_playlist, "random" );
536         if(b_value) {
537         [o_shuffle_btn setImage: o_shuffle_on_img];
538         [o_shuffle_btn setAlternateImage: o_shuffle_on_pressed_img];
539     }
540     else
541     {
542         [o_shuffle_btn setImage: o_shuffle_img];
543         [o_shuffle_btn setAlternateImage: o_shuffle_pressed_img];
544     }
545 }
546
547 - (IBAction)shuffle:(id)sender
548 {
549     [[VLCCoreInteraction sharedInstance] shuffle];
550     [self setShuffle];
551 }
552
553 - (IBAction)timeSliderAction:(id)sender
554 {
555     float f_updated;
556     input_thread_t * p_input;
557
558     switch( [[NSApp currentEvent] type] )
559     {
560         case NSLeftMouseUp:
561         case NSLeftMouseDown:
562         case NSLeftMouseDragged:
563             f_updated = [sender floatValue];
564             break;
565
566         default:
567             return;
568     }
569     p_input = pl_CurrentInput( VLCIntf );
570     if( p_input != NULL )
571     {
572         vlc_value_t time;
573         vlc_value_t pos;
574         NSString * o_time;
575         char psz_time[MSTRTIME_MAX_SIZE];
576
577         pos.f_float = f_updated / 10000.;
578         var_Set( p_input, "position", pos );
579         [o_time_sld setFloatValue: f_updated];
580
581         var_Get( p_input, "time", &time );
582
583         mtime_t dur = input_item_GetDuration( input_GetItem( p_input ) );
584         if( [o_time_fld timeRemaining] && dur != -1 )
585         {
586             o_time = [NSString stringWithFormat: @"-%s", secstotimestr( psz_time, ((dur - time.i_time) / 1000000) )];
587         }
588         else
589             o_time = [NSString stringWithUTF8String: secstotimestr( psz_time, (time.i_time / 1000000) )];
590
591         [o_time_fld setStringValue: o_time];
592         [o_fspanel setStreamPos: f_updated andTime: o_time];
593         vlc_object_release( p_input );
594     }
595     [self drawFancyGradientEffectForTimeSlider];
596 }
597
598 - (IBAction)volumeAction:(id)sender
599 {
600     if (sender == o_volume_sld)
601         [[VLCCoreInteraction sharedInstance] setVolume: [sender intValue]];
602     else if (sender == o_volume_down_btn)
603         [[VLCCoreInteraction sharedInstance] mute];
604     else
605         [[VLCCoreInteraction sharedInstance] setVolume: 400];
606 }
607
608 - (IBAction)effects:(id)sender
609 {
610     [[VLCMainMenu sharedInstance] showAudioEffects: sender];
611 }
612
613 - (IBAction)fullscreen:(id)sender
614 {
615     [[VLCCoreInteraction sharedInstance] toggleFullscreen];
616 }
617
618 - (IBAction)dropzoneButtonAction:(id)sender
619 {
620     [[[VLCMain sharedInstance] open] openFileGeneric];
621 }
622
623 #pragma mark -
624 #pragma mark Update interface and respond to foreign events
625 - (void)showDropZone
626 {
627     [o_right_split_view addSubview: o_dropzone_view];
628     [o_dropzone_view setFrame: [o_playlist_table frame]];
629     [[o_playlist_table animator] setHidden:YES];
630 }
631
632 - (void)hideDropZone
633 {
634     [o_dropzone_view removeFromSuperview];
635     [[o_playlist_table animator] setHidden: NO];
636 }
637
638 - (void)updateTimeSlider
639 {
640     input_thread_t * p_input;
641     p_input = pl_CurrentInput( VLCIntf );
642     if( p_input )
643     {
644         vlc_value_t time;
645         NSString * o_time;
646         vlc_value_t pos;
647         char psz_time[MSTRTIME_MAX_SIZE];
648         float f_updated;
649
650         var_Get( p_input, "position", &pos );
651         f_updated = 10000. * pos.f_float;
652         [o_time_sld setFloatValue: f_updated];
653
654         var_Get( p_input, "time", &time );
655
656         mtime_t dur = input_item_GetDuration( input_GetItem( p_input ) );
657         if( [o_time_fld timeRemaining] && dur != -1 )
658         {
659             o_time = [NSString stringWithFormat: @"-%s", secstotimestr( psz_time, ((dur - time.i_time) / 1000000))];
660         }
661         else
662             o_time = [NSString stringWithUTF8String: secstotimestr( psz_time, (time.i_time / 1000000) )];
663
664         if (dur == -1) {
665             [o_time_sld setEnabled: NO];
666             [o_time_sld setHidden: YES];
667         } else {
668             [o_time_sld setEnabled: YES];
669             [o_time_sld setHidden: NO];
670         }
671
672         [o_time_fld setStringValue: o_time];
673         [o_time_fld setNeedsDisplay:YES];
674         [o_fspanel setStreamPos: f_updated andTime: o_time];
675         vlc_object_release( p_input );
676     }
677     else
678     {
679         [o_time_sld setFloatValue: 0.0];
680         [o_time_fld setStringValue: @"00:00"];
681         [o_time_sld setEnabled: NO];
682         [o_time_sld setHidden: YES];
683     }
684         
685     [self performSelectorOnMainThread:@selector(drawFancyGradientEffectForTimeSlider) withObject:nil waitUntilDone:NO];
686 }
687
688 - (void)updateVolumeSlider
689 {
690     audio_volume_t i_volume;
691     playlist_t * p_playlist = pl_Get( VLCIntf );
692
693     i_volume = aout_VolumeGet( p_playlist );
694
695     if( i_volume != i_lastShownVolume )
696     {
697         i_lastShownVolume = i_volume;
698         int i_volume_step = 0;
699         i_volume_step = config_GetInt( VLCIntf->p_libvlc, "volume-step" );
700         [o_volume_sld setFloatValue: (float)i_lastShownVolume / i_volume_step];
701         [o_fspanel setVolumeLevel: (float)i_lastShownVolume / i_volume_step];
702     }
703 }
704
705 - (void)updateName
706 {
707     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
708     input_thread_t * p_input;
709     p_input = pl_CurrentInput( VLCIntf );
710     if( p_input )
711     {
712         NSString *aString;
713         char *format = var_InheritString( VLCIntf, "input-title-format" );
714         char *formated = str_format_meta( p_input, format );
715         free( format );
716         aString = [NSString stringWithUTF8String:formated];
717         free( formated );
718
719         char *uri = input_item_GetURI( input_GetItem( p_input ) );
720
721         NSURL * o_url = [NSURL URLWithString: [NSString stringWithUTF8String: uri]];
722         if ([o_url isFileURL])
723             [self setRepresentedURL: o_url];
724         else
725             [self setRepresentedURL: nil];
726         free( uri );
727
728         if ([aString isEqualToString:@""])
729         {
730             if ([o_url isFileURL])
731                 aString = [[NSFileManager defaultManager] displayNameAtPath: [o_url path]];
732             else
733                 aString = [o_url absoluteString];
734         }
735
736         [self setTitle: aString];
737         [o_fspanel setStreamTitle: aString];
738     }
739     else
740     {
741         [self setTitle: _NS("VLC media player")];
742         [self setRepresentedURL: nil];
743     }
744
745     [o_pool release];
746 }
747
748 - (void)updateWindow
749 {
750     bool b_input = false;
751     bool b_plmul = false;
752     bool b_control = false;
753     bool b_seekable = false;
754     bool b_chapters = false;
755
756     playlist_t * p_playlist = pl_Get( VLCIntf );
757
758     PL_LOCK;
759     b_plmul = playlist_CurrentSize( p_playlist ) > 1;
760     PL_UNLOCK;
761
762     input_thread_t * p_input = playlist_CurrentInput( p_playlist );
763
764     bool b_buffering = NO;
765
766     if( ( b_input = ( p_input != NULL ) ) )
767     {
768         /* seekable streams */
769         cachedInputState = input_GetState( p_input );
770         if ( cachedInputState == INIT_S || cachedInputState == OPENING_S )
771             b_buffering = YES;
772
773         /* seekable streams */
774         b_seekable = var_GetBool( p_input, "can-seek" );
775
776         /* check whether slow/fast motion is possible */
777         b_control = var_GetBool( p_input, "can-rate" );
778
779         /* chapters & titles */
780         //FIXME! b_chapters = p_input->stream.i_area_nb > 1;
781         vlc_object_release( p_input );
782     }
783
784     if( b_buffering )
785     {
786         [o_progress_bar startAnimation:self];
787         [o_progress_bar setIndeterminate:YES];
788         [o_progress_bar setHidden:NO];
789     } else {
790         [o_progress_bar stopAnimation:self];
791         [o_progress_bar setHidden:YES];
792     }
793
794     [o_stop_btn setEnabled: b_input];
795     [o_fwd_btn setEnabled: (b_seekable || b_plmul || b_chapters)];
796     [o_bwd_btn setEnabled: (b_seekable || b_plmul || b_chapters)];
797     [[VLCMainMenu sharedInstance] setRateControlsEnabled: b_control];
798
799     [o_time_sld setEnabled: b_seekable];
800     [self updateTimeSlider];
801     [o_fspanel setSeekable: b_seekable];
802
803     PL_LOCK;
804     if (playlist_CurrentSize( p_playlist ) >= 1)
805         [self hideDropZone];
806     else
807         [self showDropZone];
808     PL_UNLOCK;
809 }
810
811 - (void)setPause
812 {
813     [o_play_btn setImage: o_pause_img];
814     [o_play_btn setAlternateImage: o_pause_pressed_img];
815     [o_play_btn setToolTip: _NS("Pause")];
816     [o_fspanel setPause];
817 }
818
819 - (void)setPlay
820 {
821     [o_play_btn setImage: o_play_img];
822     [o_play_btn setAlternateImage: o_play_pressed_img];
823     [o_play_btn setToolTip: _NS("Play")];
824     [o_fspanel setPlay];
825 }
826
827 - (void)drawFancyGradientEffectForTimeSlider
828 {
829     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
830     float f_value = ([o_time_sld_middle_view frame].size.width -5) * ([o_time_sld intValue] / [o_time_sld maxValue]);
831     if (f_value > 5.0)
832     {
833         if (f_value != [o_time_sld_fancygradient_view frame].size.width)
834         {
835             [o_time_sld_fancygradient_view setHidden: NO];
836             [o_time_sld_fancygradient_view setFrame: NSMakeRect( [o_time_sld_fancygradient_view frame].origin.x, [o_time_sld_fancygradient_view frame].origin.y, f_value, [o_time_sld_fancygradient_view frame].size.height )];
837             [o_time_sld_fancygradient_view setNeedsDisplay:YES];
838             [o_time_sld_middle_view setNeedsDisplay:YES];
839         }
840     }
841     else
842     {
843         [o_time_sld_fancygradient_view setHidden: YES];
844     }
845     [o_pool release];
846 }
847
848 #pragma mark -
849 #pragma mark Video Output handling
850
851 - (id)videoView
852 {
853     vout_thread_t *p_vout = getVout();
854     if (config_GetInt( VLCIntf, "embedded-video" ))
855     {
856         if ([o_video_view window] != self)
857         {
858             [o_video_view removeFromSuperviewWithoutNeedingDisplay];
859             [o_video_view setFrame: [o_split_view frame]];
860             [[self contentView] addSubview:o_video_view positioned:NSWindowAbove relativeTo:nil];
861         }
862         b_nonembedded = NO;
863     }
864     else
865     {
866         [o_video_view removeFromSuperviewWithoutNeedingDisplay];
867         if (o_nonembedded_window)
868             [o_nonembedded_window release];
869
870         o_nonembedded_window = [[VLCWindow alloc] initWithContentRect:[o_video_view frame] styleMask: NSBorderlessWindowMask|NSResizableWindowMask backing:NSBackingStoreBuffered defer:YES];
871         [o_nonembedded_window setFrame:[o_video_view frame] display:NO];
872         [o_nonembedded_window setBackgroundColor: [NSColor blackColor]];
873         [o_nonembedded_window setMovableByWindowBackground: YES];
874         [o_nonembedded_window setCanBecomeKeyWindow: YES];
875         [o_nonembedded_window setHasShadow:YES];
876         [o_nonembedded_window setContentView: o_video_view];
877         [o_nonembedded_window setLevel:NSNormalWindowLevel];
878         [o_nonembedded_window useOptimizedDrawing: YES];
879         [o_nonembedded_window center];
880         [o_nonembedded_window makeKeyAndOrderFront:self];
881         [o_nonembedded_window orderFront:self animate:YES];
882         [o_nonembedded_window setReleasedWhenClosed:NO];
883         b_nonembedded = YES;
884     }
885
886     if (p_vout)
887     {
888         if( var_GetBool( p_vout, "video-on-top" ) )
889             [[o_video_view window] setLevel: NSStatusWindowLevel];
890         else
891             [[o_video_view window] setLevel: NSNormalWindowLevel];
892         vlc_object_release( p_vout );
893     }
894     return o_video_view;
895 }
896
897 - (void)setVideoplayEnabled
898 {
899     if (!b_nonembedded)
900         [o_playlist_btn setEnabled: [[VLCMain sharedInstance] activeVideoPlayback]];
901     else
902     {
903         [o_playlist_btn setEnabled: NO];
904         if (![[VLCMain sharedInstance] activeVideoPlayback])
905             [o_nonembedded_window orderOut: nil];
906     }
907 }
908
909 - (void)resizeWindow
910 {
911     if ( !b_fullscreen && !(OSX_LION && [NSApp currentSystemPresentationOptions] == NSApplicationPresentationFullScreen && b_nativeFullscreenMode) )
912     {
913         NSPoint topleftbase;
914         NSPoint topleftscreen;
915         NSRect new_frame;
916         topleftbase.x = 0;
917         topleftbase.y = [self frame].size.height;
918         topleftscreen = [self convertBaseToScreen: topleftbase];
919
920         /* Calculate the window's new size */
921         new_frame.size.width = [self frame].size.width - [o_video_view frame].size.width + nativeVideoSize.width;
922         new_frame.size.height = [self frame].size.height - [o_video_view frame].size.height + nativeVideoSize.height;
923
924         new_frame.origin.x = topleftscreen.x;
925         new_frame.origin.y = topleftscreen.y - new_frame.size.height;
926
927         [[self animator] setFrame:new_frame display:YES];
928     }
929 }
930
931 - (void)setNativeVideoSize:(NSSize)size
932 {
933     if (size.width != nativeVideoSize.width || size.height != nativeVideoSize.height )
934     {
935         nativeVideoSize = size;
936         [self resizeWindow];
937     }
938 }
939
940 #pragma mark -
941 #pragma mark Fullscreen support
942 - (void)showFullscreenController
943 {
944     if (b_fullscreen)
945         [o_fspanel fadeIn];
946 }
947
948 - (BOOL)isFullscreen
949 {
950     return b_fullscreen;
951 }
952
953 - (void)lockFullscreenAnimation
954 {
955     [o_animation_lock lock];
956 }
957
958 - (void)unlockFullscreenAnimation
959 {
960     [o_animation_lock unlock];
961 }
962
963 - (void)enterFullscreen
964 {
965     NSMutableDictionary *dict1, *dict2;
966     NSScreen *screen;
967     NSRect screen_rect;
968     NSRect rect;
969     vout_thread_t *p_vout = getVout();
970     BOOL blackout_other_displays = config_GetInt( VLCIntf, "macosx-black" );
971
972     if( p_vout )
973         screen = [NSScreen screenWithDisplayID:(CGDirectDisplayID)var_GetInteger( p_vout, "video-device" )];
974
975     [self lockFullscreenAnimation];
976
977     if (!screen)
978     {
979         msg_Dbg( VLCIntf, "chosen screen isn't present, using current screen for fullscreen mode" );
980         screen = [self screen];
981     }
982     if (!screen)
983     {
984         msg_Dbg( VLCIntf, "Using deepest screen" );
985         screen = [NSScreen deepestScreen];
986     }
987
988     if( p_vout )
989         vlc_object_release( p_vout );
990
991     screen_rect = [screen frame];
992
993     [o_fullscreen_btn setState: YES];
994
995     [NSCursor setHiddenUntilMouseMoves: YES];
996
997     if( blackout_other_displays )
998         [screen blackoutOtherScreens];
999
1000     /* Make sure we don't see the window flashes in float-on-top mode */
1001     i_originalLevel = [self level];
1002     [self setLevel:NSNormalWindowLevel];
1003
1004     /* Only create the o_fullscreen_window if we are not in the middle of the zooming animation */
1005     if (!o_fullscreen_window)
1006     {
1007         /* We can't change the styleMask of an already created NSWindow, so we create another window, and do eye catching stuff */
1008
1009         rect = [[o_video_view superview] convertRect: [o_video_view frame] toView: nil]; /* Convert to Window base coord */
1010         rect.origin.x += [self frame].origin.x;
1011         rect.origin.y += [self frame].origin.y;
1012         o_fullscreen_window = [[VLCWindow alloc] initWithContentRect:rect styleMask: NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:YES];
1013         [o_fullscreen_window setBackgroundColor: [NSColor blackColor]];
1014         [o_fullscreen_window setCanBecomeKeyWindow: YES];
1015
1016         if (![self isVisible] || [self alphaValue] == 0.0)
1017         {
1018             /* We don't animate if we are not visible, instead we
1019              * simply fade the display */
1020             CGDisplayFadeReservationToken token;
1021
1022             if( blackout_other_displays )
1023             {
1024                 CGAcquireDisplayFadeReservation( kCGMaxDisplayReservationInterval, &token );
1025                 CGDisplayFade( token, 0.5, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
1026             }
1027
1028             if ([screen isMainScreen])
1029             {
1030                 if (OSX_LEOPARD)
1031                     SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
1032                 else
1033                     [NSApp setPresentationOptions:(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)];
1034             }
1035
1036             [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
1037             [o_temp_view setFrame:[o_video_view frame]];
1038             [o_fullscreen_window setContentView:o_video_view];
1039
1040             [o_fullscreen_window makeKeyAndOrderFront:self];
1041             [o_fullscreen_window orderFront:self animate:YES];
1042
1043             [o_fullscreen_window setFrame:screen_rect display:YES animate:YES];
1044             [o_fullscreen_window setLevel:NSNormalWindowLevel];
1045
1046             if( blackout_other_displays )
1047             {
1048                 CGDisplayFade( token, 0.3, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
1049                 CGReleaseDisplayFadeReservation( token );
1050             }
1051
1052             /* Will release the lock */
1053             [self hasBecomeFullscreen];
1054
1055             return;
1056         }
1057
1058         /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
1059         NSDisableScreenUpdates();
1060         [[o_video_view superview] replaceSubview:o_video_view with:o_temp_view];
1061         [o_temp_view setFrame:[o_video_view frame]];
1062         [o_fullscreen_window setContentView:o_video_view];
1063         [o_fullscreen_window makeKeyAndOrderFront:self];
1064         NSEnableScreenUpdates();
1065     }
1066
1067     /* We are in fullscreen (and no animation is running) */
1068     if (b_fullscreen)
1069     {
1070         /* Make sure we are hidden */
1071         [super orderOut: self];
1072         [self unlockFullscreenAnimation];
1073         return;
1074     }
1075
1076     if (o_fullscreen_anim1)
1077     {
1078         [o_fullscreen_anim1 stopAnimation];
1079         [o_fullscreen_anim1 release];
1080     }
1081     if (o_fullscreen_anim2)
1082     {
1083         [o_fullscreen_anim2 stopAnimation];
1084         [o_fullscreen_anim2 release];
1085     }
1086
1087     if ([screen isMainScreen])
1088     {
1089         if (OSX_LEOPARD)
1090             SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
1091         else
1092             [NSApp setPresentationOptions:(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)];
1093     }
1094
1095     dict1 = [[NSMutableDictionary alloc] initWithCapacity:2];
1096     dict2 = [[NSMutableDictionary alloc] initWithCapacity:3];
1097
1098     [dict1 setObject:self forKey:NSViewAnimationTargetKey];
1099     [dict1 setObject:NSViewAnimationFadeOutEffect forKey:NSViewAnimationEffectKey];
1100
1101     [dict2 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
1102     [dict2 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
1103     [dict2 setObject:[NSValue valueWithRect:screen_rect] forKey:NSViewAnimationEndFrameKey];
1104
1105     /* Strategy with NSAnimation allocation:
1106      - Keep at most 2 animation at a time
1107      - leaveFullscreen/enterFullscreen are the only responsible for releasing and alloc-ing
1108      */
1109     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict1]];
1110     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict2]];
1111
1112     [dict1 release];
1113     [dict2 release];
1114
1115     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
1116     [o_fullscreen_anim1 setDuration: 0.3];
1117     [o_fullscreen_anim1 setFrameRate: 30];
1118     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
1119     [o_fullscreen_anim2 setDuration: 0.2];
1120     [o_fullscreen_anim2 setFrameRate: 30];
1121
1122     [o_fullscreen_anim2 setDelegate: self];
1123     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
1124
1125     [o_fullscreen_anim1 startAnimation];
1126     /* fullscreenAnimation will be unlocked when animation ends */
1127 }
1128
1129 - (void)hasBecomeFullscreen
1130 {
1131     [o_fullscreen_window makeFirstResponder: o_video_view];
1132
1133     [o_fullscreen_window makeKeyWindow];
1134     [o_fullscreen_window setAcceptsMouseMovedEvents: TRUE];
1135
1136     /* tell the fspanel to move itself to front next time it's triggered */
1137     [o_fspanel setVoutWasUpdated: (int)[[o_fullscreen_window screen] displayID]];
1138     [o_fspanel setActive: nil];
1139
1140     if([self isVisible])
1141         [super orderOut: self];
1142
1143     [o_fspanel setActive: nil];
1144
1145     b_fullscreen = YES;
1146     [self unlockFullscreenAnimation];
1147 }
1148
1149 - (void)leaveFullscreen
1150 {
1151     [self leaveFullscreenAndFadeOut: NO];
1152 }
1153
1154 - (void)leaveFullscreenAndFadeOut: (BOOL)fadeout
1155 {
1156     NSMutableDictionary *dict1, *dict2;
1157     NSRect frame;
1158     BOOL blackout_other_displays = config_GetInt( VLCIntf, "macosx-black" );
1159
1160     [self lockFullscreenAnimation];
1161
1162     b_fullscreen = NO;
1163     [o_fullscreen_btn setState: NO];
1164
1165     /* We always try to do so */
1166     [NSScreen unblackoutScreens];
1167     vout_thread_t *p_vout = getVout();
1168     if (p_vout)
1169     {
1170         if( var_GetBool( p_vout, "video-on-top" ) )
1171             [[o_video_view window] setLevel: NSStatusWindowLevel];
1172         else
1173             [[o_video_view window] setLevel: NSNormalWindowLevel];
1174         vlc_object_release( p_vout );
1175     }
1176     [[o_video_view window] makeKeyAndOrderFront: nil];
1177
1178     /* Don't do anything if o_fullscreen_window is already closed */
1179     if (!o_fullscreen_window)
1180     {
1181         [self unlockFullscreenAnimation];
1182         return;
1183     }
1184
1185     if (fadeout)
1186     {
1187         /* We don't animate if we are not visible, instead we
1188          * simply fade the display */
1189         CGDisplayFadeReservationToken token;
1190
1191         if( blackout_other_displays )
1192         {
1193             CGAcquireDisplayFadeReservation( kCGMaxDisplayReservationInterval, &token );
1194             CGDisplayFade( token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0, 0, 0, YES );
1195         }
1196
1197         [o_fspanel setNonActive: nil];
1198         if (OSX_LEOPARD)
1199             SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
1200         else
1201             [NSApp setPresentationOptions:(NSApplicationPresentationDefault)];
1202
1203         /* Will release the lock */
1204         [self hasEndedFullscreen];
1205
1206         /* Our window is hidden, and might be faded. We need to workaround that, so note it
1207          * here */
1208         b_window_is_invisible = YES;
1209
1210         if( blackout_other_displays )
1211         {
1212             CGDisplayFade( token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0, 0, 0, NO );
1213             CGReleaseDisplayFadeReservation( token );
1214         }
1215
1216         return;
1217     }
1218
1219     [self setAlphaValue: 0.0];
1220     [self orderFront: self];
1221     [[o_video_view window] orderFront: self];
1222
1223     [o_fspanel setNonActive: nil];
1224     if (OSX_LEOPARD)
1225         SetSystemUIMode( kUIModeNormal, kUIOptionAutoShowMenuBar);
1226     else
1227         [NSApp setPresentationOptions:(NSApplicationPresentationDefault)];
1228
1229     if (o_fullscreen_anim1)
1230     {
1231         [o_fullscreen_anim1 stopAnimation];
1232         [o_fullscreen_anim1 release];
1233     }
1234     if (o_fullscreen_anim2)
1235     {
1236         [o_fullscreen_anim2 stopAnimation];
1237         [o_fullscreen_anim2 release];
1238     }
1239
1240     frame = [[o_temp_view superview] convertRect: [o_temp_view frame] toView: nil]; /* Convert to Window base coord */
1241     frame.origin.x += [self frame].origin.x;
1242     frame.origin.y += [self frame].origin.y;
1243
1244     dict2 = [[NSMutableDictionary alloc] initWithCapacity:2];
1245     [dict2 setObject:self forKey:NSViewAnimationTargetKey];
1246     [dict2 setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
1247
1248     o_fullscreen_anim2 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict2, nil]];
1249     [dict2 release];
1250
1251     [o_fullscreen_anim2 setAnimationBlockingMode: NSAnimationNonblocking];
1252     [o_fullscreen_anim2 setDuration: 0.3];
1253     [o_fullscreen_anim2 setFrameRate: 30];
1254
1255     [o_fullscreen_anim2 setDelegate: self];
1256
1257     dict1 = [[NSMutableDictionary alloc] initWithCapacity:3];
1258
1259     [dict1 setObject:o_fullscreen_window forKey:NSViewAnimationTargetKey];
1260     [dict1 setObject:[NSValue valueWithRect:[o_fullscreen_window frame]] forKey:NSViewAnimationStartFrameKey];
1261     [dict1 setObject:[NSValue valueWithRect:frame] forKey:NSViewAnimationEndFrameKey];
1262
1263     o_fullscreen_anim1 = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObjects:dict1, nil]];
1264     [dict1 release];
1265
1266     [o_fullscreen_anim1 setAnimationBlockingMode: NSAnimationNonblocking];
1267     [o_fullscreen_anim1 setDuration: 0.2];
1268     [o_fullscreen_anim1 setFrameRate: 30];
1269     [o_fullscreen_anim2 startWhenAnimation: o_fullscreen_anim1 reachesProgress: 1.0];
1270
1271     /* Make sure o_fullscreen_window is the frontmost window */
1272     [o_fullscreen_window orderFront: self];
1273
1274     [o_fullscreen_anim1 startAnimation];
1275     /* fullscreenAnimation will be unlocked when animation ends */
1276 }
1277
1278 - (void)hasEndedFullscreen
1279 {
1280     /* This function is private and should be only triggered at the end of the fullscreen change animation */
1281     /* Make sure we don't see the o_video_view disappearing of the screen during this operation */
1282     NSDisableScreenUpdates();
1283     [o_video_view retain];
1284     [o_video_view removeFromSuperviewWithoutNeedingDisplay];
1285     [[o_temp_view superview] replaceSubview:o_temp_view with:o_video_view];
1286     [o_video_view release];
1287     [o_video_view setFrame:[o_temp_view frame]];
1288     [self makeFirstResponder: o_video_view];
1289     if ([self isVisible])
1290         [super makeKeyAndOrderFront:self]; /* our version contains a workaround */
1291     [o_fullscreen_window orderOut: self];
1292     NSEnableScreenUpdates();
1293
1294     [o_fullscreen_window release];
1295     o_fullscreen_window = nil;
1296     [self setLevel:i_originalLevel];
1297
1298     [self unlockFullscreenAnimation];
1299 }
1300
1301 - (void)animationDidEnd:(NSAnimation*)animation
1302 {
1303     NSArray *viewAnimations;
1304     if( o_makekey_anim == animation )
1305     {
1306         [o_makekey_anim release];
1307         return;
1308     }
1309     if ([animation currentValue] < 1.0)
1310         return;
1311
1312     /* Fullscreen ended or started (we are a delegate only for leaveFullscreen's/enterFullscren's anim2) */
1313     viewAnimations = [o_fullscreen_anim2 viewAnimations];
1314     if ([viewAnimations count] >=1 &&
1315         [[[viewAnimations objectAtIndex: 0] objectForKey: NSViewAnimationEffectKey] isEqualToString:NSViewAnimationFadeInEffect])
1316     {
1317         /* Fullscreen ended */
1318         [self hasEndedFullscreen];
1319     }
1320     else
1321     {
1322         /* Fullscreen started */
1323         [self hasBecomeFullscreen];
1324     }
1325 }
1326
1327 - (void)orderOut: (id)sender
1328 {
1329     [super orderOut: sender];
1330
1331     /* Make sure we leave fullscreen */
1332     [self leaveFullscreenAndFadeOut: YES];
1333 }
1334
1335 - (void)makeKeyAndOrderFront: (id)sender
1336 {
1337     /* Hack
1338      * when we exit fullscreen and fade out, we may endup in
1339      * having a window that is faded. We can't have it fade in unless we
1340      * animate again. */
1341
1342     if(!b_window_is_invisible)
1343     {
1344         /* Make sure we don't do it too much */
1345         [super makeKeyAndOrderFront: sender];
1346         return;
1347     }
1348
1349     [super setAlphaValue:0.0f];
1350     [super makeKeyAndOrderFront: sender];
1351
1352     NSMutableDictionary * dict = [[NSMutableDictionary alloc] initWithCapacity:2];
1353     [dict setObject:self forKey:NSViewAnimationTargetKey];
1354     [dict setObject:NSViewAnimationFadeInEffect forKey:NSViewAnimationEffectKey];
1355
1356     o_makekey_anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
1357     [dict release];
1358
1359     [o_makekey_anim setAnimationBlockingMode: NSAnimationNonblocking];
1360     [o_makekey_anim setDuration: 0.1];
1361     [o_makekey_anim setFrameRate: 30];
1362     [o_makekey_anim setDelegate: self];
1363
1364     [o_makekey_anim startAnimation];
1365     b_window_is_invisible = NO;
1366
1367     /* fullscreenAnimation will be unlocked when animation ends */
1368 }
1369
1370 /* Make sure setFrame gets executed on main thread especially if we are animating.
1371  * (Thus we won't block the video output thread) */
1372 - (void)setFrame:(NSRect)frame display:(BOOL)display animate:(BOOL)animate
1373 {
1374     struct { NSRect frame; BOOL display; BOOL animate;} args;
1375     NSData *packedargs;
1376
1377     args.frame = frame;
1378     args.display = display;
1379     args.animate = animate;
1380
1381     packedargs = [NSData dataWithBytes:&args length:sizeof(args)];
1382
1383     [self performSelectorOnMainThread:@selector(setFrameOnMainThread:)
1384                            withObject: packedargs waitUntilDone: YES];
1385 }
1386
1387 - (void)setFrameOnMainThread:(NSData*)packedargs
1388 {
1389     struct args { NSRect frame; BOOL display; BOOL animate; } * args = (struct args*)[packedargs bytes];
1390
1391     if( args->animate )
1392     {
1393         /* Make sure we don't block too long and set up a non blocking animation */
1394         NSDictionary * dict = [NSDictionary dictionaryWithObjectsAndKeys:
1395                                self, NSViewAnimationTargetKey,
1396                                [NSValue valueWithRect:[self frame]], NSViewAnimationStartFrameKey,
1397                                [NSValue valueWithRect:args->frame], NSViewAnimationEndFrameKey, nil];
1398
1399         NSViewAnimation * anim = [[NSViewAnimation alloc] initWithViewAnimations:[NSArray arrayWithObject:dict]];
1400         [dict release];
1401
1402         [anim setAnimationBlockingMode: NSAnimationNonblocking];
1403         [anim setDuration: 0.4];
1404         [anim setFrameRate: 30];
1405         [anim startAnimation];
1406     }
1407     else {
1408         [super setFrame:args->frame display:args->display animate:args->animate];
1409     }
1410 }
1411
1412 #pragma mark -
1413 #pragma mark Lion's native fullscreen handling
1414 - (void)windowWillEnterFullScreen:(NSNotification *)notification
1415 {
1416     [NSCursor setHiddenUntilMouseMoves: YES];
1417 }
1418
1419 - (void)windowWillExitFullScreen:(NSNotification *)notification
1420 {
1421     [NSCursor setHiddenUntilMouseMoves: NO];
1422 }
1423
1424 #pragma mark -
1425 #pragma mark Side Bar Data handling
1426 /* taken under BSD-new from the PXSourceList sample project, adapted for VLC */
1427 - (NSUInteger)sourceList:(PXSourceList*)sourceList numberOfChildrenOfItem:(id)item
1428 {
1429         //Works the same way as the NSOutlineView data source: `nil` means a parent item
1430         if(item==nil) {
1431                 return [o_sidebaritems count];
1432         }
1433         else {
1434                 return [[item children] count];
1435         }
1436 }
1437
1438
1439 - (id)sourceList:(PXSourceList*)aSourceList child:(NSUInteger)index ofItem:(id)item
1440 {
1441     //Works the same way as the NSOutlineView data source: `nil` means a parent item
1442         if(item==nil) {
1443                 return [o_sidebaritems objectAtIndex:index];
1444         }
1445         else {
1446                 return [[item children] objectAtIndex:index];
1447         }
1448 }
1449
1450
1451 - (id)sourceList:(PXSourceList*)aSourceList objectValueForItem:(id)item
1452 {
1453         return [item title];
1454 }
1455
1456 - (void)sourceList:(PXSourceList*)aSourceList setObjectValue:(id)object forItem:(id)item
1457 {
1458         [item setTitle:object];
1459 }
1460
1461 - (BOOL)sourceList:(PXSourceList*)aSourceList isItemExpandable:(id)item
1462 {
1463         return [item hasChildren];
1464 }
1465
1466
1467 - (BOOL)sourceList:(PXSourceList*)aSourceList itemHasBadge:(id)item
1468 {
1469     if ([[item identifier] isEqualToString: @"playlist"])
1470         return YES;
1471
1472         return [item hasBadge];
1473 }
1474
1475
1476 - (NSInteger)sourceList:(PXSourceList*)aSourceList badgeValueForItem:(id)item
1477 {
1478     if ([[item identifier] isEqualToString: @"playlist"]) {
1479         playlist_t * p_playlist = pl_Get( VLCIntf );
1480         NSInteger i_playlist_size;
1481
1482         PL_LOCK;
1483         i_playlist_size = playlist_CurrentSize( p_playlist );
1484         PL_UNLOCK;
1485
1486         return i_playlist_size;
1487     }
1488         return [item badgeValue];
1489 }
1490
1491
1492 - (BOOL)sourceList:(PXSourceList*)aSourceList itemHasIcon:(id)item
1493 {
1494         return [item hasIcon];
1495 }
1496
1497
1498 - (NSImage*)sourceList:(PXSourceList*)aSourceList iconForItem:(id)item
1499 {
1500         return [item icon];
1501 }
1502
1503 - (NSMenu*)sourceList:(PXSourceList*)aSourceList menuForEvent:(NSEvent*)theEvent item:(id)item
1504 {
1505         if ([theEvent type] == NSRightMouseDown || ([theEvent type] == NSLeftMouseDown && ([theEvent modifierFlags] & NSControlKeyMask) == NSControlKeyMask)) {
1506                 NSMenu * m = [[NSMenu alloc] init];
1507                 if (item != nil)
1508                         [m addItemWithTitle:[item title] action:nil keyEquivalent:@""];
1509                 return [m autorelease];
1510         }
1511         return nil;
1512 }
1513
1514 #pragma mark -
1515 #pragma mark Side Bar Delegate Methods
1516 /* taken under BSD-new from the PXSourceList sample project, adapted for VLC */
1517 - (BOOL)sourceList:(PXSourceList*)aSourceList isGroupAlwaysExpanded:(id)group
1518 {
1519         if([[group identifier] isEqualToString:@"library"])
1520                 return YES;
1521
1522         return NO;
1523 }
1524
1525 - (void)sourceListSelectionDidChange:(NSNotification *)notification
1526 {
1527         NSIndexSet *selectedIndexes = [o_sidebar_view selectedRowIndexes];
1528
1529         //Set the label text to represent the new selection
1530     if([selectedIndexes count]==1) {
1531                 NSString *title = [[o_sidebar_view itemAtRow:[selectedIndexes firstIndex]] title];
1532
1533                 [o_chosen_category_lbl setStringValue:title];
1534         }
1535         else {
1536                 [o_chosen_category_lbl setStringValue:@"(none)"];
1537         }
1538 }
1539
1540 @end
1541
1542 @implementation VLCProgressBarGradientEffect
1543 - (void)dealloc
1544 {
1545     [o_time_sld_gradient_left_img release];
1546     [o_time_sld_gradient_middle_img release];
1547     [o_time_sld_gradient_right_img release];
1548     [super dealloc];
1549 }
1550
1551 - (void)loadImagesInDarkStyle: (BOOL)b_value
1552 {
1553     if (b_value)
1554     {
1555         o_time_sld_gradient_left_img = [[NSImage imageNamed:@"progressbar-fill-left_dark"] retain];
1556         o_time_sld_gradient_middle_img = [[NSImage imageNamed:@"progressbar-fill-middle_dark"] retain];
1557         o_time_sld_gradient_right_img = [[NSImage imageNamed:@"progressbar-fill-right_dark"] retain];
1558     }
1559     else
1560     {
1561         o_time_sld_gradient_left_img = [[NSImage imageNamed:@"progression-fill-left"] retain];
1562         o_time_sld_gradient_middle_img = [[NSImage imageNamed:@"progression-fill-middle"] retain];
1563         o_time_sld_gradient_right_img = [[NSImage imageNamed:@"progression-fill-right"] retain];
1564     }
1565 }
1566
1567 - (void)drawRect:(NSRect)rect
1568 {
1569     NSRect bnds = [self bounds];
1570     NSDrawThreePartImage( bnds, o_time_sld_gradient_left_img, o_time_sld_gradient_middle_img, o_time_sld_gradient_right_img, NO, NSCompositeSourceOver, 1, NO );
1571 }
1572 @end