1/* 2 * QEMU Cocoa CG display driver 3 * 4 * Copyright (c) 2008 Mike Kronenberg 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 25#include "qemu/osdep.h" 26 27#import <Cocoa/Cocoa.h> 28#include <crt_externs.h> 29 30#include "qemu/help-texts.h" 31#include "qemu-main.h" 32#include "ui/clipboard.h" 33#include "ui/console.h" 34#include "ui/input.h" 35#include "ui/kbd-state.h" 36#include "sysemu/sysemu.h" 37#include "sysemu/runstate.h" 38#include "sysemu/runstate-action.h" 39#include "sysemu/cpu-throttle.h" 40#include "qapi/error.h" 41#include "qapi/qapi-commands-block.h" 42#include "qapi/qapi-commands-machine.h" 43#include "qapi/qapi-commands-misc.h" 44#include "sysemu/blockdev.h" 45#include "qemu-version.h" 46#include "qemu/cutils.h" 47#include "qemu/main-loop.h" 48#include "qemu/module.h" 49#include "qemu/error-report.h" 50#include <Carbon/Carbon.h> 51#include "hw/core/cpu.h" 52 53#ifndef MAC_OS_X_VERSION_10_13 54#define MAC_OS_X_VERSION_10_13 101300 55#endif 56 57/* 10.14 deprecates NSOnState and NSOffState in favor of 58 * NSControlStateValueOn/Off, which were introduced in 10.13. 59 * Define for older versions 60 */ 61#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_13 62#define NSControlStateValueOn NSOnState 63#define NSControlStateValueOff NSOffState 64#endif 65 66//#define DEBUG 67 68#ifdef DEBUG 69#define COCOA_DEBUG(...) { (void) fprintf (stdout, __VA_ARGS__); } 70#else 71#define COCOA_DEBUG(...) ((void) 0) 72#endif 73 74#define cgrect(nsrect) (*(CGRect *)&(nsrect)) 75 76#define UC_CTRL_KEY "\xe2\x8c\x83" 77#define UC_ALT_KEY "\xe2\x8c\xa5" 78 79typedef struct { 80 int width; 81 int height; 82} QEMUScreen; 83 84static void cocoa_update(DisplayChangeListener *dcl, 85 int x, int y, int w, int h); 86 87static void cocoa_switch(DisplayChangeListener *dcl, 88 DisplaySurface *surface); 89 90static void cocoa_refresh(DisplayChangeListener *dcl); 91 92static NSWindow *normalWindow; 93static const DisplayChangeListenerOps dcl_ops = { 94 .dpy_name = "cocoa", 95 .dpy_gfx_update = cocoa_update, 96 .dpy_gfx_switch = cocoa_switch, 97 .dpy_refresh = cocoa_refresh, 98}; 99static DisplayChangeListener dcl = { 100 .ops = &dcl_ops, 101}; 102static int last_buttons; 103static int cursor_hide = 1; 104static int left_command_key_enabled = 1; 105static bool swap_opt_cmd; 106 107static bool stretch_video; 108static NSTextField *pauseLabel; 109 110static bool allow_events; 111 112static NSInteger cbchangecount = -1; 113static QemuClipboardInfo *cbinfo; 114static QemuEvent cbevent; 115 116// Utility functions to run specified code block with iothread lock held 117typedef void (^CodeBlock)(void); 118typedef bool (^BoolCodeBlock)(void); 119 120static void with_iothread_lock(CodeBlock block) 121{ 122 bool locked = qemu_mutex_iothread_locked(); 123 if (!locked) { 124 qemu_mutex_lock_iothread(); 125 } 126 block(); 127 if (!locked) { 128 qemu_mutex_unlock_iothread(); 129 } 130} 131 132static bool bool_with_iothread_lock(BoolCodeBlock block) 133{ 134 bool locked = qemu_mutex_iothread_locked(); 135 bool val; 136 137 if (!locked) { 138 qemu_mutex_lock_iothread(); 139 } 140 val = block(); 141 if (!locked) { 142 qemu_mutex_unlock_iothread(); 143 } 144 return val; 145} 146 147// Mac to QKeyCode conversion 148static const int mac_to_qkeycode_map[] = { 149 [kVK_ANSI_A] = Q_KEY_CODE_A, 150 [kVK_ANSI_B] = Q_KEY_CODE_B, 151 [kVK_ANSI_C] = Q_KEY_CODE_C, 152 [kVK_ANSI_D] = Q_KEY_CODE_D, 153 [kVK_ANSI_E] = Q_KEY_CODE_E, 154 [kVK_ANSI_F] = Q_KEY_CODE_F, 155 [kVK_ANSI_G] = Q_KEY_CODE_G, 156 [kVK_ANSI_H] = Q_KEY_CODE_H, 157 [kVK_ANSI_I] = Q_KEY_CODE_I, 158 [kVK_ANSI_J] = Q_KEY_CODE_J, 159 [kVK_ANSI_K] = Q_KEY_CODE_K, 160 [kVK_ANSI_L] = Q_KEY_CODE_L, 161 [kVK_ANSI_M] = Q_KEY_CODE_M, 162 [kVK_ANSI_N] = Q_KEY_CODE_N, 163 [kVK_ANSI_O] = Q_KEY_CODE_O, 164 [kVK_ANSI_P] = Q_KEY_CODE_P, 165 [kVK_ANSI_Q] = Q_KEY_CODE_Q, 166 [kVK_ANSI_R] = Q_KEY_CODE_R, 167 [kVK_ANSI_S] = Q_KEY_CODE_S, 168 [kVK_ANSI_T] = Q_KEY_CODE_T, 169 [kVK_ANSI_U] = Q_KEY_CODE_U, 170 [kVK_ANSI_V] = Q_KEY_CODE_V, 171 [kVK_ANSI_W] = Q_KEY_CODE_W, 172 [kVK_ANSI_X] = Q_KEY_CODE_X, 173 [kVK_ANSI_Y] = Q_KEY_CODE_Y, 174 [kVK_ANSI_Z] = Q_KEY_CODE_Z, 175 176 [kVK_ANSI_0] = Q_KEY_CODE_0, 177 [kVK_ANSI_1] = Q_KEY_CODE_1, 178 [kVK_ANSI_2] = Q_KEY_CODE_2, 179 [kVK_ANSI_3] = Q_KEY_CODE_3, 180 [kVK_ANSI_4] = Q_KEY_CODE_4, 181 [kVK_ANSI_5] = Q_KEY_CODE_5, 182 [kVK_ANSI_6] = Q_KEY_CODE_6, 183 [kVK_ANSI_7] = Q_KEY_CODE_7, 184 [kVK_ANSI_8] = Q_KEY_CODE_8, 185 [kVK_ANSI_9] = Q_KEY_CODE_9, 186 187 [kVK_ANSI_Grave] = Q_KEY_CODE_GRAVE_ACCENT, 188 [kVK_ANSI_Minus] = Q_KEY_CODE_MINUS, 189 [kVK_ANSI_Equal] = Q_KEY_CODE_EQUAL, 190 [kVK_Delete] = Q_KEY_CODE_BACKSPACE, 191 [kVK_CapsLock] = Q_KEY_CODE_CAPS_LOCK, 192 [kVK_Tab] = Q_KEY_CODE_TAB, 193 [kVK_Return] = Q_KEY_CODE_RET, 194 [kVK_ANSI_LeftBracket] = Q_KEY_CODE_BRACKET_LEFT, 195 [kVK_ANSI_RightBracket] = Q_KEY_CODE_BRACKET_RIGHT, 196 [kVK_ANSI_Backslash] = Q_KEY_CODE_BACKSLASH, 197 [kVK_ANSI_Semicolon] = Q_KEY_CODE_SEMICOLON, 198 [kVK_ANSI_Quote] = Q_KEY_CODE_APOSTROPHE, 199 [kVK_ANSI_Comma] = Q_KEY_CODE_COMMA, 200 [kVK_ANSI_Period] = Q_KEY_CODE_DOT, 201 [kVK_ANSI_Slash] = Q_KEY_CODE_SLASH, 202 [kVK_Space] = Q_KEY_CODE_SPC, 203 204 [kVK_ANSI_Keypad0] = Q_KEY_CODE_KP_0, 205 [kVK_ANSI_Keypad1] = Q_KEY_CODE_KP_1, 206 [kVK_ANSI_Keypad2] = Q_KEY_CODE_KP_2, 207 [kVK_ANSI_Keypad3] = Q_KEY_CODE_KP_3, 208 [kVK_ANSI_Keypad4] = Q_KEY_CODE_KP_4, 209 [kVK_ANSI_Keypad5] = Q_KEY_CODE_KP_5, 210 [kVK_ANSI_Keypad6] = Q_KEY_CODE_KP_6, 211 [kVK_ANSI_Keypad7] = Q_KEY_CODE_KP_7, 212 [kVK_ANSI_Keypad8] = Q_KEY_CODE_KP_8, 213 [kVK_ANSI_Keypad9] = Q_KEY_CODE_KP_9, 214 [kVK_ANSI_KeypadDecimal] = Q_KEY_CODE_KP_DECIMAL, 215 [kVK_ANSI_KeypadEnter] = Q_KEY_CODE_KP_ENTER, 216 [kVK_ANSI_KeypadPlus] = Q_KEY_CODE_KP_ADD, 217 [kVK_ANSI_KeypadMinus] = Q_KEY_CODE_KP_SUBTRACT, 218 [kVK_ANSI_KeypadMultiply] = Q_KEY_CODE_KP_MULTIPLY, 219 [kVK_ANSI_KeypadDivide] = Q_KEY_CODE_KP_DIVIDE, 220 [kVK_ANSI_KeypadEquals] = Q_KEY_CODE_KP_EQUALS, 221 [kVK_ANSI_KeypadClear] = Q_KEY_CODE_NUM_LOCK, 222 223 [kVK_UpArrow] = Q_KEY_CODE_UP, 224 [kVK_DownArrow] = Q_KEY_CODE_DOWN, 225 [kVK_LeftArrow] = Q_KEY_CODE_LEFT, 226 [kVK_RightArrow] = Q_KEY_CODE_RIGHT, 227 228 [kVK_Help] = Q_KEY_CODE_INSERT, 229 [kVK_Home] = Q_KEY_CODE_HOME, 230 [kVK_PageUp] = Q_KEY_CODE_PGUP, 231 [kVK_PageDown] = Q_KEY_CODE_PGDN, 232 [kVK_End] = Q_KEY_CODE_END, 233 [kVK_ForwardDelete] = Q_KEY_CODE_DELETE, 234 235 [kVK_Escape] = Q_KEY_CODE_ESC, 236 237 /* The Power key can't be used directly because the operating system uses 238 * it. This key can be emulated by using it in place of another key such as 239 * F1. Don't forget to disable the real key binding. 240 */ 241 /* [kVK_F1] = Q_KEY_CODE_POWER, */ 242 243 [kVK_F1] = Q_KEY_CODE_F1, 244 [kVK_F2] = Q_KEY_CODE_F2, 245 [kVK_F3] = Q_KEY_CODE_F3, 246 [kVK_F4] = Q_KEY_CODE_F4, 247 [kVK_F5] = Q_KEY_CODE_F5, 248 [kVK_F6] = Q_KEY_CODE_F6, 249 [kVK_F7] = Q_KEY_CODE_F7, 250 [kVK_F8] = Q_KEY_CODE_F8, 251 [kVK_F9] = Q_KEY_CODE_F9, 252 [kVK_F10] = Q_KEY_CODE_F10, 253 [kVK_F11] = Q_KEY_CODE_F11, 254 [kVK_F12] = Q_KEY_CODE_F12, 255 [kVK_F13] = Q_KEY_CODE_PRINT, 256 [kVK_F14] = Q_KEY_CODE_SCROLL_LOCK, 257 [kVK_F15] = Q_KEY_CODE_PAUSE, 258 259 // JIS keyboards only 260 [kVK_JIS_Yen] = Q_KEY_CODE_YEN, 261 [kVK_JIS_Underscore] = Q_KEY_CODE_RO, 262 [kVK_JIS_KeypadComma] = Q_KEY_CODE_KP_COMMA, 263 [kVK_JIS_Eisu] = Q_KEY_CODE_MUHENKAN, 264 [kVK_JIS_Kana] = Q_KEY_CODE_HENKAN, 265 266 /* 267 * The eject and volume keys can't be used here because they are handled at 268 * a lower level than what an Application can see. 269 */ 270}; 271 272static int cocoa_keycode_to_qemu(int keycode) 273{ 274 if (ARRAY_SIZE(mac_to_qkeycode_map) <= keycode) { 275 error_report("(cocoa) warning unknown keycode 0x%x", keycode); 276 return 0; 277 } 278 return mac_to_qkeycode_map[keycode]; 279} 280 281/* Displays an alert dialog box with the specified message */ 282static void QEMU_Alert(NSString *message) 283{ 284 NSAlert *alert; 285 alert = [NSAlert new]; 286 [alert setMessageText: message]; 287 [alert runModal]; 288} 289 290/* Handles any errors that happen with a device transaction */ 291static void handleAnyDeviceErrors(Error * err) 292{ 293 if (err) { 294 QEMU_Alert([NSString stringWithCString: error_get_pretty(err) 295 encoding: NSASCIIStringEncoding]); 296 error_free(err); 297 } 298} 299 300/* 301 ------------------------------------------------------ 302 QemuCocoaView 303 ------------------------------------------------------ 304*/ 305@interface QemuCocoaView : NSView 306{ 307 QEMUScreen screen; 308 NSWindow *fullScreenWindow; 309 float cx,cy,cw,ch,cdx,cdy; 310 pixman_image_t *pixman_image; 311 QKbdState *kbd; 312 BOOL isMouseGrabbed; 313 BOOL isFullscreen; 314 BOOL isAbsoluteEnabled; 315 CFMachPortRef eventsTap; 316} 317- (void) switchSurface:(pixman_image_t *)image; 318- (void) grabMouse; 319- (void) ungrabMouse; 320- (void) toggleFullScreen:(id)sender; 321- (void) setFullGrab:(id)sender; 322- (void) handleMonitorInput:(NSEvent *)event; 323- (bool) handleEvent:(NSEvent *)event; 324- (bool) handleEventLocked:(NSEvent *)event; 325- (void) setAbsoluteEnabled:(BOOL)tIsAbsoluteEnabled; 326/* The state surrounding mouse grabbing is potentially confusing. 327 * isAbsoluteEnabled tracks qemu_input_is_absolute() [ie "is the emulated 328 * pointing device an absolute-position one?"], but is only updated on 329 * next refresh. 330 * isMouseGrabbed tracks whether GUI events are directed to the guest; 331 * it controls whether special keys like Cmd get sent to the guest, 332 * and whether we capture the mouse when in non-absolute mode. 333 */ 334- (BOOL) isMouseGrabbed; 335- (BOOL) isAbsoluteEnabled; 336- (float) cdx; 337- (float) cdy; 338- (QEMUScreen) gscreen; 339- (void) raiseAllKeys; 340@end 341 342QemuCocoaView *cocoaView; 343 344static CGEventRef handleTapEvent(CGEventTapProxy proxy, CGEventType type, CGEventRef cgEvent, void *userInfo) 345{ 346 QemuCocoaView *view = userInfo; 347 NSEvent *event = [NSEvent eventWithCGEvent:cgEvent]; 348 if ([view isMouseGrabbed] && [view handleEvent:event]) { 349 COCOA_DEBUG("Global events tap: qemu handled the event, capturing!\n"); 350 return NULL; 351 } 352 COCOA_DEBUG("Global events tap: qemu did not handle the event, letting it through...\n"); 353 354 return cgEvent; 355} 356 357@implementation QemuCocoaView 358- (id)initWithFrame:(NSRect)frameRect 359{ 360 COCOA_DEBUG("QemuCocoaView: initWithFrame\n"); 361 362 self = [super initWithFrame:frameRect]; 363 if (self) { 364 365 screen.width = frameRect.size.width; 366 screen.height = frameRect.size.height; 367 kbd = qkbd_state_init(dcl.con); 368 369 } 370 return self; 371} 372 373- (void) dealloc 374{ 375 COCOA_DEBUG("QemuCocoaView: dealloc\n"); 376 377 if (pixman_image) { 378 pixman_image_unref(pixman_image); 379 } 380 381 qkbd_state_free(kbd); 382 383 if (eventsTap) { 384 CFRelease(eventsTap); 385 } 386 387 [super dealloc]; 388} 389 390- (BOOL) isOpaque 391{ 392 return YES; 393} 394 395- (BOOL) screenContainsPoint:(NSPoint) p 396{ 397 return (p.x > -1 && p.x < screen.width && p.y > -1 && p.y < screen.height); 398} 399 400/* Get location of event and convert to virtual screen coordinate */ 401- (CGPoint) screenLocationOfEvent:(NSEvent *)ev 402{ 403 NSWindow *eventWindow = [ev window]; 404 // XXX: Use CGRect and -convertRectFromScreen: to support macOS 10.10 405 CGRect r = CGRectZero; 406 r.origin = [ev locationInWindow]; 407 if (!eventWindow) { 408 if (!isFullscreen) { 409 return [[self window] convertRectFromScreen:r].origin; 410 } else { 411 CGPoint locationInSelfWindow = [[self window] convertRectFromScreen:r].origin; 412 CGPoint loc = [self convertPoint:locationInSelfWindow fromView:nil]; 413 if (stretch_video) { 414 loc.x /= cdx; 415 loc.y /= cdy; 416 } 417 return loc; 418 } 419 } else if ([[self window] isEqual:eventWindow]) { 420 if (!isFullscreen) { 421 return r.origin; 422 } else { 423 CGPoint loc = [self convertPoint:r.origin fromView:nil]; 424 if (stretch_video) { 425 loc.x /= cdx; 426 loc.y /= cdy; 427 } 428 return loc; 429 } 430 } else { 431 return [[self window] convertRectFromScreen:[eventWindow convertRectToScreen:r]].origin; 432 } 433} 434 435- (void) hideCursor 436{ 437 if (!cursor_hide) { 438 return; 439 } 440 [NSCursor hide]; 441} 442 443- (void) unhideCursor 444{ 445 if (!cursor_hide) { 446 return; 447 } 448 [NSCursor unhide]; 449} 450 451- (void) drawRect:(NSRect) rect 452{ 453 COCOA_DEBUG("QemuCocoaView: drawRect\n"); 454 455 // get CoreGraphic context 456 CGContextRef viewContextRef = [[NSGraphicsContext currentContext] CGContext]; 457 458 CGContextSetInterpolationQuality (viewContextRef, kCGInterpolationNone); 459 CGContextSetShouldAntialias (viewContextRef, NO); 460 461 // draw screen bitmap directly to Core Graphics context 462 if (!pixman_image) { 463 // Draw request before any guest device has set up a framebuffer: 464 // just draw an opaque black rectangle 465 CGContextSetRGBFillColor(viewContextRef, 0, 0, 0, 1.0); 466 CGContextFillRect(viewContextRef, NSRectToCGRect(rect)); 467 } else { 468 int w = pixman_image_get_width(pixman_image); 469 int h = pixman_image_get_height(pixman_image); 470 int bitsPerPixel = PIXMAN_FORMAT_BPP(pixman_image_get_format(pixman_image)); 471 int stride = pixman_image_get_stride(pixman_image); 472 CGDataProviderRef dataProviderRef = CGDataProviderCreateWithData( 473 NULL, 474 pixman_image_get_data(pixman_image), 475 stride * h, 476 NULL 477 ); 478 CGImageRef imageRef = CGImageCreate( 479 w, //width 480 h, //height 481 DIV_ROUND_UP(bitsPerPixel, 8) * 2, //bitsPerComponent 482 bitsPerPixel, //bitsPerPixel 483 stride, //bytesPerRow 484 CGColorSpaceCreateWithName(kCGColorSpaceSRGB), //colorspace 485 kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst, //bitmapInfo 486 dataProviderRef, //provider 487 NULL, //decode 488 0, //interpolate 489 kCGRenderingIntentDefault //intent 490 ); 491 // selective drawing code (draws only dirty rectangles) (OS X >= 10.4) 492 const NSRect *rectList; 493 NSInteger rectCount; 494 int i; 495 CGImageRef clipImageRef; 496 CGRect clipRect; 497 498 [self getRectsBeingDrawn:&rectList count:&rectCount]; 499 for (i = 0; i < rectCount; i++) { 500 clipRect.origin.x = rectList[i].origin.x / cdx; 501 clipRect.origin.y = (float)h - (rectList[i].origin.y + rectList[i].size.height) / cdy; 502 clipRect.size.width = rectList[i].size.width / cdx; 503 clipRect.size.height = rectList[i].size.height / cdy; 504 clipImageRef = CGImageCreateWithImageInRect( 505 imageRef, 506 clipRect 507 ); 508 CGContextDrawImage (viewContextRef, cgrect(rectList[i]), clipImageRef); 509 CGImageRelease (clipImageRef); 510 } 511 CGImageRelease (imageRef); 512 CGDataProviderRelease(dataProviderRef); 513 } 514} 515 516- (void) setContentDimensions 517{ 518 COCOA_DEBUG("QemuCocoaView: setContentDimensions\n"); 519 520 if (isFullscreen) { 521 cdx = [[NSScreen mainScreen] frame].size.width / (float)screen.width; 522 cdy = [[NSScreen mainScreen] frame].size.height / (float)screen.height; 523 524 /* stretches video, but keeps same aspect ratio */ 525 if (stretch_video == true) { 526 /* use smallest stretch value - prevents clipping on sides */ 527 if (MIN(cdx, cdy) == cdx) { 528 cdy = cdx; 529 } else { 530 cdx = cdy; 531 } 532 } else { /* No stretching */ 533 cdx = cdy = 1; 534 } 535 cw = screen.width * cdx; 536 ch = screen.height * cdy; 537 cx = ([[NSScreen mainScreen] frame].size.width - cw) / 2.0; 538 cy = ([[NSScreen mainScreen] frame].size.height - ch) / 2.0; 539 } else { 540 cx = 0; 541 cy = 0; 542 cw = screen.width; 543 ch = screen.height; 544 cdx = 1.0; 545 cdy = 1.0; 546 } 547} 548 549- (void) updateUIInfoLocked 550{ 551 /* Must be called with the iothread lock, i.e. via updateUIInfo */ 552 NSSize frameSize; 553 QemuUIInfo info; 554 555 if (!qemu_console_is_graphic(dcl.con)) { 556 return; 557 } 558 559 if ([self window]) { 560 NSDictionary *description = [[[self window] screen] deviceDescription]; 561 CGDirectDisplayID display = [[description objectForKey:@"NSScreenNumber"] unsignedIntValue]; 562 NSSize screenSize = [[[self window] screen] frame].size; 563 CGSize screenPhysicalSize = CGDisplayScreenSize(display); 564 CVDisplayLinkRef displayLink; 565 566 frameSize = isFullscreen ? screenSize : [self frame].size; 567 568 if (!CVDisplayLinkCreateWithCGDisplay(display, &displayLink)) { 569 CVTime period = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(displayLink); 570 CVDisplayLinkRelease(displayLink); 571 if (!(period.flags & kCVTimeIsIndefinite)) { 572 update_displaychangelistener(&dcl, 573 1000 * period.timeValue / period.timeScale); 574 info.refresh_rate = (int64_t)1000 * period.timeScale / period.timeValue; 575 } 576 } 577 578 info.width_mm = frameSize.width / screenSize.width * screenPhysicalSize.width; 579 info.height_mm = frameSize.height / screenSize.height * screenPhysicalSize.height; 580 } else { 581 frameSize = [self frame].size; 582 info.width_mm = 0; 583 info.height_mm = 0; 584 } 585 586 info.xoff = 0; 587 info.yoff = 0; 588 info.width = frameSize.width; 589 info.height = frameSize.height; 590 591 dpy_set_ui_info(dcl.con, &info, TRUE); 592} 593 594- (void) updateUIInfo 595{ 596 if (!allow_events) { 597 /* 598 * Don't try to tell QEMU about UI information in the application 599 * startup phase -- we haven't yet registered dcl with the QEMU UI 600 * layer. 601 * When cocoa_display_init() does register the dcl, the UI layer 602 * will call cocoa_switch(), which will call updateUIInfo, so 603 * we don't lose any information here. 604 */ 605 return; 606 } 607 608 with_iothread_lock(^{ 609 [self updateUIInfoLocked]; 610 }); 611} 612 613- (void)viewDidMoveToWindow 614{ 615 [self updateUIInfo]; 616} 617 618- (void) switchSurface:(pixman_image_t *)image 619{ 620 COCOA_DEBUG("QemuCocoaView: switchSurface\n"); 621 622 int w = pixman_image_get_width(image); 623 int h = pixman_image_get_height(image); 624 /* cdx == 0 means this is our very first surface, in which case we need 625 * to recalculate the content dimensions even if it happens to be the size 626 * of the initial empty window. 627 */ 628 bool isResize = (w != screen.width || h != screen.height || cdx == 0.0); 629 630 int oldh = screen.height; 631 if (isResize) { 632 // Resize before we trigger the redraw, or we'll redraw at the wrong size 633 COCOA_DEBUG("switchSurface: new size %d x %d\n", w, h); 634 screen.width = w; 635 screen.height = h; 636 [self setContentDimensions]; 637 [self setFrame:NSMakeRect(cx, cy, cw, ch)]; 638 } 639 640 // update screenBuffer 641 if (pixman_image) { 642 pixman_image_unref(pixman_image); 643 } 644 645 pixman_image = image; 646 647 // update windows 648 if (isFullscreen) { 649 [[fullScreenWindow contentView] setFrame:[[NSScreen mainScreen] frame]]; 650 [normalWindow setFrame:NSMakeRect([normalWindow frame].origin.x, [normalWindow frame].origin.y - h + oldh, w, h + [normalWindow frame].size.height - oldh) display:NO animate:NO]; 651 } else { 652 if (qemu_name) 653 [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s", qemu_name]]; 654 [normalWindow setFrame:NSMakeRect([normalWindow frame].origin.x, [normalWindow frame].origin.y - h + oldh, w, h + [normalWindow frame].size.height - oldh) display:YES animate:NO]; 655 } 656 657 if (isResize) { 658 [normalWindow center]; 659 } 660} 661 662- (void) toggleFullScreen:(id)sender 663{ 664 COCOA_DEBUG("QemuCocoaView: toggleFullScreen\n"); 665 666 if (isFullscreen) { // switch from fullscreen to desktop 667 isFullscreen = FALSE; 668 [self ungrabMouse]; 669 [self setContentDimensions]; 670 [fullScreenWindow close]; 671 [normalWindow setContentView: self]; 672 [normalWindow makeKeyAndOrderFront: self]; 673 [NSMenu setMenuBarVisible:YES]; 674 } else { // switch from desktop to fullscreen 675 isFullscreen = TRUE; 676 [normalWindow orderOut: nil]; /* Hide the window */ 677 [self grabMouse]; 678 [self setContentDimensions]; 679 [NSMenu setMenuBarVisible:NO]; 680 fullScreenWindow = [[NSWindow alloc] initWithContentRect:[[NSScreen mainScreen] frame] 681 styleMask:NSWindowStyleMaskBorderless 682 backing:NSBackingStoreBuffered 683 defer:NO]; 684 [fullScreenWindow setAcceptsMouseMovedEvents: YES]; 685 [fullScreenWindow setHasShadow:NO]; 686 [fullScreenWindow setBackgroundColor: [NSColor blackColor]]; 687 [self setFrame:NSMakeRect(cx, cy, cw, ch)]; 688 [[fullScreenWindow contentView] addSubview: self]; 689 [fullScreenWindow makeKeyAndOrderFront:self]; 690 } 691} 692 693- (void) setFullGrab:(id)sender 694{ 695 COCOA_DEBUG("QemuCocoaView: setFullGrab\n"); 696 697 CGEventMask mask = CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventKeyUp) | CGEventMaskBit(kCGEventFlagsChanged); 698 eventsTap = CGEventTapCreate(kCGHIDEventTap, kCGHeadInsertEventTap, kCGEventTapOptionDefault, 699 mask, handleTapEvent, self); 700 if (!eventsTap) { 701 warn_report("Could not create event tap, system key combos will not be captured.\n"); 702 return; 703 } else { 704 COCOA_DEBUG("Global events tap created! Will capture system key combos.\n"); 705 } 706 707 CFRunLoopRef runLoop = CFRunLoopGetCurrent(); 708 if (!runLoop) { 709 warn_report("Could not obtain current CF RunLoop, system key combos will not be captured.\n"); 710 return; 711 } 712 713 CFRunLoopSourceRef tapEventsSrc = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventsTap, 0); 714 if (!tapEventsSrc ) { 715 warn_report("Could not obtain current CF RunLoop, system key combos will not be captured.\n"); 716 return; 717 } 718 719 CFRunLoopAddSource(runLoop, tapEventsSrc, kCFRunLoopDefaultMode); 720 CFRelease(tapEventsSrc); 721} 722 723- (void) toggleKey: (int)keycode { 724 qkbd_state_key_event(kbd, keycode, !qkbd_state_key_get(kbd, keycode)); 725} 726 727// Does the work of sending input to the monitor 728- (void) handleMonitorInput:(NSEvent *)event 729{ 730 int keysym = 0; 731 int control_key = 0; 732 733 // if the control key is down 734 if ([event modifierFlags] & NSEventModifierFlagControl) { 735 control_key = 1; 736 } 737 738 /* translates Macintosh keycodes to QEMU's keysym */ 739 740 static const int without_control_translation[] = { 741 [0 ... 0xff] = 0, // invalid key 742 743 [kVK_UpArrow] = QEMU_KEY_UP, 744 [kVK_DownArrow] = QEMU_KEY_DOWN, 745 [kVK_RightArrow] = QEMU_KEY_RIGHT, 746 [kVK_LeftArrow] = QEMU_KEY_LEFT, 747 [kVK_Home] = QEMU_KEY_HOME, 748 [kVK_End] = QEMU_KEY_END, 749 [kVK_PageUp] = QEMU_KEY_PAGEUP, 750 [kVK_PageDown] = QEMU_KEY_PAGEDOWN, 751 [kVK_ForwardDelete] = QEMU_KEY_DELETE, 752 [kVK_Delete] = QEMU_KEY_BACKSPACE, 753 }; 754 755 static const int with_control_translation[] = { 756 [0 ... 0xff] = 0, // invalid key 757 758 [kVK_UpArrow] = QEMU_KEY_CTRL_UP, 759 [kVK_DownArrow] = QEMU_KEY_CTRL_DOWN, 760 [kVK_RightArrow] = QEMU_KEY_CTRL_RIGHT, 761 [kVK_LeftArrow] = QEMU_KEY_CTRL_LEFT, 762 [kVK_Home] = QEMU_KEY_CTRL_HOME, 763 [kVK_End] = QEMU_KEY_CTRL_END, 764 [kVK_PageUp] = QEMU_KEY_CTRL_PAGEUP, 765 [kVK_PageDown] = QEMU_KEY_CTRL_PAGEDOWN, 766 }; 767 768 if (control_key != 0) { /* If the control key is being used */ 769 if ([event keyCode] < ARRAY_SIZE(with_control_translation)) { 770 keysym = with_control_translation[[event keyCode]]; 771 } 772 } else { 773 if ([event keyCode] < ARRAY_SIZE(without_control_translation)) { 774 keysym = without_control_translation[[event keyCode]]; 775 } 776 } 777 778 // if not a key that needs translating 779 if (keysym == 0) { 780 NSString *ks = [event characters]; 781 if ([ks length] > 0) { 782 keysym = [ks characterAtIndex:0]; 783 } 784 } 785 786 if (keysym) { 787 qemu_text_console_put_keysym(NULL, keysym); 788 } 789} 790 791- (bool) handleEvent:(NSEvent *)event 792{ 793 return bool_with_iothread_lock(^{ 794 return [self handleEventLocked:event]; 795 }); 796} 797 798- (bool) handleEventLocked:(NSEvent *)event 799{ 800 /* Return true if we handled the event, false if it should be given to OSX */ 801 COCOA_DEBUG("QemuCocoaView: handleEvent\n"); 802 int buttons = 0; 803 int keycode = 0; 804 bool mouse_event = false; 805 // Location of event in virtual screen coordinates 806 NSPoint p = [self screenLocationOfEvent:event]; 807 NSUInteger modifiers = [event modifierFlags]; 808 809 /* 810 * Check -[NSEvent modifierFlags] here. 811 * 812 * There is a NSEventType for an event notifying the change of 813 * -[NSEvent modifierFlags], NSEventTypeFlagsChanged but these operations 814 * are performed for any events because a modifier state may change while 815 * the application is inactive (i.e. no events fire) and we don't want to 816 * wait for another modifier state change to detect such a change. 817 * 818 * NSEventModifierFlagCapsLock requires a special treatment. The other flags 819 * are handled in similar manners. 820 * 821 * NSEventModifierFlagCapsLock 822 * --------------------------- 823 * 824 * If CapsLock state is changed, "up" and "down" events will be fired in 825 * sequence, effectively updates CapsLock state on the guest. 826 * 827 * The other flags 828 * --------------- 829 * 830 * If a flag is not set, fire "up" events for all keys which correspond to 831 * the flag. Note that "down" events are not fired here because the flags 832 * checked here do not tell what exact keys are down. 833 * 834 * If one of the keys corresponding to a flag is down, we rely on 835 * -[NSEvent keyCode] of an event whose -[NSEvent type] is 836 * NSEventTypeFlagsChanged to know the exact key which is down, which has 837 * the following two downsides: 838 * - It does not work when the application is inactive as described above. 839 * - It malfactions *after* the modifier state is changed while the 840 * application is inactive. It is because -[NSEvent keyCode] does not tell 841 * if the key is up or down, and requires to infer the current state from 842 * the previous state. It is still possible to fix such a malfanction by 843 * completely leaving your hands from the keyboard, which hopefully makes 844 * this implementation usable enough. 845 */ 846 if (!!(modifiers & NSEventModifierFlagCapsLock) != 847 qkbd_state_modifier_get(kbd, QKBD_MOD_CAPSLOCK)) { 848 qkbd_state_key_event(kbd, Q_KEY_CODE_CAPS_LOCK, true); 849 qkbd_state_key_event(kbd, Q_KEY_CODE_CAPS_LOCK, false); 850 } 851 852 if (!(modifiers & NSEventModifierFlagShift)) { 853 qkbd_state_key_event(kbd, Q_KEY_CODE_SHIFT, false); 854 qkbd_state_key_event(kbd, Q_KEY_CODE_SHIFT_R, false); 855 } 856 if (!(modifiers & NSEventModifierFlagControl)) { 857 qkbd_state_key_event(kbd, Q_KEY_CODE_CTRL, false); 858 qkbd_state_key_event(kbd, Q_KEY_CODE_CTRL_R, false); 859 } 860 if (!(modifiers & NSEventModifierFlagOption)) { 861 if (swap_opt_cmd) { 862 qkbd_state_key_event(kbd, Q_KEY_CODE_META_L, false); 863 qkbd_state_key_event(kbd, Q_KEY_CODE_META_R, false); 864 } else { 865 qkbd_state_key_event(kbd, Q_KEY_CODE_ALT, false); 866 qkbd_state_key_event(kbd, Q_KEY_CODE_ALT_R, false); 867 } 868 } 869 if (!(modifiers & NSEventModifierFlagCommand)) { 870 if (swap_opt_cmd) { 871 qkbd_state_key_event(kbd, Q_KEY_CODE_ALT, false); 872 qkbd_state_key_event(kbd, Q_KEY_CODE_ALT_R, false); 873 } else { 874 qkbd_state_key_event(kbd, Q_KEY_CODE_META_L, false); 875 qkbd_state_key_event(kbd, Q_KEY_CODE_META_R, false); 876 } 877 } 878 879 switch ([event type]) { 880 case NSEventTypeFlagsChanged: 881 switch ([event keyCode]) { 882 case kVK_Shift: 883 if (!!(modifiers & NSEventModifierFlagShift)) { 884 [self toggleKey:Q_KEY_CODE_SHIFT]; 885 } 886 break; 887 888 case kVK_RightShift: 889 if (!!(modifiers & NSEventModifierFlagShift)) { 890 [self toggleKey:Q_KEY_CODE_SHIFT_R]; 891 } 892 break; 893 894 case kVK_Control: 895 if (!!(modifiers & NSEventModifierFlagControl)) { 896 [self toggleKey:Q_KEY_CODE_CTRL]; 897 } 898 break; 899 900 case kVK_RightControl: 901 if (!!(modifiers & NSEventModifierFlagControl)) { 902 [self toggleKey:Q_KEY_CODE_CTRL_R]; 903 } 904 break; 905 906 case kVK_Option: 907 if (!!(modifiers & NSEventModifierFlagOption)) { 908 if (swap_opt_cmd) { 909 [self toggleKey:Q_KEY_CODE_META_L]; 910 } else { 911 [self toggleKey:Q_KEY_CODE_ALT]; 912 } 913 } 914 break; 915 916 case kVK_RightOption: 917 if (!!(modifiers & NSEventModifierFlagOption)) { 918 if (swap_opt_cmd) { 919 [self toggleKey:Q_KEY_CODE_META_R]; 920 } else { 921 [self toggleKey:Q_KEY_CODE_ALT_R]; 922 } 923 } 924 break; 925 926 /* Don't pass command key changes to guest unless mouse is grabbed */ 927 case kVK_Command: 928 if (isMouseGrabbed && 929 !!(modifiers & NSEventModifierFlagCommand) && 930 left_command_key_enabled) { 931 if (swap_opt_cmd) { 932 [self toggleKey:Q_KEY_CODE_ALT]; 933 } else { 934 [self toggleKey:Q_KEY_CODE_META_L]; 935 } 936 } 937 break; 938 939 case kVK_RightCommand: 940 if (isMouseGrabbed && 941 !!(modifiers & NSEventModifierFlagCommand)) { 942 if (swap_opt_cmd) { 943 [self toggleKey:Q_KEY_CODE_ALT_R]; 944 } else { 945 [self toggleKey:Q_KEY_CODE_META_R]; 946 } 947 } 948 break; 949 } 950 break; 951 case NSEventTypeKeyDown: 952 keycode = cocoa_keycode_to_qemu([event keyCode]); 953 954 // forward command key combos to the host UI unless the mouse is grabbed 955 if (!isMouseGrabbed && ([event modifierFlags] & NSEventModifierFlagCommand)) { 956 return false; 957 } 958 959 // default 960 961 // handle control + alt Key Combos (ctrl+alt+[1..9,g] is reserved for QEMU) 962 if (([event modifierFlags] & NSEventModifierFlagControl) && ([event modifierFlags] & NSEventModifierFlagOption)) { 963 NSString *keychar = [event charactersIgnoringModifiers]; 964 if ([keychar length] == 1) { 965 char key = [keychar characterAtIndex:0]; 966 switch (key) { 967 968 // enable graphic console 969 case '1' ... '9': 970 console_select(key - '0' - 1); /* ascii math */ 971 return true; 972 973 // release the mouse grab 974 case 'g': 975 [self ungrabMouse]; 976 return true; 977 } 978 } 979 } 980 981 if (qemu_console_is_graphic(NULL)) { 982 qkbd_state_key_event(kbd, keycode, true); 983 } else { 984 [self handleMonitorInput: event]; 985 } 986 break; 987 case NSEventTypeKeyUp: 988 keycode = cocoa_keycode_to_qemu([event keyCode]); 989 990 // don't pass the guest a spurious key-up if we treated this 991 // command-key combo as a host UI action 992 if (!isMouseGrabbed && ([event modifierFlags] & NSEventModifierFlagCommand)) { 993 return true; 994 } 995 996 if (qemu_console_is_graphic(NULL)) { 997 qkbd_state_key_event(kbd, keycode, false); 998 } 999 break; 1000 case NSEventTypeMouseMoved: 1001 if (isAbsoluteEnabled) { 1002 // Cursor re-entered into a window might generate events bound to screen coordinates 1003 // and `nil` window property, and in full screen mode, current window might not be 1004 // key window, where event location alone should suffice. 1005 if (![self screenContainsPoint:p] || !([[self window] isKeyWindow] || isFullscreen)) { 1006 if (isMouseGrabbed) { 1007 [self ungrabMouse]; 1008 } 1009 } else { 1010 if (!isMouseGrabbed) { 1011 [self grabMouse]; 1012 } 1013 } 1014 } 1015 mouse_event = true; 1016 break; 1017 case NSEventTypeLeftMouseDown: 1018 buttons |= MOUSE_EVENT_LBUTTON; 1019 mouse_event = true; 1020 break; 1021 case NSEventTypeRightMouseDown: 1022 buttons |= MOUSE_EVENT_RBUTTON; 1023 mouse_event = true; 1024 break; 1025 case NSEventTypeOtherMouseDown: 1026 buttons |= MOUSE_EVENT_MBUTTON; 1027 mouse_event = true; 1028 break; 1029 case NSEventTypeLeftMouseDragged: 1030 buttons |= MOUSE_EVENT_LBUTTON; 1031 mouse_event = true; 1032 break; 1033 case NSEventTypeRightMouseDragged: 1034 buttons |= MOUSE_EVENT_RBUTTON; 1035 mouse_event = true; 1036 break; 1037 case NSEventTypeOtherMouseDragged: 1038 buttons |= MOUSE_EVENT_MBUTTON; 1039 mouse_event = true; 1040 break; 1041 case NSEventTypeLeftMouseUp: 1042 mouse_event = true; 1043 if (!isMouseGrabbed && [self screenContainsPoint:p]) { 1044 /* 1045 * In fullscreen mode, the window of cocoaView may not be the 1046 * key window, therefore the position relative to the virtual 1047 * screen alone will be sufficient. 1048 */ 1049 if(isFullscreen || [[self window] isKeyWindow]) { 1050 [self grabMouse]; 1051 } 1052 } 1053 break; 1054 case NSEventTypeRightMouseUp: 1055 mouse_event = true; 1056 break; 1057 case NSEventTypeOtherMouseUp: 1058 mouse_event = true; 1059 break; 1060 case NSEventTypeScrollWheel: 1061 /* 1062 * Send wheel events to the guest regardless of window focus. 1063 * This is in-line with standard Mac OS X UI behaviour. 1064 */ 1065 1066 /* 1067 * We shouldn't have got a scroll event when deltaY and delta Y 1068 * are zero, hence no harm in dropping the event 1069 */ 1070 if ([event deltaY] != 0 || [event deltaX] != 0) { 1071 /* Determine if this is a scroll up or scroll down event */ 1072 if ([event deltaY] != 0) { 1073 buttons = ([event deltaY] > 0) ? 1074 INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN; 1075 } else if ([event deltaX] != 0) { 1076 buttons = ([event deltaX] > 0) ? 1077 INPUT_BUTTON_WHEEL_LEFT : INPUT_BUTTON_WHEEL_RIGHT; 1078 } 1079 1080 qemu_input_queue_btn(dcl.con, buttons, true); 1081 qemu_input_event_sync(); 1082 qemu_input_queue_btn(dcl.con, buttons, false); 1083 qemu_input_event_sync(); 1084 } 1085 1086 /* 1087 * Since deltaX/deltaY also report scroll wheel events we prevent mouse 1088 * movement code from executing. 1089 */ 1090 mouse_event = false; 1091 break; 1092 default: 1093 return false; 1094 } 1095 1096 if (mouse_event) { 1097 /* Don't send button events to the guest unless we've got a 1098 * mouse grab or window focus. If we have neither then this event 1099 * is the user clicking on the background window to activate and 1100 * bring us to the front, which will be done by the sendEvent 1101 * call below. We definitely don't want to pass that click through 1102 * to the guest. 1103 */ 1104 if ((isMouseGrabbed || [[self window] isKeyWindow]) && 1105 (last_buttons != buttons)) { 1106 static uint32_t bmap[INPUT_BUTTON__MAX] = { 1107 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON, 1108 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON, 1109 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON 1110 }; 1111 qemu_input_update_buttons(dcl.con, bmap, last_buttons, buttons); 1112 last_buttons = buttons; 1113 } 1114 if (isMouseGrabbed) { 1115 if (isAbsoluteEnabled) { 1116 /* Note that the origin for Cocoa mouse coords is bottom left, not top left. 1117 * The check on screenContainsPoint is to avoid sending out of range values for 1118 * clicks in the titlebar. 1119 */ 1120 if ([self screenContainsPoint:p]) { 1121 qemu_input_queue_abs(dcl.con, INPUT_AXIS_X, p.x, 0, screen.width); 1122 qemu_input_queue_abs(dcl.con, INPUT_AXIS_Y, screen.height - p.y, 0, screen.height); 1123 } 1124 } else { 1125 qemu_input_queue_rel(dcl.con, INPUT_AXIS_X, (int)[event deltaX]); 1126 qemu_input_queue_rel(dcl.con, INPUT_AXIS_Y, (int)[event deltaY]); 1127 } 1128 } else { 1129 return false; 1130 } 1131 qemu_input_event_sync(); 1132 } 1133 return true; 1134} 1135 1136- (void) grabMouse 1137{ 1138 COCOA_DEBUG("QemuCocoaView: grabMouse\n"); 1139 1140 if (!isFullscreen) { 1141 if (qemu_name) 1142 [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s - (Press " UC_CTRL_KEY " " UC_ALT_KEY " G to release Mouse)", qemu_name]]; 1143 else 1144 [normalWindow setTitle:@"QEMU - (Press " UC_CTRL_KEY " " UC_ALT_KEY " G to release Mouse)"]; 1145 } 1146 [self hideCursor]; 1147 CGAssociateMouseAndMouseCursorPosition(isAbsoluteEnabled); 1148 isMouseGrabbed = TRUE; // while isMouseGrabbed = TRUE, QemuCocoaApp sends all events to [cocoaView handleEvent:] 1149} 1150 1151- (void) ungrabMouse 1152{ 1153 COCOA_DEBUG("QemuCocoaView: ungrabMouse\n"); 1154 1155 if (!isFullscreen) { 1156 if (qemu_name) 1157 [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s", qemu_name]]; 1158 else 1159 [normalWindow setTitle:@"QEMU"]; 1160 } 1161 [self unhideCursor]; 1162 CGAssociateMouseAndMouseCursorPosition(TRUE); 1163 isMouseGrabbed = FALSE; 1164} 1165 1166- (void) setAbsoluteEnabled:(BOOL)tIsAbsoluteEnabled { 1167 isAbsoluteEnabled = tIsAbsoluteEnabled; 1168 if (isMouseGrabbed) { 1169 CGAssociateMouseAndMouseCursorPosition(isAbsoluteEnabled); 1170 } 1171} 1172- (BOOL) isMouseGrabbed {return isMouseGrabbed;} 1173- (BOOL) isAbsoluteEnabled {return isAbsoluteEnabled;} 1174- (float) cdx {return cdx;} 1175- (float) cdy {return cdy;} 1176- (QEMUScreen) gscreen {return screen;} 1177 1178/* 1179 * Makes the target think all down keys are being released. 1180 * This prevents a stuck key problem, since we will not see 1181 * key up events for those keys after we have lost focus. 1182 */ 1183- (void) raiseAllKeys 1184{ 1185 with_iothread_lock(^{ 1186 qkbd_state_lift_all_keys(kbd); 1187 }); 1188} 1189@end 1190 1191 1192 1193/* 1194 ------------------------------------------------------ 1195 QemuCocoaAppController 1196 ------------------------------------------------------ 1197*/ 1198@interface QemuCocoaAppController : NSObject 1199 <NSWindowDelegate, NSApplicationDelegate> 1200{ 1201} 1202- (void)doToggleFullScreen:(id)sender; 1203- (void)toggleFullScreen:(id)sender; 1204- (void)showQEMUDoc:(id)sender; 1205- (void)zoomToFit:(id) sender; 1206- (void)displayConsole:(id)sender; 1207- (void)pauseQEMU:(id)sender; 1208- (void)resumeQEMU:(id)sender; 1209- (void)displayPause; 1210- (void)removePause; 1211- (void)restartQEMU:(id)sender; 1212- (void)powerDownQEMU:(id)sender; 1213- (void)ejectDeviceMedia:(id)sender; 1214- (void)changeDeviceMedia:(id)sender; 1215- (BOOL)verifyQuit; 1216- (void)openDocumentation:(NSString *)filename; 1217- (IBAction) do_about_menu_item: (id) sender; 1218- (void)adjustSpeed:(id)sender; 1219@end 1220 1221@implementation QemuCocoaAppController 1222- (id) init 1223{ 1224 COCOA_DEBUG("QemuCocoaAppController: init\n"); 1225 1226 self = [super init]; 1227 if (self) { 1228 1229 // create a view and add it to the window 1230 cocoaView = [[QemuCocoaView alloc] initWithFrame:NSMakeRect(0.0, 0.0, 640.0, 480.0)]; 1231 if(!cocoaView) { 1232 error_report("(cocoa) can't create a view"); 1233 exit(1); 1234 } 1235 1236 // create a window 1237 normalWindow = [[NSWindow alloc] initWithContentRect:[cocoaView frame] 1238 styleMask:NSWindowStyleMaskTitled|NSWindowStyleMaskMiniaturizable|NSWindowStyleMaskClosable 1239 backing:NSBackingStoreBuffered defer:NO]; 1240 if(!normalWindow) { 1241 error_report("(cocoa) can't create window"); 1242 exit(1); 1243 } 1244 [normalWindow setAcceptsMouseMovedEvents:YES]; 1245 [normalWindow setTitle:@"QEMU"]; 1246 [normalWindow setContentView:cocoaView]; 1247 [normalWindow makeKeyAndOrderFront:self]; 1248 [normalWindow center]; 1249 [normalWindow setDelegate: self]; 1250 1251 /* Used for displaying pause on the screen */ 1252 pauseLabel = [NSTextField new]; 1253 [pauseLabel setBezeled:YES]; 1254 [pauseLabel setDrawsBackground:YES]; 1255 [pauseLabel setBackgroundColor: [NSColor whiteColor]]; 1256 [pauseLabel setEditable:NO]; 1257 [pauseLabel setSelectable:NO]; 1258 [pauseLabel setStringValue: @"Paused"]; 1259 [pauseLabel setFont: [NSFont fontWithName: @"Helvetica" size: 90]]; 1260 [pauseLabel setTextColor: [NSColor blackColor]]; 1261 [pauseLabel sizeToFit]; 1262 } 1263 return self; 1264} 1265 1266- (void) dealloc 1267{ 1268 COCOA_DEBUG("QemuCocoaAppController: dealloc\n"); 1269 1270 if (cocoaView) 1271 [cocoaView release]; 1272 [super dealloc]; 1273} 1274 1275- (void)applicationDidFinishLaunching: (NSNotification *) note 1276{ 1277 COCOA_DEBUG("QemuCocoaAppController: applicationDidFinishLaunching\n"); 1278 allow_events = true; 1279} 1280 1281- (void)applicationWillTerminate:(NSNotification *)aNotification 1282{ 1283 COCOA_DEBUG("QemuCocoaAppController: applicationWillTerminate\n"); 1284 1285 with_iothread_lock(^{ 1286 shutdown_action = SHUTDOWN_ACTION_POWEROFF; 1287 qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI); 1288 }); 1289 1290 /* 1291 * Sleep here, because returning will cause OSX to kill us 1292 * immediately; the QEMU main loop will handle the shutdown 1293 * request and terminate the process. 1294 */ 1295 [NSThread sleepForTimeInterval:INFINITY]; 1296} 1297 1298- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)theApplication 1299{ 1300 return YES; 1301} 1302 1303- (NSApplicationTerminateReply)applicationShouldTerminate: 1304 (NSApplication *)sender 1305{ 1306 COCOA_DEBUG("QemuCocoaAppController: applicationShouldTerminate\n"); 1307 return [self verifyQuit]; 1308} 1309 1310- (void)windowDidChangeScreen:(NSNotification *)notification 1311{ 1312 [cocoaView updateUIInfo]; 1313} 1314 1315- (void)windowDidResize:(NSNotification *)notification 1316{ 1317 [cocoaView updateUIInfo]; 1318} 1319 1320/* Called when the user clicks on a window's close button */ 1321- (BOOL)windowShouldClose:(id)sender 1322{ 1323 COCOA_DEBUG("QemuCocoaAppController: windowShouldClose\n"); 1324 [NSApp terminate: sender]; 1325 /* If the user allows the application to quit then the call to 1326 * NSApp terminate will never return. If we get here then the user 1327 * cancelled the quit, so we should return NO to not permit the 1328 * closing of this window. 1329 */ 1330 return NO; 1331} 1332 1333/* 1334 * Called when QEMU goes into the background. Note that 1335 * [-NSWindowDelegate windowDidResignKey:] is used here instead of 1336 * [-NSApplicationDelegate applicationWillResignActive:] because it cannot 1337 * detect that the window loses focus when the deck is clicked on macOS 13.2.1. 1338 */ 1339- (void) windowDidResignKey: (NSNotification *)aNotification 1340{ 1341 COCOA_DEBUG("%s\n", __func__); 1342 [cocoaView ungrabMouse]; 1343 [cocoaView raiseAllKeys]; 1344} 1345 1346/* We abstract the method called by the Enter Fullscreen menu item 1347 * because Mac OS 10.7 and higher disables it. This is because of the 1348 * menu item's old selector's name toggleFullScreen: 1349 */ 1350- (void) doToggleFullScreen:(id)sender 1351{ 1352 [self toggleFullScreen:(id)sender]; 1353} 1354 1355- (void)toggleFullScreen:(id)sender 1356{ 1357 COCOA_DEBUG("QemuCocoaAppController: toggleFullScreen\n"); 1358 1359 [cocoaView toggleFullScreen:sender]; 1360} 1361 1362- (void) setFullGrab:(id)sender 1363{ 1364 COCOA_DEBUG("QemuCocoaAppController: setFullGrab\n"); 1365 1366 [cocoaView setFullGrab:sender]; 1367} 1368 1369/* Tries to find then open the specified filename */ 1370- (void) openDocumentation: (NSString *) filename 1371{ 1372 /* Where to look for local files */ 1373 NSString *path_array[] = {@"../share/doc/qemu/", @"../doc/qemu/", @"docs/"}; 1374 NSString *full_file_path; 1375 NSURL *full_file_url; 1376 1377 /* iterate thru the possible paths until the file is found */ 1378 int index; 1379 for (index = 0; index < ARRAY_SIZE(path_array); index++) { 1380 full_file_path = [[NSBundle mainBundle] executablePath]; 1381 full_file_path = [full_file_path stringByDeletingLastPathComponent]; 1382 full_file_path = [NSString stringWithFormat: @"%@/%@%@", full_file_path, 1383 path_array[index], filename]; 1384 full_file_url = [NSURL fileURLWithPath: full_file_path 1385 isDirectory: false]; 1386 if ([[NSWorkspace sharedWorkspace] openURL: full_file_url] == YES) { 1387 return; 1388 } 1389 } 1390 1391 /* If none of the paths opened a file */ 1392 NSBeep(); 1393 QEMU_Alert(@"Failed to open file"); 1394} 1395 1396- (void)showQEMUDoc:(id)sender 1397{ 1398 COCOA_DEBUG("QemuCocoaAppController: showQEMUDoc\n"); 1399 1400 [self openDocumentation: @"index.html"]; 1401} 1402 1403/* Stretches video to fit host monitor size */ 1404- (void)zoomToFit:(id) sender 1405{ 1406 stretch_video = !stretch_video; 1407 if (stretch_video == true) { 1408 [sender setState: NSControlStateValueOn]; 1409 } else { 1410 [sender setState: NSControlStateValueOff]; 1411 } 1412} 1413 1414/* Displays the console on the screen */ 1415- (void)displayConsole:(id)sender 1416{ 1417 console_select([sender tag]); 1418} 1419 1420/* Pause the guest */ 1421- (void)pauseQEMU:(id)sender 1422{ 1423 with_iothread_lock(^{ 1424 qmp_stop(NULL); 1425 }); 1426 [sender setEnabled: NO]; 1427 [[[sender menu] itemWithTitle: @"Resume"] setEnabled: YES]; 1428 [self displayPause]; 1429} 1430 1431/* Resume running the guest operating system */ 1432- (void)resumeQEMU:(id) sender 1433{ 1434 with_iothread_lock(^{ 1435 qmp_cont(NULL); 1436 }); 1437 [sender setEnabled: NO]; 1438 [[[sender menu] itemWithTitle: @"Pause"] setEnabled: YES]; 1439 [self removePause]; 1440} 1441 1442/* Displays the word pause on the screen */ 1443- (void)displayPause 1444{ 1445 /* Coordinates have to be calculated each time because the window can change its size */ 1446 int xCoord, yCoord, width, height; 1447 xCoord = ([normalWindow frame].size.width - [pauseLabel frame].size.width)/2; 1448 yCoord = [normalWindow frame].size.height - [pauseLabel frame].size.height - ([pauseLabel frame].size.height * .5); 1449 width = [pauseLabel frame].size.width; 1450 height = [pauseLabel frame].size.height; 1451 [pauseLabel setFrame: NSMakeRect(xCoord, yCoord, width, height)]; 1452 [cocoaView addSubview: pauseLabel]; 1453} 1454 1455/* Removes the word pause from the screen */ 1456- (void)removePause 1457{ 1458 [pauseLabel removeFromSuperview]; 1459} 1460 1461/* Restarts QEMU */ 1462- (void)restartQEMU:(id)sender 1463{ 1464 with_iothread_lock(^{ 1465 qmp_system_reset(NULL); 1466 }); 1467} 1468 1469/* Powers down QEMU */ 1470- (void)powerDownQEMU:(id)sender 1471{ 1472 with_iothread_lock(^{ 1473 qmp_system_powerdown(NULL); 1474 }); 1475} 1476 1477/* Ejects the media. 1478 * Uses sender's tag to figure out the device to eject. 1479 */ 1480- (void)ejectDeviceMedia:(id)sender 1481{ 1482 NSString * drive; 1483 drive = [sender representedObject]; 1484 if(drive == nil) { 1485 NSBeep(); 1486 QEMU_Alert(@"Failed to find drive to eject!"); 1487 return; 1488 } 1489 1490 __block Error *err = NULL; 1491 with_iothread_lock(^{ 1492 qmp_eject([drive cStringUsingEncoding: NSASCIIStringEncoding], 1493 NULL, false, false, &err); 1494 }); 1495 handleAnyDeviceErrors(err); 1496} 1497 1498/* Displays a dialog box asking the user to select an image file to load. 1499 * Uses sender's represented object value to figure out which drive to use. 1500 */ 1501- (void)changeDeviceMedia:(id)sender 1502{ 1503 /* Find the drive name */ 1504 NSString * drive; 1505 drive = [sender representedObject]; 1506 if(drive == nil) { 1507 NSBeep(); 1508 QEMU_Alert(@"Could not find drive!"); 1509 return; 1510 } 1511 1512 /* Display the file open dialog */ 1513 NSOpenPanel * openPanel; 1514 openPanel = [NSOpenPanel openPanel]; 1515 [openPanel setCanChooseFiles: YES]; 1516 [openPanel setAllowsMultipleSelection: NO]; 1517 if([openPanel runModal] == NSModalResponseOK) { 1518 NSString * file = [[[openPanel URLs] objectAtIndex: 0] path]; 1519 if(file == nil) { 1520 NSBeep(); 1521 QEMU_Alert(@"Failed to convert URL to file path!"); 1522 return; 1523 } 1524 1525 __block Error *err = NULL; 1526 with_iothread_lock(^{ 1527 qmp_blockdev_change_medium([drive cStringUsingEncoding: 1528 NSASCIIStringEncoding], 1529 NULL, 1530 [file cStringUsingEncoding: 1531 NSASCIIStringEncoding], 1532 "raw", 1533 true, false, 1534 false, 0, 1535 &err); 1536 }); 1537 handleAnyDeviceErrors(err); 1538 } 1539} 1540 1541/* Verifies if the user really wants to quit */ 1542- (BOOL)verifyQuit 1543{ 1544 NSAlert *alert = [NSAlert new]; 1545 [alert autorelease]; 1546 [alert setMessageText: @"Are you sure you want to quit QEMU?"]; 1547 [alert addButtonWithTitle: @"Cancel"]; 1548 [alert addButtonWithTitle: @"Quit"]; 1549 if([alert runModal] == NSAlertSecondButtonReturn) { 1550 return YES; 1551 } else { 1552 return NO; 1553 } 1554} 1555 1556/* The action method for the About menu item */ 1557- (IBAction) do_about_menu_item: (id) sender 1558{ 1559 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 1560 char *icon_path_c = get_relocated_path(CONFIG_QEMU_ICONDIR "/hicolor/512x512/apps/qemu.png"); 1561 NSString *icon_path = [NSString stringWithUTF8String:icon_path_c]; 1562 g_free(icon_path_c); 1563 NSImage *icon = [[NSImage alloc] initWithContentsOfFile:icon_path]; 1564 NSString *version = @"QEMU emulator version " QEMU_FULL_VERSION; 1565 NSString *copyright = @QEMU_COPYRIGHT; 1566 NSDictionary *options; 1567 if (icon) { 1568 options = @{ 1569 NSAboutPanelOptionApplicationIcon : icon, 1570 NSAboutPanelOptionApplicationVersion : version, 1571 @"Copyright" : copyright, 1572 }; 1573 [icon release]; 1574 } else { 1575 options = @{ 1576 NSAboutPanelOptionApplicationVersion : version, 1577 @"Copyright" : copyright, 1578 }; 1579 } 1580 [NSApp orderFrontStandardAboutPanelWithOptions:options]; 1581 [pool release]; 1582} 1583 1584/* Used by the Speed menu items */ 1585- (void)adjustSpeed:(id)sender 1586{ 1587 int throttle_pct; /* throttle percentage */ 1588 NSMenu *menu; 1589 1590 menu = [sender menu]; 1591 if (menu != nil) 1592 { 1593 /* Unselect the currently selected item */ 1594 for (NSMenuItem *item in [menu itemArray]) { 1595 if (item.state == NSControlStateValueOn) { 1596 [item setState: NSControlStateValueOff]; 1597 break; 1598 } 1599 } 1600 } 1601 1602 // check the menu item 1603 [sender setState: NSControlStateValueOn]; 1604 1605 // get the throttle percentage 1606 throttle_pct = [sender tag]; 1607 1608 with_iothread_lock(^{ 1609 cpu_throttle_set(throttle_pct); 1610 }); 1611 COCOA_DEBUG("cpu throttling at %d%c\n", cpu_throttle_get_percentage(), '%'); 1612} 1613 1614@end 1615 1616@interface QemuApplication : NSApplication 1617@end 1618 1619@implementation QemuApplication 1620- (void)sendEvent:(NSEvent *)event 1621{ 1622 COCOA_DEBUG("QemuApplication: sendEvent\n"); 1623 if (![cocoaView handleEvent:event]) { 1624 [super sendEvent: event]; 1625 } 1626} 1627@end 1628 1629static void create_initial_menus(void) 1630{ 1631 // Add menus 1632 NSMenu *menu; 1633 NSMenuItem *menuItem; 1634 1635 [NSApp setMainMenu:[[NSMenu alloc] init]]; 1636 [NSApp setServicesMenu:[[NSMenu alloc] initWithTitle:@"Services"]]; 1637 1638 // Application menu 1639 menu = [[NSMenu alloc] initWithTitle:@""]; 1640 [menu addItemWithTitle:@"About QEMU" action:@selector(do_about_menu_item:) keyEquivalent:@""]; // About QEMU 1641 [menu addItem:[NSMenuItem separatorItem]]; //Separator 1642 menuItem = [menu addItemWithTitle:@"Services" action:nil keyEquivalent:@""]; 1643 [menuItem setSubmenu:[NSApp servicesMenu]]; 1644 [menu addItem:[NSMenuItem separatorItem]]; 1645 [menu addItemWithTitle:@"Hide QEMU" action:@selector(hide:) keyEquivalent:@"h"]; //Hide QEMU 1646 menuItem = (NSMenuItem *)[menu addItemWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"]; // Hide Others 1647 [menuItem setKeyEquivalentModifierMask:(NSEventModifierFlagOption|NSEventModifierFlagCommand)]; 1648 [menu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""]; // Show All 1649 [menu addItem:[NSMenuItem separatorItem]]; //Separator 1650 [menu addItemWithTitle:@"Quit QEMU" action:@selector(terminate:) keyEquivalent:@"q"]; 1651 menuItem = [[NSMenuItem alloc] initWithTitle:@"Apple" action:nil keyEquivalent:@""]; 1652 [menuItem setSubmenu:menu]; 1653 [[NSApp mainMenu] addItem:menuItem]; 1654 [NSApp performSelector:@selector(setAppleMenu:) withObject:menu]; // Workaround (this method is private since 10.4+) 1655 1656 // Machine menu 1657 menu = [[NSMenu alloc] initWithTitle: @"Machine"]; 1658 [menu setAutoenablesItems: NO]; 1659 [menu addItem: [[[NSMenuItem alloc] initWithTitle: @"Pause" action: @selector(pauseQEMU:) keyEquivalent: @""] autorelease]]; 1660 menuItem = [[[NSMenuItem alloc] initWithTitle: @"Resume" action: @selector(resumeQEMU:) keyEquivalent: @""] autorelease]; 1661 [menu addItem: menuItem]; 1662 [menuItem setEnabled: NO]; 1663 [menu addItem: [NSMenuItem separatorItem]]; 1664 [menu addItem: [[[NSMenuItem alloc] initWithTitle: @"Reset" action: @selector(restartQEMU:) keyEquivalent: @""] autorelease]]; 1665 [menu addItem: [[[NSMenuItem alloc] initWithTitle: @"Power Down" action: @selector(powerDownQEMU:) keyEquivalent: @""] autorelease]]; 1666 menuItem = [[[NSMenuItem alloc] initWithTitle: @"Machine" action:nil keyEquivalent:@""] autorelease]; 1667 [menuItem setSubmenu:menu]; 1668 [[NSApp mainMenu] addItem:menuItem]; 1669 1670 // View menu 1671 menu = [[NSMenu alloc] initWithTitle:@"View"]; 1672 [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"Enter Fullscreen" action:@selector(doToggleFullScreen:) keyEquivalent:@"f"] autorelease]]; // Fullscreen 1673 menuItem = [[[NSMenuItem alloc] initWithTitle:@"Zoom To Fit" action:@selector(zoomToFit:) keyEquivalent:@""] autorelease]; 1674 [menuItem setState: stretch_video ? NSControlStateValueOn : NSControlStateValueOff]; 1675 [menu addItem: menuItem]; 1676 menuItem = [[[NSMenuItem alloc] initWithTitle:@"View" action:nil keyEquivalent:@""] autorelease]; 1677 [menuItem setSubmenu:menu]; 1678 [[NSApp mainMenu] addItem:menuItem]; 1679 1680 // Speed menu 1681 menu = [[NSMenu alloc] initWithTitle:@"Speed"]; 1682 1683 // Add the rest of the Speed menu items 1684 int p, percentage, throttle_pct; 1685 for (p = 10; p >= 0; p--) 1686 { 1687 percentage = p * 10 > 1 ? p * 10 : 1; // prevent a 0% menu item 1688 1689 menuItem = [[[NSMenuItem alloc] 1690 initWithTitle: [NSString stringWithFormat: @"%d%%", percentage] action:@selector(adjustSpeed:) keyEquivalent:@""] autorelease]; 1691 1692 if (percentage == 100) { 1693 [menuItem setState: NSControlStateValueOn]; 1694 } 1695 1696 /* Calculate the throttle percentage */ 1697 throttle_pct = -1 * percentage + 100; 1698 1699 [menuItem setTag: throttle_pct]; 1700 [menu addItem: menuItem]; 1701 } 1702 menuItem = [[[NSMenuItem alloc] initWithTitle:@"Speed" action:nil keyEquivalent:@""] autorelease]; 1703 [menuItem setSubmenu:menu]; 1704 [[NSApp mainMenu] addItem:menuItem]; 1705 1706 // Window menu 1707 menu = [[NSMenu alloc] initWithTitle:@"Window"]; 1708 [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"] autorelease]]; // Miniaturize 1709 menuItem = [[[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""] autorelease]; 1710 [menuItem setSubmenu:menu]; 1711 [[NSApp mainMenu] addItem:menuItem]; 1712 [NSApp setWindowsMenu:menu]; 1713 1714 // Help menu 1715 menu = [[NSMenu alloc] initWithTitle:@"Help"]; 1716 [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"QEMU Documentation" action:@selector(showQEMUDoc:) keyEquivalent:@"?"] autorelease]]; // QEMU Help 1717 menuItem = [[[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""] autorelease]; 1718 [menuItem setSubmenu:menu]; 1719 [[NSApp mainMenu] addItem:menuItem]; 1720} 1721 1722/* Returns a name for a given console */ 1723static NSString * getConsoleName(QemuConsole * console) 1724{ 1725 g_autofree char *label = qemu_console_get_label(console); 1726 1727 return [NSString stringWithUTF8String:label]; 1728} 1729 1730/* Add an entry to the View menu for each console */ 1731static void add_console_menu_entries(void) 1732{ 1733 NSMenu *menu; 1734 NSMenuItem *menuItem; 1735 int index = 0; 1736 1737 menu = [[[NSApp mainMenu] itemWithTitle:@"View"] submenu]; 1738 1739 [menu addItem:[NSMenuItem separatorItem]]; 1740 1741 while (qemu_console_lookup_by_index(index) != NULL) { 1742 menuItem = [[[NSMenuItem alloc] initWithTitle: getConsoleName(qemu_console_lookup_by_index(index)) 1743 action: @selector(displayConsole:) keyEquivalent: @""] autorelease]; 1744 [menuItem setTag: index]; 1745 [menu addItem: menuItem]; 1746 index++; 1747 } 1748} 1749 1750/* Make menu items for all removable devices. 1751 * Each device is given an 'Eject' and 'Change' menu item. 1752 */ 1753static void addRemovableDevicesMenuItems(void) 1754{ 1755 NSMenu *menu; 1756 NSMenuItem *menuItem; 1757 BlockInfoList *currentDevice, *pointerToFree; 1758 NSString *deviceName; 1759 1760 currentDevice = qmp_query_block(NULL); 1761 pointerToFree = currentDevice; 1762 1763 menu = [[[NSApp mainMenu] itemWithTitle:@"Machine"] submenu]; 1764 1765 // Add a separator between related groups of menu items 1766 [menu addItem:[NSMenuItem separatorItem]]; 1767 1768 // Set the attributes to the "Removable Media" menu item 1769 NSString *titleString = @"Removable Media"; 1770 NSMutableAttributedString *attString=[[NSMutableAttributedString alloc] initWithString:titleString]; 1771 NSColor *newColor = [NSColor blackColor]; 1772 NSFontManager *fontManager = [NSFontManager sharedFontManager]; 1773 NSFont *font = [fontManager fontWithFamily:@"Helvetica" 1774 traits:NSBoldFontMask|NSItalicFontMask 1775 weight:0 1776 size:14]; 1777 [attString addAttribute:NSFontAttributeName value:font range:NSMakeRange(0, [titleString length])]; 1778 [attString addAttribute:NSForegroundColorAttributeName value:newColor range:NSMakeRange(0, [titleString length])]; 1779 [attString addAttribute:NSUnderlineStyleAttributeName value:[NSNumber numberWithInt: 1] range:NSMakeRange(0, [titleString length])]; 1780 1781 // Add the "Removable Media" menu item 1782 menuItem = [NSMenuItem new]; 1783 [menuItem setAttributedTitle: attString]; 1784 [menuItem setEnabled: NO]; 1785 [menu addItem: menuItem]; 1786 1787 /* Loop through all the block devices in the emulator */ 1788 while (currentDevice) { 1789 deviceName = [[NSString stringWithFormat: @"%s", currentDevice->value->device] retain]; 1790 1791 if(currentDevice->value->removable) { 1792 menuItem = [[NSMenuItem alloc] initWithTitle: [NSString stringWithFormat: @"Change %s...", currentDevice->value->device] 1793 action: @selector(changeDeviceMedia:) 1794 keyEquivalent: @""]; 1795 [menu addItem: menuItem]; 1796 [menuItem setRepresentedObject: deviceName]; 1797 [menuItem autorelease]; 1798 1799 menuItem = [[NSMenuItem alloc] initWithTitle: [NSString stringWithFormat: @"Eject %s", currentDevice->value->device] 1800 action: @selector(ejectDeviceMedia:) 1801 keyEquivalent: @""]; 1802 [menu addItem: menuItem]; 1803 [menuItem setRepresentedObject: deviceName]; 1804 [menuItem autorelease]; 1805 } 1806 currentDevice = currentDevice->next; 1807 } 1808 qapi_free_BlockInfoList(pointerToFree); 1809} 1810 1811@interface QemuCocoaPasteboardTypeOwner : NSObject<NSPasteboardTypeOwner> 1812@end 1813 1814@implementation QemuCocoaPasteboardTypeOwner 1815 1816- (void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSPasteboardType)type 1817{ 1818 if (type != NSPasteboardTypeString) { 1819 return; 1820 } 1821 1822 with_iothread_lock(^{ 1823 QemuClipboardInfo *info = qemu_clipboard_info_ref(cbinfo); 1824 qemu_event_reset(&cbevent); 1825 qemu_clipboard_request(info, QEMU_CLIPBOARD_TYPE_TEXT); 1826 1827 while (info == cbinfo && 1828 info->types[QEMU_CLIPBOARD_TYPE_TEXT].available && 1829 info->types[QEMU_CLIPBOARD_TYPE_TEXT].data == NULL) { 1830 qemu_mutex_unlock_iothread(); 1831 qemu_event_wait(&cbevent); 1832 qemu_mutex_lock_iothread(); 1833 } 1834 1835 if (info == cbinfo) { 1836 NSData *data = [[NSData alloc] initWithBytes:info->types[QEMU_CLIPBOARD_TYPE_TEXT].data 1837 length:info->types[QEMU_CLIPBOARD_TYPE_TEXT].size]; 1838 [sender setData:data forType:NSPasteboardTypeString]; 1839 [data release]; 1840 } 1841 1842 qemu_clipboard_info_unref(info); 1843 }); 1844} 1845 1846@end 1847 1848static QemuCocoaPasteboardTypeOwner *cbowner; 1849 1850static void cocoa_clipboard_notify(Notifier *notifier, void *data); 1851static void cocoa_clipboard_request(QemuClipboardInfo *info, 1852 QemuClipboardType type); 1853 1854static QemuClipboardPeer cbpeer = { 1855 .name = "cocoa", 1856 .notifier = { .notify = cocoa_clipboard_notify }, 1857 .request = cocoa_clipboard_request 1858}; 1859 1860static void cocoa_clipboard_update_info(QemuClipboardInfo *info) 1861{ 1862 if (info->owner == &cbpeer || info->selection != QEMU_CLIPBOARD_SELECTION_CLIPBOARD) { 1863 return; 1864 } 1865 1866 if (info != cbinfo) { 1867 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 1868 qemu_clipboard_info_unref(cbinfo); 1869 cbinfo = qemu_clipboard_info_ref(info); 1870 cbchangecount = [[NSPasteboard generalPasteboard] declareTypes:@[NSPasteboardTypeString] owner:cbowner]; 1871 [pool release]; 1872 } 1873 1874 qemu_event_set(&cbevent); 1875} 1876 1877static void cocoa_clipboard_notify(Notifier *notifier, void *data) 1878{ 1879 QemuClipboardNotify *notify = data; 1880 1881 switch (notify->type) { 1882 case QEMU_CLIPBOARD_UPDATE_INFO: 1883 cocoa_clipboard_update_info(notify->info); 1884 return; 1885 case QEMU_CLIPBOARD_RESET_SERIAL: 1886 /* ignore */ 1887 return; 1888 } 1889} 1890 1891static void cocoa_clipboard_request(QemuClipboardInfo *info, 1892 QemuClipboardType type) 1893{ 1894 NSAutoreleasePool *pool; 1895 NSData *text; 1896 1897 switch (type) { 1898 case QEMU_CLIPBOARD_TYPE_TEXT: 1899 pool = [[NSAutoreleasePool alloc] init]; 1900 text = [[NSPasteboard generalPasteboard] dataForType:NSPasteboardTypeString]; 1901 if (text) { 1902 qemu_clipboard_set_data(&cbpeer, info, type, 1903 [text length], [text bytes], true); 1904 } 1905 [pool release]; 1906 break; 1907 default: 1908 break; 1909 } 1910} 1911 1912/* 1913 * The startup process for the OSX/Cocoa UI is complicated, because 1914 * OSX insists that the UI runs on the initial main thread, and so we 1915 * need to start a second thread which runs the qemu_default_main(): 1916 * in main(): 1917 * in cocoa_display_init(): 1918 * assign cocoa_main to qemu_main 1919 * create application, menus, etc 1920 * in cocoa_main(): 1921 * create qemu-main thread 1922 * enter OSX run loop 1923 */ 1924 1925static void *call_qemu_main(void *opaque) 1926{ 1927 int status; 1928 1929 COCOA_DEBUG("Second thread: calling qemu_default_main()\n"); 1930 qemu_mutex_lock_iothread(); 1931 status = qemu_default_main(); 1932 qemu_mutex_unlock_iothread(); 1933 COCOA_DEBUG("Second thread: qemu_default_main() returned, exiting\n"); 1934 [cbowner release]; 1935 exit(status); 1936} 1937 1938static int cocoa_main(void) 1939{ 1940 QemuThread thread; 1941 1942 COCOA_DEBUG("Entered %s()\n", __func__); 1943 1944 qemu_mutex_unlock_iothread(); 1945 qemu_thread_create(&thread, "qemu_main", call_qemu_main, 1946 NULL, QEMU_THREAD_DETACHED); 1947 1948 // Start the main event loop 1949 COCOA_DEBUG("Main thread: entering OSX run loop\n"); 1950 [NSApp run]; 1951 COCOA_DEBUG("Main thread: left OSX run loop, which should never happen\n"); 1952 1953 abort(); 1954} 1955 1956 1957 1958#pragma mark qemu 1959static void cocoa_update(DisplayChangeListener *dcl, 1960 int x, int y, int w, int h) 1961{ 1962 COCOA_DEBUG("qemu_cocoa: cocoa_update\n"); 1963 1964 dispatch_async(dispatch_get_main_queue(), ^{ 1965 NSRect rect; 1966 if ([cocoaView cdx] == 1.0) { 1967 rect = NSMakeRect(x, [cocoaView gscreen].height - y - h, w, h); 1968 } else { 1969 rect = NSMakeRect( 1970 x * [cocoaView cdx], 1971 ([cocoaView gscreen].height - y - h) * [cocoaView cdy], 1972 w * [cocoaView cdx], 1973 h * [cocoaView cdy]); 1974 } 1975 [cocoaView setNeedsDisplayInRect:rect]; 1976 }); 1977} 1978 1979static void cocoa_switch(DisplayChangeListener *dcl, 1980 DisplaySurface *surface) 1981{ 1982 pixman_image_t *image = surface->image; 1983 1984 COCOA_DEBUG("qemu_cocoa: cocoa_switch\n"); 1985 1986 // The DisplaySurface will be freed as soon as this callback returns. 1987 // We take a reference to the underlying pixman image here so it does 1988 // not disappear from under our feet; the switchSurface method will 1989 // deref the old image when it is done with it. 1990 pixman_image_ref(image); 1991 1992 dispatch_async(dispatch_get_main_queue(), ^{ 1993 [cocoaView updateUIInfo]; 1994 [cocoaView switchSurface:image]; 1995 }); 1996} 1997 1998static void cocoa_refresh(DisplayChangeListener *dcl) 1999{ 2000 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 2001 2002 COCOA_DEBUG("qemu_cocoa: cocoa_refresh\n"); 2003 graphic_hw_update(NULL); 2004 2005 if (qemu_input_is_absolute(dcl->con)) { 2006 dispatch_async(dispatch_get_main_queue(), ^{ 2007 if (![cocoaView isAbsoluteEnabled]) { 2008 if ([cocoaView isMouseGrabbed]) { 2009 [cocoaView ungrabMouse]; 2010 } 2011 } 2012 [cocoaView setAbsoluteEnabled:YES]; 2013 }); 2014 } 2015 2016 if (cbchangecount != [[NSPasteboard generalPasteboard] changeCount]) { 2017 qemu_clipboard_info_unref(cbinfo); 2018 cbinfo = qemu_clipboard_info_new(&cbpeer, QEMU_CLIPBOARD_SELECTION_CLIPBOARD); 2019 if ([[NSPasteboard generalPasteboard] availableTypeFromArray:@[NSPasteboardTypeString]]) { 2020 cbinfo->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true; 2021 } 2022 qemu_clipboard_update(cbinfo); 2023 cbchangecount = [[NSPasteboard generalPasteboard] changeCount]; 2024 qemu_event_set(&cbevent); 2025 } 2026 2027 [pool release]; 2028} 2029 2030static void cocoa_display_init(DisplayState *ds, DisplayOptions *opts) 2031{ 2032 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 2033 2034 COCOA_DEBUG("qemu_cocoa: cocoa_display_init\n"); 2035 2036 qemu_main = cocoa_main; 2037 2038 // Pull this console process up to being a fully-fledged graphical 2039 // app with a menubar and Dock icon 2040 ProcessSerialNumber psn = { 0, kCurrentProcess }; 2041 TransformProcessType(&psn, kProcessTransformToForegroundApplication); 2042 2043 [QemuApplication sharedApplication]; 2044 2045 // Create an Application controller 2046 QemuCocoaAppController *controller = [[QemuCocoaAppController alloc] init]; 2047 [NSApp setDelegate:controller]; 2048 2049 /* if fullscreen mode is to be used */ 2050 if (opts->has_full_screen && opts->full_screen) { 2051 [NSApp activateIgnoringOtherApps: YES]; 2052 [controller toggleFullScreen: nil]; 2053 } 2054 if (opts->u.cocoa.has_full_grab && opts->u.cocoa.full_grab) { 2055 [controller setFullGrab: nil]; 2056 } 2057 2058 if (opts->has_show_cursor && opts->show_cursor) { 2059 cursor_hide = 0; 2060 } 2061 if (opts->u.cocoa.has_swap_opt_cmd) { 2062 swap_opt_cmd = opts->u.cocoa.swap_opt_cmd; 2063 } 2064 2065 if (opts->u.cocoa.has_left_command_key && !opts->u.cocoa.left_command_key) { 2066 left_command_key_enabled = 0; 2067 } 2068 2069 if (opts->u.cocoa.has_zoom_to_fit && opts->u.cocoa.zoom_to_fit) { 2070 stretch_video = true; 2071 } 2072 2073 create_initial_menus(); 2074 /* 2075 * Create the menu entries which depend on QEMU state (for consoles 2076 * and removable devices). These make calls back into QEMU functions, 2077 * which is OK because at this point we know that the second thread 2078 * holds the iothread lock and is synchronously waiting for us to 2079 * finish. 2080 */ 2081 add_console_menu_entries(); 2082 addRemovableDevicesMenuItems(); 2083 2084 // register vga output callbacks 2085 register_displaychangelistener(&dcl); 2086 2087 qemu_event_init(&cbevent, false); 2088 cbowner = [[QemuCocoaPasteboardTypeOwner alloc] init]; 2089 qemu_clipboard_peer_register(&cbpeer); 2090 2091 [pool release]; 2092} 2093 2094static QemuDisplay qemu_display_cocoa = { 2095 .type = DISPLAY_TYPE_COCOA, 2096 .init = cocoa_display_init, 2097}; 2098 2099static void register_cocoa(void) 2100{ 2101 qemu_display_register(&qemu_display_cocoa); 2102} 2103 2104type_init(register_cocoa); 2105
