765d36cbed59bbe8b58672d028cbfbe0ef4104b7
[vlc.git] / modules / gui / macosx / intf.m
1 /*****************************************************************************
2  * intf.m: MacOS X interface module
3  *****************************************************************************
4  * Copyright (C) 2002-2011 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
8  *          Christophe Massiot <massiot@via.ecp.fr>
9  *          Derk-Jan Hartman <hartman at videolan.org>
10  *          Felix Paul K├╝hne <fkuehne at videolan dot 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 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #include <stdlib.h>                                      /* malloc(), free() */
31 #include <sys/param.h>                                    /* for MAXPATHLEN */
32 #include <string.h>
33 #include <vlc_common.h>
34 #include <vlc_keys.h>
35 #include <vlc_dialog.h>
36 #include <vlc_url.h>
37 #include <vlc_modules.h>
38 #include <vlc_aout_intf.h>
39 #include <vlc_vout_window.h>
40 #include <unistd.h> /* execl() */
41
42 #import "intf.h"
43 #import "MainMenu.h"
44 #import "MainWindow.h"
45 #import "fspanel.h"
46 #import "vout.h"
47 #import "prefs.h"
48 #import "playlist.h"
49 #import "playlistinfo.h"
50 #import "controls.h"
51 #import "open.h"
52 #import "wizard.h"
53 #import "bookmarks.h"
54 #import "coredialogs.h"
55 #import "embeddedwindow.h"
56 #import "AppleRemote.h"
57 #import "eyetv.h"
58 #import "simple_prefs.h"
59 #import "CoreInteraction.h"
60
61 #import <AddressBook/AddressBook.h>         /* for crashlog send mechanism */
62 #import <Sparkle/Sparkle.h>                 /* we're the update delegate */
63
64 /*****************************************************************************
65  * Local prototypes.
66  *****************************************************************************/
67 static void Run ( intf_thread_t *p_intf );
68
69 static void * ManageThread( void *user_data );
70
71 static void updateProgressPanel (void *, const char *, float);
72 static bool checkProgressPanel (void *);
73 static void destroyProgressPanel (void *);
74
75 static void MsgCallback( msg_cb_data_t *, const msg_item_t * );
76
77 #pragma mark -
78 #pragma mark VLC Interface Object Callbacks
79
80 /*****************************************************************************
81  * OpenIntf: initialize interface
82  *****************************************************************************/
83 int OpenIntf ( vlc_object_t *p_this )
84 {
85     intf_thread_t *p_intf = (intf_thread_t*) p_this;
86
87     p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
88     if( p_intf->p_sys == NULL )
89         return VLC_ENOMEM;
90
91     memset( p_intf->p_sys, 0, sizeof( *p_intf->p_sys ) );
92
93     /* subscribe to LibVLCCore's messages */
94     p_intf->p_sys->p_sub = msg_Subscribe( p_intf->p_libvlc, MsgCallback, NULL );
95     p_intf->pf_run = Run;
96     p_intf->b_should_run_on_first_thread = true;
97
98     return VLC_SUCCESS;
99 }
100
101 /*****************************************************************************
102  * CloseIntf: destroy interface
103  *****************************************************************************/
104 void CloseIntf ( vlc_object_t *p_this )
105 {
106     intf_thread_t *p_intf = (intf_thread_t*) p_this;
107
108     free( p_intf->p_sys );
109 }
110
111 static int WindowControl( vout_window_t *, int i_query, va_list );
112
113 int WindowOpen( vout_window_t *p_wnd, const vout_window_cfg_t *cfg )
114 {
115     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
116     intf_thread_t *p_intf = VLCIntf;
117     if (!p_intf) {
118         msg_Err( p_wnd, "Mac OS X interface not found" );
119         return VLC_EGENERIC;
120     }
121
122     msg_Dbg( p_wnd, "looking for video view" );
123     int i_x = cfg->x;
124     int i_y = cfg->y;
125     unsigned i_width = cfg->width;
126     unsigned i_height = cfg->height;
127     p_wnd->handle.nsobject = [[VLCMain sharedInstance] getVideoViewAtPositionX: &i_x Y: &i_y withWidth: &i_width andHeight: &i_height];
128
129     if ( !p_wnd->handle.nsobject ) {
130         msg_Err( p_wnd, "got no video view from the interface" );
131         [o_pool release];
132         return VLC_EGENERIC;
133     }
134
135     [[VLCMainWindow sharedInstance] setVideoplayEnabled:YES];
136     [[VLCMainWindow sharedInstance] togglePlaylist:nil];
137     p_wnd->control = WindowControl;
138     p_wnd->sys = (vout_window_sys_t *)VLCIntf;
139     [o_pool release];
140     return VLC_SUCCESS;
141 }
142
143 static int WindowControl( vout_window_t *p_wnd, int i_query, va_list args )
144 {
145     /* TODO */
146     if( i_query == VOUT_WINDOW_SET_STATE )
147         NSLog( @"WindowControl:VOUT_WINDOW_SET_STATE" );
148     else if( i_query == VOUT_WINDOW_SET_SIZE )
149         NSLog( @"WindowControl:VOUT_WINDOW_SET_SIZE" );
150     else if( i_query == VOUT_WINDOW_SET_FULLSCREEN )
151         NSLog( @"WindowControl:VOUT_WINDOW_SET_FULLSCREEN" );
152     else
153         NSLog( @"WindowControl: unknown query" );
154     return VLC_SUCCESS;
155 }
156
157 void WindowClose( vout_window_t *p_wnd )
158 {
159     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
160     [[VLCMainWindow sharedInstance] setVideoplayEnabled:NO];
161     NSLog( @"Window Close" );
162     // tell the interface to get rid of the video, TODO
163     [o_pool release];
164 }
165
166 /*****************************************************************************
167  * Run: main loop
168  *****************************************************************************/
169 static NSLock * o_appLock = nil;    // controls access to f_appExit
170 static int f_appExit = 0;           // set to 1 when application termination signaled
171
172 static void Run( intf_thread_t *p_intf )
173 {
174     sigset_t set;
175
176     /* Make sure the "force quit" menu item does quit instantly.
177      * VLC overrides SIGTERM which is sent by the "force quit"
178      * menu item to make sure deamon mode quits gracefully, so
179      * we un-override SIGTERM here. */
180     sigemptyset( &set );
181     sigaddset( &set, SIGTERM );
182     pthread_sigmask( SIG_UNBLOCK, &set, NULL );
183
184     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
185
186     o_appLock = [[NSLock alloc] init];
187
188     [VLCApplication sharedApplication];
189
190     [[VLCMain sharedInstance] setIntf: p_intf];
191     [NSBundle loadNibNamed: @"MainMenu" owner: NSApp];
192
193     [NSApp run];
194     [[VLCMain sharedInstance] applicationWillTerminate:nil];
195     [o_appLock release];
196     [o_pool release];
197 }
198
199 #pragma mark -
200 #pragma mark Variables Callback
201
202 /*****************************************************************************
203  * MsgCallback: Callback triggered by the core once a new debug message is
204  * ready to be displayed. We store everything in a NSArray in our Cocoa part
205  * of this file.
206  *****************************************************************************/
207 static void MsgCallback( msg_cb_data_t *data, const msg_item_t *item )
208 {
209     int canc = vlc_savecancel();
210
211     /* this may happen from time to time, let's bail out as info would be useless anyway */
212     if( !item->psz_module || !item->psz_msg )
213         return;
214
215     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
216     [[VLCMain sharedInstance] processReceivedlibvlcMessage: item];
217     [o_pool release];
218
219     vlc_restorecancel( canc );
220 }
221
222 /*****************************************************************************
223  * playlistChanged: Callback triggered by the intf-change playlist
224  * variable, to let the intf update the playlist.
225  *****************************************************************************/
226 static int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
227                      vlc_value_t old_val, vlc_value_t new_val, void *param )
228 {
229     intf_thread_t * p_intf = VLCIntf;
230     if( p_intf && p_intf->p_sys )
231     {
232         NSLog( @"event from %s", psz_variable );
233         p_intf->p_sys->b_intf_update = true;
234         p_intf->p_sys->b_playlist_update = true;
235         p_intf->p_sys->b_playmode_update = true;
236         p_intf->p_sys->b_current_title_update = true;
237     }
238     return VLC_SUCCESS;
239 }
240
241 /*****************************************************************************
242  * ShowController: Callback triggered by the show-intf playlist variable
243  * through the ShowIntf-control-intf, to let us show the controller-win;
244  * usually when in fullscreen-mode
245  *****************************************************************************/
246 static int ShowController( vlc_object_t *p_this, const char *psz_variable,
247                      vlc_value_t old_val, vlc_value_t new_val, void *param )
248 {
249     intf_thread_t * p_intf = VLCIntf;
250     if( p_intf && p_intf->p_sys )
251         p_intf->p_sys->b_intf_show = true;
252     return VLC_SUCCESS;
253 }
254
255 /*****************************************************************************
256  * FullscreenChanged: Callback triggered by the fullscreen-change playlist
257  * variable, to let the intf update the controller.
258  *****************************************************************************/
259 static int FullscreenChanged( vlc_object_t *p_this, const char *psz_variable,
260                      vlc_value_t old_val, vlc_value_t new_val, void *param )
261 {
262     intf_thread_t * p_intf = VLCIntf;
263     if( p_intf && p_intf->p_sys )
264         p_intf->p_sys->b_fullscreen_update = true;
265     return VLC_SUCCESS;
266 }
267
268 /*****************************************************************************
269  * DialogCallback: Callback triggered by the "dialog-*" variables
270  * to let the intf display error and interaction dialogs
271  *****************************************************************************/
272 static int DialogCallback( vlc_object_t *p_this, const char *type, vlc_value_t previous, vlc_value_t value, void *data )
273 {
274     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
275     VLCMain *interface = (VLCMain *)data;
276
277     if( [[NSString stringWithUTF8String: type] isEqualToString: @"dialog-progress-bar"] )
278     {
279         /* the progress panel needs to update itself and therefore wants special treatment within this context */
280         dialog_progress_bar_t *p_dialog = (dialog_progress_bar_t *)value.p_address;
281
282         p_dialog->pf_update = updateProgressPanel;
283         p_dialog->pf_check = checkProgressPanel;
284         p_dialog->pf_destroy = destroyProgressPanel;
285         p_dialog->p_sys = VLCIntf->p_libvlc;
286     }
287
288     NSValue *o_value = [NSValue valueWithPointer:value.p_address];
289     [[NSNotificationCenter defaultCenter] postNotificationName: @"VLCNewCoreDialogEventNotification" object:[interface coreDialogProvider] userInfo:[NSDictionary dictionaryWithObjectsAndKeys: o_value, @"VLCDialogPointer", [NSString stringWithUTF8String: type], @"VLCDialogType", nil]];
290
291     [o_pool release];
292     return VLC_SUCCESS;
293 }
294
295 void updateProgressPanel (void *priv, const char *text, float value)
296 {
297     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
298
299     NSString *o_txt;
300     if( text != NULL )
301         o_txt = [NSString stringWithUTF8String: text];
302     else
303         o_txt = @"";
304
305     [[[VLCMain sharedInstance] coreDialogProvider] updateProgressPanelWithText: o_txt andNumber: (double)(value * 1000.)];
306
307     [o_pool release];
308 }
309
310 void destroyProgressPanel (void *priv)
311 {
312     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
313     [[[VLCMain sharedInstance] coreDialogProvider] destroyProgressPanel];
314     [o_pool release];
315 }
316
317 bool checkProgressPanel (void *priv)
318 {
319     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
320     return [[[VLCMain sharedInstance] coreDialogProvider] progressCancelled];
321     [o_pool release];
322 }
323
324 #pragma mark -
325 #pragma mark Helpers
326
327 input_thread_t *getInput(void)
328 {
329     intf_thread_t *p_intf = VLCIntf;
330     if (!p_intf)
331         return NULL;
332     return pl_CurrentInput(p_intf);
333 }
334
335 vout_thread_t *getVout(void)
336 {
337     input_thread_t *p_input = getInput();
338     if (!p_input)
339         return NULL;
340     vout_thread_t *p_vout = input_GetVout(p_input);
341     vlc_object_release(p_input);
342     return p_vout;
343 }
344
345 aout_instance_t *getAout(void)
346 {
347     input_thread_t *p_input = getInput();
348     if (!p_input)
349         return NULL;
350     aout_instance_t *p_aout = input_GetAout(p_input);
351     vlc_object_release(p_input);
352     return p_aout;
353 }
354
355 #pragma mark -
356 #pragma mark Private
357
358 @interface VLCMain ()
359 - (void)_removeOldPreferences;
360 @end
361
362 /*****************************************************************************
363  * VLCMain implementation
364  *****************************************************************************/
365 @implementation VLCMain
366
367 #pragma mark -
368 #pragma mark Initialization
369
370 static VLCMain *_o_sharedMainInstance = nil;
371
372 + (VLCMain *)sharedInstance
373 {
374     return _o_sharedMainInstance ? _o_sharedMainInstance : [[self alloc] init];
375 }
376
377 - (id)init
378 {
379     if( _o_sharedMainInstance)
380     {
381         [self dealloc];
382         return _o_sharedMainInstance;
383     }
384     else
385         _o_sharedMainInstance = [super init];
386
387     p_intf = NULL;
388
389     o_msg_lock = [[NSLock alloc] init];
390     o_msg_arr = [[NSMutableArray arrayWithCapacity: 600] retain];
391     /* subscribe to LibVLC's debug messages as early as possible (for us) */
392     [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(libvlcMessageReceived:) name: @"VLCCoreMessageReceived" object: nil];
393
394     o_open = [[VLCOpen alloc] init];
395     //o_embedded_list = [[VLCEmbeddedList alloc] init];
396     o_coredialogs = [[VLCCoreDialogProvider alloc] init];
397     o_info = [[VLCInfo alloc] init];
398     o_mainmenu = [[VLCMainMenu alloc] init];
399     o_coreinteraction = [[VLCCoreInteraction alloc] init];
400     o_eyetv = [[VLCEyeTVController alloc] init];
401
402     /* announce our launch to a potential eyetv plugin */
403     [[NSDistributedNotificationCenter defaultCenter] postNotificationName: @"VLCOSXGUIInit"
404                                                                    object: @"VLCEyeTVSupport"
405                                                                  userInfo: NULL
406                                                        deliverImmediately: YES];
407     return _o_sharedMainInstance;
408 }
409
410 - (void)setIntf: (intf_thread_t *)p_mainintf {
411     p_intf = p_mainintf;
412 }
413
414 - (intf_thread_t *)intf {
415     return p_intf;
416 }
417
418 - (void)awakeFromNib
419 {
420     playlist_t *p_playlist;
421     vlc_value_t val;
422     var_Create( p_intf, "intf-change", VLC_VAR_BOOL );
423
424     [o_msgs_panel setExcludedFromWindowsMenu: YES];
425     [o_msgs_panel setDelegate: self];
426
427     p_playlist = pl_Get( p_intf );
428
429     val.b_bool = false;
430
431     var_AddCallback( p_playlist, "fullscreen", FullscreenChanged, self);
432     var_AddCallback( p_intf->p_libvlc, "intf-show", ShowController, self);
433
434     /* load our Core Dialogs nib */
435     nib_coredialogs_loaded = [NSBundle loadNibNamed:@"CoreDialogs" owner: NSApp];
436
437     /* subscribe to various interactive dialogues */
438     var_Create( p_intf, "dialog-error", VLC_VAR_ADDRESS );
439     var_AddCallback( p_intf, "dialog-error", DialogCallback, self );
440     var_Create( p_intf, "dialog-critical", VLC_VAR_ADDRESS );
441     var_AddCallback( p_intf, "dialog-critical", DialogCallback, self );
442     var_Create( p_intf, "dialog-login", VLC_VAR_ADDRESS );
443     var_AddCallback( p_intf, "dialog-login", DialogCallback, self );
444     var_Create( p_intf, "dialog-question", VLC_VAR_ADDRESS );
445     var_AddCallback( p_intf, "dialog-question", DialogCallback, self );
446     var_Create( p_intf, "dialog-progress-bar", VLC_VAR_ADDRESS );
447     var_AddCallback( p_intf, "dialog-progress-bar", DialogCallback, self );
448     dialog_Register( p_intf );
449
450     /* update the playmode stuff */
451     p_intf->p_sys->b_playmode_update = true;
452
453     /* init Apple Remote support */
454     o_remote = [[AppleRemote alloc] init];
455     [o_remote setClickCountEnabledButtons: kRemoteButtonPlay];
456     [o_remote setDelegate: _o_sharedMainInstance];
457
458     /* yeah, we are done */
459     nib_main_loaded = TRUE;
460 }
461
462 - (void)applicationWillFinishLaunching:(NSNotification *)o_notification
463 {
464     if( !p_intf ) return;
465
466     /* FIXME: don't poll */
467     interfaceTimer = [[NSTimer scheduledTimerWithTimeInterval: 0.5
468                                      target: self selector: @selector(manageIntf:)
469                                    userInfo: nil repeats: FALSE] retain];
470
471     /* Note: we use the pthread API to support pre-10.5 */
472     pthread_create( &manage_thread, NULL, ManageThread, self );
473 }
474
475 - (void)applicationDidFinishLaunching:(NSNotification *)aNotification
476 {
477     if( !p_intf ) return;
478
479     /* init media key support */
480     b_mediaKeySupport = config_GetInt( VLCIntf, "macosx-mediakeys" );
481     if( b_mediaKeySupport )
482     {
483         o_mediaKeyController = [[SPMediaKeyTap alloc] initWithDelegate:self];
484         [o_mediaKeyController startWatchingMediaKeys];
485         [[NSUserDefaults standardUserDefaults] registerDefaults:[NSDictionary dictionaryWithObjectsAndKeys:
486                                                                  [SPMediaKeyTap defaultMediaKeyUserBundleIdentifiers], kMediaKeyUsingBundleIdentifiersDefaultsKey,
487                                                                  nil]];
488     }
489     [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(coreChangedMediaKeySupportSetting:) name: @"VLCMediaKeySupportSettingChanged" object: nil];
490
491     [self _removeOldPreferences];
492
493     [o_mainwindow makeKeyAndOrderFront: self];
494
495     /* Handle sleep notification */
496     [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver:self selector:@selector(computerWillSleep:)
497            name:NSWorkspaceWillSleepNotification object:nil];
498
499     [NSThread detachNewThreadSelector:@selector(lookForCrashLog) toTarget:self withObject:nil];
500 }
501
502 - (void)initStrings
503 {
504     if( !p_intf ) return;
505
506     /* messages panel */
507     [o_msgs_panel setTitle: _NS("Messages")];
508     [o_msgs_crashlog_btn setTitle: _NS("Open CrashLog...")];
509     [o_msgs_save_btn setTitle: _NS("Save this Log...")];
510
511     /* crash reporter panel */
512     [o_crashrep_send_btn setTitle: _NS("Send")];
513     [o_crashrep_dontSend_btn setTitle: _NS("Don't Send")];
514     [o_crashrep_title_txt setStringValue: _NS("VLC crashed previously")];
515     [o_crashrep_win setTitle: _NS("VLC crashed previously")];
516     [o_crashrep_desc_txt setStringValue: _NS("Do you want to send details on the crash to VLC's development team?\n\nIf you want, you can enter a few lines on what you did before VLC crashed along with other helpful information: a link to download a sample file, a URL of a network stream, ...")];
517     [o_crashrep_includeEmail_ckb setTitle: _NS("I agree to be possibly contacted about this bugreport.")];
518     [o_crashrep_includeEmail_txt setStringValue: _NS("Only your default E-Mail address will be submitted, including no further information.")];
519 }
520
521 #pragma mark -
522 #pragma mark Termination
523
524 - (void)applicationWillTerminate:(NSNotification *)notification
525 {
526     playlist_t * p_playlist;
527     vout_thread_t * p_vout;
528     int returnedValue = 0;
529
530     if( !p_intf )
531         return;
532
533     // don't allow a double termination call. If the user has
534     // already invoked the quit then simply return this time.
535     int isTerminating = false;
536
537     [o_appLock lock];
538     isTerminating = (f_appExit++ > 0 ? 1 : 0);
539     [o_appLock unlock];
540
541     if (isTerminating)
542         return;
543
544     msg_Dbg( p_intf, "Terminating" );
545
546     pthread_join( manage_thread, NULL );
547
548     /* Make sure the intf object is getting killed */
549     vlc_object_kill( p_intf );
550
551     /* Make sure the interfaceTimer is destroyed */
552     [interfaceTimer invalidate];
553     [interfaceTimer release];
554     interfaceTimer = nil;
555
556     /* unsubscribe from the interactive dialogues */
557     dialog_Unregister( p_intf );
558     var_DelCallback( p_intf, "dialog-error", DialogCallback, self );
559     var_DelCallback( p_intf, "dialog-critical", DialogCallback, self );
560     var_DelCallback( p_intf, "dialog-login", DialogCallback, self );
561     var_DelCallback( p_intf, "dialog-question", DialogCallback, self );
562     var_DelCallback( p_intf, "dialog-progress-bar", DialogCallback, self );
563
564     /* remove global observer watching for vout device changes correctly */
565     [[NSNotificationCenter defaultCenter] removeObserver: self];
566
567     /* release some other objects here, because it isn't sure whether dealloc
568      * will be called later on */
569     if( o_sprefs )
570         [o_sprefs release];
571
572     if( o_prefs )
573         [o_prefs release];
574
575     [o_open release];
576
577     if( o_info )
578     {
579         [o_info stopTimers];
580         [o_info release];
581     }
582
583     if( o_wizard )
584         [o_wizard release];
585
586     [crashLogURLConnection cancel];
587     [crashLogURLConnection release];
588
589     [o_embedded_list release];
590     [o_coredialogs release];
591     [o_eyetv release];
592
593     /* unsubscribe from libvlc's debug messages */
594     msg_Unsubscribe( p_intf->p_sys->p_sub );
595
596     [o_msg_arr removeAllObjects];
597     [o_msg_arr release];
598
599     [o_msg_lock release];
600
601     /* write cached user defaults to disk */
602     [[NSUserDefaults standardUserDefaults] synchronize];
603
604     /* Make sure the Menu doesn't have any references to vlc objects anymore */
605     //FIXME: this should be moved to VLCMainMenu
606     [o_mainmenu releaseRepresentedObjects:[NSApp mainMenu]];
607     [o_mainmenu release];
608
609     /* Kill the playlist, so that it doesn't accept new request
610      * such as the play request from vlc.c (we are a blocking interface). */
611     p_playlist = pl_Get( p_intf );
612     vlc_object_kill( p_playlist );
613     libvlc_Quit( p_intf->p_libvlc );
614
615     [self setIntf:nil];
616 }
617
618 #pragma mark -
619 #pragma mark Sparkle delegate
620 /* received directly before the update gets installed, so let's shut down a bit */
621 - (void)updater:(SUUpdater *)updater willInstallUpdate:(SUAppcastItem *)update
622 {
623     [o_remote stopListening: self];
624     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_STOP );
625
626     /* Close the window directly, because we do know that there
627      * won't be anymore video. It's currently waiting a bit. */
628     [[[o_coreinteraction voutView] window] orderOut:self];
629 }
630
631 #pragma mark -
632 #pragma mark Media Key support
633
634 -(void)mediaKeyTap:(SPMediaKeyTap*)keyTap receivedMediaKeyEvent:(NSEvent*)event
635 {
636     if( b_mediaKeySupport )
637        {
638         assert([event type] == NSSystemDefined && [event subtype] == SPSystemDefinedEventMediaKeys);
639
640         int keyCode = (([event data1] & 0xFFFF0000) >> 16);
641         int keyFlags = ([event data1] & 0x0000FFFF);
642         int keyState = (((keyFlags & 0xFF00) >> 8)) == 0xA;
643         int keyRepeat = (keyFlags & 0x1);
644
645         if( keyCode == NX_KEYTYPE_PLAY && keyState == 0 )
646             var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_PLAY_PAUSE );
647
648         if( keyCode == NX_KEYTYPE_FAST && !b_mediakeyJustJumped )
649         {
650             if( keyState == 0 && keyRepeat == 0 )
651                 var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_NEXT );
652             else if( keyRepeat == 1 )
653             {
654                 var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_FORWARD_SHORT );
655                 b_mediakeyJustJumped = YES;
656                 [self performSelector:@selector(resetMediaKeyJump)
657                            withObject: NULL
658                            afterDelay:0.25];
659             }
660         }
661
662         if( keyCode == NX_KEYTYPE_REWIND && !b_mediakeyJustJumped )
663         {
664             if( keyState == 0 && keyRepeat == 0 )
665                 var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_PREV );
666             else if( keyRepeat == 1 )
667             {
668                 var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_BACKWARD_SHORT );
669                 b_mediakeyJustJumped = YES;
670                 [self performSelector:@selector(resetMediaKeyJump)
671                            withObject: NULL
672                            afterDelay:0.25];
673             }
674         }
675     }
676 }
677
678 #pragma mark -
679 #pragma mark Other notification
680
681 /* Listen to the remote in exclusive mode, only when VLC is the active
682    application */
683 - (void)applicationDidBecomeActive:(NSNotification *)aNotification
684 {
685     if( !p_intf ) return;
686         if( config_GetInt( p_intf, "macosx-appleremote" ) == YES )
687                 [o_remote startListening: self];
688 }
689 - (void)applicationDidResignActive:(NSNotification *)aNotification
690 {
691     if( !p_intf ) return;
692     [o_remote stopListening: self];
693 }
694
695 /* Triggered when the computer goes to sleep */
696 - (void)computerWillSleep: (NSNotification *)notification
697 {
698     /* Pause */
699     if( p_intf && p_intf->p_sys->i_play_status == PLAYING_S )
700     {
701         var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_PLAY_PAUSE );
702     }
703 }
704
705 #pragma mark -
706 #pragma mark File opening
707
708 - (BOOL)application:(NSApplication *)o_app openFile:(NSString *)o_filename
709 {
710     BOOL b_autoplay = config_GetInt( VLCIntf, "macosx-autoplay" );
711     char *psz_uri = make_URI([o_filename UTF8String], "file" );
712     if( !psz_uri )
713         return( FALSE );
714
715     NSDictionary *o_dic = [NSDictionary dictionaryWithObject:[NSString stringWithCString:psz_uri encoding:NSUTF8StringEncoding] forKey:@"ITEM_URL"];
716
717     free( psz_uri );
718
719     if( b_autoplay )
720         [o_playlist appendArray: [NSArray arrayWithObject: o_dic] atPos: -1 enqueue: NO];
721     else
722         [o_playlist appendArray: [NSArray arrayWithObject: o_dic] atPos: -1 enqueue: YES];
723
724     return( TRUE );
725 }
726
727 /* When user click in the Dock icon our double click in the finder */
728 - (BOOL)applicationShouldHandleReopen:(NSApplication *)theApplication hasVisibleWindows:(BOOL)hasVisibleWindows
729 {
730     if(!hasVisibleWindows)
731         [o_mainwindow makeKeyAndOrderFront:self];
732
733     return YES;
734 }
735
736 #pragma mark -
737 #pragma mark Apple Remote Control
738
739 /* Helper method for the remote control interface in order to trigger forward/backward and volume
740    increase/decrease as long as the user holds the left/right, plus/minus button */
741 - (void) executeHoldActionForRemoteButton: (NSNumber*) buttonIdentifierNumber
742 {
743     if(b_remote_button_hold)
744     {
745         switch([buttonIdentifierNumber intValue])
746         {
747             case kRemoteButtonRight_Hold:
748                   [o_controls forward: self];
749             break;
750             case kRemoteButtonLeft_Hold:
751                   [o_controls backward: self];
752             break;
753             case kRemoteButtonVolume_Plus_Hold:
754                 [o_controls volumeUp: self];
755             break;
756             case kRemoteButtonVolume_Minus_Hold:
757                 [o_controls volumeDown: self];
758             break;
759         }
760         if(b_remote_button_hold)
761         {
762             /* trigger event */
763             [self performSelector:@selector(executeHoldActionForRemoteButton:)
764                          withObject:buttonIdentifierNumber
765                          afterDelay:0.25];
766         }
767     }
768 }
769
770 /* Apple Remote callback */
771 - (void) appleRemoteButton: (AppleRemoteEventIdentifier)buttonIdentifier
772                pressedDown: (BOOL) pressedDown
773                 clickCount: (unsigned int) count
774 {
775     switch( buttonIdentifier )
776     {
777         case k2009RemoteButtonFullscreen:
778             [o_controls toogleFullscreen:self];
779             break;
780         case k2009RemoteButtonPlay:
781             [o_controls play:self];
782             break;
783         case kRemoteButtonPlay:
784             if(count >= 2) {
785                 [o_controls toogleFullscreen:self];
786             } else {
787                 [o_controls play: self];
788             }
789             break;
790         case kRemoteButtonVolume_Plus:
791             [o_controls volumeUp: self];
792             break;
793         case kRemoteButtonVolume_Minus:
794             [o_controls volumeDown: self];
795             break;
796         case kRemoteButtonRight:
797             [o_controls next: self];
798             break;
799         case kRemoteButtonLeft:
800             [o_controls prev: self];
801             break;
802         case kRemoteButtonRight_Hold:
803         case kRemoteButtonLeft_Hold:
804         case kRemoteButtonVolume_Plus_Hold:
805         case kRemoteButtonVolume_Minus_Hold:
806             /* simulate an event as long as the user holds the button */
807             b_remote_button_hold = pressedDown;
808             if( pressedDown )
809             {
810                 NSNumber* buttonIdentifierNumber = [NSNumber numberWithInt: buttonIdentifier];
811                 [self performSelector:@selector(executeHoldActionForRemoteButton:)
812                            withObject:buttonIdentifierNumber];
813             }
814             break;
815         case kRemoteButtonMenu:
816             [o_controls showPosition: self];
817             break;
818         default:
819             /* Add here whatever you want other buttons to do */
820             break;
821     }
822 }
823
824 #pragma mark -
825 #pragma mark String utility
826 // FIXME: this has nothing to do here
827
828 - (NSString *)localizedString:(const char *)psz
829 {
830     NSString * o_str = nil;
831
832     if( psz != NULL )
833     {
834         o_str = [NSString stringWithCString: psz encoding:NSUTF8StringEncoding];
835
836         if( o_str == NULL )
837         {
838             msg_Err( VLCIntf, "could not translate: %s", psz );
839             return( @"" );
840         }
841     }
842     else
843     {
844         msg_Warn( VLCIntf, "can't translate empty strings" );
845         return( @"" );
846     }
847
848     return( o_str );
849 }
850
851
852
853 - (char *)delocalizeString:(NSString *)id
854 {
855     NSData * o_data = [id dataUsingEncoding: NSUTF8StringEncoding
856                           allowLossyConversion: NO];
857     char * psz_string;
858
859     if( o_data == nil )
860     {
861         o_data = [id dataUsingEncoding: NSUTF8StringEncoding
862                      allowLossyConversion: YES];
863         psz_string = malloc( [o_data length] + 1 );
864         [o_data getBytes: psz_string];
865         psz_string[ [o_data length] ] = '\0';
866         msg_Err( VLCIntf, "cannot convert to the requested encoding: %s",
867                  psz_string );
868     }
869     else
870     {
871         psz_string = malloc( [o_data length] + 1 );
872         [o_data getBytes: psz_string];
873         psz_string[ [o_data length] ] = '\0';
874     }
875
876     return psz_string;
877 }
878
879 /* i_width is in pixels */
880 - (NSString *)wrapString: (NSString *)o_in_string toWidth: (int) i_width
881 {
882     NSMutableString *o_wrapped;
883     NSString *o_out_string;
884     NSRange glyphRange, effectiveRange, charRange;
885     NSRect lineFragmentRect;
886     unsigned glyphIndex, breaksInserted = 0;
887
888     NSTextStorage *o_storage = [[NSTextStorage alloc] initWithString: o_in_string
889         attributes: [NSDictionary dictionaryWithObjectsAndKeys:
890         [NSFont labelFontOfSize: 0.0], NSFontAttributeName, nil]];
891     NSLayoutManager *o_layout_manager = [[NSLayoutManager alloc] init];
892     NSTextContainer *o_container = [[NSTextContainer alloc]
893         initWithContainerSize: NSMakeSize(i_width, 2000)];
894
895     [o_layout_manager addTextContainer: o_container];
896     [o_container release];
897     [o_storage addLayoutManager: o_layout_manager];
898     [o_layout_manager release];
899
900     o_wrapped = [o_in_string mutableCopy];
901     glyphRange = [o_layout_manager glyphRangeForTextContainer: o_container];
902
903     for( glyphIndex = glyphRange.location ; glyphIndex < NSMaxRange(glyphRange) ;
904             glyphIndex += effectiveRange.length) {
905         lineFragmentRect = [o_layout_manager lineFragmentRectForGlyphAtIndex: glyphIndex
906                                             effectiveRange: &effectiveRange];
907         charRange = [o_layout_manager characterRangeForGlyphRange: effectiveRange
908                                     actualGlyphRange: &effectiveRange];
909         if([o_wrapped lineRangeForRange:
910                 NSMakeRange(charRange.location + breaksInserted, charRange.length)].length > charRange.length) {
911             [o_wrapped insertString: @"\n" atIndex: NSMaxRange(charRange) + breaksInserted];
912             breaksInserted++;
913         }
914     }
915     o_out_string = [NSString stringWithString: o_wrapped];
916     [o_wrapped release];
917     [o_storage release];
918
919     return o_out_string;
920 }
921
922
923 #pragma mark -
924 #pragma mark Key Shortcuts
925
926 static struct
927 {
928     unichar i_nskey;
929     unsigned int i_vlckey;
930 } nskeys_to_vlckeys[] =
931 {
932     { NSUpArrowFunctionKey, KEY_UP },
933     { NSDownArrowFunctionKey, KEY_DOWN },
934     { NSLeftArrowFunctionKey, KEY_LEFT },
935     { NSRightArrowFunctionKey, KEY_RIGHT },
936     { NSF1FunctionKey, KEY_F1 },
937     { NSF2FunctionKey, KEY_F2 },
938     { NSF3FunctionKey, KEY_F3 },
939     { NSF4FunctionKey, KEY_F4 },
940     { NSF5FunctionKey, KEY_F5 },
941     { NSF6FunctionKey, KEY_F6 },
942     { NSF7FunctionKey, KEY_F7 },
943     { NSF8FunctionKey, KEY_F8 },
944     { NSF9FunctionKey, KEY_F9 },
945     { NSF10FunctionKey, KEY_F10 },
946     { NSF11FunctionKey, KEY_F11 },
947     { NSF12FunctionKey, KEY_F12 },
948     { NSInsertFunctionKey, KEY_INSERT },
949     { NSHomeFunctionKey, KEY_HOME },
950     { NSEndFunctionKey, KEY_END },
951     { NSPageUpFunctionKey, KEY_PAGEUP },
952     { NSPageDownFunctionKey, KEY_PAGEDOWN },
953     { NSMenuFunctionKey, KEY_MENU },
954     { NSTabCharacter, KEY_TAB },
955     { NSCarriageReturnCharacter, KEY_ENTER },
956     { NSEnterCharacter, KEY_ENTER },
957     { NSBackspaceCharacter, KEY_BACKSPACE },
958     {0,0}
959 };
960
961 unsigned int CocoaKeyToVLC( unichar i_key )
962 {
963     unsigned int i;
964
965     for( i = 0; nskeys_to_vlckeys[i].i_nskey != 0; i++ )
966     {
967         if( nskeys_to_vlckeys[i].i_nskey == i_key )
968         {
969             return nskeys_to_vlckeys[i].i_vlckey;
970         }
971     }
972     return (unsigned int)i_key;
973 }
974
975 - (unsigned int)VLCModifiersToCocoa:(NSString *)theString
976 {
977     unsigned int new = 0;
978
979     if([theString rangeOfString:@"Command"].location != NSNotFound)
980         new |= NSCommandKeyMask;
981     if([theString rangeOfString:@"Alt"].location != NSNotFound)
982         new |= NSAlternateKeyMask;
983     if([theString rangeOfString:@"Shift"].location != NSNotFound)
984         new |= NSShiftKeyMask;
985     if([theString rangeOfString:@"Ctrl"].location != NSNotFound)
986         new |= NSControlKeyMask;
987     return new;
988 }
989
990 - (NSString *)VLCKeyToString:(NSString *)theString
991 {
992     if (![theString isEqualToString:@""]) {
993         theString = [theString stringByReplacingOccurrencesOfString:@"Command" withString:@""];
994         theString = [theString stringByReplacingOccurrencesOfString:@"Alt" withString:@""];
995         theString = [theString stringByReplacingOccurrencesOfString:@"Shift" withString:@""];
996         theString = [theString stringByReplacingOccurrencesOfString:@"Ctrl" withString:@""];
997         theString = [theString stringByReplacingOccurrencesOfString:@"+" withString:@""];
998         theString = [theString stringByReplacingOccurrencesOfString:@"-" withString:@""];
999     }
1000     return theString;
1001 }
1002
1003
1004 /*****************************************************************************
1005  * hasDefinedShortcutKey: Check to see if the key press is a defined VLC
1006  * shortcut key.  If it is, pass it off to VLC for handling and return YES,
1007  * otherwise ignore it and return NO (where it will get handled by Cocoa).
1008  *****************************************************************************/
1009 - (BOOL)hasDefinedShortcutKey:(NSEvent *)o_event
1010 {
1011     unichar key = 0;
1012     vlc_value_t val;
1013     unsigned int i_pressed_modifiers = 0;
1014     const struct hotkey *p_hotkeys;
1015     int i;
1016     NSMutableString *tempString = [[[NSMutableString alloc] init] autorelease];
1017     NSMutableString *tempStringPlus = [[[NSMutableString alloc] init] autorelease];
1018
1019     val.i_int = 0;
1020     p_hotkeys = p_intf->p_libvlc->p_hotkeys;
1021
1022     i_pressed_modifiers = [o_event modifierFlags];
1023
1024     if( i_pressed_modifiers & NSShiftKeyMask ) {
1025         val.i_int |= KEY_MODIFIER_SHIFT;
1026         [tempString appendString:@"Shift-"];
1027         [tempStringPlus appendString:@"Shift+"];
1028     }
1029     if( i_pressed_modifiers & NSControlKeyMask ) {
1030         val.i_int |= KEY_MODIFIER_CTRL;
1031         [tempString appendString:@"Ctrl-"];
1032         [tempStringPlus appendString:@"Ctrl+"];
1033     }
1034     if( i_pressed_modifiers & NSAlternateKeyMask ) {
1035         val.i_int |= KEY_MODIFIER_ALT;
1036         [tempString appendString:@"Alt-"];
1037         [tempStringPlus appendString:@"Alt+"];
1038     }
1039     if( i_pressed_modifiers & NSCommandKeyMask ) {
1040         val.i_int |= KEY_MODIFIER_COMMAND;
1041         [tempString appendString:@"Command-"];
1042         [tempStringPlus appendString:@"Command+"];
1043     }
1044
1045     [tempString appendString:[[o_event charactersIgnoringModifiers] lowercaseString]];
1046     [tempStringPlus appendString:[[o_event charactersIgnoringModifiers] lowercaseString]];
1047
1048     key = [[o_event charactersIgnoringModifiers] characterAtIndex: 0];
1049
1050     switch( key )
1051     {
1052         case NSDeleteCharacter:
1053         case NSDeleteFunctionKey:
1054         case NSDeleteCharFunctionKey:
1055         case NSBackspaceCharacter:
1056         case NSUpArrowFunctionKey:
1057         case NSDownArrowFunctionKey:
1058         case NSRightArrowFunctionKey:
1059         case NSLeftArrowFunctionKey:
1060         case NSEnterCharacter:
1061         case NSCarriageReturnCharacter:
1062             return NO;
1063     }
1064
1065     val.i_int |= CocoaKeyToVLC( key );
1066
1067     if( [o_usedHotkeys indexOfObject: tempString] != NSNotFound || [o_usedHotkeys indexOfObject: tempStringPlus] != NSNotFound )
1068     {
1069         var_SetInteger( p_intf->p_libvlc, "key-pressed", val.i_int );
1070         return YES;
1071     }
1072
1073     return NO;
1074 }
1075
1076 - (void)updateCurrentlyUsedHotkeys
1077 {
1078     NSMutableArray *o_tempArray = [[NSMutableArray alloc] init];
1079     /* Get the main Module */
1080     module_t *p_main = module_get_main();
1081     assert( p_main );
1082     unsigned confsize;
1083     module_config_t *p_config;
1084
1085     p_config = module_config_get (p_main, &confsize);
1086
1087     for (size_t i = 0; i < confsize; i++)
1088     {
1089         module_config_t *p_item = p_config + i;
1090
1091         if( CONFIG_ITEM(p_item->i_type) && p_item->psz_name != NULL
1092            && !strncmp( p_item->psz_name , "key-", 4 )
1093            && !EMPTY_STR( p_item->psz_text ) )
1094         {
1095             if (p_item->value.psz)
1096                 [o_tempArray addObject: [NSString stringWithUTF8String:p_item->value.psz]];
1097         }
1098     }
1099     module_config_free (p_config);
1100     module_release (p_main);
1101     o_usedHotkeys = [[NSArray alloc] initWithArray: o_usedHotkeys copyItems: YES];
1102 }
1103
1104
1105 #pragma mark -
1106 #pragma mark Other objects getters
1107
1108 - (id)mainMenu
1109 {
1110     return o_mainmenu;
1111 }
1112
1113 - (id)controls
1114 {
1115     if( o_controls )
1116         return o_controls;
1117
1118     return nil;
1119 }
1120
1121 - (id)bookmarks
1122 {
1123     if (!o_bookmarks )
1124         o_bookmarks = [[VLCBookmarks alloc] init];
1125
1126     if( !nib_bookmarks_loaded )
1127         nib_bookmarks_loaded = [NSBundle loadNibNamed:@"Bookmarks" owner: NSApp];
1128
1129     return o_bookmarks;
1130 }
1131
1132 - (id)open
1133 {
1134     if (!o_open)
1135         return nil;
1136
1137     if (!nib_open_loaded)
1138         nib_open_loaded = [NSBundle loadNibNamed:@"Open" owner: NSApp];
1139
1140     return o_open;
1141 }
1142
1143 - (id)simplePreferences
1144 {
1145     if (!o_sprefs)
1146         o_sprefs = [[VLCSimplePrefs alloc] init];
1147
1148     if (!nib_prefs_loaded)
1149         nib_prefs_loaded = [NSBundle loadNibNamed:@"Preferences" owner: NSApp];
1150
1151     return o_sprefs;
1152 }
1153
1154 - (id)preferences
1155 {
1156     if( !o_prefs )
1157         o_prefs = [[VLCPrefs alloc] init];
1158
1159     if( !nib_prefs_loaded )
1160         nib_prefs_loaded = [NSBundle loadNibNamed:@"Preferences" owner: NSApp];
1161
1162     return o_prefs;
1163 }
1164
1165 - (id)playlist
1166 {
1167     if( o_playlist )
1168         return o_playlist;
1169
1170     return nil;
1171 }
1172
1173 - (id)info
1174 {
1175     if(! nib_info_loaded )
1176         nib_info_loaded = [NSBundle loadNibNamed:@"MediaInfo" owner: NSApp];
1177
1178     if( o_info )
1179         return o_info;
1180
1181     return nil;
1182 }
1183
1184 - (id)wizard
1185 {
1186     if( !o_wizard )
1187         o_wizard = [[VLCWizard alloc] init];
1188
1189     if( !nib_wizard_loaded )
1190     {
1191         nib_wizard_loaded = [NSBundle loadNibNamed:@"Wizard" owner: NSApp];
1192         [o_wizard initStrings];
1193     }
1194     return o_wizard;
1195 }
1196
1197 - (id)getVideoViewAtPositionX: (int *)pi_x Y: (int *)pi_y withWidth: (unsigned int*)pi_width andHeight: (unsigned int*)pi_height
1198 {
1199     id videoView = [o_mainwindow videoView];
1200     NSRect videoRect = [videoView frame];
1201     int i_x = (int)videoRect.origin.x;
1202     int i_y = (int)videoRect.origin.y;
1203     unsigned int i_width = (int)videoRect.size.width;
1204     unsigned int i_height = (int)videoRect.size.height;
1205     pi_x = (int *)i_x;
1206     pi_y = (int *)i_y;
1207     pi_width = (unsigned int*)i_width;
1208     pi_height = (unsigned int*)i_height;
1209     msg_Dbg( VLCIntf, "returning videoview with x=%i, y=%i, width=%i, height=%i", i_x, i_y, i_width, i_height );
1210     return videoView;
1211 }
1212
1213 - (id)embeddedList
1214 {
1215     if( o_embedded_list )
1216         return o_embedded_list;
1217
1218     return nil;
1219 }
1220
1221 - (id)coreDialogProvider
1222 {
1223     if( o_coredialogs )
1224         return o_coredialogs;
1225
1226     return nil;
1227 }
1228
1229 - (id)eyeTVController
1230 {
1231     if( o_eyetv )
1232         return o_eyetv;
1233
1234     return nil;
1235 }
1236
1237 - (id)appleRemoteController
1238 {
1239         return o_remote;
1240 }
1241
1242 #pragma mark -
1243 #pragma mark Polling
1244
1245 /*****************************************************************************
1246  * ManageThread: An ugly thread that polls
1247  *****************************************************************************/
1248 static void * ManageThread( void *user_data )
1249 {
1250     id self = user_data;
1251
1252     [self manage];
1253
1254     return NULL;
1255 }
1256
1257 struct manage_cleanup_stack {
1258     intf_thread_t * p_intf;
1259     input_thread_t ** p_input;
1260     playlist_t * p_playlist;
1261     id self;
1262 };
1263
1264 static void manage_cleanup( void * args )
1265 {
1266     struct manage_cleanup_stack * manage_cleanup_stack = args;
1267     intf_thread_t * p_intf = manage_cleanup_stack->p_intf;
1268     input_thread_t * p_input = *manage_cleanup_stack->p_input;
1269     id self = manage_cleanup_stack->self;
1270     playlist_t * p_playlist = manage_cleanup_stack->p_playlist;
1271
1272     var_DelCallback( p_playlist, "item-current", PlaylistChanged, self );
1273     var_DelCallback( p_playlist, "intf-change", PlaylistChanged, self );
1274     var_DelCallback( p_playlist, "item-change", PlaylistChanged, self );
1275     var_DelCallback( p_playlist, "playlist-item-append", PlaylistChanged, self );
1276     var_DelCallback( p_playlist, "playlist-item-deleted", PlaylistChanged, self );
1277
1278     if( p_input ) vlc_object_release( p_input );
1279 }
1280
1281 - (void)manage
1282 {
1283     playlist_t * p_playlist;
1284     input_thread_t * p_input = NULL;
1285
1286     /* new thread requires a new pool */
1287
1288     p_playlist = pl_Get( p_intf );
1289
1290     var_AddCallback( p_playlist, "item-current", PlaylistChanged, self );
1291     var_AddCallback( p_playlist, "intf-change", PlaylistChanged, self );
1292     var_AddCallback( p_playlist, "item-change", PlaylistChanged, self );
1293     var_AddCallback( p_playlist, "playlist-item-append", PlaylistChanged, self );
1294     var_AddCallback( p_playlist, "playlist-item-deleted", PlaylistChanged, self );
1295
1296     struct manage_cleanup_stack stack = { p_intf, &p_input, p_playlist, self };
1297     pthread_cleanup_push(manage_cleanup, &stack);
1298
1299     bool exitLoop = false;
1300     while( !exitLoop )
1301     {
1302         NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
1303
1304         if( !p_input )
1305         {
1306             p_input = playlist_CurrentInput( p_playlist );
1307
1308             /* Refresh the interface */
1309             if( p_input )
1310             {
1311                 msg_Dbg( p_intf, "input has changed, refreshing interface" );
1312                 p_intf->p_sys->b_input_update = true;
1313             }
1314         }
1315         else if( !vlc_object_alive (p_input) || p_input->b_dead )
1316         {
1317             /* input stopped */
1318             p_intf->p_sys->b_intf_update = true;
1319             p_intf->p_sys->i_play_status = END_S;
1320             msg_Dbg( p_intf, "input has stopped, refreshing interface" );
1321             vlc_object_release( p_input );
1322             p_input = NULL;
1323         }
1324         else if( cachedInputState != input_GetState( p_input ) )
1325         {
1326             cachedInputState = input_GetState( p_input );
1327             p_intf->p_sys->b_intf_update = true;
1328         }
1329
1330         /* Manage volume status */
1331         [o_mainwindow updateVolumeSlider];
1332
1333         msleep( INTF_IDLE_SLEEP );
1334
1335         [pool release];
1336
1337         [o_appLock lock];
1338         exitLoop = (f_appExit != 0 ? true : false);
1339         [o_appLock unlock];
1340     }
1341
1342     pthread_cleanup_pop(1);
1343 }
1344
1345 - (void)manageIntf:(NSTimer *)o_timer
1346 {
1347     vlc_value_t val;
1348     playlist_t * p_playlist;
1349     input_thread_t * p_input;
1350
1351     if( p_intf->p_sys->b_input_update )
1352     {
1353         /* Called when new input is opened */
1354         p_intf->p_sys->b_current_title_update = true;
1355         p_intf->p_sys->b_intf_update = true;
1356         p_intf->p_sys->b_input_update = false;
1357         [o_mainmenu setupMenus]; /* Make sure input menu is up to date */
1358     }
1359     if( p_intf->p_sys->b_intf_update )
1360     {
1361         [o_mainwindow updateWindow];
1362         p_intf->p_sys->b_current_title_update = true;
1363         p_intf->p_sys->b_intf_update = false;
1364     }
1365
1366     if( p_intf->p_sys->b_playmode_update )
1367     {
1368         [o_playlist playModeUpdated];
1369         p_intf->p_sys->b_playmode_update = false;
1370     }
1371     if( p_intf->p_sys->b_playlist_update )
1372     {
1373         [o_playlist playlistUpdated];
1374         p_intf->p_sys->b_playlist_update = false;
1375     }
1376
1377     if( p_intf->p_sys->b_fullscreen_update )
1378     {
1379         p_intf->p_sys->b_fullscreen_update = false;
1380     }
1381
1382     if( p_intf->p_sys->b_intf_show )
1383     {
1384         if( [[o_coreinteraction voutView] isFullscreen] && config_GetInt( VLCIntf, "macosx-fspanel" ) )
1385             [[o_controls fspanel] fadeIn];
1386         else
1387             [o_mainwindow makeKeyAndOrderFront: self];
1388
1389         p_intf->p_sys->b_intf_show = false;
1390     }
1391
1392     p_input = pl_CurrentInput( p_intf );
1393     if( p_input && vlc_object_alive (p_input) )
1394     {
1395         vlc_value_t val;
1396
1397         if( p_intf->p_sys->b_current_title_update )
1398         {
1399             NSString *aString;
1400             input_item_t * p_item = input_GetItem( p_input );
1401             char * name = input_item_GetNowPlaying( p_item );
1402
1403             if( !name )
1404                 name = input_item_GetName( p_item );
1405
1406             aString = [NSString stringWithUTF8String:name];
1407
1408             free(name);
1409
1410             [o_mainwindow setTitle: aString];
1411             [[[self controls] fspanel] setStreamTitle: aString];
1412
1413             [[o_coreinteraction voutView] updateTitle];
1414
1415             [o_playlist updateRowSelection];
1416
1417             p_intf->p_sys->b_current_title_update = FALSE;
1418         }
1419
1420         [o_mainwindow updateTimeSlider];
1421
1422         /* Manage Playing status */
1423         var_Get( p_input, "state", &val );
1424         if( p_intf->p_sys->i_play_status != val.i_int )
1425         {
1426             p_intf->p_sys->i_play_status = val.i_int;
1427             [self playStatusUpdated: p_intf->p_sys->i_play_status];
1428         }
1429         vlc_object_release( p_input );
1430     }
1431     else if( p_input )
1432     {
1433         vlc_object_release( p_input );
1434     }
1435     else
1436     {
1437         p_intf->p_sys->i_play_status = END_S;
1438         if (p_intf->p_sys->i_old_play_status != p_intf->p_sys->i_play_status)
1439         {
1440             [self playStatusUpdated: p_intf->p_sys->i_play_status];
1441             [o_mainmenu setSubmenusEnabled: FALSE];
1442             p_intf->p_sys->i_old_play_status = p_intf->p_sys->i_play_status;
1443         }
1444     }
1445 end:
1446     [self updateMessageDisplay];
1447
1448     [interfaceTimer autorelease];
1449
1450     interfaceTimer = [[NSTimer scheduledTimerWithTimeInterval: 0.3
1451         target: self selector: @selector(manageIntf:)
1452         userInfo: nil repeats: FALSE] retain];
1453 }
1454
1455 #pragma mark -
1456 #pragma mark Interface update
1457
1458 - (void)playStatusUpdated:(int)i_status
1459 {
1460     if( i_status == PLAYING_S )
1461     {
1462         [[[self controls] fspanel] setPause];
1463         [[self mainMenu] setPause];
1464         [o_mainwindow setPause];
1465     }
1466     else
1467     {
1468         [[[self controls] fspanel] setPlay];
1469         [[self mainMenu] setPlay];
1470         [o_mainwindow setPlay];
1471     }
1472 }
1473
1474 - (IBAction)showController:(id)sender
1475 {
1476     //FIXME: why is this function here?!
1477     [o_mainwindow makeKeyAndOrderFront:sender];
1478 }
1479
1480 #pragma mark -
1481 #pragma mark Crash Log
1482 - (void)sendCrashLog:(NSString *)crashLog withUserComment:(NSString *)userComment
1483 {
1484     NSString *urlStr = @"http://jones.videolan.org/crashlog/sendcrashreport.php";
1485     NSURL *url = [NSURL URLWithString:urlStr];
1486
1487     NSMutableURLRequest *req = [NSMutableURLRequest requestWithURL:url];
1488     [req setHTTPMethod:@"POST"];
1489
1490     NSString * email;
1491     if( [o_crashrep_includeEmail_ckb state] == NSOnState )
1492     {
1493         ABPerson * contact = [[ABAddressBook sharedAddressBook] me];
1494         ABMultiValue *emails = [contact valueForProperty:kABEmailProperty];
1495         email = [emails valueAtIndex:[emails indexForIdentifier:
1496                     [emails primaryIdentifier]]];
1497     }
1498     else
1499         email = [NSString string];
1500
1501     NSString *postBody;
1502     postBody = [NSString stringWithFormat:@"CrashLog=%@&Comment=%@&Email=%@\r\n",
1503             [crashLog stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding],
1504             [userComment stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding],
1505             [email stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]];
1506
1507     [req setHTTPBody:[postBody dataUsingEncoding:NSUTF8StringEncoding]];
1508
1509     /* Released from delegate */
1510     crashLogURLConnection = [[NSURLConnection alloc] initWithRequest:req delegate:self];
1511 }
1512
1513 - (void)connectionDidFinishLoading:(NSURLConnection *)connection
1514 {
1515     [crashLogURLConnection release];
1516     crashLogURLConnection = nil;
1517 }
1518
1519 - (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error
1520 {
1521     NSRunCriticalAlertPanel(_NS("Error when sending the Crash Report"), [error localizedDescription], @"OK", nil, nil);
1522     [crashLogURLConnection release];
1523     crashLogURLConnection = nil;
1524 }
1525
1526 - (NSString *)latestCrashLogPathPreviouslySeen:(BOOL)previouslySeen
1527 {
1528     NSString * crashReporter = [@"~/Library/Logs/CrashReporter" stringByExpandingTildeInPath];
1529     NSDirectoryEnumerator *direnum = [[NSFileManager defaultManager] enumeratorAtPath:crashReporter];
1530     NSString *fname;
1531     NSString * latestLog = nil;
1532     int year  = !previouslySeen ? [[NSUserDefaults standardUserDefaults] integerForKey:@"LatestCrashReportYear"] : 0;
1533     int month = !previouslySeen ? [[NSUserDefaults standardUserDefaults] integerForKey:@"LatestCrashReportMonth"]: 0;
1534     int day   = !previouslySeen ? [[NSUserDefaults standardUserDefaults] integerForKey:@"LatestCrashReportDay"]  : 0;
1535     int hours = !previouslySeen ? [[NSUserDefaults standardUserDefaults] integerForKey:@"LatestCrashReportHours"]: 0;
1536
1537     while (fname = [direnum nextObject])
1538     {
1539         [direnum skipDescendents];
1540         if([fname hasPrefix:@"VLC"] && [fname hasSuffix:@"crash"])
1541         {
1542             NSArray * compo = [fname componentsSeparatedByString:@"_"];
1543             if( [compo count] < 3 ) continue;
1544             compo = [[compo objectAtIndex:1] componentsSeparatedByString:@"-"];
1545             if( [compo count] < 4 ) continue;
1546
1547             // Dooh. ugly.
1548             if( year < [[compo objectAtIndex:0] intValue] ||
1549                 (year ==[[compo objectAtIndex:0] intValue] &&
1550                  (month < [[compo objectAtIndex:1] intValue] ||
1551                   (month ==[[compo objectAtIndex:1] intValue] &&
1552                    (day   < [[compo objectAtIndex:2] intValue] ||
1553                     (day   ==[[compo objectAtIndex:2] intValue] &&
1554                       hours < [[compo objectAtIndex:3] intValue] ))))))
1555             {
1556                 year  = [[compo objectAtIndex:0] intValue];
1557                 month = [[compo objectAtIndex:1] intValue];
1558                 day   = [[compo objectAtIndex:2] intValue];
1559                 hours = [[compo objectAtIndex:3] intValue];
1560                 latestLog = [crashReporter stringByAppendingPathComponent:fname];
1561             }
1562         }
1563     }
1564
1565     if(!(latestLog && [[NSFileManager defaultManager] fileExistsAtPath:latestLog]))
1566         return nil;
1567
1568     if( !previouslySeen )
1569     {
1570         [[NSUserDefaults standardUserDefaults] setInteger:year  forKey:@"LatestCrashReportYear"];
1571         [[NSUserDefaults standardUserDefaults] setInteger:month forKey:@"LatestCrashReportMonth"];
1572         [[NSUserDefaults standardUserDefaults] setInteger:day   forKey:@"LatestCrashReportDay"];
1573         [[NSUserDefaults standardUserDefaults] setInteger:hours forKey:@"LatestCrashReportHours"];
1574     }
1575     return latestLog;
1576 }
1577
1578 - (NSString *)latestCrashLogPath
1579 {
1580     return [self latestCrashLogPathPreviouslySeen:YES];
1581 }
1582
1583 - (void)lookForCrashLog
1584 {
1585     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
1586     // This pref key doesn't exists? this VLC is an upgrade, and this crash log come from previous version
1587     BOOL areCrashLogsTooOld = ![[NSUserDefaults standardUserDefaults] integerForKey:@"LatestCrashReportYear"];
1588     NSString * latestLog = [self latestCrashLogPathPreviouslySeen:NO];
1589     if( latestLog && !areCrashLogsTooOld )
1590         [NSApp runModalForWindow: o_crashrep_win];
1591     [o_pool release];
1592 }
1593
1594 - (IBAction)crashReporterAction:(id)sender
1595 {
1596     if( sender == o_crashrep_send_btn )
1597         [self sendCrashLog:[NSString stringWithContentsOfFile: [self latestCrashLogPath] encoding: NSUTF8StringEncoding error: NULL] withUserComment: [o_crashrep_fld string]];
1598
1599     [NSApp stopModal];
1600     [o_crashrep_win orderOut: sender];
1601 }
1602
1603 - (IBAction)openCrashLog:(id)sender
1604 {
1605     NSString * latestLog = [self latestCrashLogPath];
1606     if( latestLog )
1607     {
1608         [[NSWorkspace sharedWorkspace] openFile: latestLog withApplication: @"Console"];
1609     }
1610     else
1611     {
1612         NSBeginInformationalAlertSheet(_NS("No CrashLog found"), _NS("Continue"), nil, nil, o_msgs_panel, self, NULL, NULL, nil, _NS("Couldn't find any trace of a previous crash.") );
1613     }
1614 }
1615
1616 #pragma mark -
1617 #pragma mark Remove old prefs
1618
1619 - (void)_removeOldPreferences
1620 {
1621     static NSString * kVLCPreferencesVersion = @"VLCPreferencesVersion";
1622     static const int kCurrentPreferencesVersion = 1;
1623     int version = [[NSUserDefaults standardUserDefaults] integerForKey:kVLCPreferencesVersion];
1624     if( version >= kCurrentPreferencesVersion ) return;
1625
1626     NSArray *libraries = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory,
1627         NSUserDomainMask, YES);
1628     if( !libraries || [libraries count] == 0) return;
1629     NSString * preferences = [[libraries objectAtIndex:0] stringByAppendingPathComponent:@"Preferences"];
1630
1631     /* File not found, don't attempt anything */
1632     if(![[NSFileManager defaultManager] fileExistsAtPath:[preferences stringByAppendingPathComponent:@"VLC"]] &&
1633        ![[NSFileManager defaultManager] fileExistsAtPath:[preferences stringByAppendingPathComponent:@"org.videolan.vlc.plist"]] )
1634     {
1635         [[NSUserDefaults standardUserDefaults] setInteger:kCurrentPreferencesVersion forKey:kVLCPreferencesVersion];
1636         return;
1637     }
1638
1639     int res = NSRunInformationalAlertPanel(_NS("Remove old preferences?"),
1640                 _NS("We just found an older version of VLC's preferences files."),
1641                 _NS("Move To Trash and Relaunch VLC"), _NS("Ignore"), nil, nil);
1642     if( res != NSOKButton )
1643     {
1644         [[NSUserDefaults standardUserDefaults] setInteger:kCurrentPreferencesVersion forKey:kVLCPreferencesVersion];
1645         return;
1646     }
1647
1648     NSArray * ourPreferences = [NSArray arrayWithObjects:@"org.videolan.vlc.plist", @"VLC", nil];
1649
1650     /* Move the file to trash so that user can find them later */
1651     [[NSWorkspace sharedWorkspace] performFileOperation:NSWorkspaceRecycleOperation source:preferences destination:nil files:ourPreferences tag:0];
1652
1653     /* really reset the defaults from now on */
1654     [NSUserDefaults resetStandardUserDefaults];
1655
1656     [[NSUserDefaults standardUserDefaults] setInteger:kCurrentPreferencesVersion forKey:kVLCPreferencesVersion];
1657     [[NSUserDefaults standardUserDefaults] synchronize];
1658
1659     /* Relaunch now */
1660     const char * path = [[[NSBundle mainBundle] executablePath] UTF8String];
1661
1662     /* For some reason we need to fork(), not just execl(), which reports a ENOTSUP then. */
1663     if(fork() != 0)
1664     {
1665         exit(0);
1666         return;
1667     }
1668     execl(path, path, NULL);
1669 }
1670
1671 #pragma mark -
1672 #pragma mark Errors, warnings and messages
1673 - (IBAction)showMessagesPanel:(id)sender
1674 {
1675     [o_msgs_panel makeKeyAndOrderFront: sender];
1676 }
1677
1678 - (void)windowDidBecomeKey:(NSNotification *)o_notification
1679 {
1680     if( [o_notification object] == o_msgs_panel )
1681         [self updateMessageDisplay];
1682 }
1683
1684 - (void)updateMessageDisplay
1685 {
1686     if( [o_msgs_panel isVisible] && b_msg_arr_changed )
1687     {
1688         id o_msg;
1689         NSEnumerator * o_enum;
1690
1691         [o_messages setString: @""];
1692
1693         [o_msg_lock lock];
1694
1695         o_enum = [o_msg_arr objectEnumerator];
1696
1697         while( ( o_msg = [o_enum nextObject] ) != nil )
1698         {
1699             [o_messages insertText: o_msg];
1700         }
1701
1702         b_msg_arr_changed = NO;
1703         [o_msg_lock unlock];
1704     }
1705 }
1706
1707 - (void)processReceivedlibvlcMessage:(const msg_item_t *)item
1708 {
1709     NSColor *o_white = [NSColor whiteColor];
1710     NSColor *o_red = [NSColor redColor];
1711     NSColor *o_yellow = [NSColor yellowColor];
1712     NSColor *o_gray = [NSColor grayColor];
1713
1714     NSColor * pp_color[4] = { o_white, o_red, o_yellow, o_gray };
1715     static const char * ppsz_type[4] = { ": ", " error: ", " warning: ", " debug: " };
1716
1717     NSDictionary *o_attr;
1718     NSAttributedString *o_msg_color;
1719
1720     int i_type = item->i_type;
1721
1722     [o_msg_lock lock];
1723
1724     if( [o_msg_arr count] + 2 > 600 )
1725     {
1726         [o_msg_arr removeObjectAtIndex: 0];
1727         [o_msg_arr removeObjectAtIndex: 1];
1728     }
1729
1730     o_attr = [NSDictionary dictionaryWithObject: o_gray forKey: NSForegroundColorAttributeName];
1731     o_msg_color = [[NSAttributedString alloc] initWithString: [NSString stringWithFormat: @"%s%s", item->psz_module, ppsz_type[i_type]] attributes: o_attr];
1732     [o_msg_arr addObject: [o_msg_color autorelease]];
1733
1734     o_attr = [NSDictionary dictionaryWithObject: pp_color[i_type] forKey: NSForegroundColorAttributeName];
1735     o_msg_color = [[NSAttributedString alloc] initWithString: [NSString stringWithFormat: @"%s\n", item->psz_msg] attributes: o_attr];
1736     [o_msg_arr addObject: [o_msg_color autorelease]];
1737
1738     b_msg_arr_changed = YES;
1739     [o_msg_lock unlock];
1740 }
1741
1742 - (IBAction)saveDebugLog:(id)sender
1743 {
1744     NSOpenPanel * saveFolderPanel = [[NSSavePanel alloc] init];
1745
1746     [saveFolderPanel setCanChooseDirectories: NO];
1747     [saveFolderPanel setCanChooseFiles: YES];
1748     [saveFolderPanel setCanSelectHiddenExtension: NO];
1749     [saveFolderPanel setCanCreateDirectories: YES];
1750     [saveFolderPanel setAllowedFileTypes: [NSArray arrayWithObject:@"rtfd"]];
1751     [saveFolderPanel beginSheetForDirectory:nil file: [NSString stringWithFormat: _NS("VLC Debug Log (%s).rtfd"), VERSION_MESSAGE] modalForWindow: o_msgs_panel modalDelegate:self didEndSelector:@selector(saveDebugLogAsRTF:returnCode:contextInfo:) contextInfo:nil];
1752 }
1753
1754 - (void)saveDebugLogAsRTF: (NSSavePanel *)sheet returnCode: (int)returnCode contextInfo: (void *)contextInfo
1755 {
1756     BOOL b_returned;
1757     if( returnCode == NSOKButton )
1758     {
1759         b_returned = [o_messages writeRTFDToFile: [[sheet URL] path] atomically: YES];
1760         if(! b_returned )
1761             msg_Warn( p_intf, "Error while saving the debug log" );
1762     }
1763 }
1764
1765 #pragma mark -
1766 #pragma mark Playlist toggling
1767
1768 - (IBAction)togglePlaylist:(id)sender
1769 {
1770     NSLog( @"needs to be re-implemented" );
1771 }
1772
1773 - (void)updateTogglePlaylistState
1774 {
1775     [[self playlist] outlineViewSelectionDidChange: NULL];
1776 }
1777
1778 #pragma mark -
1779
1780 @end
1781
1782 @implementation VLCMain (Internal)
1783
1784 - (void)handlePortMessage:(NSPortMessage *)o_msg
1785 {
1786     id ** val;
1787     NSData * o_data;
1788     NSValue * o_value;
1789     NSInvocation * o_inv;
1790     NSConditionLock * o_lock;
1791
1792     o_data = [[o_msg components] lastObject];
1793     o_inv = *((NSInvocation **)[o_data bytes]);
1794     [o_inv getArgument: &o_value atIndex: 2];
1795     val = (id **)[o_value pointerValue];
1796     [o_inv setArgument: val[1] atIndex: 2];
1797     o_lock = *(val[0]);
1798
1799     [o_lock lock];
1800     [o_inv invoke];
1801     [o_lock unlockWithCondition: 1];
1802 }
1803 - (void)resetMediaKeyJump
1804 {
1805     b_mediakeyJustJumped = NO;
1806 }
1807 - (void)coreChangedMediaKeySupportSetting: (NSNotification *)o_notification
1808 {
1809     b_mediaKeySupport = config_GetInt( VLCIntf, "macosx-mediakeys" );
1810     if (b_mediaKeySupport) {
1811         if (!o_mediaKeyController)
1812             o_mediaKeyController = [[SPMediaKeyTap alloc] initWithDelegate:self];
1813         [o_mediaKeyController startWatchingMediaKeys];
1814     }
1815     else if (!b_mediaKeySupport && o_mediaKeyController)
1816     {
1817         int returnedValue = NSRunInformationalAlertPanel(_NS("Relaunch required"),
1818                                                _NS("To make sure that VLC no longer listens to your media key events, it needs to be restarted."),
1819                                                _NS("Relaunch VLC"), _NS("Ignore"), nil, nil);
1820         if( returnedValue == NSOKButton )
1821         {
1822             /* Relaunch now */
1823             const char * path = [[[NSBundle mainBundle] executablePath] UTF8String];
1824
1825             /* For some reason we need to fork(), not just execl(), which reports a ENOTSUP then. */
1826             if(fork() != 0)
1827             {
1828                 exit(0);
1829                 return;
1830             }
1831             execl(path, path, NULL);
1832         }
1833     }
1834 }
1835
1836 @end
1837
1838 /*****************************************************************************
1839  * VLCApplication interface
1840  *****************************************************************************/
1841
1842 @implementation VLCApplication
1843 // when user selects the quit menu from dock it sends a terminate:
1844 // but we need to send a stop: to properly exits libvlc.
1845 // However, we are not able to change the action-method sent by this standard menu item.
1846 // thus we override terminat: to send a stop:
1847 // see [af97f24d528acab89969d6541d83f17ce1ecd580] that introduced the removal of setjmp() and longjmp()
1848 - (void)terminate:(id)sender
1849 {
1850     [self activateIgnoringOtherApps:YES];
1851     [self stop:sender];
1852 }
1853
1854 @end