libvo/cocoa_common.m

   1 #import <Cocoa/Cocoa.h>
   2 #import <OpenGL/OpenGL.h>
   3 #import <QuartzCore/QuartzCore.h>
   4 #import <CoreServices/CoreServices.h> // for CGDisplayHideCursor
   5 #include "cocoa_common.h"
   6
   7 #include "options.h"
   8 #include "video_out.h"
   9 #include "aspect.h"
  10
  11 #include "mp_fifo.h"
  12 #include "talloc.h"
  13
  14 #include "input/input.h"
  15 #include "input/keycodes.h"
  16 #include "osx_common.h"
  17 #include "mp_msg.h"
  18
  19 #define NSLeftAlternateKeyMask (0x000020 | NSAlternateKeyMask)
  20 #define NSRightAlternateKeyMask (0x000040 | NSAlternateKeyMask)
  21
  22 @interface GLMPlayerWindow : NSWindow <NSWindowDelegate>
  23 - (BOOL) canBecomeKeyWindow;
  24 - (BOOL) canBecomeMainWindow;
  25 - (void) fullscreen;
  26 - (void) mouseEvent:(NSEvent *)theEvent;
  27 - (void) mulSize:(float)multiplier;
  28 - (void) setContentSize:(NSSize)newSize keepCentered:(BOOL)keepCentered;
  29 @end
  30
  31 @interface GLMPlayerOpenGLView : NSView
  32 @end
  33
  34 struct vo_cocoa_state {
  35     NSAutoreleasePool *pool;
  36     GLMPlayerWindow *window;
  37     NSOpenGLContext *glContext;
  38
  39     NSSize current_video_size;
  40     NSSize previous_video_size;
  41
  42     NSRect screen_frame;
  43     NSScreen *screen_handle;
  44     NSArray *screen_array;
  45
  46     NSInteger windowed_mask;
  47     NSInteger fullscreen_mask;
  48
  49     NSRect windowed_frame;
  50
  51     NSString *window_title;
  52
  53     int last_screensaver_update;
  54
  55     bool did_resize;
  56     bool out_fs_resize;
  57 };
  58
  59 struct vo_cocoa_state *s;
  60
  61 struct vo *l_vo;
  62
  63 // local function definitions
  64 struct vo_cocoa_state *vo_cocoa_init_state(void);
  65 void update_screen_info(void);
  66 void resize_window(struct vo *vo);
  67 void create_menu(void);
  68
  69 struct vo_cocoa_state *vo_cocoa_init_state(void)
  70 {
  71     struct vo_cocoa_state *s = talloc_ptrtype(NULL, s);
  72     *s = (struct vo_cocoa_state){
  73         .did_resize = NO,
  74         .current_video_size = {0,0},
  75         .previous_video_size = {0,0},
  76         .windowed_mask = NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask|NSResizableWindowMask,
  77         .fullscreen_mask = NSBorderlessWindowMask,
  78         .windowed_frame = {{0,0},{0,0}},
  79         .out_fs_resize = NO,
  80     };
  81     return s;
  82 }
  83
  84 int vo_cocoa_init(struct vo *vo)
  85 {
  86     s = vo_cocoa_init_state();
  87     s->pool = [[NSAutoreleasePool alloc] init];
  88     NSApplicationLoad();
  89     NSApp = [NSApplication sharedApplication];
  90     [NSApp setActivationPolicy: NSApplicationActivationPolicyRegular];
  91
  92     return 1;
  93 }
  94
  95 void vo_cocoa_uninit(struct vo *vo)
  96 {
  97     CGDisplayShowCursor(kCGDirectMainDisplay);
  98     [s->window release];
  99     s->window = nil;
 100     [s->glContext release];
 101     s->glContext = nil;
 102     [s->pool release];
 103     s->pool = nil;
 104
 105     talloc_free(s);
 106 }
 107
 108 void update_screen_info(void)
 109 {
 110     s->screen_array = [NSScreen screens];
 111     if (xinerama_screen >= (int)[s->screen_array count]) {
 112         mp_msg(MSGT_VO, MSGL_INFO, "[cocoa] Device ID %d does not exist, falling back to main device\n", xinerama_screen);
 113         xinerama_screen = -1;
 114     }
 115
 116     if (xinerama_screen < 0) { // default behaviour
 117         if (! (s->screen_handle = [s->window screen]) )
 118             s->screen_handle = [s->screen_array objectAtIndex:0];
 119     } else {
 120         s->screen_handle = [s->screen_array objectAtIndex:(xinerama_screen)];
 121     }
 122
 123     s->screen_frame = [s->screen_handle frame];
 124 }
 125
 126 void vo_cocoa_update_xinerama_info(struct vo *vo)
 127 {
 128     update_screen_info();
 129     aspect_save_screenres(vo, s->screen_frame.size.width, s->screen_frame.size.height);
 130 }
 131
 132 int vo_cocoa_change_attributes(struct vo *vo)
 133 {
 134     return 0;
 135 }
 136
 137 void resize_window(struct vo *vo)
 138 {
 139     vo->dwidth = [[s->window contentView] frame].size.width;
 140     vo->dheight = [[s->window contentView] frame].size.height;
 141     [s->glContext update];
 142 }
 143
 144 int vo_cocoa_create_window(struct vo *vo, uint32_t d_width,
 145                            uint32_t d_height, uint32_t flags)
 146 {
 147     if (s->current_video_size.width > 0 || s->current_video_size.height > 0)
 148         s->previous_video_size = s->current_video_size;
 149     s->current_video_size = NSMakeSize(d_width, d_height);
 150
 151     if (!(s->window || s->glContext)) { // keep using the same window
 152         s->window = [[GLMPlayerWindow alloc] initWithContentRect:NSMakeRect(0, 0, d_width, d_height)
 153                                              styleMask:s->windowed_mask
 154                                              backing:NSBackingStoreBuffered defer:NO];
 155
 156         GLMPlayerOpenGLView *glView = [[GLMPlayerOpenGLView alloc] initWithFrame:NSMakeRect(0, 0, 100, 100)];
 157
 158         NSOpenGLPixelFormatAttribute attrs[] = {
 159             NSOpenGLPFADoubleBuffer, // double buffered
 160             NSOpenGLPFADepthSize, (NSOpenGLPixelFormatAttribute)16, // 16 bit depth buffer
 161             (NSOpenGLPixelFormatAttribute)0
 162         };
 163
 164         NSOpenGLPixelFormat *pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attrs];
 165         s->glContext = [[NSOpenGLContext alloc] initWithFormat:pixelFormat shareContext:nil];
 166
 167         create_menu();
 168
 169         [s->window setContentView:glView];
 170         [glView release];
 171         [s->window setAcceptsMouseMovedEvents:YES];
 172         [s->glContext setView:glView];
 173         [s->glContext makeCurrentContext];
 174
 175         [NSApp setDelegate:s->window];
 176         [s->window setDelegate:s->window];
 177         [s->window setContentSize:s->current_video_size];
 178         [s->window setContentAspectRatio:s->current_video_size];
 179         [s->window center];
 180
 181         if (flags & VOFLAG_HIDDEN) {
 182             [s->window orderOut:nil];
 183         } else {
 184             [s->window makeKeyAndOrderFront:nil];
 185             [NSApp activateIgnoringOtherApps:YES];
 186         }
 187
 188         if (flags & VOFLAG_FULLSCREEN)
 189             vo_cocoa_fullscreen(vo);
 190     } else {
 191         if (s->current_video_size.width  != s->previous_video_size.width ||
 192             s->current_video_size.height != s->previous_video_size.height) {
 193             if (vo_fs) {
 194                 // we will resize as soon as we get out of fullscreen
 195                 s->out_fs_resize = YES;
 196             } else {
 197                 // only if we are not in fullscreen and the video size did change
 198                 // we actually resize the window and set a new aspect ratio
 199                 [s->window setContentSize:s->current_video_size keepCentered:YES];
 200                 [s->window setContentAspectRatio:s->current_video_size];
 201             }
 202         }
 203     }
 204
 205     resize_window(vo);
 206
 207     if (s->window_title)
 208         [s->window_title release];
 209
 210     s->window_title = [[NSString alloc] initWithUTF8String:vo_get_window_title(vo)];
 211     [s->window setTitle: s->window_title];
 212
 213     return 0;
 214 }
 215
 216 void vo_cocoa_swap_buffers()
 217 {
 218     [s->glContext flushBuffer];
 219 }
 220
 221 int vo_cocoa_check_events(struct vo *vo)
 222 {
 223     //update activity every 30 seconds to prevent
 224     //screensaver from starting up.
 225     int curTime = TickCount()/60;
 226     if (curTime - s->last_screensaver_update >= 30 || s->last_screensaver_update == 0)
 227     {
 228         UpdateSystemActivity(UsrActivity);
 229         s->last_screensaver_update = curTime;
 230     }
 231
 232     NSEvent *event;
 233     event = [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:nil
 234                    inMode:NSEventTrackingRunLoopMode dequeue:YES];
 235     if (event == nil)
 236         return 0;
 237     l_vo = vo;
 238     [NSApp sendEvent:event];
 239     l_vo = nil;
 240
 241     if (s->did_resize) {
 242         s->did_resize = NO;
 243         resize_window(vo);
 244         return VO_EVENT_RESIZE;
 245     }
 246     // Without SDL's bootstrap code (include SDL.h in mplayer.c),
 247     // on Leopard, we have trouble to get the play window automatically focused
 248     // when the app is actived. The Following code fix this problem.
 249 #ifndef CONFIG_SDL
 250     if ([event type] == NSAppKitDefined
 251             && [event subtype] == NSApplicationActivatedEventType) {
 252         [s->window makeMainWindow];
 253         [s->window makeKeyAndOrderFront:nil];
 254     }
 255 #endif
 256     return 0;
 257 }
 258
 259 void vo_cocoa_fullscreen(struct vo *vo)
 260 {
 261     [s->window fullscreen];
 262     resize_window(vo);
 263 }
 264
 265 int vo_cocoa_swap_interval(int enabled)
 266 {
 267     [s->glContext setValues:&enabled forParameter:NSOpenGLCPSwapInterval];
 268     return 0;
 269 }
 270
 271 void create_menu()
 272 {
 273     NSMenu *menu;
 274     NSMenuItem *menuItem;
 275
 276     menu = [[NSMenu new] autorelease];
 277     menuItem = [[NSMenuItem new] autorelease];
 278     [menu addItem: menuItem];
 279     [NSApp setMainMenu: menu];
 280
 281     menu = [[NSMenu alloc] initWithTitle:@"Movie"];
 282     menuItem = [[NSMenuItem alloc] initWithTitle:@"Half Size" action:@selector(halfSize) keyEquivalent:@"0"]; [menu addItem:menuItem];
 283     menuItem = [[NSMenuItem alloc] initWithTitle:@"Normal Size" action:@selector(normalSize) keyEquivalent:@"1"]; [menu addItem:menuItem];
 284     menuItem = [[NSMenuItem alloc] initWithTitle:@"Double Size" action:@selector(doubleSize) keyEquivalent:@"2"]; [menu addItem:menuItem];
 285
 286     menuItem = [[NSMenuItem alloc] initWithTitle:@"Movie" action:nil keyEquivalent:@""];
 287     [menuItem setSubmenu:menu];
 288     [[NSApp mainMenu] addItem:menuItem];
 289
 290     [menu release];
 291     [menuItem release];
 292 }
 293
 294 @implementation GLMPlayerWindow
 295
 296 - (void) windowDidResize:(NSNotification *) notification
 297 {
 298     if (l_vo)
 299         s->did_resize = YES;
 300 }
 301
 302 - (void) fullscreen
 303 {
 304     if (!vo_fs) {
 305         [NSApp setPresentationOptions:NSApplicationPresentationHideDock|NSApplicationPresentationHideMenuBar];
 306         s->windowed_frame = [self frame];
 307         [self setHasShadow:NO];
 308         [self setStyleMask:s->fullscreen_mask];
 309         [self setFrame:s->screen_frame display:YES animate:NO];
 310         [self setLevel:NSNormalWindowLevel + 1];
 311         CGDisplayHideCursor(kCGDirectMainDisplay);
 312         vo_fs = VO_TRUE;
 313     } else {
 314         [NSApp setPresentationOptions:NSApplicationPresentationDefault];
 315         [self setHasShadow:YES];
 316         [self setStyleMask:s->windowed_mask];
 317         [self setTitle:s->window_title];
 318         [self setFrame:s->windowed_frame display:YES animate:NO];
 319         if (s->out_fs_resize) {
 320             [self setContentSize:s->current_video_size keepCentered:YES];
 321             s->out_fs_resize = NO;
 322         }
 323         [self setContentAspectRatio:s->current_video_size];
 324         [self setLevel:NSNormalWindowLevel];
 325         CGDisplayShowCursor(kCGDirectMainDisplay);
 326         vo_fs = VO_FALSE;
 327     }
 328 }
 329
 330 - (BOOL) canBecomeMainWindow { return YES; }
 331 - (BOOL) canBecomeKeyWindow { return YES; }
 332 - (BOOL) acceptsFirstResponder { return YES; }
 333 - (BOOL) becomeFirstResponder { return YES; }
 334 - (BOOL) resignFirstResponder { return YES; }
 335 - (BOOL) windowShouldClose:(id)sender
 336 {
 337     mplayer_put_key(l_vo->key_fifo, KEY_CLOSE_WIN);
 338     // We have to wait for MPlayer to handle this,
 339     // otherwise we are in trouble if the
 340     // KEY_CLOSE_WIN handler is disabled
 341     return NO;
 342 }
 343
 344 - (void) handleQuitEvent:(NSAppleEventDescriptor*)e withReplyEvent:(NSAppleEventDescriptor*)r
 345 {
 346     mplayer_put_key(l_vo->key_fifo, KEY_CLOSE_WIN);
 347 }
 348
 349 - (void) keyDown:(NSEvent *)theEvent
 350 {
 351     unsigned char charcode;
 352     if (([theEvent modifierFlags] & NSRightAlternateKeyMask) == NSRightAlternateKeyMask)
 353         charcode = *[[theEvent characters] UTF8String];
 354     else
 355         charcode = [[theEvent charactersIgnoringModifiers] characterAtIndex:0];
 356
 357     int key = convert_key([theEvent keyCode], charcode);
 358
 359     if (key > -1) {
 360         if ([theEvent modifierFlags] & NSShiftKeyMask)
 361             key |= KEY_MODIFIER_SHIFT;
 362         if ([theEvent modifierFlags] & NSControlKeyMask)
 363             key |= KEY_MODIFIER_CTRL;
 364         if (([theEvent modifierFlags] & NSLeftAlternateKeyMask) == NSLeftAlternateKeyMask)
 365             key |= KEY_MODIFIER_ALT;
 366         if ([theEvent modifierFlags] & NSCommandKeyMask)
 367             key |= KEY_MODIFIER_META;
 368         mplayer_put_key(l_vo->key_fifo, key);
 369     }
 370 }
 371
 372 - (void) mouseDragged:(NSEvent *)theEvent
 373 {
 374     [self mouseEvent: theEvent];
 375 }
 376
 377 - (void) mouseDown:(NSEvent *)theEvent
 378 {
 379     [self mouseEvent: theEvent];
 380 }
 381
 382 - (void) mouseUp:(NSEvent *)theEvent
 383 {
 384     [self mouseEvent: theEvent];
 385 }
 386
 387 - (void) rightMouseDown:(NSEvent *)theEvent
 388 {
 389     [self mouseEvent: theEvent];
 390 }
 391
 392 - (void) rightMouseUp:(NSEvent *)theEvent
 393 {
 394     [self mouseEvent: theEvent];
 395 }
 396
 397 - (void) otherMouseDown:(NSEvent *)theEvent
 398 {
 399     [self mouseEvent: theEvent];
 400 }
 401
 402 - (void) otherMouseUp:(NSEvent *)theEvent
 403 {
 404     [self mouseEvent: theEvent];
 405 }
 406
 407 - (void) scrollWheel:(NSEvent *)theEvent
 408 {
 409     if ([theEvent deltaY] > 0)
 410         mplayer_put_key(l_vo->key_fifo, MOUSE_BTN3);
 411     else
 412         mplayer_put_key(l_vo->key_fifo, MOUSE_BTN4);
 413 }
 414
 415 - (void) mouseEvent:(NSEvent *)theEvent
 416 {
 417     if ( [theEvent buttonNumber] >= 0 && [theEvent buttonNumber] <= 9 )
 418     {
 419         int buttonNumber = [theEvent buttonNumber];
 420         // Fix to mplayer defined button order: left, middle, right
 421         if (buttonNumber == 1)
 422             buttonNumber = 2;
 423         else if (buttonNumber == 2)
 424             buttonNumber = 1;
 425         switch ([theEvent type]) {
 426             case NSLeftMouseDown:
 427                 break;
 428             case NSRightMouseDown:
 429             case NSOtherMouseDown:
 430                 mplayer_put_key(l_vo->key_fifo, (MOUSE_BTN0 + buttonNumber) | MP_KEY_DOWN);
 431                 break;
 432             case NSLeftMouseUp:
 433                 break;
 434             case NSRightMouseUp:
 435             case NSOtherMouseUp:
 436                 mplayer_put_key(l_vo->key_fifo, MOUSE_BTN0 + buttonNumber);
 437                 break;
 438         }
 439     }
 440 }
 441
 442 - (void) applicationWillBecomeActive:(NSNotification *)aNotification
 443 {
 444     if (vo_fs) {
 445         [s->window setLevel:NSNormalWindowLevel + 1];
 446         [NSApp setPresentationOptions:NSApplicationPresentationHideDock|NSApplicationPresentationHideMenuBar];
 447         [s->window makeKeyAndOrderFront:nil];
 448         [NSApp activateIgnoringOtherApps: YES];
 449     }
 450 }
 451
 452 - (void) applicationWillResignActive:(NSNotification *)aNotification
 453 {
 454     if (vo_fs) {
 455         [s->window setLevel:NSNormalWindowLevel];
 456         [NSApp setPresentationOptions:NSApplicationPresentationDefault];
 457     }
 458 }
 459
 460 - (void) applicationDidFinishLaunching:(NSNotification*)notification
 461 {
 462     // Install an event handler so the Quit menu entry works
 463     // The proper way using NSApp setDelegate: and
 464     // applicationShouldTerminate: does not work,
 465     // probably NSApplication never installs its handler.
 466     [[NSAppleEventManager sharedAppleEventManager]
 467         setEventHandler:self
 468         andSelector:@selector(handleQuitEvent:withReplyEvent:)
 469         forEventClass:kCoreEventClass
 470         andEventID:kAEQuitApplication];
 471 }
 472
 473 - (void) normalSize
 474 {
 475     if (!vo_fs)
 476       [self setContentSize:s->current_video_size keepCentered:YES];
 477 }
 478
 479 - (void) halfSize { [self mulSize:0.5f];}
 480
 481 - (void) doubleSize { [self mulSize:2.0f];}
 482
 483 - (void) mulSize:(float)multiplier
 484 {
 485     if (!vo_fs) {
 486         NSSize size = [[self contentView] frame].size;
 487         size.width  = s->current_video_size.width  * (multiplier);
 488         size.height = s->current_video_size.height * (multiplier);
 489         [self setContentSize:size keepCentered:YES];
 490     }
 491 }
 492
 493 - (void) setContentSize:(NSSize)ns keepCentered:(BOOL)keepCentered
 494 {
 495     if (keepCentered) {
 496         NSRect nf = [self frame];
 497         NSRect vf = [[self screen] visibleFrame];
 498         int title_height = nf.size.height - [[self contentView] bounds].size.height;
 499         double ratio = (double)ns.width / (double)ns.height;
 500
 501         // clip the new size to the visibleFrame's size if needed
 502         if (ns.width > vf.size.width || ns.height + title_height > vf.size.height) {
 503             ns = vf.size;
 504             ns.height -= title_height; // make space for the title bar
 505
 506             if (ns.width > ns.height) {
 507                 ns.height = ((double)ns.width * 1/ratio + 0.5);
 508             } else {
 509                 ns.width = ((double)ns.height * ratio + 0.5);
 510             }
 511         }
 512
 513         int dw = nf.size.width - ns.width;
 514         int dh = nf.size.height - ns.height - title_height;
 515
 516         nf.origin.x += dw / 2;
 517         nf.origin.y += dh / 2;
 518
 519         [self setFrame: NSMakeRect(nf.origin.x, nf.origin.y, ns.width, ns.height + title_height) display:YES animate:NO];
 520     } else {
 521         [self setContentSize:ns];
 522     }
 523 }
 524 @end
 525
 526 @implementation GLMPlayerOpenGLView
 527 - (void) drawRect: (NSRect)rect
 528 {
 529     [[NSColor clearColor] set];
 530     NSRectFill([self bounds]);
 531 }
 532 @end