git.sesse.net Git - vlc/blob - modules/gui/macosx/controls.m

   1 /*****************************************************************************
   2  * controls.m: MacOS X interface module
   3  *****************************************************************************
   4  * Copyright (C) 2002-2009 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 dot org>
  10  *          Benjamin Pracht <bigben at videolan doit org>
  11  *          Felix Paul Kühne <fkuehne at videolan dot org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 /*****************************************************************************
  29  * Preamble
  30  *****************************************************************************/
  31 #include <stdlib.h>                                      /* malloc(), free() */
  32 #include <sys/param.h>                                    /* for MAXPATHLEN */
  33 #include <string.h>
  34
  35 #import "intf.h"
  36 #import "vout.h"
  37 #import "open.h"
  38 #import "controls.h"
  39 #import "playlist.h"
  40 #include <vlc_osd.h>
  41 #include <vlc_keys.h>
  42
  43 #pragma mark -
  44 /*****************************************************************************
  45  * VLCControls implementation
  46  *****************************************************************************/
  47 @implementation VLCControls
  48
  49 - (id)init
  50 {
  51     [super init];
  52     o_fs_panel = [[VLCFSPanel alloc] init];
  53     b_lockAspectRatio = YES;
  54     return self;
  55 }
  56
  57 - (void)awakeFromNib
  58 {
  59     [o_specificTime_mi setTitle: _NS("Jump To Time")];
  60     [o_specificTime_cancel_btn setTitle: _NS("Cancel")];
  61     [o_specificTime_ok_btn setTitle: _NS("OK")];
  62     [o_specificTime_sec_lbl setStringValue: _NS("sec.")];
  63     [o_specificTime_goTo_lbl setStringValue: _NS("Jump to time")];
  64
  65     o_repeat_off = [NSImage imageNamed:@"repeat_embedded"];
  66
  67     [self controlTintChanged];
  68
  69     [[NSNotificationCenter defaultCenter] addObserver: self
  70                                              selector: @selector( controlTintChanged )
  71                                                  name: NSControlTintDidChangeNotification
  72                                                object: nil];
  73 }
  74
  75 - (void)controlTintChanged
  76 {
  77     int i_repeat = 0;
  78     if( [o_btn_repeat image] == o_repeat_single )
  79         i_repeat = 1;
  80     else if( [o_btn_repeat image] == o_repeat_all )
  81         i_repeat = 2;
  82
  83     if( [NSColor currentControlTint] == NSGraphiteControlTint )
  84     {
  85         o_repeat_single = [NSImage imageNamed:@"repeat_single_embedded_graphite"];
  86         o_repeat_all = [NSImage imageNamed:@"repeat_embedded_graphite"];
  87
  88         [o_btn_shuffle setAlternateImage: [NSImage imageNamed: @"shuffle_embedded_graphite"]];
  89         [o_btn_addNode setAlternateImage: [NSImage imageNamed: @"add_embedded_graphite"]];
  90     }
  91     else
  92     {
  93         o_repeat_single = [NSImage imageNamed:@"repeat_single_embedded_blue"];
  94         o_repeat_all = [NSImage imageNamed:@"repeat_embedded_blue"];
  95
  96         [o_btn_shuffle setAlternateImage: [NSImage imageNamed: @"shuffle_embedded_blue"]];
  97         [o_btn_addNode setAlternateImage: [NSImage imageNamed: @"add_embedded_blue"]];
  98     }
  99
 100     /* update the repeat button, but keep its state */
 101     if( i_repeat == 1 )
 102         [self repeatOne];
 103     else if( i_repeat == 2 )
 104         [self repeatAll];
 105     else
 106         [self repeatOff];
 107 }
 108
 109 - (void)dealloc
 110 {
 111     [[NSNotificationCenter defaultCenter] removeObserver: self];
 112
 113     [o_fs_panel release];
 114     [o_repeat_single release];
 115     [o_repeat_all release];
 116     [o_repeat_off release];
 117
 118     [super dealloc];
 119 }
 120
 121 - (IBAction)play:(id)sender
 122 {
 123     intf_thread_t * p_intf = VLCIntf;
 124     playlist_t * p_playlist = pl_Hold( p_intf );
 125     bool empty;
 126
 127     PL_LOCK;
 128     empty = playlist_IsEmpty( p_playlist );
 129     PL_UNLOCK;
 130
 131     pl_Release( p_intf );
 132
 133     if( empty )
 134         [o_main intfOpenFileGeneric: (id)sender];
 135
 136     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_PLAY_PAUSE );
 137 }
 138
 139 - (id)voutView
 140 {
 141     id o_window;
 142     id o_voutView = nil;
 143     id o_embeddedViewList = [[VLCMain sharedInstance] embeddedList];
 144     NSEnumerator *o_enumerator = [[NSApp orderedWindows] objectEnumerator];
 145     while( !o_voutView && ( o_window = [o_enumerator nextObject] ) )
 146     {
 147         /* We have an embedded vout */
 148         if( [o_embeddedViewList windowContainsEmbedded: o_window] )
 149         {
 150             o_voutView = [o_embeddedViewList viewForWindow: o_window];
 151         }
 152         /* We have a detached vout */
 153         else if( [[o_window className] isEqualToString: @"VLCVoutWindow"] )
 154         {
 155             o_voutView = [o_window voutView];
 156         }
 157     }
 158     return [[o_voutView retain] autorelease];
 159 }
 160
 161 - (BOOL)aspectRatioIsLocked
 162 {
 163     return b_lockAspectRatio;
 164 }
 165
 166 - (IBAction)stop:(id)sender
 167 {
 168     intf_thread_t * p_intf = VLCIntf;
 169     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_STOP );
 170     /* Close the window directly, because we do know that there
 171      * won't be anymore video. It's currently waiting a bit. */
 172     [[[self voutView] window] orderOut:self];
 173 }
 174
 175 - (IBAction)faster:(id)sender
 176 {
 177     intf_thread_t * p_intf = VLCIntf;
 178     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_FASTER );
 179 }
 180
 181 - (IBAction)slower:(id)sender
 182 {
 183     intf_thread_t * p_intf = VLCIntf;
 184     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_SLOWER );
 185 }
 186
 187 - (IBAction)prev:(id)sender
 188 {
 189     intf_thread_t * p_intf = VLCIntf;
 190     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_PREV );
 191 }
 192
 193 - (IBAction)next:(id)sender
 194 {
 195     intf_thread_t * p_intf = VLCIntf;
 196     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_NEXT );
 197 }
 198
 199 - (IBAction)random:(id)sender
 200 {
 201     vlc_value_t val;
 202     intf_thread_t * p_intf = VLCIntf;
 203     playlist_t * p_playlist = pl_Hold( p_intf );
 204
 205     var_Get( p_playlist, "random", &val );
 206     val.b_bool = !val.b_bool;
 207     var_Set( p_playlist, "random", val );
 208     if( val.b_bool )
 209     {
 210         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random On" ) );
 211         config_PutInt( p_playlist, "random", 1 );
 212     }
 213     else
 214     {
 215         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Random Off" ) );
 216         config_PutInt( p_playlist, "random", 0 );
 217     }
 218
 219     p_intf->p_sys->b_playmode_update = true;
 220     p_intf->p_sys->b_intf_update = true;
 221     pl_Release( p_intf );
 222 }
 223
 224 /* three little ugly helpers */
 225 - (void)repeatOne
 226 {
 227     [o_btn_repeat setImage: o_repeat_single];
 228     [o_btn_repeat setAlternateImage: o_repeat_all];
 229     [o_btn_repeat_embed setImage: [NSImage imageNamed:@"sidebarRepeatOneOn"]];
 230 }
 231 - (void)repeatAll
 232 {
 233     [o_btn_repeat setImage: o_repeat_all];
 234     [o_btn_repeat setAlternateImage: o_repeat_off];
 235     [o_btn_repeat_embed setImage: [NSImage imageNamed:@"sidebarRepeatOn"]];
 236 }
 237 - (void)repeatOff
 238 {
 239     [o_btn_repeat setImage: o_repeat_off];
 240     [o_btn_repeat setAlternateImage: o_repeat_single];
 241     [o_btn_repeat_embed setImage: [NSImage imageNamed:@"sidebarRepeat"]];
 242 }
 243 - (void)shuffle
 244 {
 245     vlc_value_t val;
 246     playlist_t *p_playlist = pl_Hold( VLCIntf );
 247     var_Get( p_playlist, "random", &val );
 248     [o_btn_shuffle setState: val.b_bool];
 249         if(val.b_bool)
 250         [o_btn_shuffle_embed setImage: [NSImage imageNamed:@"sidebarShuffleOn"]];
 251         else
 252         [o_btn_shuffle_embed setImage: [NSImage imageNamed:@"sidebarShuffle"]];
 253     pl_Release( VLCIntf );
 254 }
 255
 256 - (IBAction)repeatButtonAction:(id)sender
 257 {
 258     vlc_value_t looping,repeating;
 259     intf_thread_t * p_intf = VLCIntf;
 260     playlist_t * p_playlist = pl_Hold( p_intf );
 261
 262     var_Get( p_playlist, "repeat", &repeating );
 263     var_Get( p_playlist, "loop", &looping );
 264
 265     if( !repeating.b_bool && !looping.b_bool )
 266     {
 267         /* was: no repeating at all, switching to Repeat One */
 268
 269         /* set our button's look */
 270         [self repeatOne];
 271
 272         /* prepare core communication */
 273         repeating.b_bool = true;
 274         looping.b_bool = false;
 275         config_PutInt( p_playlist, "repeat", 1 );
 276         config_PutInt( p_playlist, "loop", 0 );
 277
 278         /* show the change */
 279         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat One" ) );
 280     }
 281     else if( repeating.b_bool && !looping.b_bool )
 282     {
 283         /* was: Repeat One, switching to Repeat All */
 284
 285         /* set our button's look */
 286         [self repeatAll];
 287
 288         /* prepare core communication */
 289         repeating.b_bool = false;
 290         looping.b_bool = true;
 291         config_PutInt( p_playlist, "repeat", 0 );
 292         config_PutInt( p_playlist, "loop", 1 );
 293
 294         /* show the change */
 295         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat All" ) );
 296     }
 297     else
 298     {
 299         /* was: Repeat All or bug in VLC, switching to Repeat Off */
 300
 301         /* set our button's look */
 302         [self repeatOff];
 303
 304         /* prepare core communication */
 305         repeating.b_bool = false;
 306         looping.b_bool = false;
 307         config_PutInt( p_playlist, "repeat", 0 );
 308         config_PutInt( p_playlist, "loop", 0 );
 309
 310         /* show the change */
 311         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
 312     }
 313
 314     /* communicate with core and the main intf loop */
 315     var_Set( p_playlist, "repeat", repeating );
 316     var_Set( p_playlist, "loop", looping );
 317     p_intf->p_sys->b_playmode_update = true;
 318     p_intf->p_sys->b_intf_update = true;
 319
 320     pl_Release( p_intf );
 321 }
 322
 323
 324 - (IBAction)repeat:(id)sender
 325 {
 326     vlc_value_t val;
 327     intf_thread_t * p_intf = VLCIntf;
 328     playlist_t * p_playlist = pl_Hold( p_intf );
 329
 330     var_Get( p_playlist, "repeat", &val );
 331     if (!val.b_bool)
 332     {
 333         var_Set( p_playlist, "loop", val );
 334     }
 335     val.b_bool = !val.b_bool;
 336     var_Set( p_playlist, "repeat", val );
 337     if( val.b_bool )
 338     {
 339         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat One" ) );
 340         config_PutInt( p_playlist, "repeat", 1 );
 341     }
 342     else
 343     {
 344         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
 345         config_PutInt( p_playlist, "repeat", 0 );
 346     }
 347
 348     p_intf->p_sys->b_playmode_update = true;
 349     p_intf->p_sys->b_intf_update = true;
 350     pl_Release( p_intf );
 351 }
 352
 353 - (IBAction)loop:(id)sender
 354 {
 355     vlc_value_t val;
 356     intf_thread_t * p_intf = VLCIntf;
 357     playlist_t * p_playlist = pl_Hold( p_intf );
 358
 359     var_Get( p_playlist, "loop", &val );
 360     if (!val.b_bool)
 361     {
 362         var_Set( p_playlist, "repeat", val );
 363     }
 364     val.b_bool = !val.b_bool;
 365     var_Set( p_playlist, "loop", val );
 366     if( val.b_bool )
 367     {
 368         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat All" ) );
 369         config_PutInt( p_playlist, "loop", 1 );
 370     }
 371     else
 372     {
 373         vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Repeat Off" ) );
 374         config_PutInt( p_playlist, "loop", 0 );
 375     }
 376
 377     p_intf->p_sys->b_playmode_update = true;
 378     p_intf->p_sys->b_intf_update = true;
 379     pl_Release( p_intf );
 380 }
 381
 382 - (IBAction)forward:(id)sender
 383 {
 384     intf_thread_t * p_intf = VLCIntf;
 385     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_FORWARD_SHORT );
 386 }
 387
 388 - (IBAction)backward:(id)sender
 389 {
 390     vlc_value_t val;
 391     intf_thread_t * p_intf = VLCIntf;
 392     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_BACKWARD_SHORT );
 393 }
 394
 395
 396 - (IBAction)volumeUp:(id)sender
 397 {
 398     intf_thread_t * p_intf = VLCIntf;
 399     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_VOL_UP );
 400     /* Manage volume status */
 401     [o_main manageVolumeSlider];
 402 }
 403
 404 - (IBAction)volumeDown:(id)sender
 405 {
 406     intf_thread_t * p_intf = VLCIntf;
 407     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_VOL_DOWN );
 408     /* Manage volume status */
 409     [o_main manageVolumeSlider];
 410 }
 411
 412 - (IBAction)mute:(id)sender
 413 {
 414     intf_thread_t * p_intf = VLCIntf;
 415     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_VOL_MUTE );
 416     /* Manage volume status */
 417     [o_main manageVolumeSlider];
 418 }
 419
 420 - (IBAction)volumeSliderUpdated:(id)sender
 421 {
 422     intf_thread_t * p_intf = VLCIntf;
 423     playlist_t * p_playlist = pl_Hold( p_intf );
 424     audio_volume_t i_volume = (audio_volume_t)[sender intValue];
 425     int i_volume_step;
 426
 427     i_volume_step = config_GetInt( p_intf->p_libvlc, "volume-step" );
 428     aout_VolumeSet( p_playlist, i_volume * i_volume_step );
 429     pl_Release( p_playlist );
 430     /* Manage volume status */
 431     [o_main manageVolumeSlider];
 432 }
 433
 434 - (IBAction)showPosition: (id)sender
 435 {
 436     input_thread_t * p_input = pl_CurrentInput( VLCIntf );
 437     if( p_input != NULL )
 438     {
 439         vout_thread_t *p_vout = input_GetVout( p_input );
 440         if( p_vout != NULL )
 441         {
 442             var_SetInteger( VLCIntf->p_libvlc, "key-action", ACTIONID_POSITION );
 443             vlc_object_release( (vlc_object_t *)p_vout );
 444         }
 445         vlc_object_release( p_input );
 446     }
 447 }
 448
 449 - (IBAction)toogleFullscreen:(id)sender {
 450     NSMenuItem *o_mi = [[NSMenuItem alloc] initWithTitle: _NS("Fullscreen") action: nil keyEquivalent:@""];
 451     [self windowAction: [o_mi autorelease]];
 452 }
 453
 454 - (BOOL) isFullscreen {
 455     id o_vout_view = [self voutView];
 456     if( o_vout_view )
 457     {
 458         return [o_vout_view isFullscreen];
 459     }
 460     return NO;
 461 }
 462
 463 - (IBAction)windowAction:(id)sender
 464 {
 465     NSString *o_title = [sender title];
 466     input_thread_t * p_input = pl_CurrentInput( VLCIntf );
 467
 468     if( p_input != NULL )
 469     {
 470         vout_thread_t *p_vout = input_GetVout( p_input );
 471         if( p_vout != NULL )
 472         {
 473             id o_vout_view = [self voutView];
 474             if( o_vout_view )
 475             {
 476                 if( [o_title isEqualToString: _NS("Half Size") ] )
 477                     [o_vout_view scaleWindowWithFactor: 0.5 animate: YES];
 478                 else if( [o_title isEqualToString: _NS("Normal Size") ] )
 479                     [o_vout_view scaleWindowWithFactor: 1.0 animate: YES];
 480                 else if( [o_title isEqualToString: _NS("Double Size") ] )
 481                     [o_vout_view scaleWindowWithFactor: 2.0 animate: YES];
 482                 else if( [o_title isEqualToString: _NS("Float on Top") ] )
 483                     [o_vout_view toggleFloatOnTop];
 484                 else if( [o_title isEqualToString: _NS("Fit to Screen") ] )
 485                 {
 486                     id o_window = [o_vout_view voutWindow];
 487                     if( ![o_window isZoomed] )
 488                         [o_window performZoom:self];
 489                 }
 490                 else if( [o_title isEqualToString: _NS("Snapshot") ] )
 491                 {
 492                     [o_vout_view snapshot];
 493                 }
 494                 else
 495                 {
 496                     /* Fullscreen state for next time will be saved here too */
 497                     [o_vout_view toggleFullscreen];
 498                 }
 499             }
 500             vlc_object_release( (vlc_object_t *)p_vout );
 501         }
 502         else
 503         {
 504             playlist_t * p_playlist = pl_Hold( VLCIntf );
 505
 506             if( [o_title isEqualToString: _NS("Fullscreen")] ||
 507                 [sender isKindOfClass:[NSButton class]] )
 508             {
 509                 vlc_value_t val;
 510                 var_Get( p_playlist, "fullscreen", &val );
 511                 var_Set( p_playlist, "fullscreen", (vlc_value_t)!val.b_bool );
 512             }
 513
 514             pl_Release( VLCIntf );
 515         }
 516         vlc_object_release( p_input );
 517     }
 518 }
 519
 520 - (IBAction)telxTransparent:(id)sender
 521 {
 522     intf_thread_t * p_intf = VLCIntf;
 523     vlc_object_t *p_vbi;
 524     p_vbi = (vlc_object_t *) vlc_object_find_name( p_intf,
 525                     "zvbi", FIND_ANYWHERE );
 526     if( p_vbi )
 527     {
 528         var_SetBool( p_vbi, "vbi-opaque", [sender state] );
 529         [sender setState: ![sender state]];
 530         vlc_object_release( p_vbi );
 531     }
 532 }
 533
 534 - (IBAction)telxNavLink:(id)sender
 535 {
 536     intf_thread_t * p_intf = VLCIntf;
 537     vlc_object_t *p_vbi;
 538     int i_page = 0;
 539
 540     if( [[sender title] isEqualToString: _NS("Index")] )
 541         i_page = 'i' << 16;
 542     else if( [[sender title] isEqualToString: _NS("Red")] )
 543         i_page = 'r' << 16;
 544     else if( [[sender title] isEqualToString: _NS("Green")] )
 545         i_page = 'g' << 16;
 546     else if( [[sender title] isEqualToString: _NS("Yellow")] )
 547         i_page = 'y' << 16;
 548     else if( [[sender title] isEqualToString: _NS("Blue")] )
 549         i_page = 'b' << 16;
 550     if( i_page == 0 ) return;
 551
 552     p_vbi = (vlc_object_t *) vlc_object_find_name( p_intf,
 553                 "zvbi", FIND_ANYWHERE );
 554     if( p_vbi )
 555     {
 556         var_SetInteger( p_vbi, "vbi-page", i_page );
 557         vlc_object_release( p_vbi );
 558     }
 559 }
 560
 561 - (IBAction)lockVideosAspectRatio:(id)sender
 562 {
 563     if( [sender state] == NSOffState )
 564         [sender setState: NSOnState];
 565     else
 566         [sender setState: NSOffState];
 567
 568     b_lockAspectRatio = !b_lockAspectRatio;
 569 }
 570
 571 - (IBAction)addSubtitleFile:(id)sender
 572 {
 573     NSInteger i_returnValue = 0;
 574     input_thread_t * p_input = pl_CurrentInput( VLCIntf );
 575     if( !p_input ) return;
 576
 577     input_item_t *p_item = input_GetItem( p_input );
 578     if( !p_item ) return;
 579
 580     char *path = input_item_GetURI( p_item );
 581     if( !path ) path = strdup( "" );
 582
 583     NSOpenPanel * openPanel = [NSOpenPanel openPanel];
 584     [openPanel setCanChooseFiles: YES];
 585     [openPanel setCanChooseDirectories: NO];
 586     [openPanel setAllowsMultipleSelection: YES];
 587     i_returnValue = [openPanel runModalForDirectory: [NSString stringWithUTF8String: path] file: nil types: [NSArray arrayWithObjects: @"cdg",@"@idx",@"srt",@"sub",@"utf",@"ass",@"ssa",@"aqt",@"jss",@"psb",@"rt",@"smi", nil]];
 588     free( path );
 589
 590     if( i_returnValue == NSOKButton )
 591     {
 592         NSUInteger c = 0;
 593         if( !p_input ) return;
 594
 595         c = [[openPanel filenames] count];
 596
 597         for (int i = 0; i < [[openPanel filenames] count] ; i++)
 598         {
 599             msg_Dbg( VLCIntf, "loading subs from %s", [[[openPanel filenames] objectAtIndex: i] UTF8String] );
 600             if( input_AddSubtitle( p_input, [[[openPanel filenames] objectAtIndex: i] UTF8String], TRUE ) )
 601                 msg_Warn( VLCIntf, "unable to load subtitles from '%s'",
 602                          [[[openPanel filenames] objectAtIndex: i] UTF8String] );
 603         }
 604     }
 605 }
 606
 607 - (void)scrollWheel:(NSEvent *)theEvent
 608 {
 609     intf_thread_t * p_intf = VLCIntf;
 610     float f_yabsvalue = [theEvent deltaY] > 0.0f ? [theEvent deltaY] : -[theEvent deltaY];
 611     float f_xabsvalue = [theEvent deltaX] > 0.0f ? [theEvent deltaX] : -[theEvent deltaX];
 612     int i, i_yvlckey, i_xvlckey;
 613
 614     if ([theEvent deltaY] < 0.0f)
 615         i_yvlckey = KEY_MOUSEWHEELDOWN;
 616     else
 617         i_yvlckey = KEY_MOUSEWHEELUP;
 618
 619     if ([theEvent deltaX] < 0.0f)
 620         i_xvlckey = KEY_MOUSEWHEELRIGHT;
 621     else
 622         i_xvlckey = KEY_MOUSEWHEELLEFT;
 623
 624     /* Send multiple key event, depending on the intensity of the event */
 625     for (i = 0; i < (int)(f_yabsvalue/4.+1.) && f_yabsvalue > 0.05 ; i++)
 626         var_SetInteger( p_intf->p_libvlc, "key-pressed", i_yvlckey );
 627
 628     /* Prioritize Y event (sound volume) over X event */
 629     if (f_yabsvalue < 0.05)
 630     {
 631         for (i = 0; i < (int)(f_xabsvalue/6.+1.) && f_xabsvalue > 0.05; i++)
 632          var_SetInteger( p_intf->p_libvlc, "key-pressed", i_xvlckey );
 633     }
 634 }
 635
 636 - (BOOL)keyEvent:(NSEvent *)o_event
 637 {
 638     BOOL eventHandled = NO;
 639     unichar key = [[o_event charactersIgnoringModifiers] characterAtIndex: 0];
 640
 641     if( key )
 642     {
 643         input_thread_t * p_input = pl_CurrentInput( VLCIntf );
 644         if( p_input != NULL )
 645         {
 646             vout_thread_t *p_vout = input_GetVout( p_input );
 647
 648             if( p_vout != NULL )
 649             {
 650                 /* Escape */
 651                 if( key == (unichar) 0x1b )
 652                 {
 653                     id o_vout_view = [self voutView];
 654                     if( o_vout_view && [o_vout_view isFullscreen] )
 655                     {
 656                         [o_vout_view toggleFullscreen];
 657                         eventHandled = YES;
 658                     }
 659                 }
 660                 else if( key == ' ' )
 661                 {
 662                     [self play:self];
 663                     eventHandled = YES;
 664                 }
 665                 vlc_object_release( (vlc_object_t *)p_vout );
 666             }
 667             vlc_object_release( p_input );
 668         }
 669     }
 670     return eventHandled;
 671 }
 672
 673 - (void)setupVarMenuItem:(NSMenuItem *)o_mi
 674                     target:(vlc_object_t *)p_object
 675                     var:(const char *)psz_variable
 676                     selector:(SEL)pf_callback
 677 {
 678     vlc_value_t val, text;
 679     int i_type = var_Type( p_object, psz_variable );
 680
 681     switch( i_type & VLC_VAR_TYPE )
 682     {
 683     case VLC_VAR_VOID:
 684     case VLC_VAR_BOOL:
 685     case VLC_VAR_VARIABLE:
 686     case VLC_VAR_STRING:
 687     case VLC_VAR_INTEGER:
 688         break;
 689     default:
 690         /* Variable doesn't exist or isn't handled */
 691         return;
 692     }
 693
 694     /* Make sure we want to display the variable */
 695     if( i_type & VLC_VAR_HASCHOICE )
 696     {
 697         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
 698         if( val.i_int == 0 ) return;
 699         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
 700             return;
 701     }
 702
 703     /* Get the descriptive name of the variable */
 704     var_Change( p_object, psz_variable, VLC_VAR_GETTEXT, &text, NULL );
 705     [o_mi setTitle: [[VLCMain sharedInstance] localizedString: text.psz_string ?
 706                                         text.psz_string : psz_variable ]];
 707
 708     if( i_type & VLC_VAR_HASCHOICE )
 709     {
 710         NSMenu *o_menu = [o_mi submenu];
 711
 712         [self setupVarMenu: o_menu forMenuItem: o_mi target:p_object
 713                         var:psz_variable selector:pf_callback];
 714
 715         free( text.psz_string );
 716         return;
 717     }
 718     if( var_Get( p_object, psz_variable, &val ) < 0 )
 719     {
 720         return;
 721     }
 722
 723     VLCAutoGeneratedMenuContent *o_data;
 724     switch( i_type & VLC_VAR_TYPE )
 725     {
 726     case VLC_VAR_VOID:
 727         o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
 728                 andValue: val ofType: i_type];
 729         [o_mi setRepresentedObject: [o_data autorelease]];
 730         break;
 731
 732     case VLC_VAR_BOOL:
 733         o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
 734                 andValue: val ofType: i_type];
 735         [o_mi setRepresentedObject: [o_data autorelease]];
 736         if( !( i_type & VLC_VAR_ISCOMMAND ) )
 737             [o_mi setState: val.b_bool ? TRUE : FALSE ];
 738         break;
 739
 740     default:
 741         break;
 742     }
 743
 744     if( ( i_type & VLC_VAR_TYPE ) == VLC_VAR_STRING ) free( val.psz_string );
 745     free( text.psz_string );
 746 }
 747
 748
 749 - (void)setupVarMenu:(NSMenu *)o_menu
 750                     forMenuItem: (NSMenuItem *)o_parent
 751                     target:(vlc_object_t *)p_object
 752                     var:(const char *)psz_variable
 753                     selector:(SEL)pf_callback
 754 {
 755     vlc_value_t val, val_list, text_list;
 756     int i_type, i, i_nb_items;
 757
 758     /* remove previous items */
 759     i_nb_items = [o_menu numberOfItems];
 760     for( i = 0; i < i_nb_items; i++ )
 761     {
 762         [o_menu removeItemAtIndex: 0];
 763     }
 764
 765     /* Check the type of the object variable */
 766     i_type = var_Type( p_object, psz_variable );
 767
 768     /* Make sure we want to display the variable */
 769     if( i_type & VLC_VAR_HASCHOICE )
 770     {
 771         var_Change( p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
 772         if( val.i_int == 0 ) return;
 773         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
 774             return;
 775     }
 776     else
 777     {
 778         return;
 779     }
 780
 781     switch( i_type & VLC_VAR_TYPE )
 782     {
 783     case VLC_VAR_VOID:
 784     case VLC_VAR_BOOL:
 785     case VLC_VAR_VARIABLE:
 786     case VLC_VAR_STRING:
 787     case VLC_VAR_INTEGER:
 788         break;
 789     default:
 790         /* Variable doesn't exist or isn't handled */
 791         return;
 792     }
 793
 794     if( var_Get( p_object, psz_variable, &val ) < 0 )
 795     {
 796         return;
 797     }
 798
 799     if( var_Change( p_object, psz_variable, VLC_VAR_GETLIST,
 800                     &val_list, &text_list ) < 0 )
 801     {
 802         if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
 803         return;
 804     }
 805
 806     /* make (un)sensitive */
 807     [o_parent setEnabled: ( val_list.p_list->i_count > 1 )];
 808
 809     /* Aspect Ratio */
 810     if( [[o_parent title] isEqualToString: _NS("Aspect-ratio")] == YES )
 811     {
 812         NSMenuItem *o_lmi_tmp2;
 813         o_lmi_tmp2 = [o_menu addItemWithTitle: _NS("Lock Aspect Ratio") action: @selector(lockVideosAspectRatio:) keyEquivalent: @""];
 814         [o_lmi_tmp2 setTarget: self];
 815         [o_lmi_tmp2 setEnabled: YES];
 816         [o_lmi_tmp2 setState: b_lockAspectRatio];
 817         [o_parent setEnabled: YES];
 818         [o_menu addItem: [NSMenuItem separatorItem]];
 819     }
 820
 821     /* special case for the subtitles items */
 822     if( [[o_parent title] isEqualToString: _NS("Subtitles Track")] == YES )
 823     {
 824         NSMenuItem * o_lmi_tmp;
 825         o_lmi_tmp = [o_menu addItemWithTitle: _NS("Open File...") action: @selector(addSubtitleFile:) keyEquivalent: @""];
 826         [o_lmi_tmp setTarget: self];
 827         [o_lmi_tmp setEnabled: YES];
 828         [o_parent setEnabled: YES];
 829         [o_menu addItem: [NSMenuItem separatorItem]];
 830     }
 831
 832     for( i = 0; i < val_list.p_list->i_count; i++ )
 833     {
 834         NSMenuItem * o_lmi;
 835         NSString *o_title = @"";
 836         VLCAutoGeneratedMenuContent *o_data;
 837
 838         switch( i_type & VLC_VAR_TYPE )
 839         {
 840         case VLC_VAR_STRING:
 841
 842             o_title = [[VLCMain sharedInstance] localizedString: text_list.p_list->p_values[i].psz_string ?
 843                 text_list.p_list->p_values[i].psz_string : val_list.p_list->p_values[i].psz_string ];
 844
 845             o_lmi = [o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""];
 846             o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
 847                     andValue: val_list.p_list->p_values[i] ofType: i_type];
 848             [o_lmi setRepresentedObject: [o_data autorelease]];
 849             [o_lmi setTarget: self];
 850
 851             if( !strcmp( val.psz_string, val_list.p_list->p_values[i].psz_string ) && !( i_type & VLC_VAR_ISCOMMAND ) )
 852                 [o_lmi setState: TRUE ];
 853
 854             break;
 855
 856         case VLC_VAR_INTEGER:
 857
 858              o_title = text_list.p_list->p_values[i].psz_string ?
 859                                  [[VLCMain sharedInstance] localizedString: text_list.p_list->p_values[i].psz_string] :
 860                                  [NSString stringWithFormat: @"%d",
 861                                  val_list.p_list->p_values[i].i_int];
 862
 863             o_lmi = [o_menu addItemWithTitle: o_title action: pf_callback keyEquivalent: @""];
 864             o_data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName: psz_variable ofObject: p_object
 865                     andValue: val_list.p_list->p_values[i] ofType: i_type];
 866             [o_lmi setRepresentedObject: [o_data autorelease]];
 867             [o_lmi setTarget: self];
 868
 869             if( val_list.p_list->p_values[i].i_int == val.i_int && !( i_type & VLC_VAR_ISCOMMAND ) )
 870                 [o_lmi setState: TRUE ];
 871             break;
 872
 873         default:
 874           break;
 875         }
 876     }
 877
 878     /* special case for the subtitles sub-menu
 879      * In case that we don't have any subs, we don't want a separator item at the end */
 880     if( [[o_parent title] isEqualToString: _NS("Subtitles Track")] == YES )
 881     {
 882         if( [o_menu numberOfItems] == 2 )
 883             [o_menu removeItemAtIndex: 1];
 884     }
 885
 886     /* clean up everything */
 887     if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
 888     var_FreeList( &val_list, &text_list );
 889 }
 890
 891 - (IBAction)toggleVar:(id)sender
 892 {
 893     NSMenuItem *o_mi = (NSMenuItem *)sender;
 894     VLCAutoGeneratedMenuContent *o_data = [o_mi representedObject];
 895     [NSThread detachNewThreadSelector: @selector(toggleVarThread:)
 896         toTarget: self withObject: o_data];
 897
 898     return;
 899 }
 900
 901 - (int)toggleVarThread: (id)data
 902 {
 903     vlc_object_t *p_object;
 904     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
 905
 906     assert([data isKindOfClass:[VLCAutoGeneratedMenuContent class]]);
 907     VLCAutoGeneratedMenuContent *menuContent = (VLCAutoGeneratedMenuContent *)data;
 908
 909     vlc_thread_set_priority( VLCIntf , VLC_THREAD_PRIORITY_LOW );
 910
 911     p_object = [menuContent vlcObject];
 912
 913     if( p_object != NULL )
 914     {
 915         var_Set( p_object, [menuContent name], [menuContent value] );
 916         vlc_object_release( p_object );
 917         [o_pool release];
 918         return true;
 919     }
 920     [o_pool release];
 921     return VLC_EGENERIC;
 922 }
 923
 924 - (IBAction)goToSpecificTime:(id)sender
 925 {
 926     if( sender == o_specificTime_cancel_btn )
 927     {
 928         [NSApp endSheet: o_specificTime_win];
 929         [o_specificTime_win close];
 930     }
 931     else if( sender == o_specificTime_ok_btn )
 932     {
 933         input_thread_t * p_input = pl_CurrentInput( VLCIntf );
 934         if( p_input )
 935         {
 936             unsigned int timeInSec = 0;
 937             NSString * fieldContent = [o_specificTime_enter_fld stringValue];
 938             if( [[fieldContent componentsSeparatedByString: @":"] count] > 1 &&
 939                 [[fieldContent componentsSeparatedByString: @":"] count] <= 3 )
 940             {
 941                 NSArray * ourTempArray = \
 942                     [fieldContent componentsSeparatedByString: @":"];
 943
 944                 if( [[fieldContent componentsSeparatedByString: @":"] count] == 3 )
 945                 {
 946                     timeInSec += ([[ourTempArray objectAtIndex: 0] intValue] * 3600); //h
 947                     timeInSec += ([[ourTempArray objectAtIndex: 1] intValue] * 60); //m
 948                     timeInSec += [[ourTempArray objectAtIndex: 2] intValue];        //s
 949                 }
 950                 else
 951                 {
 952                     timeInSec += ([[ourTempArray objectAtIndex: 0] intValue] * 60); //m
 953                     timeInSec += [[ourTempArray objectAtIndex: 1] intValue]; //s
 954                 }
 955             }
 956             else
 957                 timeInSec = [fieldContent intValue];
 958
 959             input_Control( p_input, INPUT_SET_TIME, (int64_t)(timeInSec * 1000000));
 960             vlc_object_release( p_input );
 961         }
 962
 963         [NSApp endSheet: o_specificTime_win];
 964         [o_specificTime_win close];
 965     }
 966     else
 967     {
 968         input_thread_t * p_input = pl_CurrentInput( VLCIntf );
 969         if( p_input )
 970         {
 971             /* we can obviously only do that if an input is available */
 972             vlc_value_t pos, length;
 973             var_Get( p_input, "time", &pos );
 974             [o_specificTime_enter_fld setIntValue: (pos.i_time / 1000000)];
 975             var_Get( p_input, "length", &length );
 976             [o_specificTime_stepper setMaxValue: (length.i_time / 1000000)];
 977
 978             [NSApp beginSheet: o_specificTime_win modalForWindow: \
 979                 [NSApp mainWindow] modalDelegate: self didEndSelector: nil \
 980                 contextInfo: nil];
 981             [o_specificTime_win makeKeyWindow];
 982             vlc_object_release( p_input );
 983         }
 984     }
 985 }
 986
 987 - (id)fspanel
 988 {
 989     if( o_fs_panel )
 990         return o_fs_panel;
 991     else
 992     {
 993         msg_Err( VLCIntf, "FSPanel is nil" );
 994         return NULL;
 995     }
 996 }
 997
 998 @end
 999
1000 @implementation VLCControls (NSMenuValidation)
1001
1002 - (BOOL)validateMenuItem:(NSMenuItem *)o_mi
1003 {
1004     BOOL bEnabled = TRUE;
1005     vlc_value_t val;
1006     intf_thread_t * p_intf = VLCIntf;
1007     playlist_t * p_playlist = pl_Hold( p_intf );
1008     input_thread_t * p_input = playlist_CurrentInput( p_playlist );
1009
1010     if( [[o_mi title] isEqualToString: _NS("Faster")] ||
1011         [[o_mi title] isEqualToString: _NS("Slower")] )
1012     {
1013         if( p_input != NULL )
1014         {
1015             bEnabled = var_GetBool( p_input, "can-rate" );
1016         }
1017         else
1018         {
1019             bEnabled = FALSE;
1020         }
1021     }
1022     else if( [[o_mi title] isEqualToString: _NS("Stop")] )
1023     {
1024         if( p_input == NULL )
1025         {
1026             bEnabled = FALSE;
1027         }
1028         [o_main setupMenus]; /* Make sure input menu is up to date */
1029     }
1030     else if( [[o_mi title] isEqualToString: _NS("Previous")] ||
1031              [[o_mi title] isEqualToString: _NS("Next")] )
1032     {
1033         PL_LOCK;
1034         bEnabled = playlist_CurrentSize( p_playlist ) > 1;
1035         PL_UNLOCK;
1036     }
1037     else if( [[o_mi title] isEqualToString: _NS("Random")] )
1038     {
1039         int i_state;
1040         var_Get( p_playlist, "random", &val );
1041         i_state = val.b_bool ? NSOnState : NSOffState;
1042         [o_mi setState: i_state];
1043     }
1044     else if( [[o_mi title] isEqualToString: _NS("Repeat One")] )
1045     {
1046         int i_state;
1047         var_Get( p_playlist, "repeat", &val );
1048         i_state = val.b_bool ? NSOnState : NSOffState;
1049         [o_mi setState: i_state];
1050     }
1051     else if( [[o_mi title] isEqualToString: _NS("Repeat All")] )
1052     {
1053         int i_state;
1054         var_Get( p_playlist, "loop", &val );
1055         i_state = val.b_bool ? NSOnState : NSOffState;
1056         [o_mi setState: i_state];
1057     }
1058     else if( [[o_mi title] isEqualToString: _NS("Step Forward")] ||
1059              [[o_mi title] isEqualToString: _NS("Step Backward")] ||
1060              [[o_mi title] isEqualToString: _NS("Jump To Time")])
1061     {
1062         if( p_input != NULL )
1063         {
1064             var_Get( p_input, "can-seek", &val);
1065             bEnabled = val.b_bool;
1066         }
1067         else bEnabled = FALSE;
1068     }
1069     else if( [[o_mi title] isEqualToString: _NS("Mute")] )
1070     {
1071         [o_mi setState: p_intf->p_sys->b_mute ? NSOnState : NSOffState];
1072         [o_main setupMenus]; /* Make sure audio menu is up to date */
1073     }
1074     else if( [[o_mi title] isEqualToString: _NS("Half Size")] ||
1075                 [[o_mi title] isEqualToString: _NS("Normal Size")] ||
1076                 [[o_mi title] isEqualToString: _NS("Double Size")] ||
1077                 [[o_mi title] isEqualToString: _NS("Fit to Screen")] ||
1078                 [[o_mi title] isEqualToString: _NS("Snapshot")] ||
1079                 [[o_mi title] isEqualToString: _NS("Fullscreen")] ||
1080                 [[o_mi title] isEqualToString: _NS("Float on Top")] )
1081     {
1082         id o_window;
1083         NSArray *o_windows = [NSApp orderedWindows];
1084         NSEnumerator *o_enumerator = [o_windows objectEnumerator];
1085         bEnabled = FALSE;
1086
1087         if( p_input != NULL )
1088         {
1089             vout_thread_t *p_vout = input_GetVout( p_input );
1090             if( p_vout != NULL )
1091             {
1092                 if( [[o_mi title] isEqualToString: _NS("Float on Top")] )
1093                 {
1094                     var_Get( p_vout, "video-on-top", &val );
1095                     [o_mi setState: val.b_bool ?  NSOnState : NSOffState];
1096                 }
1097
1098                 while( (o_window = [o_enumerator nextObject]))
1099                 {
1100                     if( [[o_window className] isEqualToString: @"VLCVoutWindow"] ||
1101                                 [[[VLCMain sharedInstance] embeddedList]
1102                                 windowContainsEmbedded: o_window])
1103                     {
1104                         bEnabled = TRUE;
1105                         break;
1106                     }
1107                 }
1108
1109                 vlc_object_release( (vlc_object_t *)p_vout );
1110             }
1111             vlc_object_release( p_input );
1112         }
1113         if( [[o_mi title] isEqualToString: _NS("Fullscreen")] )
1114         {
1115             var_Get( p_playlist, "fullscreen", &val );
1116             [o_mi setState: val.b_bool];
1117             bEnabled = TRUE;
1118         }
1119         [o_main setupMenus]; /* Make sure video menu is up to date */
1120     }
1121
1122     /* Special case for telx menu */
1123     if( [[o_mi title] isEqualToString: _NS("Normal Size")] )
1124     {
1125         NSMenuItem *item = [[o_mi menu] itemWithTitle:_NS("Teletext")];
1126                 bool b_telx = p_input && var_GetInteger( p_input, "teletext-es" ) >= 0;
1127
1128         [[item submenu] setAutoenablesItems:NO];
1129         for( int k=0; k < [[item submenu] numberOfItems]; k++ )
1130         {
1131             [[[item submenu] itemAtIndex:k] setEnabled: b_telx];
1132         }
1133     }
1134
1135     if( p_input ) vlc_object_release( p_input );
1136     pl_Release( p_intf );
1137
1138     return( bEnabled );
1139 }
1140
1141 @end
1142
1143 /*****************************************************************************
1144  * VLCAutoGeneratedMenuContent implementation
1145  *****************************************************************************
1146  * Object connected to a playlistitem which remembers the data belonging to
1147  * the variable of the autogenerated menu
1148  *****************************************************************************/
1149 @implementation VLCAutoGeneratedMenuContent
1150
1151 -(id) initWithVariableName:(const char *)name ofObject:(vlc_object_t *)object
1152         andValue:(vlc_value_t)val ofType:(int)type
1153 {
1154     self = [super init];
1155
1156     if( self != nil )
1157     {
1158         _vlc_object = vlc_object_hold( object );
1159         psz_name = strdup( name );
1160         i_type = type;
1161         value = val;
1162         if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING )
1163             value.psz_string = strdup( val.psz_string );
1164     }
1165
1166     return( self );
1167 }
1168
1169 - (void)dealloc
1170 {
1171     vlc_object_release( _vlc_object );
1172     if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING )
1173         free( value.psz_string );
1174     free( psz_name );
1175     [super dealloc];
1176 }
1177
1178 - (const char *)name
1179 {
1180     return psz_name;
1181 }
1182
1183 - (vlc_value_t)value
1184 {
1185     return value;
1186 }
1187
1188 - (vlc_object_t *)vlcObject
1189 {
1190     return vlc_object_hold( _vlc_object );
1191 }
1192
1193
1194 - (int)type
1195 {
1196     return i_type;
1197 }
1198
1199 @end
1200
1201
1202 /*****************************************************************************
1203  * VLCTimeField implementation
1204  *****************************************************************************
1205  * we need this to catch our click-event in the controller window
1206  *****************************************************************************/
1207
1208 @implementation VLCTimeField
1209 - (void)mouseDown: (NSEvent *)ourEvent
1210 {
1211     if( [ourEvent clickCount] > 1 )
1212         [[[VLCMain sharedInstance] controls] goToSpecificTime: nil];
1213     else
1214         [[VLCMain sharedInstance] timeFieldWasClicked: self];
1215 }
1216 @end