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-common.h" 31#include "ui/console.h" 32#include "ui/input.h" 33#include "sysemu/sysemu.h" 34#include "qapi/error.h" 35#include "qapi/qapi-commands-block.h" 36#include "qapi/qapi-commands-misc.h" 37#include "sysemu/blockdev.h" 38#include "qemu-version.h" 39#include "qemu/module.h" 40#include <Carbon/Carbon.h> 41#include "qom/cpu.h" 42 43#ifndef MAC_OS_X_VERSION_10_5 44#define MAC_OS_X_VERSION_10_5 1050 45#endif 46#ifndef MAC_OS_X_VERSION_10_6 47#define MAC_OS_X_VERSION_10_6 1060 48#endif 49#ifndef MAC_OS_X_VERSION_10_9 50#define MAC_OS_X_VERSION_10_9 1090 51#endif 52#ifndef MAC_OS_X_VERSION_10_10 53#define MAC_OS_X_VERSION_10_10 101000 54#endif 55#ifndef MAC_OS_X_VERSION_10_12 56#define MAC_OS_X_VERSION_10_12 101200 57#endif 58#ifndef MAC_OS_X_VERSION_10_13 59#define MAC_OS_X_VERSION_10_13 101300 60#endif 61 62/* macOS 10.12 deprecated many constants, #define the new names for older SDKs */ 63#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_12 64#define NSEventMaskAny NSAnyEventMask 65#define NSEventModifierFlagCapsLock NSAlphaShiftKeyMask 66#define NSEventModifierFlagShift NSShiftKeyMask 67#define NSEventModifierFlagCommand NSCommandKeyMask 68#define NSEventModifierFlagControl NSControlKeyMask 69#define NSEventModifierFlagOption NSAlternateKeyMask 70#define NSEventTypeFlagsChanged NSFlagsChanged 71#define NSEventTypeKeyUp NSKeyUp 72#define NSEventTypeKeyDown NSKeyDown 73#define NSEventTypeMouseMoved NSMouseMoved 74#define NSEventTypeLeftMouseDown NSLeftMouseDown 75#define NSEventTypeRightMouseDown NSRightMouseDown 76#define NSEventTypeOtherMouseDown NSOtherMouseDown 77#define NSEventTypeLeftMouseDragged NSLeftMouseDragged 78#define NSEventTypeRightMouseDragged NSRightMouseDragged 79#define NSEventTypeOtherMouseDragged NSOtherMouseDragged 80#define NSEventTypeLeftMouseUp NSLeftMouseUp 81#define NSEventTypeRightMouseUp NSRightMouseUp 82#define NSEventTypeOtherMouseUp NSOtherMouseUp 83#define NSEventTypeScrollWheel NSScrollWheel 84#define NSTextAlignmentCenter NSCenterTextAlignment 85#define NSWindowStyleMaskBorderless NSBorderlessWindowMask 86#define NSWindowStyleMaskClosable NSClosableWindowMask 87#define NSWindowStyleMaskMiniaturizable NSMiniaturizableWindowMask 88#define NSWindowStyleMaskTitled NSTitledWindowMask 89#endif 90/* 10.13 deprecates NSFileHandlingPanelOKButton in favour of 91 * NSModalResponseOK, which was introduced in 10.9. Define 92 * it for older versions. 93 */ 94#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_9 95#define NSModalResponseOK NSFileHandlingPanelOKButton 96#endif 97/* 10.14 deprecates NSOnState and NSOffState in favor of 98 * NSControlStateValueOn/Off, which were introduced in 10.13. 99 * Define for older versions 100 */ 101#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_13 102#define NSControlStateValueOn NSOnState 103#define NSControlStateValueOff NSOffState 104#endif 105 106//#define DEBUG 107 108#ifdef DEBUG 109#define COCOA_DEBUG(...) { (void) fprintf (stdout, __VA_ARGS__); } 110#else 111#define COCOA_DEBUG(...) ((void) 0) 112#endif 113 114#define cgrect(nsrect) (*(CGRect *)&(nsrect)) 115 116typedef struct { 117 int width; 118 int height; 119 int bitsPerComponent; 120 int bitsPerPixel; 121} QEMUScreen; 122 123NSWindow *normalWindow, *about_window; 124static DisplayChangeListener *dcl; 125static int last_buttons; 126 127int gArgc; 128char **gArgv; 129bool stretch_video; 130NSTextField *pauseLabel; 131NSArray * supportedImageFileTypes; 132 133static QemuSemaphore display_init_sem; 134static QemuSemaphore app_started_sem; 135 136// Utility functions to run specified code block with iothread lock held 137typedef void (^CodeBlock)(void); 138typedef bool (^BoolCodeBlock)(void); 139 140static void with_iothread_lock(CodeBlock block) 141{ 142 bool locked = qemu_mutex_iothread_locked(); 143 if (!locked) { 144 qemu_mutex_lock_iothread(); 145 } 146 block(); 147 if (!locked) { 148 qemu_mutex_unlock_iothread(); 149 } 150} 151 152static bool bool_with_iothread_lock(BoolCodeBlock block) 153{ 154 bool locked = qemu_mutex_iothread_locked(); 155 bool val; 156 157 if (!locked) { 158 qemu_mutex_lock_iothread(); 159 } 160 val = block(); 161 if (!locked) { 162 qemu_mutex_unlock_iothread(); 163 } 164 return val; 165} 166 167// Mac to QKeyCode conversion 168const int mac_to_qkeycode_map[] = { 169 [kVK_ANSI_A] = Q_KEY_CODE_A, 170 [kVK_ANSI_B] = Q_KEY_CODE_B, 171 [kVK_ANSI_C] = Q_KEY_CODE_C, 172 [kVK_ANSI_D] = Q_KEY_CODE_D, 173 [kVK_ANSI_E] = Q_KEY_CODE_E, 174 [kVK_ANSI_F] = Q_KEY_CODE_F, 175 [kVK_ANSI_G] = Q_KEY_CODE_G, 176 [kVK_ANSI_H] = Q_KEY_CODE_H, 177 [kVK_ANSI_I] = Q_KEY_CODE_I, 178 [kVK_ANSI_J] = Q_KEY_CODE_J, 179 [kVK_ANSI_K] = Q_KEY_CODE_K, 180 [kVK_ANSI_L] = Q_KEY_CODE_L, 181 [kVK_ANSI_M] = Q_KEY_CODE_M, 182 [kVK_ANSI_N] = Q_KEY_CODE_N, 183 [kVK_ANSI_O] = Q_KEY_CODE_O, 184 [kVK_ANSI_P] = Q_KEY_CODE_P, 185 [kVK_ANSI_Q] = Q_KEY_CODE_Q, 186 [kVK_ANSI_R] = Q_KEY_CODE_R, 187 [kVK_ANSI_S] = Q_KEY_CODE_S, 188 [kVK_ANSI_T] = Q_KEY_CODE_T, 189 [kVK_ANSI_U] = Q_KEY_CODE_U, 190 [kVK_ANSI_V] = Q_KEY_CODE_V, 191 [kVK_ANSI_W] = Q_KEY_CODE_W, 192 [kVK_ANSI_X] = Q_KEY_CODE_X, 193 [kVK_ANSI_Y] = Q_KEY_CODE_Y, 194 [kVK_ANSI_Z] = Q_KEY_CODE_Z, 195 196 [kVK_ANSI_0] = Q_KEY_CODE_0, 197 [kVK_ANSI_1] = Q_KEY_CODE_1, 198 [kVK_ANSI_2] = Q_KEY_CODE_2, 199 [kVK_ANSI_3] = Q_KEY_CODE_3, 200 [kVK_ANSI_4] = Q_KEY_CODE_4, 201 [kVK_ANSI_5] = Q_KEY_CODE_5, 202 [kVK_ANSI_6] = Q_KEY_CODE_6, 203 [kVK_ANSI_7] = Q_KEY_CODE_7, 204 [kVK_ANSI_8] = Q_KEY_CODE_8, 205 [kVK_ANSI_9] = Q_KEY_CODE_9, 206 207 [kVK_ANSI_Grave] = Q_KEY_CODE_GRAVE_ACCENT, 208 [kVK_ANSI_Minus] = Q_KEY_CODE_MINUS, 209 [kVK_ANSI_Equal] = Q_KEY_CODE_EQUAL, 210 [kVK_Delete] = Q_KEY_CODE_BACKSPACE, 211 [kVK_CapsLock] = Q_KEY_CODE_CAPS_LOCK, 212 [kVK_Tab] = Q_KEY_CODE_TAB, 213 [kVK_Return] = Q_KEY_CODE_RET, 214 [kVK_ANSI_LeftBracket] = Q_KEY_CODE_BRACKET_LEFT, 215 [kVK_ANSI_RightBracket] = Q_KEY_CODE_BRACKET_RIGHT, 216 [kVK_ANSI_Backslash] = Q_KEY_CODE_BACKSLASH, 217 [kVK_ANSI_Semicolon] = Q_KEY_CODE_SEMICOLON, 218 [kVK_ANSI_Quote] = Q_KEY_CODE_APOSTROPHE, 219 [kVK_ANSI_Comma] = Q_KEY_CODE_COMMA, 220 [kVK_ANSI_Period] = Q_KEY_CODE_DOT, 221 [kVK_ANSI_Slash] = Q_KEY_CODE_SLASH, 222 [kVK_Shift] = Q_KEY_CODE_SHIFT, 223 [kVK_RightShift] = Q_KEY_CODE_SHIFT_R, 224 [kVK_Control] = Q_KEY_CODE_CTRL, 225 [kVK_RightControl] = Q_KEY_CODE_CTRL_R, 226 [kVK_Option] = Q_KEY_CODE_ALT, 227 [kVK_RightOption] = Q_KEY_CODE_ALT_R, 228 [kVK_Command] = Q_KEY_CODE_META_L, 229 [0x36] = Q_KEY_CODE_META_R, /* There is no kVK_RightCommand */ 230 [kVK_Space] = Q_KEY_CODE_SPC, 231 232 [kVK_ANSI_Keypad0] = Q_KEY_CODE_KP_0, 233 [kVK_ANSI_Keypad1] = Q_KEY_CODE_KP_1, 234 [kVK_ANSI_Keypad2] = Q_KEY_CODE_KP_2, 235 [kVK_ANSI_Keypad3] = Q_KEY_CODE_KP_3, 236 [kVK_ANSI_Keypad4] = Q_KEY_CODE_KP_4, 237 [kVK_ANSI_Keypad5] = Q_KEY_CODE_KP_5, 238 [kVK_ANSI_Keypad6] = Q_KEY_CODE_KP_6, 239 [kVK_ANSI_Keypad7] = Q_KEY_CODE_KP_7, 240 [kVK_ANSI_Keypad8] = Q_KEY_CODE_KP_8, 241 [kVK_ANSI_Keypad9] = Q_KEY_CODE_KP_9, 242 [kVK_ANSI_KeypadDecimal] = Q_KEY_CODE_KP_DECIMAL, 243 [kVK_ANSI_KeypadEnter] = Q_KEY_CODE_KP_ENTER, 244 [kVK_ANSI_KeypadPlus] = Q_KEY_CODE_KP_ADD, 245 [kVK_ANSI_KeypadMinus] = Q_KEY_CODE_KP_SUBTRACT, 246 [kVK_ANSI_KeypadMultiply] = Q_KEY_CODE_KP_MULTIPLY, 247 [kVK_ANSI_KeypadDivide] = Q_KEY_CODE_KP_DIVIDE, 248 [kVK_ANSI_KeypadEquals] = Q_KEY_CODE_KP_EQUALS, 249 [kVK_ANSI_KeypadClear] = Q_KEY_CODE_NUM_LOCK, 250 251 [kVK_UpArrow] = Q_KEY_CODE_UP, 252 [kVK_DownArrow] = Q_KEY_CODE_DOWN, 253 [kVK_LeftArrow] = Q_KEY_CODE_LEFT, 254 [kVK_RightArrow] = Q_KEY_CODE_RIGHT, 255 256 [kVK_Help] = Q_KEY_CODE_INSERT, 257 [kVK_Home] = Q_KEY_CODE_HOME, 258 [kVK_PageUp] = Q_KEY_CODE_PGUP, 259 [kVK_PageDown] = Q_KEY_CODE_PGDN, 260 [kVK_End] = Q_KEY_CODE_END, 261 [kVK_ForwardDelete] = Q_KEY_CODE_DELETE, 262 263 [kVK_Escape] = Q_KEY_CODE_ESC, 264 265 /* The Power key can't be used directly because the operating system uses 266 * it. This key can be emulated by using it in place of another key such as 267 * F1. Don't forget to disable the real key binding. 268 */ 269 /* [kVK_F1] = Q_KEY_CODE_POWER, */ 270 271 [kVK_F1] = Q_KEY_CODE_F1, 272 [kVK_F2] = Q_KEY_CODE_F2, 273 [kVK_F3] = Q_KEY_CODE_F3, 274 [kVK_F4] = Q_KEY_CODE_F4, 275 [kVK_F5] = Q_KEY_CODE_F5, 276 [kVK_F6] = Q_KEY_CODE_F6, 277 [kVK_F7] = Q_KEY_CODE_F7, 278 [kVK_F8] = Q_KEY_CODE_F8, 279 [kVK_F9] = Q_KEY_CODE_F9, 280 [kVK_F10] = Q_KEY_CODE_F10, 281 [kVK_F11] = Q_KEY_CODE_F11, 282 [kVK_F12] = Q_KEY_CODE_F12, 283 [kVK_F13] = Q_KEY_CODE_PRINT, 284 [kVK_F14] = Q_KEY_CODE_SCROLL_LOCK, 285 [kVK_F15] = Q_KEY_CODE_PAUSE, 286 287 /* 288 * The eject and volume keys can't be used here because they are handled at 289 * a lower level than what an Application can see. 290 */ 291}; 292 293static int cocoa_keycode_to_qemu(int keycode) 294{ 295 if (ARRAY_SIZE(mac_to_qkeycode_map) <= keycode) { 296 fprintf(stderr, "(cocoa) warning unknown keycode 0x%x\n", keycode); 297 return 0; 298 } 299 return mac_to_qkeycode_map[keycode]; 300} 301 302/* Displays an alert dialog box with the specified message */ 303static void QEMU_Alert(NSString *message) 304{ 305 NSAlert *alert; 306 alert = [NSAlert new]; 307 [alert setMessageText: message]; 308 [alert runModal]; 309} 310 311/* Handles any errors that happen with a device transaction */ 312static void handleAnyDeviceErrors(Error * err) 313{ 314 if (err) { 315 QEMU_Alert([NSString stringWithCString: error_get_pretty(err) 316 encoding: NSASCIIStringEncoding]); 317 error_free(err); 318 } 319} 320 321/* 322 ------------------------------------------------------ 323 QemuCocoaView 324 ------------------------------------------------------ 325*/ 326@interface QemuCocoaView : NSView 327{ 328 QEMUScreen screen; 329 NSWindow *fullScreenWindow; 330 float cx,cy,cw,ch,cdx,cdy; 331 CGDataProviderRef dataProviderRef; 332 pixman_image_t *pixman_image; 333 BOOL modifiers_state[256]; 334 BOOL isMouseGrabbed; 335 BOOL isFullscreen; 336 BOOL isAbsoluteEnabled; 337 BOOL isMouseDeassociated; 338} 339- (void) switchSurface:(pixman_image_t *)image; 340- (void) grabMouse; 341- (void) ungrabMouse; 342- (void) toggleFullScreen:(id)sender; 343- (void) handleMonitorInput:(NSEvent *)event; 344- (bool) handleEvent:(NSEvent *)event; 345- (bool) handleEventLocked:(NSEvent *)event; 346- (void) setAbsoluteEnabled:(BOOL)tIsAbsoluteEnabled; 347/* The state surrounding mouse grabbing is potentially confusing. 348 * isAbsoluteEnabled tracks qemu_input_is_absolute() [ie "is the emulated 349 * pointing device an absolute-position one?"], but is only updated on 350 * next refresh. 351 * isMouseGrabbed tracks whether GUI events are directed to the guest; 352 * it controls whether special keys like Cmd get sent to the guest, 353 * and whether we capture the mouse when in non-absolute mode. 354 * isMouseDeassociated tracks whether we've told MacOSX to disassociate 355 * the mouse and mouse cursor position by calling 356 * CGAssociateMouseAndMouseCursorPosition(FALSE) 357 * (which basically happens if we grab in non-absolute mode). 358 */ 359- (BOOL) isMouseGrabbed; 360- (BOOL) isAbsoluteEnabled; 361- (BOOL) isMouseDeassociated; 362- (float) cdx; 363- (float) cdy; 364- (QEMUScreen) gscreen; 365- (void) raiseAllKeys; 366@end 367 368QemuCocoaView *cocoaView; 369 370@implementation QemuCocoaView 371- (id)initWithFrame:(NSRect)frameRect 372{ 373 COCOA_DEBUG("QemuCocoaView: initWithFrame\n"); 374 375 self = [super initWithFrame:frameRect]; 376 if (self) { 377 378 screen.bitsPerComponent = 8; 379 screen.bitsPerPixel = 32; 380 screen.width = frameRect.size.width; 381 screen.height = frameRect.size.height; 382 383 } 384 return self; 385} 386 387- (void) dealloc 388{ 389 COCOA_DEBUG("QemuCocoaView: dealloc\n"); 390 391 if (dataProviderRef) { 392 CGDataProviderRelease(dataProviderRef); 393 pixman_image_unref(pixman_image); 394 } 395 396 [super dealloc]; 397} 398 399- (BOOL) isOpaque 400{ 401 return YES; 402} 403 404- (BOOL) screenContainsPoint:(NSPoint) p 405{ 406 return (p.x > -1 && p.x < screen.width && p.y > -1 && p.y < screen.height); 407} 408 409- (void) hideCursor 410{ 411 if (!cursor_hide) { 412 return; 413 } 414 [NSCursor hide]; 415} 416 417- (void) unhideCursor 418{ 419 if (!cursor_hide) { 420 return; 421 } 422 [NSCursor unhide]; 423} 424 425- (void) drawRect:(NSRect) rect 426{ 427 COCOA_DEBUG("QemuCocoaView: drawRect\n"); 428 429 // get CoreGraphic context 430#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_10 431 CGContextRef viewContextRef = [[NSGraphicsContext currentContext] graphicsPort]; 432#else 433 CGContextRef viewContextRef = [[NSGraphicsContext currentContext] CGContext]; 434#endif 435 436 CGContextSetInterpolationQuality (viewContextRef, kCGInterpolationNone); 437 CGContextSetShouldAntialias (viewContextRef, NO); 438 439 // draw screen bitmap directly to Core Graphics context 440 if (!dataProviderRef) { 441 // Draw request before any guest device has set up a framebuffer: 442 // just draw an opaque black rectangle 443 CGContextSetRGBFillColor(viewContextRef, 0, 0, 0, 1.0); 444 CGContextFillRect(viewContextRef, NSRectToCGRect(rect)); 445 } else { 446 CGImageRef imageRef = CGImageCreate( 447 screen.width, //width 448 screen.height, //height 449 screen.bitsPerComponent, //bitsPerComponent 450 screen.bitsPerPixel, //bitsPerPixel 451 (screen.width * (screen.bitsPerComponent/2)), //bytesPerRow 452#ifdef __LITTLE_ENDIAN__ 453 CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB), //colorspace for OS X >= 10.4 454 kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst, 455#else 456 CGColorSpaceCreateDeviceRGB(), //colorspace for OS X < 10.4 (actually ppc) 457 kCGImageAlphaNoneSkipFirst, //bitmapInfo 458#endif 459 dataProviderRef, //provider 460 NULL, //decode 461 0, //interpolate 462 kCGRenderingIntentDefault //intent 463 ); 464 // selective drawing code (draws only dirty rectangles) (OS X >= 10.4) 465 const NSRect *rectList; 466 NSInteger rectCount; 467 int i; 468 CGImageRef clipImageRef; 469 CGRect clipRect; 470 471 [self getRectsBeingDrawn:&rectList count:&rectCount]; 472 for (i = 0; i < rectCount; i++) { 473 clipRect.origin.x = rectList[i].origin.x / cdx; 474 clipRect.origin.y = (float)screen.height - (rectList[i].origin.y + rectList[i].size.height) / cdy; 475 clipRect.size.width = rectList[i].size.width / cdx; 476 clipRect.size.height = rectList[i].size.height / cdy; 477 clipImageRef = CGImageCreateWithImageInRect( 478 imageRef, 479 clipRect 480 ); 481 CGContextDrawImage (viewContextRef, cgrect(rectList[i]), clipImageRef); 482 CGImageRelease (clipImageRef); 483 } 484 CGImageRelease (imageRef); 485 } 486} 487 488- (void) setContentDimensions 489{ 490 COCOA_DEBUG("QemuCocoaView: setContentDimensions\n"); 491 492 if (isFullscreen) { 493 cdx = [[NSScreen mainScreen] frame].size.width / (float)screen.width; 494 cdy = [[NSScreen mainScreen] frame].size.height / (float)screen.height; 495 496 /* stretches video, but keeps same aspect ratio */ 497 if (stretch_video == true) { 498 /* use smallest stretch value - prevents clipping on sides */ 499 if (MIN(cdx, cdy) == cdx) { 500 cdy = cdx; 501 } else { 502 cdx = cdy; 503 } 504 } else { /* No stretching */ 505 cdx = cdy = 1; 506 } 507 cw = screen.width * cdx; 508 ch = screen.height * cdy; 509 cx = ([[NSScreen mainScreen] frame].size.width - cw) / 2.0; 510 cy = ([[NSScreen mainScreen] frame].size.height - ch) / 2.0; 511 } else { 512 cx = 0; 513 cy = 0; 514 cw = screen.width; 515 ch = screen.height; 516 cdx = 1.0; 517 cdy = 1.0; 518 } 519} 520 521- (void) switchSurface:(pixman_image_t *)image 522{ 523 COCOA_DEBUG("QemuCocoaView: switchSurface\n"); 524 525 int w = pixman_image_get_width(image); 526 int h = pixman_image_get_height(image); 527 pixman_format_code_t image_format = pixman_image_get_format(image); 528 /* cdx == 0 means this is our very first surface, in which case we need 529 * to recalculate the content dimensions even if it happens to be the size 530 * of the initial empty window. 531 */ 532 bool isResize = (w != screen.width || h != screen.height || cdx == 0.0); 533 534 int oldh = screen.height; 535 if (isResize) { 536 // Resize before we trigger the redraw, or we'll redraw at the wrong size 537 COCOA_DEBUG("switchSurface: new size %d x %d\n", w, h); 538 screen.width = w; 539 screen.height = h; 540 [self setContentDimensions]; 541 [self setFrame:NSMakeRect(cx, cy, cw, ch)]; 542 } 543 544 // update screenBuffer 545 if (dataProviderRef) { 546 CGDataProviderRelease(dataProviderRef); 547 pixman_image_unref(pixman_image); 548 } 549 550 //sync host window color space with guests 551 screen.bitsPerPixel = PIXMAN_FORMAT_BPP(image_format); 552 screen.bitsPerComponent = DIV_ROUND_UP(screen.bitsPerPixel, 8) * 2; 553 554 pixman_image = image; 555 dataProviderRef = CGDataProviderCreateWithData(NULL, pixman_image_get_data(image), w * 4 * h, NULL); 556 557 // update windows 558 if (isFullscreen) { 559 [[fullScreenWindow contentView] setFrame:[[NSScreen mainScreen] frame]]; 560 [normalWindow setFrame:NSMakeRect([normalWindow frame].origin.x, [normalWindow frame].origin.y - h + oldh, w, h + [normalWindow frame].size.height - oldh) display:NO animate:NO]; 561 } else { 562 if (qemu_name) 563 [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s", qemu_name]]; 564 [normalWindow setFrame:NSMakeRect([normalWindow frame].origin.x, [normalWindow frame].origin.y - h + oldh, w, h + [normalWindow frame].size.height - oldh) display:YES animate:NO]; 565 } 566 567 if (isResize) { 568 [normalWindow center]; 569 } 570} 571 572- (void) toggleFullScreen:(id)sender 573{ 574 COCOA_DEBUG("QemuCocoaView: toggleFullScreen\n"); 575 576 if (isFullscreen) { // switch from fullscreen to desktop 577 isFullscreen = FALSE; 578 [self ungrabMouse]; 579 [self setContentDimensions]; 580 if ([NSView respondsToSelector:@selector(exitFullScreenModeWithOptions:)]) { // test if "exitFullScreenModeWithOptions" is supported on host at runtime 581 [self exitFullScreenModeWithOptions:nil]; 582 } else { 583 [fullScreenWindow close]; 584 [normalWindow setContentView: self]; 585 [normalWindow makeKeyAndOrderFront: self]; 586 [NSMenu setMenuBarVisible:YES]; 587 } 588 } else { // switch from desktop to fullscreen 589 isFullscreen = TRUE; 590 [normalWindow orderOut: nil]; /* Hide the window */ 591 [self grabMouse]; 592 [self setContentDimensions]; 593 if ([NSView respondsToSelector:@selector(enterFullScreenMode:withOptions:)]) { // test if "enterFullScreenMode:withOptions" is supported on host at runtime 594 [self enterFullScreenMode:[NSScreen mainScreen] withOptions:[NSDictionary dictionaryWithObjectsAndKeys: 595 [NSNumber numberWithBool:NO], NSFullScreenModeAllScreens, 596 [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:NO], kCGDisplayModeIsStretched, nil], NSFullScreenModeSetting, 597 nil]]; 598 } else { 599 [NSMenu setMenuBarVisible:NO]; 600 fullScreenWindow = [[NSWindow alloc] initWithContentRect:[[NSScreen mainScreen] frame] 601 styleMask:NSWindowStyleMaskBorderless 602 backing:NSBackingStoreBuffered 603 defer:NO]; 604 [fullScreenWindow setAcceptsMouseMovedEvents: YES]; 605 [fullScreenWindow setHasShadow:NO]; 606 [fullScreenWindow setBackgroundColor: [NSColor blackColor]]; 607 [self setFrame:NSMakeRect(cx, cy, cw, ch)]; 608 [[fullScreenWindow contentView] addSubview: self]; 609 [fullScreenWindow makeKeyAndOrderFront:self]; 610 } 611 } 612} 613 614- (void) toggleModifier: (int)keycode { 615 // Toggle the stored state. 616 modifiers_state[keycode] = !modifiers_state[keycode]; 617 // Send a keyup or keydown depending on the state. 618 qemu_input_event_send_key_qcode(dcl->con, keycode, modifiers_state[keycode]); 619} 620 621- (void) toggleStatefulModifier: (int)keycode { 622 // Toggle the stored state. 623 modifiers_state[keycode] = !modifiers_state[keycode]; 624 // Generate keydown and keyup. 625 qemu_input_event_send_key_qcode(dcl->con, keycode, true); 626 qemu_input_event_send_key_qcode(dcl->con, keycode, false); 627} 628 629// Does the work of sending input to the monitor 630- (void) handleMonitorInput:(NSEvent *)event 631{ 632 int keysym = 0; 633 int control_key = 0; 634 635 // if the control key is down 636 if ([event modifierFlags] & NSEventModifierFlagControl) { 637 control_key = 1; 638 } 639 640 /* translates Macintosh keycodes to QEMU's keysym */ 641 642 int without_control_translation[] = { 643 [0 ... 0xff] = 0, // invalid key 644 645 [kVK_UpArrow] = QEMU_KEY_UP, 646 [kVK_DownArrow] = QEMU_KEY_DOWN, 647 [kVK_RightArrow] = QEMU_KEY_RIGHT, 648 [kVK_LeftArrow] = QEMU_KEY_LEFT, 649 [kVK_Home] = QEMU_KEY_HOME, 650 [kVK_End] = QEMU_KEY_END, 651 [kVK_PageUp] = QEMU_KEY_PAGEUP, 652 [kVK_PageDown] = QEMU_KEY_PAGEDOWN, 653 [kVK_ForwardDelete] = QEMU_KEY_DELETE, 654 [kVK_Delete] = QEMU_KEY_BACKSPACE, 655 }; 656 657 int with_control_translation[] = { 658 [0 ... 0xff] = 0, // invalid key 659 660 [kVK_UpArrow] = QEMU_KEY_CTRL_UP, 661 [kVK_DownArrow] = QEMU_KEY_CTRL_DOWN, 662 [kVK_RightArrow] = QEMU_KEY_CTRL_RIGHT, 663 [kVK_LeftArrow] = QEMU_KEY_CTRL_LEFT, 664 [kVK_Home] = QEMU_KEY_CTRL_HOME, 665 [kVK_End] = QEMU_KEY_CTRL_END, 666 [kVK_PageUp] = QEMU_KEY_CTRL_PAGEUP, 667 [kVK_PageDown] = QEMU_KEY_CTRL_PAGEDOWN, 668 }; 669 670 if (control_key != 0) { /* If the control key is being used */ 671 if ([event keyCode] < ARRAY_SIZE(with_control_translation)) { 672 keysym = with_control_translation[[event keyCode]]; 673 } 674 } else { 675 if ([event keyCode] < ARRAY_SIZE(without_control_translation)) { 676 keysym = without_control_translation[[event keyCode]]; 677 } 678 } 679 680 // if not a key that needs translating 681 if (keysym == 0) { 682 NSString *ks = [event characters]; 683 if ([ks length] > 0) { 684 keysym = [ks characterAtIndex:0]; 685 } 686 } 687 688 if (keysym) { 689 kbd_put_keysym(keysym); 690 } 691} 692 693- (bool) handleEvent:(NSEvent *)event 694{ 695 return bool_with_iothread_lock(^{ 696 return [self handleEventLocked:event]; 697 }); 698} 699 700- (bool) handleEventLocked:(NSEvent *)event 701{ 702 /* Return true if we handled the event, false if it should be given to OSX */ 703 COCOA_DEBUG("QemuCocoaView: handleEvent\n"); 704 int buttons = 0; 705 int keycode = 0; 706 bool mouse_event = false; 707 static bool switched_to_fullscreen = false; 708 NSPoint p = [event locationInWindow]; 709 710 switch ([event type]) { 711 case NSEventTypeFlagsChanged: 712 if ([event keyCode] == 0) { 713 // When the Cocoa keyCode is zero that means keys should be 714 // synthesized based on the values in in the eventModifiers 715 // bitmask. 716 717 if (qemu_console_is_graphic(NULL)) { 718 NSUInteger modifiers = [event modifierFlags]; 719 720 if (!!(modifiers & NSEventModifierFlagCapsLock) != !!modifiers_state[Q_KEY_CODE_CAPS_LOCK]) { 721 [self toggleStatefulModifier:Q_KEY_CODE_CAPS_LOCK]; 722 } 723 if (!!(modifiers & NSEventModifierFlagShift) != !!modifiers_state[Q_KEY_CODE_SHIFT]) { 724 [self toggleModifier:Q_KEY_CODE_SHIFT]; 725 } 726 if (!!(modifiers & NSEventModifierFlagControl) != !!modifiers_state[Q_KEY_CODE_CTRL]) { 727 [self toggleModifier:Q_KEY_CODE_CTRL]; 728 } 729 if (!!(modifiers & NSEventModifierFlagOption) != !!modifiers_state[Q_KEY_CODE_ALT]) { 730 [self toggleModifier:Q_KEY_CODE_ALT]; 731 } 732 if (!!(modifiers & NSEventModifierFlagCommand) != !!modifiers_state[Q_KEY_CODE_META_L]) { 733 [self toggleModifier:Q_KEY_CODE_META_L]; 734 } 735 } 736 } else { 737 keycode = cocoa_keycode_to_qemu([event keyCode]); 738 } 739 740 if ((keycode == Q_KEY_CODE_META_L || keycode == Q_KEY_CODE_META_R) 741 && !isMouseGrabbed) { 742 /* Don't pass command key changes to guest unless mouse is grabbed */ 743 keycode = 0; 744 } 745 746 if (keycode) { 747 // emulate caps lock and num lock keydown and keyup 748 if (keycode == Q_KEY_CODE_CAPS_LOCK || 749 keycode == Q_KEY_CODE_NUM_LOCK) { 750 [self toggleStatefulModifier:keycode]; 751 } else if (qemu_console_is_graphic(NULL)) { 752 if (switched_to_fullscreen) { 753 switched_to_fullscreen = false; 754 } else { 755 [self toggleModifier:keycode]; 756 } 757 } 758 } 759 760 break; 761 case NSEventTypeKeyDown: 762 keycode = cocoa_keycode_to_qemu([event keyCode]); 763 764 // forward command key combos to the host UI unless the mouse is grabbed 765 if (!isMouseGrabbed && ([event modifierFlags] & NSEventModifierFlagCommand)) { 766 /* 767 * Prevent the command key from being stuck down in the guest 768 * when using Command-F to switch to full screen mode. 769 */ 770 if (keycode == Q_KEY_CODE_F) { 771 switched_to_fullscreen = true; 772 } 773 return false; 774 } 775 776 // default 777 778 // handle control + alt Key Combos (ctrl+alt+[1..9,g] is reserved for QEMU) 779 if (([event modifierFlags] & NSEventModifierFlagControl) && ([event modifierFlags] & NSEventModifierFlagOption)) { 780 NSString *keychar = [event charactersIgnoringModifiers]; 781 if ([keychar length] == 1) { 782 char key = [keychar characterAtIndex:0]; 783 switch (key) { 784 785 // enable graphic console 786 case '1' ... '9': 787 console_select(key - '0' - 1); /* ascii math */ 788 return true; 789 790 // release the mouse grab 791 case 'g': 792 [self ungrabMouse]; 793 return true; 794 } 795 } 796 } 797 798 if (qemu_console_is_graphic(NULL)) { 799 qemu_input_event_send_key_qcode(dcl->con, keycode, true); 800 } else { 801 [self handleMonitorInput: event]; 802 } 803 break; 804 case NSEventTypeKeyUp: 805 keycode = cocoa_keycode_to_qemu([event keyCode]); 806 807 // don't pass the guest a spurious key-up if we treated this 808 // command-key combo as a host UI action 809 if (!isMouseGrabbed && ([event modifierFlags] & NSEventModifierFlagCommand)) { 810 return true; 811 } 812 813 if (qemu_console_is_graphic(NULL)) { 814 qemu_input_event_send_key_qcode(dcl->con, keycode, false); 815 } 816 break; 817 case NSEventTypeMouseMoved: 818 if (isAbsoluteEnabled) { 819 if (![self screenContainsPoint:p] || ![[self window] isKeyWindow]) { 820 if (isMouseGrabbed) { 821 [self ungrabMouse]; 822 } 823 } else { 824 if (!isMouseGrabbed) { 825 [self grabMouse]; 826 } 827 } 828 } 829 mouse_event = true; 830 break; 831 case NSEventTypeLeftMouseDown: 832 if ([event modifierFlags] & NSEventModifierFlagCommand) { 833 buttons |= MOUSE_EVENT_RBUTTON; 834 } else { 835 buttons |= MOUSE_EVENT_LBUTTON; 836 } 837 mouse_event = true; 838 break; 839 case NSEventTypeRightMouseDown: 840 buttons |= MOUSE_EVENT_RBUTTON; 841 mouse_event = true; 842 break; 843 case NSEventTypeOtherMouseDown: 844 buttons |= MOUSE_EVENT_MBUTTON; 845 mouse_event = true; 846 break; 847 case NSEventTypeLeftMouseDragged: 848 if ([event modifierFlags] & NSEventModifierFlagCommand) { 849 buttons |= MOUSE_EVENT_RBUTTON; 850 } else { 851 buttons |= MOUSE_EVENT_LBUTTON; 852 } 853 mouse_event = true; 854 break; 855 case NSEventTypeRightMouseDragged: 856 buttons |= MOUSE_EVENT_RBUTTON; 857 mouse_event = true; 858 break; 859 case NSEventTypeOtherMouseDragged: 860 buttons |= MOUSE_EVENT_MBUTTON; 861 mouse_event = true; 862 break; 863 case NSEventTypeLeftMouseUp: 864 mouse_event = true; 865 if (!isMouseGrabbed && [self screenContainsPoint:p]) { 866 if([[self window] isKeyWindow]) { 867 [self grabMouse]; 868 } 869 } 870 break; 871 case NSEventTypeRightMouseUp: 872 mouse_event = true; 873 break; 874 case NSEventTypeOtherMouseUp: 875 mouse_event = true; 876 break; 877 case NSEventTypeScrollWheel: 878 /* 879 * Send wheel events to the guest regardless of window focus. 880 * This is in-line with standard Mac OS X UI behaviour. 881 */ 882 883 /* 884 * When deltaY is zero, it means that this scrolling event was 885 * either horizontal, or so fine that it only appears in 886 * scrollingDeltaY. So we drop the event. 887 */ 888 if ([event deltaY] != 0) { 889 /* Determine if this is a scroll up or scroll down event */ 890 buttons = ([event deltaY] > 0) ? 891 INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN; 892 qemu_input_queue_btn(dcl->con, buttons, true); 893 qemu_input_event_sync(); 894 qemu_input_queue_btn(dcl->con, buttons, false); 895 qemu_input_event_sync(); 896 } 897 /* 898 * Since deltaY also reports scroll wheel events we prevent mouse 899 * movement code from executing. 900 */ 901 mouse_event = false; 902 break; 903 default: 904 return false; 905 } 906 907 if (mouse_event) { 908 /* Don't send button events to the guest unless we've got a 909 * mouse grab or window focus. If we have neither then this event 910 * is the user clicking on the background window to activate and 911 * bring us to the front, which will be done by the sendEvent 912 * call below. We definitely don't want to pass that click through 913 * to the guest. 914 */ 915 if ((isMouseGrabbed || [[self window] isKeyWindow]) && 916 (last_buttons != buttons)) { 917 static uint32_t bmap[INPUT_BUTTON__MAX] = { 918 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON, 919 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON, 920 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON 921 }; 922 qemu_input_update_buttons(dcl->con, bmap, last_buttons, buttons); 923 last_buttons = buttons; 924 } 925 if (isMouseGrabbed) { 926 if (isAbsoluteEnabled) { 927 /* Note that the origin for Cocoa mouse coords is bottom left, not top left. 928 * The check on screenContainsPoint is to avoid sending out of range values for 929 * clicks in the titlebar. 930 */ 931 if ([self screenContainsPoint:p]) { 932 qemu_input_queue_abs(dcl->con, INPUT_AXIS_X, p.x, 0, screen.width); 933 qemu_input_queue_abs(dcl->con, INPUT_AXIS_Y, screen.height - p.y, 0, screen.height); 934 } 935 } else { 936 qemu_input_queue_rel(dcl->con, INPUT_AXIS_X, (int)[event deltaX]); 937 qemu_input_queue_rel(dcl->con, INPUT_AXIS_Y, (int)[event deltaY]); 938 } 939 } else { 940 return false; 941 } 942 qemu_input_event_sync(); 943 } 944 return true; 945} 946 947- (void) grabMouse 948{ 949 COCOA_DEBUG("QemuCocoaView: grabMouse\n"); 950 951 if (!isFullscreen) { 952 if (qemu_name) 953 [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s - (Press ctrl + alt + g to release Mouse)", qemu_name]]; 954 else 955 [normalWindow setTitle:@"QEMU - (Press ctrl + alt + g to release Mouse)"]; 956 } 957 [self hideCursor]; 958 if (!isAbsoluteEnabled) { 959 isMouseDeassociated = TRUE; 960 CGAssociateMouseAndMouseCursorPosition(FALSE); 961 } 962 isMouseGrabbed = TRUE; // while isMouseGrabbed = TRUE, QemuCocoaApp sends all events to [cocoaView handleEvent:] 963} 964 965- (void) ungrabMouse 966{ 967 COCOA_DEBUG("QemuCocoaView: ungrabMouse\n"); 968 969 if (!isFullscreen) { 970 if (qemu_name) 971 [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s", qemu_name]]; 972 else 973 [normalWindow setTitle:@"QEMU"]; 974 } 975 [self unhideCursor]; 976 if (isMouseDeassociated) { 977 CGAssociateMouseAndMouseCursorPosition(TRUE); 978 isMouseDeassociated = FALSE; 979 } 980 isMouseGrabbed = FALSE; 981} 982 983- (void) setAbsoluteEnabled:(BOOL)tIsAbsoluteEnabled {isAbsoluteEnabled = tIsAbsoluteEnabled;} 984- (BOOL) isMouseGrabbed {return isMouseGrabbed;} 985- (BOOL) isAbsoluteEnabled {return isAbsoluteEnabled;} 986- (BOOL) isMouseDeassociated {return isMouseDeassociated;} 987- (float) cdx {return cdx;} 988- (float) cdy {return cdy;} 989- (QEMUScreen) gscreen {return screen;} 990 991/* 992 * Makes the target think all down keys are being released. 993 * This prevents a stuck key problem, since we will not see 994 * key up events for those keys after we have lost focus. 995 */ 996- (void) raiseAllKeys 997{ 998 const int max_index = ARRAY_SIZE(modifiers_state); 999 1000 with_iothread_lock(^{ 1001 int index; 1002 1003 for (index = 0; index < max_index; index++) { 1004 if (modifiers_state[index]) { 1005 modifiers_state[index] = 0; 1006 qemu_input_event_send_key_qcode(dcl->con, index, false); 1007 } 1008 } 1009 }); 1010} 1011@end 1012 1013 1014 1015/* 1016 ------------------------------------------------------ 1017 QemuCocoaAppController 1018 ------------------------------------------------------ 1019*/ 1020@interface QemuCocoaAppController : NSObject 1021#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6) 1022 <NSWindowDelegate, NSApplicationDelegate> 1023#endif 1024{ 1025} 1026- (void)doToggleFullScreen:(id)sender; 1027- (void)toggleFullScreen:(id)sender; 1028- (void)showQEMUDoc:(id)sender; 1029- (void)zoomToFit:(id) sender; 1030- (void)displayConsole:(id)sender; 1031- (void)pauseQEMU:(id)sender; 1032- (void)resumeQEMU:(id)sender; 1033- (void)displayPause; 1034- (void)removePause; 1035- (void)restartQEMU:(id)sender; 1036- (void)powerDownQEMU:(id)sender; 1037- (void)ejectDeviceMedia:(id)sender; 1038- (void)changeDeviceMedia:(id)sender; 1039- (BOOL)verifyQuit; 1040- (void)openDocumentation:(NSString *)filename; 1041- (IBAction) do_about_menu_item: (id) sender; 1042- (void)make_about_window; 1043- (void)adjustSpeed:(id)sender; 1044@end 1045 1046@implementation QemuCocoaAppController 1047- (id) init 1048{ 1049 COCOA_DEBUG("QemuCocoaAppController: init\n"); 1050 1051 self = [super init]; 1052 if (self) { 1053 1054 // create a view and add it to the window 1055 cocoaView = [[QemuCocoaView alloc] initWithFrame:NSMakeRect(0.0, 0.0, 640.0, 480.0)]; 1056 if(!cocoaView) { 1057 fprintf(stderr, "(cocoa) can't create a view\n"); 1058 exit(1); 1059 } 1060 1061 // create a window 1062 normalWindow = [[NSWindow alloc] initWithContentRect:[cocoaView frame] 1063 styleMask:NSWindowStyleMaskTitled|NSWindowStyleMaskMiniaturizable|NSWindowStyleMaskClosable 1064 backing:NSBackingStoreBuffered defer:NO]; 1065 if(!normalWindow) { 1066 fprintf(stderr, "(cocoa) can't create window\n"); 1067 exit(1); 1068 } 1069 [normalWindow setAcceptsMouseMovedEvents:YES]; 1070 [normalWindow setTitle:@"QEMU"]; 1071 [normalWindow setContentView:cocoaView]; 1072#if (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_10) 1073 [normalWindow useOptimizedDrawing:YES]; 1074#endif 1075 [normalWindow makeKeyAndOrderFront:self]; 1076 [normalWindow center]; 1077 [normalWindow setDelegate: self]; 1078 stretch_video = false; 1079 1080 /* Used for displaying pause on the screen */ 1081 pauseLabel = [NSTextField new]; 1082 [pauseLabel setBezeled:YES]; 1083 [pauseLabel setDrawsBackground:YES]; 1084 [pauseLabel setBackgroundColor: [NSColor whiteColor]]; 1085 [pauseLabel setEditable:NO]; 1086 [pauseLabel setSelectable:NO]; 1087 [pauseLabel setStringValue: @"Paused"]; 1088 [pauseLabel setFont: [NSFont fontWithName: @"Helvetica" size: 90]]; 1089 [pauseLabel setTextColor: [NSColor blackColor]]; 1090 [pauseLabel sizeToFit]; 1091 1092 // set the supported image file types that can be opened 1093 supportedImageFileTypes = [NSArray arrayWithObjects: @"img", @"iso", @"dmg", 1094 @"qcow", @"qcow2", @"cloop", @"vmdk", @"cdr", 1095 @"toast", nil]; 1096 [self make_about_window]; 1097 } 1098 return self; 1099} 1100 1101- (void) dealloc 1102{ 1103 COCOA_DEBUG("QemuCocoaAppController: dealloc\n"); 1104 1105 if (cocoaView) 1106 [cocoaView release]; 1107 [super dealloc]; 1108} 1109 1110- (void)applicationDidFinishLaunching: (NSNotification *) note 1111{ 1112 COCOA_DEBUG("QemuCocoaAppController: applicationDidFinishLaunching\n"); 1113 /* Tell cocoa_display_init to proceed */ 1114 qemu_sem_post(&app_started_sem); 1115} 1116 1117- (void)applicationWillTerminate:(NSNotification *)aNotification 1118{ 1119 COCOA_DEBUG("QemuCocoaAppController: applicationWillTerminate\n"); 1120 1121 qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI); 1122 exit(0); 1123} 1124 1125- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)theApplication 1126{ 1127 return YES; 1128} 1129 1130- (NSApplicationTerminateReply)applicationShouldTerminate: 1131 (NSApplication *)sender 1132{ 1133 COCOA_DEBUG("QemuCocoaAppController: applicationShouldTerminate\n"); 1134 return [self verifyQuit]; 1135} 1136 1137/* Called when the user clicks on a window's close button */ 1138- (BOOL)windowShouldClose:(id)sender 1139{ 1140 COCOA_DEBUG("QemuCocoaAppController: windowShouldClose\n"); 1141 [NSApp terminate: sender]; 1142 /* If the user allows the application to quit then the call to 1143 * NSApp terminate will never return. If we get here then the user 1144 * cancelled the quit, so we should return NO to not permit the 1145 * closing of this window. 1146 */ 1147 return NO; 1148} 1149 1150/* Called when QEMU goes into the background */ 1151- (void) applicationWillResignActive: (NSNotification *)aNotification 1152{ 1153 COCOA_DEBUG("QemuCocoaAppController: applicationWillResignActive\n"); 1154 [cocoaView raiseAllKeys]; 1155} 1156 1157/* We abstract the method called by the Enter Fullscreen menu item 1158 * because Mac OS 10.7 and higher disables it. This is because of the 1159 * menu item's old selector's name toggleFullScreen: 1160 */ 1161- (void) doToggleFullScreen:(id)sender 1162{ 1163 [self toggleFullScreen:(id)sender]; 1164} 1165 1166- (void)toggleFullScreen:(id)sender 1167{ 1168 COCOA_DEBUG("QemuCocoaAppController: toggleFullScreen\n"); 1169 1170 [cocoaView toggleFullScreen:sender]; 1171} 1172 1173/* Tries to find then open the specified filename */ 1174- (void) openDocumentation: (NSString *) filename 1175{ 1176 /* Where to look for local files */ 1177 NSString *path_array[] = {@"../share/doc/qemu/", @"../doc/qemu/", @"../"}; 1178 NSString *full_file_path; 1179 1180 /* iterate thru the possible paths until the file is found */ 1181 int index; 1182 for (index = 0; index < ARRAY_SIZE(path_array); index++) { 1183 full_file_path = [[NSBundle mainBundle] executablePath]; 1184 full_file_path = [full_file_path stringByDeletingLastPathComponent]; 1185 full_file_path = [NSString stringWithFormat: @"%@/%@%@", full_file_path, 1186 path_array[index], filename]; 1187 if ([[NSWorkspace sharedWorkspace] openFile: full_file_path] == YES) { 1188 return; 1189 } 1190 } 1191 1192 /* If none of the paths opened a file */ 1193 NSBeep(); 1194 QEMU_Alert(@"Failed to open file"); 1195} 1196 1197- (void)showQEMUDoc:(id)sender 1198{ 1199 COCOA_DEBUG("QemuCocoaAppController: showQEMUDoc\n"); 1200 1201 [self openDocumentation: @"qemu-doc.html"]; 1202} 1203 1204/* Stretches video to fit host monitor size */ 1205- (void)zoomToFit:(id) sender 1206{ 1207 stretch_video = !stretch_video; 1208 if (stretch_video == true) { 1209 [sender setState: NSControlStateValueOn]; 1210 } else { 1211 [sender setState: NSControlStateValueOff]; 1212 } 1213} 1214 1215/* Displays the console on the screen */ 1216- (void)displayConsole:(id)sender 1217{ 1218 console_select([sender tag]); 1219} 1220 1221/* Pause the guest */ 1222- (void)pauseQEMU:(id)sender 1223{ 1224 with_iothread_lock(^{ 1225 qmp_stop(NULL); 1226 }); 1227 [sender setEnabled: NO]; 1228 [[[sender menu] itemWithTitle: @"Resume"] setEnabled: YES]; 1229 [self displayPause]; 1230} 1231 1232/* Resume running the guest operating system */ 1233- (void)resumeQEMU:(id) sender 1234{ 1235 with_iothread_lock(^{ 1236 qmp_cont(NULL); 1237 }); 1238 [sender setEnabled: NO]; 1239 [[[sender menu] itemWithTitle: @"Pause"] setEnabled: YES]; 1240 [self removePause]; 1241} 1242 1243/* Displays the word pause on the screen */ 1244- (void)displayPause 1245{ 1246 /* Coordinates have to be calculated each time because the window can change its size */ 1247 int xCoord, yCoord, width, height; 1248 xCoord = ([normalWindow frame].size.width - [pauseLabel frame].size.width)/2; 1249 yCoord = [normalWindow frame].size.height - [pauseLabel frame].size.height - ([pauseLabel frame].size.height * .5); 1250 width = [pauseLabel frame].size.width; 1251 height = [pauseLabel frame].size.height; 1252 [pauseLabel setFrame: NSMakeRect(xCoord, yCoord, width, height)]; 1253 [cocoaView addSubview: pauseLabel]; 1254} 1255 1256/* Removes the word pause from the screen */ 1257- (void)removePause 1258{ 1259 [pauseLabel removeFromSuperview]; 1260} 1261 1262/* Restarts QEMU */ 1263- (void)restartQEMU:(id)sender 1264{ 1265 with_iothread_lock(^{ 1266 qmp_system_reset(NULL); 1267 }); 1268} 1269 1270/* Powers down QEMU */ 1271- (void)powerDownQEMU:(id)sender 1272{ 1273 with_iothread_lock(^{ 1274 qmp_system_powerdown(NULL); 1275 }); 1276} 1277 1278/* Ejects the media. 1279 * Uses sender's tag to figure out the device to eject. 1280 */ 1281- (void)ejectDeviceMedia:(id)sender 1282{ 1283 NSString * drive; 1284 drive = [sender representedObject]; 1285 if(drive == nil) { 1286 NSBeep(); 1287 QEMU_Alert(@"Failed to find drive to eject!"); 1288 return; 1289 } 1290 1291 __block Error *err = NULL; 1292 with_iothread_lock(^{ 1293 qmp_eject(true, [drive cStringUsingEncoding: NSASCIIStringEncoding], 1294 false, NULL, false, false, &err); 1295 }); 1296 handleAnyDeviceErrors(err); 1297} 1298 1299/* Displays a dialog box asking the user to select an image file to load. 1300 * Uses sender's represented object value to figure out which drive to use. 1301 */ 1302- (void)changeDeviceMedia:(id)sender 1303{ 1304 /* Find the drive name */ 1305 NSString * drive; 1306 drive = [sender representedObject]; 1307 if(drive == nil) { 1308 NSBeep(); 1309 QEMU_Alert(@"Could not find drive!"); 1310 return; 1311 } 1312 1313 /* Display the file open dialog */ 1314 NSOpenPanel * openPanel; 1315 openPanel = [NSOpenPanel openPanel]; 1316 [openPanel setCanChooseFiles: YES]; 1317 [openPanel setAllowsMultipleSelection: NO]; 1318 [openPanel setAllowedFileTypes: supportedImageFileTypes]; 1319 if([openPanel runModal] == NSModalResponseOK) { 1320 NSString * file = [[[openPanel URLs] objectAtIndex: 0] path]; 1321 if(file == nil) { 1322 NSBeep(); 1323 QEMU_Alert(@"Failed to convert URL to file path!"); 1324 return; 1325 } 1326 1327 __block Error *err = NULL; 1328 with_iothread_lock(^{ 1329 qmp_blockdev_change_medium(true, 1330 [drive cStringUsingEncoding: 1331 NSASCIIStringEncoding], 1332 false, NULL, 1333 [file cStringUsingEncoding: 1334 NSASCIIStringEncoding], 1335 true, "raw", 1336 false, 0, 1337 &err); 1338 }); 1339 handleAnyDeviceErrors(err); 1340 } 1341} 1342 1343/* Verifies if the user really wants to quit */ 1344- (BOOL)verifyQuit 1345{ 1346 NSAlert *alert = [NSAlert new]; 1347 [alert autorelease]; 1348 [alert setMessageText: @"Are you sure you want to quit QEMU?"]; 1349 [alert addButtonWithTitle: @"Cancel"]; 1350 [alert addButtonWithTitle: @"Quit"]; 1351 if([alert runModal] == NSAlertSecondButtonReturn) { 1352 return YES; 1353 } else { 1354 return NO; 1355 } 1356} 1357 1358/* The action method for the About menu item */ 1359- (IBAction) do_about_menu_item: (id) sender 1360{ 1361 [about_window makeKeyAndOrderFront: nil]; 1362} 1363 1364/* Create and display the about dialog */ 1365- (void)make_about_window 1366{ 1367 /* Make the window */ 1368 int x = 0, y = 0, about_width = 400, about_height = 200; 1369 NSRect window_rect = NSMakeRect(x, y, about_width, about_height); 1370 about_window = [[NSWindow alloc] initWithContentRect:window_rect 1371 styleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | 1372 NSWindowStyleMaskMiniaturizable 1373 backing:NSBackingStoreBuffered 1374 defer:NO]; 1375 [about_window setTitle: @"About"]; 1376 [about_window setReleasedWhenClosed: NO]; 1377 [about_window center]; 1378 NSView *superView = [about_window contentView]; 1379 1380 /* Create the dimensions of the picture */ 1381 int picture_width = 80, picture_height = 80; 1382 x = (about_width - picture_width)/2; 1383 y = about_height - picture_height - 10; 1384 NSRect picture_rect = NSMakeRect(x, y, picture_width, picture_height); 1385 1386 /* Get the path to the QEMU binary */ 1387 NSString *binary_name = [NSString stringWithCString: gArgv[0] 1388 encoding: NSASCIIStringEncoding]; 1389 binary_name = [binary_name lastPathComponent]; 1390 NSString *program_path = [[NSString alloc] initWithFormat: @"%@/%@", 1391 [[NSBundle mainBundle] bundlePath], binary_name]; 1392 1393 /* Make the picture of QEMU */ 1394 NSImageView *picture_view = [[NSImageView alloc] initWithFrame: 1395 picture_rect]; 1396 NSImage *qemu_image = [[NSWorkspace sharedWorkspace] iconForFile: 1397 program_path]; 1398 [picture_view setImage: qemu_image]; 1399 [picture_view setImageScaling: NSImageScaleProportionallyUpOrDown]; 1400 [superView addSubview: picture_view]; 1401 1402 /* Make the name label */ 1403 x = 0; 1404 y = y - 25; 1405 int name_width = about_width, name_height = 20; 1406 NSRect name_rect = NSMakeRect(x, y, name_width, name_height); 1407 NSTextField *name_label = [[NSTextField alloc] initWithFrame: name_rect]; 1408 [name_label setEditable: NO]; 1409 [name_label setBezeled: NO]; 1410 [name_label setDrawsBackground: NO]; 1411 [name_label setAlignment: NSTextAlignmentCenter]; 1412 NSString *qemu_name = [[NSString alloc] initWithCString: gArgv[0] 1413 encoding: NSASCIIStringEncoding]; 1414 qemu_name = [qemu_name lastPathComponent]; 1415 [name_label setStringValue: qemu_name]; 1416 [superView addSubview: name_label]; 1417 1418 /* Set the version label's attributes */ 1419 x = 0; 1420 y = 50; 1421 int version_width = about_width, version_height = 20; 1422 NSRect version_rect = NSMakeRect(x, y, version_width, version_height); 1423 NSTextField *version_label = [[NSTextField alloc] initWithFrame: 1424 version_rect]; 1425 [version_label setEditable: NO]; 1426 [version_label setBezeled: NO]; 1427 [version_label setAlignment: NSTextAlignmentCenter]; 1428 [version_label setDrawsBackground: NO]; 1429 1430 /* Create the version string*/ 1431 NSString *version_string; 1432 version_string = [[NSString alloc] initWithFormat: 1433 @"QEMU emulator version %s", QEMU_FULL_VERSION]; 1434 [version_label setStringValue: version_string]; 1435 [superView addSubview: version_label]; 1436 1437 /* Make copyright label */ 1438 x = 0; 1439 y = 35; 1440 int copyright_width = about_width, copyright_height = 20; 1441 NSRect copyright_rect = NSMakeRect(x, y, copyright_width, copyright_height); 1442 NSTextField *copyright_label = [[NSTextField alloc] initWithFrame: 1443 copyright_rect]; 1444 [copyright_label setEditable: NO]; 1445 [copyright_label setBezeled: NO]; 1446 [copyright_label setDrawsBackground: NO]; 1447 [copyright_label setAlignment: NSTextAlignmentCenter]; 1448 [copyright_label setStringValue: [NSString stringWithFormat: @"%s", 1449 QEMU_COPYRIGHT]]; 1450 [superView addSubview: copyright_label]; 1451} 1452 1453/* Used by the Speed menu items */ 1454- (void)adjustSpeed:(id)sender 1455{ 1456 int throttle_pct; /* throttle percentage */ 1457 NSMenu *menu; 1458 1459 menu = [sender menu]; 1460 if (menu != nil) 1461 { 1462 /* Unselect the currently selected item */ 1463 for (NSMenuItem *item in [menu itemArray]) { 1464 if (item.state == NSControlStateValueOn) { 1465 [item setState: NSControlStateValueOff]; 1466 break; 1467 } 1468 } 1469 } 1470 1471 // check the menu item 1472 [sender setState: NSControlStateValueOn]; 1473 1474 // get the throttle percentage 1475 throttle_pct = [sender tag]; 1476 1477 with_iothread_lock(^{ 1478 cpu_throttle_set(throttle_pct); 1479 }); 1480 COCOA_DEBUG("cpu throttling at %d%c\n", cpu_throttle_get_percentage(), '%'); 1481} 1482 1483@end 1484 1485@interface QemuApplication : NSApplication 1486@end 1487 1488@implementation QemuApplication 1489- (void)sendEvent:(NSEvent *)event 1490{ 1491 COCOA_DEBUG("QemuApplication: sendEvent\n"); 1492 if (![cocoaView handleEvent:event]) { 1493 [super sendEvent: event]; 1494 } 1495} 1496@end 1497 1498static void create_initial_menus(void) 1499{ 1500 // Add menus 1501 NSMenu *menu; 1502 NSMenuItem *menuItem; 1503 1504 [NSApp setMainMenu:[[NSMenu alloc] init]]; 1505 1506 // Application menu 1507 menu = [[NSMenu alloc] initWithTitle:@""]; 1508 [menu addItemWithTitle:@"About QEMU" action:@selector(do_about_menu_item:) keyEquivalent:@""]; // About QEMU 1509 [menu addItem:[NSMenuItem separatorItem]]; //Separator 1510 [menu addItemWithTitle:@"Hide QEMU" action:@selector(hide:) keyEquivalent:@"h"]; //Hide QEMU 1511 menuItem = (NSMenuItem *)[menu addItemWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"]; // Hide Others 1512 [menuItem setKeyEquivalentModifierMask:(NSEventModifierFlagOption|NSEventModifierFlagCommand)]; 1513 [menu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""]; // Show All 1514 [menu addItem:[NSMenuItem separatorItem]]; //Separator 1515 [menu addItemWithTitle:@"Quit QEMU" action:@selector(terminate:) keyEquivalent:@"q"]; 1516 menuItem = [[NSMenuItem alloc] initWithTitle:@"Apple" action:nil keyEquivalent:@""]; 1517 [menuItem setSubmenu:menu]; 1518 [[NSApp mainMenu] addItem:menuItem]; 1519 [NSApp performSelector:@selector(setAppleMenu:) withObject:menu]; // Workaround (this method is private since 10.4+) 1520 1521 // Machine menu 1522 menu = [[NSMenu alloc] initWithTitle: @"Machine"]; 1523 [menu setAutoenablesItems: NO]; 1524 [menu addItem: [[[NSMenuItem alloc] initWithTitle: @"Pause" action: @selector(pauseQEMU:) keyEquivalent: @""] autorelease]]; 1525 menuItem = [[[NSMenuItem alloc] initWithTitle: @"Resume" action: @selector(resumeQEMU:) keyEquivalent: @""] autorelease]; 1526 [menu addItem: menuItem]; 1527 [menuItem setEnabled: NO]; 1528 [menu addItem: [NSMenuItem separatorItem]]; 1529 [menu addItem: [[[NSMenuItem alloc] initWithTitle: @"Reset" action: @selector(restartQEMU:) keyEquivalent: @""] autorelease]]; 1530 [menu addItem: [[[NSMenuItem alloc] initWithTitle: @"Power Down" action: @selector(powerDownQEMU:) keyEquivalent: @""] autorelease]]; 1531 menuItem = [[[NSMenuItem alloc] initWithTitle: @"Machine" action:nil keyEquivalent:@""] autorelease]; 1532 [menuItem setSubmenu:menu]; 1533 [[NSApp mainMenu] addItem:menuItem]; 1534 1535 // View menu 1536 menu = [[NSMenu alloc] initWithTitle:@"View"]; 1537 [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"Enter Fullscreen" action:@selector(doToggleFullScreen:) keyEquivalent:@"f"] autorelease]]; // Fullscreen 1538 [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"Zoom To Fit" action:@selector(zoomToFit:) keyEquivalent:@""] autorelease]]; 1539 menuItem = [[[NSMenuItem alloc] initWithTitle:@"View" action:nil keyEquivalent:@""] autorelease]; 1540 [menuItem setSubmenu:menu]; 1541 [[NSApp mainMenu] addItem:menuItem]; 1542 1543 // Speed menu 1544 menu = [[NSMenu alloc] initWithTitle:@"Speed"]; 1545 1546 // Add the rest of the Speed menu items 1547 int p, percentage, throttle_pct; 1548 for (p = 10; p >= 0; p--) 1549 { 1550 percentage = p * 10 > 1 ? p * 10 : 1; // prevent a 0% menu item 1551 1552 menuItem = [[[NSMenuItem alloc] 1553 initWithTitle: [NSString stringWithFormat: @"%d%%", percentage] action:@selector(adjustSpeed:) keyEquivalent:@""] autorelease]; 1554 1555 if (percentage == 100) { 1556 [menuItem setState: NSControlStateValueOn]; 1557 } 1558 1559 /* Calculate the throttle percentage */ 1560 throttle_pct = -1 * percentage + 100; 1561 1562 [menuItem setTag: throttle_pct]; 1563 [menu addItem: menuItem]; 1564 } 1565 menuItem = [[[NSMenuItem alloc] initWithTitle:@"Speed" action:nil keyEquivalent:@""] autorelease]; 1566 [menuItem setSubmenu:menu]; 1567 [[NSApp mainMenu] addItem:menuItem]; 1568 1569 // Window menu 1570 menu = [[NSMenu alloc] initWithTitle:@"Window"]; 1571 [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"] autorelease]]; // Miniaturize 1572 menuItem = [[[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""] autorelease]; 1573 [menuItem setSubmenu:menu]; 1574 [[NSApp mainMenu] addItem:menuItem]; 1575 [NSApp setWindowsMenu:menu]; 1576 1577 // Help menu 1578 menu = [[NSMenu alloc] initWithTitle:@"Help"]; 1579 [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"QEMU Documentation" action:@selector(showQEMUDoc:) keyEquivalent:@"?"] autorelease]]; // QEMU Help 1580 menuItem = [[[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""] autorelease]; 1581 [menuItem setSubmenu:menu]; 1582 [[NSApp mainMenu] addItem:menuItem]; 1583} 1584 1585/* Returns a name for a given console */ 1586static NSString * getConsoleName(QemuConsole * console) 1587{ 1588 return [NSString stringWithFormat: @"%s", qemu_console_get_label(console)]; 1589} 1590 1591/* Add an entry to the View menu for each console */ 1592static void add_console_menu_entries(void) 1593{ 1594 NSMenu *menu; 1595 NSMenuItem *menuItem; 1596 int index = 0; 1597 1598 menu = [[[NSApp mainMenu] itemWithTitle:@"View"] submenu]; 1599 1600 [menu addItem:[NSMenuItem separatorItem]]; 1601 1602 while (qemu_console_lookup_by_index(index) != NULL) { 1603 menuItem = [[[NSMenuItem alloc] initWithTitle: getConsoleName(qemu_console_lookup_by_index(index)) 1604 action: @selector(displayConsole:) keyEquivalent: @""] autorelease]; 1605 [menuItem setTag: index]; 1606 [menu addItem: menuItem]; 1607 index++; 1608 } 1609} 1610 1611/* Make menu items for all removable devices. 1612 * Each device is given an 'Eject' and 'Change' menu item. 1613 */ 1614static void addRemovableDevicesMenuItems(void) 1615{ 1616 NSMenu *menu; 1617 NSMenuItem *menuItem; 1618 BlockInfoList *currentDevice, *pointerToFree; 1619 NSString *deviceName; 1620 1621 currentDevice = qmp_query_block(NULL); 1622 pointerToFree = currentDevice; 1623 if(currentDevice == NULL) { 1624 NSBeep(); 1625 QEMU_Alert(@"Failed to query for block devices!"); 1626 return; 1627 } 1628 1629 menu = [[[NSApp mainMenu] itemWithTitle:@"Machine"] submenu]; 1630 1631 // Add a separator between related groups of menu items 1632 [menu addItem:[NSMenuItem separatorItem]]; 1633 1634 // Set the attributes to the "Removable Media" menu item 1635 NSString *titleString = @"Removable Media"; 1636 NSMutableAttributedString *attString=[[NSMutableAttributedString alloc] initWithString:titleString]; 1637 NSColor *newColor = [NSColor blackColor]; 1638 NSFontManager *fontManager = [NSFontManager sharedFontManager]; 1639 NSFont *font = [fontManager fontWithFamily:@"Helvetica" 1640 traits:NSBoldFontMask|NSItalicFontMask 1641 weight:0 1642 size:14]; 1643 [attString addAttribute:NSFontAttributeName value:font range:NSMakeRange(0, [titleString length])]; 1644 [attString addAttribute:NSForegroundColorAttributeName value:newColor range:NSMakeRange(0, [titleString length])]; 1645 [attString addAttribute:NSUnderlineStyleAttributeName value:[NSNumber numberWithInt: 1] range:NSMakeRange(0, [titleString length])]; 1646 1647 // Add the "Removable Media" menu item 1648 menuItem = [NSMenuItem new]; 1649 [menuItem setAttributedTitle: attString]; 1650 [menuItem setEnabled: NO]; 1651 [menu addItem: menuItem]; 1652 1653 /* Loop through all the block devices in the emulator */ 1654 while (currentDevice) { 1655 deviceName = [[NSString stringWithFormat: @"%s", currentDevice->value->device] retain]; 1656 1657 if(currentDevice->value->removable) { 1658 menuItem = [[NSMenuItem alloc] initWithTitle: [NSString stringWithFormat: @"Change %s...", currentDevice->value->device] 1659 action: @selector(changeDeviceMedia:) 1660 keyEquivalent: @""]; 1661 [menu addItem: menuItem]; 1662 [menuItem setRepresentedObject: deviceName]; 1663 [menuItem autorelease]; 1664 1665 menuItem = [[NSMenuItem alloc] initWithTitle: [NSString stringWithFormat: @"Eject %s", currentDevice->value->device] 1666 action: @selector(ejectDeviceMedia:) 1667 keyEquivalent: @""]; 1668 [menu addItem: menuItem]; 1669 [menuItem setRepresentedObject: deviceName]; 1670 [menuItem autorelease]; 1671 } 1672 currentDevice = currentDevice->next; 1673 } 1674 qapi_free_BlockInfoList(pointerToFree); 1675} 1676 1677/* 1678 * The startup process for the OSX/Cocoa UI is complicated, because 1679 * OSX insists that the UI runs on the initial main thread, and so we 1680 * need to start a second thread which runs the vl.c qemu_main(): 1681 * 1682 * Initial thread: 2nd thread: 1683 * in main(): 1684 * create qemu-main thread 1685 * wait on display_init semaphore 1686 * call qemu_main() 1687 * ... 1688 * in cocoa_display_init(): 1689 * post the display_init semaphore 1690 * wait on app_started semaphore 1691 * create application, menus, etc 1692 * enter OSX run loop 1693 * in applicationDidFinishLaunching: 1694 * post app_started semaphore 1695 * tell main thread to fullscreen if needed 1696 * [...] 1697 * run qemu main-loop 1698 * 1699 * We do this in two stages so that we don't do the creation of the 1700 * GUI application menus and so on for command line options like --help 1701 * where we want to just print text to stdout and exit immediately. 1702 */ 1703 1704static void *call_qemu_main(void *opaque) 1705{ 1706 int status; 1707 1708 COCOA_DEBUG("Second thread: calling qemu_main()\n"); 1709 status = qemu_main(gArgc, gArgv, *_NSGetEnviron()); 1710 COCOA_DEBUG("Second thread: qemu_main() returned, exiting\n"); 1711 exit(status); 1712} 1713 1714int main (int argc, const char * argv[]) { 1715 QemuThread thread; 1716 1717 COCOA_DEBUG("Entered main()\n"); 1718 gArgc = argc; 1719 gArgv = (char **)argv; 1720 1721 qemu_sem_init(&display_init_sem, 0); 1722 qemu_sem_init(&app_started_sem, 0); 1723 1724 qemu_thread_create(&thread, "qemu_main", call_qemu_main, 1725 NULL, QEMU_THREAD_DETACHED); 1726 1727 COCOA_DEBUG("Main thread: waiting for display_init_sem\n"); 1728 qemu_sem_wait(&display_init_sem); 1729 COCOA_DEBUG("Main thread: initializing app\n"); 1730 1731 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 1732 1733 // Pull this console process up to being a fully-fledged graphical 1734 // app with a menubar and Dock icon 1735 ProcessSerialNumber psn = { 0, kCurrentProcess }; 1736 TransformProcessType(&psn, kProcessTransformToForegroundApplication); 1737 1738 [QemuApplication sharedApplication]; 1739 1740 create_initial_menus(); 1741 1742 /* 1743 * Create the menu entries which depend on QEMU state (for consoles 1744 * and removeable devices). These make calls back into QEMU functions, 1745 * which is OK because at this point we know that the second thread 1746 * holds the iothread lock and is synchronously waiting for us to 1747 * finish. 1748 */ 1749 add_console_menu_entries(); 1750 addRemovableDevicesMenuItems(); 1751 1752 // Create an Application controller 1753 QemuCocoaAppController *appController = [[QemuCocoaAppController alloc] init]; 1754 [NSApp setDelegate:appController]; 1755 1756 // Start the main event loop 1757 COCOA_DEBUG("Main thread: entering OSX run loop\n"); 1758 [NSApp run]; 1759 COCOA_DEBUG("Main thread: left OSX run loop, exiting\n"); 1760 1761 [appController release]; 1762 [pool release]; 1763 1764 return 0; 1765} 1766 1767 1768 1769#pragma mark qemu 1770static void cocoa_update(DisplayChangeListener *dcl, 1771 int x, int y, int w, int h) 1772{ 1773 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 1774 1775 COCOA_DEBUG("qemu_cocoa: cocoa_update\n"); 1776 1777 dispatch_async(dispatch_get_main_queue(), ^{ 1778 NSRect rect; 1779 if ([cocoaView cdx] == 1.0) { 1780 rect = NSMakeRect(x, [cocoaView gscreen].height - y - h, w, h); 1781 } else { 1782 rect = NSMakeRect( 1783 x * [cocoaView cdx], 1784 ([cocoaView gscreen].height - y - h) * [cocoaView cdy], 1785 w * [cocoaView cdx], 1786 h * [cocoaView cdy]); 1787 } 1788 [cocoaView setNeedsDisplayInRect:rect]; 1789 }); 1790 1791 [pool release]; 1792} 1793 1794static void cocoa_switch(DisplayChangeListener *dcl, 1795 DisplaySurface *surface) 1796{ 1797 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 1798 pixman_image_t *image = surface->image; 1799 1800 COCOA_DEBUG("qemu_cocoa: cocoa_switch\n"); 1801 1802 // The DisplaySurface will be freed as soon as this callback returns. 1803 // We take a reference to the underlying pixman image here so it does 1804 // not disappear from under our feet; the switchSurface method will 1805 // deref the old image when it is done with it. 1806 pixman_image_ref(image); 1807 1808 dispatch_async(dispatch_get_main_queue(), ^{ 1809 [cocoaView switchSurface:image]; 1810 }); 1811 [pool release]; 1812} 1813 1814static void cocoa_refresh(DisplayChangeListener *dcl) 1815{ 1816 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 1817 1818 COCOA_DEBUG("qemu_cocoa: cocoa_refresh\n"); 1819 graphic_hw_update(NULL); 1820 1821 if (qemu_input_is_absolute()) { 1822 dispatch_async(dispatch_get_main_queue(), ^{ 1823 if (![cocoaView isAbsoluteEnabled]) { 1824 if ([cocoaView isMouseGrabbed]) { 1825 [cocoaView ungrabMouse]; 1826 } 1827 } 1828 [cocoaView setAbsoluteEnabled:YES]; 1829 }); 1830 } 1831 [pool release]; 1832} 1833 1834static void cocoa_cleanup(void) 1835{ 1836 COCOA_DEBUG("qemu_cocoa: cocoa_cleanup\n"); 1837 g_free(dcl); 1838} 1839 1840static const DisplayChangeListenerOps dcl_ops = { 1841 .dpy_name = "cocoa", 1842 .dpy_gfx_update = cocoa_update, 1843 .dpy_gfx_switch = cocoa_switch, 1844 .dpy_refresh = cocoa_refresh, 1845}; 1846 1847static void cocoa_display_init(DisplayState *ds, DisplayOptions *opts) 1848{ 1849 COCOA_DEBUG("qemu_cocoa: cocoa_display_init\n"); 1850 1851 /* Tell main thread to go ahead and create the app and enter the run loop */ 1852 qemu_sem_post(&display_init_sem); 1853 qemu_sem_wait(&app_started_sem); 1854 COCOA_DEBUG("cocoa_display_init: app start completed\n"); 1855 1856 /* if fullscreen mode is to be used */ 1857 if (opts->has_full_screen && opts->full_screen) { 1858 dispatch_async(dispatch_get_main_queue(), ^{ 1859 [NSApp activateIgnoringOtherApps: YES]; 1860 [(QemuCocoaAppController *)[[NSApplication sharedApplication] delegate] toggleFullScreen: nil]; 1861 }); 1862 } 1863 1864 dcl = g_malloc0(sizeof(DisplayChangeListener)); 1865 1866 // register vga output callbacks 1867 dcl->ops = &dcl_ops; 1868 register_displaychangelistener(dcl); 1869 1870 // register cleanup function 1871 atexit(cocoa_cleanup); 1872} 1873 1874static QemuDisplay qemu_display_cocoa = { 1875 .type = DISPLAY_TYPE_COCOA, 1876 .init = cocoa_display_init, 1877}; 1878 1879static void register_cocoa(void) 1880{ 1881 qemu_display_register(&qemu_display_cocoa); 1882} 1883 1884type_init(register_cocoa); 1885