← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to cocoa.m

  • Committer: pbrook
  • Date: 2007-03-04 00:52:16 UTC
  • Revision ID: git-v1:7a2d6d9650ed16b2cdb0b4876fe9efce7ef8ea6d
64bit->win32 cross build fix.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2467 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
cocoa.m
1
1
/*
2
 
 * QEMU Cocoa CG display driver
3
 
 *
4
 
 * Copyright (c) 2008 Mike Kronenberg
5
 
 *
 
2
 * QEMU Cocoa display driver
 
3
 * 
 
4
 * Copyright (c) 2005 Pierre d'Herbemont
 
5
 *                    many code/inspiration from SDL 1.2 code (LGPL)
 
6
 * 
6
7
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
8
 * of this software and associated documentation files (the "Software"), to deal
8
9
 * in the Software without restriction, including without limitation the rights
21
22
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
23
 * THE SOFTWARE.
23
24
 */
 
25
/*
 
26
    Todo :    x  miniaturize window 
 
27
              x  center the window
 
28
              -  save window position
 
29
              -  handle keyboard event
 
30
              -  handle mouse event
 
31
              -  non 32 bpp support
 
32
              -  full screen
 
33
              -  mouse focus
 
34
              x  simple graphical prompt to demo
 
35
              -  better graphical prompt
 
36
*/
24
37
 
25
38
#import <Cocoa/Cocoa.h>
26
39
 
27
 
#include "qemu-common.h"
28
 
#include "console.h"
29
 
#include "sysemu.h"
30
 
 
31
 
 
32
 
//#define DEBUG
33
 
 
34
 
#ifdef DEBUG
35
 
#define COCOA_DEBUG(...)  { (void) fprintf (stdout, __VA_ARGS__); }
36
 
#else
37
 
#define COCOA_DEBUG(...)  ((void) 0)
38
 
#endif
39
 
 
40
 
#define cgrect(nsrect) (*(CGRect *)&(nsrect))
41
 
#define COCOA_MOUSE_EVENT \
42
 
        if (isTabletEnabled) { \
43
 
            kbd_mouse_event((int)(p.x * 0x7FFF / (screen.width - 1)), (int)((screen.height - p.y) * 0x7FFF / (screen.height - 1)), 0, buttons); \
44
 
        } else if (isMouseGrabed) { \
45
 
            kbd_mouse_event((int)[event deltaX], (int)[event deltaY], 0, buttons); \
46
 
        } else { \
47
 
            [NSApp sendEvent:event]; \
48
 
        }
49
 
 
50
 
typedef struct {
51
 
    int width;
52
 
    int height;
53
 
    int bitsPerComponent;
54
 
    int bitsPerPixel;
55
 
} QEMUScreen;
56
 
 
57
 
int qemu_main(int argc, char **argv); // main defined in qemu/vl.c
58
 
NSWindow *normalWindow;
59
 
id cocoaView;
60
 
static void *screenBuffer;
 
40
#include "vl.h"
 
41
 
 
42
NSWindow *window = NULL;
 
43
NSQuickDrawView *qd_view = NULL;
 
44
 
61
45
 
62
46
int gArgc;
63
47
char **gArgv;
64
 
 
65
 
// keymap conversion
 
48
DisplayState current_ds;
 
49
 
 
50
int grab = 0;
 
51
int modifiers_state[256];
 
52
 
 
53
/* main defined in qemu/vl.c */
 
54
int qemu_main(int argc, char **argv);
 
55
 
 
56
/* To deal with miniaturization */
 
57
@interface QemuWindow : NSWindow
 
58
{ }
 
59
@end
 
60
 
 
61
 
 
62
/*
 
63
 ------------------------------------------------------
 
64
    Qemu Video Driver
 
65
 ------------------------------------------------------
 
66
*/
 
67
 
 
68
/*
 
69
 ------------------------------------------------------
 
70
    cocoa_update
 
71
 ------------------------------------------------------
 
72
*/
 
73
static void cocoa_update(DisplayState *ds, int x, int y, int w, int h)
 
74
{
 
75
    //printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
 
76
 
 
77
    /* Use QDFlushPortBuffer() to flush content to display */
 
78
    RgnHandle dirty = NewRgn ();
 
79
    RgnHandle temp  = NewRgn ();
 
80
 
 
81
    SetEmptyRgn (dirty);
 
82
 
 
83
    /* Build the region of dirty rectangles */
 
84
    MacSetRectRgn (temp, x, y,
 
85
                        x + w, y + h);
 
86
    MacUnionRgn (dirty, temp, dirty);
 
87
                
 
88
    /* Flush the dirty region */
 
89
    QDFlushPortBuffer ( [ qd_view  qdPort ], dirty );
 
90
    DisposeRgn (dirty);
 
91
    DisposeRgn (temp);
 
92
}
 
93
 
 
94
/*
 
95
 ------------------------------------------------------
 
96
    cocoa_resize
 
97
 ------------------------------------------------------
 
98
*/
 
99
static void cocoa_resize(DisplayState *ds, int w, int h)
 
100
{
 
101
    const int device_bpp = 32;
 
102
    static void *screen_pixels;
 
103
    static int  screen_pitch;
 
104
    NSRect contentRect;
 
105
    
 
106
    //printf("resizing to %d %d\n", w, h);
 
107
    
 
108
    contentRect = NSMakeRect (0, 0, w, h);
 
109
    if(window)
 
110
    {
 
111
        [window close];
 
112
        [window release];
 
113
    }
 
114
    window = [ [ QemuWindow alloc ] initWithContentRect:contentRect
 
115
                                  styleMask:NSTitledWindowMask|NSMiniaturizableWindowMask|NSClosableWindowMask
 
116
                                  backing:NSBackingStoreBuffered defer:NO];
 
117
    if(!window)
 
118
    {
 
119
        fprintf(stderr, "(cocoa) can't create window\n");
 
120
        exit(1);
 
121
    }
 
122
    
 
123
    if(qd_view)
 
124
        [qd_view release];
 
125
    
 
126
    qd_view = [ [ NSQuickDrawView alloc ] initWithFrame:contentRect ];
 
127
    
 
128
    if(!qd_view)
 
129
    {
 
130
         fprintf(stderr, "(cocoa) can't create qd_view\n");
 
131
        exit(1);
 
132
    }
 
133
    
 
134
    [ window setAcceptsMouseMovedEvents:YES ];
 
135
    [ window setTitle:@"Qemu" ];
 
136
    [ window setReleasedWhenClosed:NO ];
 
137
    
 
138
    /* Set screen to black */
 
139
    [ window setBackgroundColor: [NSColor blackColor] ];
 
140
    
 
141
    /* set window position */
 
142
    [ window center ];
 
143
    
 
144
    [ qd_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
 
145
    [ [ window contentView ] addSubview:qd_view ];
 
146
    [ qd_view release ];
 
147
    [ window makeKeyAndOrderFront:nil ];
 
148
    
 
149
    /* Careful here, the window seems to have to be onscreen to do that */
 
150
    LockPortBits ( [ qd_view qdPort ] );
 
151
    screen_pixels = GetPixBaseAddr ( GetPortPixMap ( [ qd_view qdPort ] ) );
 
152
    screen_pitch  = GetPixRowBytes ( GetPortPixMap ( [ qd_view qdPort ] ) );
 
153
    UnlockPortBits ( [ qd_view qdPort ] );
 
154
    { 
 
155
            int vOffset = [ window frame ].size.height - 
 
156
                [ qd_view frame ].size.height - [ qd_view frame ].origin.y;
 
157
            
 
158
            int hOffset = [ qd_view frame ].origin.x;
 
159
                    
 
160
            screen_pixels += (vOffset * screen_pitch) + hOffset * (device_bpp/8);
 
161
    }
 
162
    ds->data = screen_pixels;
 
163
    ds->linesize = screen_pitch;
 
164
    ds->depth = device_bpp;
 
165
    ds->width = w;
 
166
    ds->height = h;
 
167
    
 
168
    current_ds = *ds;
 
169
}
 
170
 
 
171
/*
 
172
 ------------------------------------------------------
 
173
    keymap conversion
 
174
 ------------------------------------------------------
 
175
*/
 
176
 
66
177
int keymap[] =
67
178
{
68
179
//  SdlI    macI    macH    SdlH    104xtH  104xtC  sdl
171
282
    0,  //  102     0x66    Undefined
172
283
    87, //  103     0x67    0x57            F11     QZ_F11
173
284
    0,  //  104     0x68    Undefined
174
 
    183,//  105     0x69    0xb7                    QZ_PRINT
 
285
    183,//  105     0x69    0xb7            QZ_PRINT
175
286
    0,  //  106     0x6A    Undefined
176
287
    70, //  107     0x6B    0x46            SCROLL  QZ_SCROLLOCK
177
288
    0,  //  108     0x6C    Undefined
194
305
    208,//  125     0x7D    0xd0    E0,50   D ARROW QZ_DOWN
195
306
    200,//  126     0x7E    0xc8    E0,48   U ARROW QZ_UP
196
307
/* completed according to http://www.libsdl.org/cgi/cvsweb.cgi/SDL12/src/video/quartz/SDL_QuartzKeys.h?rev=1.6&content-type=text/x-cvsweb-markup */
197
 
 
 
308
  
198
309
/* Aditional 104 Key XP-Keyboard Scancodes from http://www.computer-engineering.org/ps2keyboard/scancodes1.html */
199
310
/*
200
 
    219 //          0xdb            e0,5b   L GUI
201
 
    220 //          0xdc            e0,5c   R GUI
202
 
    221 //          0xdd            e0,5d   APPS
203
 
        //              E0,2A,E0,37         PRNT SCRN
204
 
        //              E1,1D,45,E1,9D,C5   PAUSE
205
 
    83  //          0x53    0x53            KP .
206
 
// ACPI Scan Codes
207
 
    222 //          0xde            E0, 5E  Power
208
 
    223 //          0xdf            E0, 5F  Sleep
209
 
    227 //          0xe3            E0, 63  Wake
210
 
// Windows Multimedia Scan Codes
211
 
    153 //          0x99            E0, 19  Next Track
212
 
    144 //          0x90            E0, 10  Previous Track
213
 
    164 //          0xa4            E0, 24  Stop
214
 
    162 //          0xa2            E0, 22  Play/Pause
215
 
    160 //          0xa0            E0, 20  Mute
216
 
    176 //          0xb0            E0, 30  Volume Up
217
 
    174 //          0xae            E0, 2E  Volume Down
218
 
    237 //          0xed            E0, 6D  Media Select
219
 
    236 //          0xec            E0, 6C  E-Mail
220
 
    161 //          0xa1            E0, 21  Calculator
221
 
    235 //          0xeb            E0, 6B  My Computer
222
 
    229 //          0xe5            E0, 65  WWW Search
223
 
    178 //          0xb2            E0, 32  WWW Home
224
 
    234 //          0xea            E0, 6A  WWW Back
225
 
    233 //          0xe9            E0, 69  WWW Forward
226
 
    232 //          0xe8            E0, 68  WWW Stop
227
 
    231 //          0xe7            E0, 67  WWW Refresh
228
 
    230 //          0xe6            E0, 66  WWW Favorites
 
311
    219 //          0xdb            e0,5b   L GUI   
 
312
    220 //          0xdc            e0,5c   R GUI   
 
313
    221 //          0xdd            e0,5d   APPS    
 
314
        //              E0,2A,E0,37         PRNT SCRN   
 
315
        //              E1,1D,45,E1,9D,C5   PAUSE   
 
316
    83  //          0x53    0x53            KP .    
 
317
// ACPI Scan Codes                              
 
318
    222 //          0xde            E0, 5E  Power   
 
319
    223 //          0xdf            E0, 5F  Sleep   
 
320
    227 //          0xe3            E0, 63  Wake    
 
321
// Windows Multimedia Scan Codes                                
 
322
    153 //          0x99            E0, 19  Next Track  
 
323
    144 //          0x90            E0, 10  Previous Track  
 
324
    164 //          0xa4            E0, 24  Stop    
 
325
    162 //          0xa2            E0, 22  Play/Pause  
 
326
    160 //          0xa0            E0, 20  Mute    
 
327
    176 //          0xb0            E0, 30  Volume Up   
 
328
    174 //          0xae            E0, 2E  Volume Down 
 
329
    237 //          0xed            E0, 6D  Media Select    
 
330
    236 //          0xec            E0, 6C  E-Mail  
 
331
    161 //          0xa1            E0, 21  Calculator  
 
332
    235 //          0xeb            E0, 6B  My Computer 
 
333
    229 //          0xe5            E0, 65  WWW Search  
 
334
    178 //          0xb2            E0, 32  WWW Home    
 
335
    234 //          0xea            E0, 6A  WWW Back    
 
336
    233 //          0xe9            E0, 69  WWW Forward 
 
337
    232 //          0xe8            E0, 68  WWW Stop    
 
338
    231 //          0xe7            E0, 67  WWW Refresh 
 
339
    230 //          0xe6            E0, 66  WWW Favorites   
229
340
*/
230
341
};
231
342
 
239
350
    return keymap[keycode];
240
351
}
241
352
 
242
 
 
243
 
 
244
353
/*
245
354
 ------------------------------------------------------
246
 
    QemuCocoaView
 
355
    cocoa_refresh
247
356
 ------------------------------------------------------
248
357
*/
249
 
@interface QemuCocoaView : NSView
250
 
{
251
 
    QEMUScreen screen;
252
 
    NSWindow *fullScreenWindow;
253
 
    float cx,cy,cw,ch,cdx,cdy;
254
 
    CGDataProviderRef dataProviderRef;
255
 
    int modifiers_state[256];
256
 
    BOOL isMouseGrabed;
257
 
    BOOL isFullscreen;
258
 
    BOOL isAbsoluteEnabled;
259
 
    BOOL isTabletEnabled;
260
 
}
261
 
- (void) resizeContentToWidth:(int)w height:(int)h displayState:(DisplayState *)ds;
262
 
- (void) grabMouse;
263
 
- (void) ungrabMouse;
264
 
- (void) toggleFullScreen:(id)sender;
265
 
- (void) handleEvent:(NSEvent *)event;
266
 
- (void) setAbsoluteEnabled:(BOOL)tIsAbsoluteEnabled;
267
 
- (BOOL) isMouseGrabed;
268
 
- (BOOL) isAbsoluteEnabled;
269
 
- (float) cdx;
270
 
- (float) cdy;
271
 
- (QEMUScreen) gscreen;
272
 
@end
273
 
 
274
 
@implementation QemuCocoaView
275
 
- (id)initWithFrame:(NSRect)frameRect
276
 
{
277
 
    COCOA_DEBUG("QemuCocoaView: initWithFrame\n");
278
 
 
279
 
    self = [super initWithFrame:frameRect];
280
 
    if (self) {
281
 
 
282
 
        screen.bitsPerComponent = 8;
283
 
        screen.bitsPerPixel = 32;
284
 
        screen.width = frameRect.size.width;
285
 
        screen.height = frameRect.size.height;
286
 
 
287
 
    }
288
 
    return self;
289
 
}
290
 
 
291
 
- (void) dealloc
292
 
{
293
 
    COCOA_DEBUG("QemuCocoaView: dealloc\n");
294
 
 
295
 
    if (screenBuffer)
296
 
        free(screenBuffer);
297
 
 
298
 
    if (dataProviderRef)
299
 
        CGDataProviderRelease(dataProviderRef);
300
 
 
301
 
    [super dealloc];
302
 
}
303
 
 
304
 
- (void) drawRect:(NSRect) rect
305
 
{
306
 
    COCOA_DEBUG("QemuCocoaView: drawRect\n");
307
 
 
308
 
    if ((int)screenBuffer == -1)
309
 
        return;
310
 
 
311
 
    // get CoreGraphic context
312
 
    CGContextRef viewContextRef = [[NSGraphicsContext currentContext] graphicsPort];
313
 
    CGContextSetInterpolationQuality (viewContextRef, kCGInterpolationNone);
314
 
    CGContextSetShouldAntialias (viewContextRef, NO);
315
 
 
316
 
    // draw screen bitmap directly to Core Graphics context
317
 
    if (dataProviderRef) {
318
 
        CGImageRef imageRef = CGImageCreate(
319
 
            screen.width, //width
320
 
            screen.height, //height
321
 
            screen.bitsPerComponent, //bitsPerComponent
322
 
            screen.bitsPerPixel, //bitsPerPixel
323
 
            (screen.width * 4), //bytesPerRow
324
 
#if __LITTLE_ENDIAN__
325
 
            CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB), //colorspace for OS X >= 10.4
326
 
            kCGImageAlphaNoneSkipLast,
327
 
#else
328
 
            CGColorSpaceCreateDeviceRGB(), //colorspace for OS X < 10.4 (actually ppc)
329
 
            kCGImageAlphaNoneSkipFirst, //bitmapInfo
330
 
#endif
331
 
            dataProviderRef, //provider
332
 
            NULL, //decode
333
 
            0, //interpolate
334
 
            kCGRenderingIntentDefault //intent
335
 
        );
336
 
// test if host support "CGImageCreateWithImageInRect" at compiletime
337
 
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
338
 
        if (CGImageCreateWithImageInRect == NULL) { // test if "CGImageCreateWithImageInRect" is supported on host at runtime
339
 
#endif
340
 
            // compatibility drawing code (draws everything) (OS X < 10.4)
341
 
            CGContextDrawImage (viewContextRef, CGRectMake(0, 0, [self bounds].size.width, [self bounds].size.height), imageRef);
342
 
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
343
 
        } else {
344
 
            // selective drawing code (draws only dirty rectangles) (OS X >= 10.4)
345
 
            const NSRect *rectList;
346
 
            int rectCount;
347
 
            int i;
348
 
            CGImageRef clipImageRef;
349
 
            CGRect clipRect;
350
 
 
351
 
            [self getRectsBeingDrawn:&rectList count:&rectCount];
352
 
            for (i = 0; i < rectCount; i++) {
353
 
                clipRect.origin.x = rectList[i].origin.x / cdx;
354
 
                clipRect.origin.y = (float)screen.height - (rectList[i].origin.y + rectList[i].size.height) / cdy;
355
 
                clipRect.size.width = rectList[i].size.width / cdx;
356
 
                clipRect.size.height = rectList[i].size.height / cdy;
357
 
                clipImageRef = CGImageCreateWithImageInRect(
358
 
                    imageRef,
359
 
                    clipRect
360
 
                );
361
 
                CGContextDrawImage (viewContextRef, cgrect(rectList[i]), clipImageRef);
362
 
                CGImageRelease (clipImageRef);
363
 
            }
364
 
        }
365
 
#endif
366
 
        CGImageRelease (imageRef);
367
 
    }
368
 
}
369
 
 
370
 
- (void) setContentDimensions
371
 
{
372
 
    COCOA_DEBUG("QemuCocoaView: setContentDimensions\n");
373
 
 
374
 
    if (isFullscreen) {
375
 
        cdx = [[NSScreen mainScreen] frame].size.width / (float)screen.width;
376
 
        cdy = [[NSScreen mainScreen] frame].size.height / (float)screen.height;
377
 
        cw = screen.width * cdx;
378
 
        ch = screen.height * cdy;
379
 
        cx = ([[NSScreen mainScreen] frame].size.width - cw) / 2.0;
380
 
        cy = ([[NSScreen mainScreen] frame].size.height - ch) / 2.0;
381
 
    } else {
382
 
        cx = 0;
383
 
        cy = 0;
384
 
        cw = screen.width;
385
 
        ch = screen.height;
386
 
        cdx = 1.0;
387
 
        cdy = 1.0;
388
 
    }
389
 
}
390
 
 
391
 
- (void) resizeContentToWidth:(int)w height:(int)h displayState:(DisplayState *)ds
392
 
{
393
 
    COCOA_DEBUG("QemuCocoaView: resizeContent\n");
394
 
 
395
 
    // update screenBuffer
396
 
    if (dataProviderRef)
397
 
        CGDataProviderRelease(dataProviderRef);
398
 
    if (screenBuffer)
399
 
        free(screenBuffer);
400
 
    screenBuffer = malloc( w * 4 * h );
401
 
 
402
 
    ds->data = screenBuffer;
403
 
    ds->linesize =  (w * 4);
404
 
    ds->depth = 32;
405
 
    ds->width = w;
406
 
    ds->height = h;
407
 
#ifdef __LITTLE_ENDIAN__
408
 
    ds->bgr = 1;
409
 
#else
410
 
    ds->bgr = 0;
411
 
#endif
412
 
 
413
 
    dataProviderRef = CGDataProviderCreateWithData(NULL, screenBuffer, w * 4 * h, NULL);
414
 
 
415
 
    // update windows
416
 
    if (isFullscreen) {
417
 
        [[fullScreenWindow contentView] setFrame:[[NSScreen mainScreen] frame]];
418
 
        [normalWindow setFrame:NSMakeRect([normalWindow frame].origin.x, [normalWindow frame].origin.y - h + screen.height, w, h + [normalWindow frame].size.height - screen.height) display:NO animate:NO];
419
 
    } else {
420
 
        if (qemu_name)
421
 
            [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s", qemu_name]];
422
 
        [normalWindow setFrame:NSMakeRect([normalWindow frame].origin.x, [normalWindow frame].origin.y - h + screen.height, w, h + [normalWindow frame].size.height - screen.height) display:YES animate:YES];
423
 
    }
424
 
    screen.width = w;
425
 
    screen.height = h;
426
 
    [self setContentDimensions];
427
 
    [self setFrame:NSMakeRect(cx, cy, cw, ch)];
428
 
}
429
 
 
430
 
- (void) toggleFullScreen:(id)sender
431
 
{
432
 
    COCOA_DEBUG("QemuCocoaView: toggleFullScreen\n");
433
 
 
434
 
    if (isFullscreen) { // switch from fullscreen to desktop
435
 
        isFullscreen = FALSE;
436
 
        [self ungrabMouse];
437
 
        [self setContentDimensions];
438
 
// test if host support "enterFullScreenMode:withOptions" at compiletime
439
 
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
440
 
        if ([NSView respondsToSelector:@selector(exitFullScreenModeWithOptions:)]) { // test if "exitFullScreenModeWithOptions" is supported on host at runtime
441
 
            [self exitFullScreenModeWithOptions:nil];
442
 
        } else {
443
 
#endif
444
 
            [fullScreenWindow close];
445
 
            [normalWindow setContentView: self];
446
 
            [normalWindow makeKeyAndOrderFront: self];
447
 
            [NSMenu setMenuBarVisible:YES];
448
 
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
449
 
        }
450
 
#endif
451
 
    } else { // switch from desktop to fullscreen
452
 
        isFullscreen = TRUE;
453
 
        [self grabMouse];
454
 
        [self setContentDimensions];
455
 
// test if host support "enterFullScreenMode:withOptions" at compiletime
456
 
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
457
 
        if ([NSView respondsToSelector:@selector(enterFullScreenMode:withOptions:)]) { // test if "enterFullScreenMode:withOptions" is supported on host at runtime
458
 
            [self enterFullScreenMode:[NSScreen mainScreen] withOptions:[NSDictionary dictionaryWithObjectsAndKeys:
459
 
                [NSNumber numberWithBool:NO], NSFullScreenModeAllScreens,
460
 
                [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:NO], kCGDisplayModeIsStretched, nil], NSFullScreenModeSetting,
461
 
                 nil]];
462
 
        } else {
463
 
#endif
464
 
            [NSMenu setMenuBarVisible:NO];
465
 
            fullScreenWindow = [[NSWindow alloc] initWithContentRect:[[NSScreen mainScreen] frame]
466
 
                styleMask:NSBorderlessWindowMask
467
 
                backing:NSBackingStoreBuffered
468
 
                defer:NO];
469
 
            [fullScreenWindow setHasShadow:NO];
470
 
            [fullScreenWindow setContentView:self];
471
 
            [fullScreenWindow makeKeyAndOrderFront:self];
472
 
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
473
 
        }
474
 
#endif
475
 
    }
476
 
}
477
 
 
478
 
- (void) handleEvent:(NSEvent *)event
479
 
{
480
 
    COCOA_DEBUG("QemuCocoaView: handleEvent\n");
481
 
 
482
 
    int buttons = 0;
483
 
    int keycode;
484
 
    NSPoint p = [event locationInWindow];
485
 
 
486
 
    switch ([event type]) {
487
 
        case NSFlagsChanged:
488
 
            keycode = cocoa_keycode_to_qemu([event keyCode]);
489
 
            if (keycode) {
490
 
                if (keycode == 58 || keycode == 69) { // emulate caps lock and num lock keydown and keyup
491
 
                    kbd_put_keycode(keycode);
492
 
                    kbd_put_keycode(keycode | 0x80);
493
 
                } else if (is_graphic_console()) {
494
 
                    if (keycode & 0x80)
495
 
                        kbd_put_keycode(0xe0);
496
 
                    if (modifiers_state[keycode] == 0) { // keydown
497
 
                        kbd_put_keycode(keycode & 0x7f);
498
 
                        modifiers_state[keycode] = 1;
499
 
                    } else { // keyup
500
 
                        kbd_put_keycode(keycode | 0x80);
501
 
                        modifiers_state[keycode] = 0;
502
 
                    }
503
 
                }
504
 
            }
505
 
 
506
 
            // release Mouse grab when pressing ctrl+alt
507
 
            if (!isFullscreen && ([event modifierFlags] & NSControlKeyMask) && ([event modifierFlags] & NSAlternateKeyMask)) {
508
 
                [self ungrabMouse];
509
 
            }
510
 
            break;
511
 
        case NSKeyDown:
512
 
 
513
 
            // forward command Key Combos
514
 
            if ([event modifierFlags] & NSCommandKeyMask) {
515
 
                [NSApp sendEvent:event];
516
 
                return;
517
 
            }
518
 
 
519
 
            // default
520
 
            keycode = cocoa_keycode_to_qemu([event keyCode]);
521
 
 
522
 
            // handle control + alt Key Combos (ctrl+alt is reserved for QEMU)
523
 
            if (([event modifierFlags] & NSControlKeyMask) && ([event modifierFlags] & NSAlternateKeyMask)) {
524
 
                switch (keycode) {
525
 
 
526
 
                    // enable graphic console
527
 
                    case 0x02 ... 0x0a: // '1' to '9' keys
528
 
                        console_select(keycode - 0x02);
529
 
                        break;
530
 
                }
531
 
 
532
 
            // handle keys for graphic console
533
 
            } else if (is_graphic_console()) {
534
 
                if (keycode & 0x80) //check bit for e0 in front
535
 
                    kbd_put_keycode(0xe0);
536
 
                kbd_put_keycode(keycode & 0x7f); //remove e0 bit in front
537
 
 
538
 
            // handlekeys for Monitor
539
 
            } else {
540
 
                int keysym = 0;
541
 
                switch([event keyCode]) {
542
 
                case 115:
543
 
                    keysym = QEMU_KEY_HOME;
544
 
                    break;
545
 
                case 117:
546
 
                    keysym = QEMU_KEY_DELETE;
547
 
                    break;
548
 
                case 119:
549
 
                    keysym = QEMU_KEY_END;
550
 
                    break;
551
 
                case 123:
552
 
                    keysym = QEMU_KEY_LEFT;
553
 
                    break;
554
 
                case 124:
555
 
                    keysym = QEMU_KEY_RIGHT;
556
 
                    break;
557
 
                case 125:
558
 
                    keysym = QEMU_KEY_DOWN;
559
 
                    break;
560
 
                case 126:
561
 
                    keysym = QEMU_KEY_UP;
562
 
                    break;
563
 
                default:
564
 
                    {
565
 
                        NSString *ks = [event characters];
566
 
                        if ([ks length] > 0)
567
 
                            keysym = [ks characterAtIndex:0];
568
 
                    }
569
 
                }
570
 
                if (keysym)
571
 
                    kbd_put_keysym(keysym);
572
 
            }
573
 
            break;
574
 
        case NSKeyUp:
575
 
            keycode = cocoa_keycode_to_qemu([event keyCode]);
576
 
            if (is_graphic_console()) {
577
 
                if (keycode & 0x80)
578
 
                    kbd_put_keycode(0xe0);
579
 
                kbd_put_keycode(keycode | 0x80); //add 128 to signal release of key
580
 
            }
581
 
            break;
582
 
        case NSMouseMoved:
583
 
            if (isAbsoluteEnabled) {
584
 
                if (p.x < 0 || p.x > screen.width || p.y < 0 || p.y > screen.height || ![[self window] isKeyWindow]) {
585
 
                    if (isTabletEnabled) { // if we leave the window, deactivate the tablet
586
 
                        [NSCursor unhide];
587
 
                        isTabletEnabled = FALSE;
588
 
                    }
589
 
                } else {
590
 
                    if (!isTabletEnabled) { // if we enter the window, activate the tablet
 
358
static void cocoa_refresh(DisplayState *ds)
 
359
{
 
360
    //printf("cocoa_refresh \n");
 
361
    NSDate *distantPast;
 
362
    NSEvent *event;
 
363
    NSAutoreleasePool *pool;
 
364
    
 
365
    pool = [ [ NSAutoreleasePool alloc ] init ];
 
366
    distantPast = [ NSDate distantPast ];
 
367
    
 
368
    vga_hw_update();
 
369
 
 
370
    do {
 
371
        event = [ NSApp nextEventMatchingMask:NSAnyEventMask untilDate:distantPast
 
372
                        inMode: NSDefaultRunLoopMode dequeue:YES ];
 
373
        if (event != nil) {
 
374
            switch ([event type]) {
 
375
                case NSFlagsChanged:
 
376
                    {
 
377
                        int keycode = cocoa_keycode_to_qemu([event keyCode]);
 
378
 
 
379
                        if (keycode)
 
380
                        {
 
381
                            if (keycode == 58 || keycode == 69) {
 
382
                                /* emulate caps lock and num lock keydown and keyup */
 
383
                                kbd_put_keycode(keycode);
 
384
                                kbd_put_keycode(keycode | 0x80);
 
385
                            } else if (is_graphic_console()) {
 
386
                                if (keycode & 0x80)
 
387
                                    kbd_put_keycode(0xe0);
 
388
                                if (modifiers_state[keycode] == 0) {
 
389
                                    /* keydown */
 
390
                                    kbd_put_keycode(keycode & 0x7f);
 
391
                                    modifiers_state[keycode] = 1;
 
392
                                } else {
 
393
                                    /* keyup */
 
394
                                    kbd_put_keycode(keycode | 0x80);
 
395
                                    modifiers_state[keycode] = 0;
 
396
                                }
 
397
                            }
 
398
                        }
 
399
 
 
400
                        /* release Mouse grab when pressing ctrl+alt */
 
401
                        if (([event modifierFlags] & NSControlKeyMask) && ([event modifierFlags] & NSAlternateKeyMask))
 
402
                        {
 
403
                            [window setTitle: @"QEMU"];
 
404
                            [NSCursor unhide];
 
405
                            CGAssociateMouseAndMouseCursorPosition ( TRUE );
 
406
                            grab = 0;
 
407
                        }
 
408
                    }
 
409
                    break;
 
410
 
 
411
                case NSKeyDown:
 
412
                    {
 
413
                        int keycode = cocoa_keycode_to_qemu([event keyCode]);               
 
414
                        
 
415
                        /* handle command Key Combos */
 
416
                        if ([event modifierFlags] & NSCommandKeyMask) {
 
417
                            switch ([event keyCode]) {
 
418
                                /* quit */
 
419
                                case 12: /* q key */
 
420
                                    /* switch to windowed View */
 
421
                                    exit(0);
 
422
                                    return;
 
423
                            }
 
424
                        }
 
425
                        
 
426
                        /* handle control + alt Key Combos */
 
427
                        if (([event modifierFlags] & NSControlKeyMask) && ([event modifierFlags] & NSAlternateKeyMask)) {
 
428
                            switch (keycode) {
 
429
                                /* toggle Monitor */
 
430
                                case 0x02 ... 0x0a: /* '1' to '9' keys */
 
431
                                    console_select(keycode - 0x02);
 
432
                                    break;
 
433
                            }
 
434
                        } else {
 
435
                            /* handle standard key events */
 
436
                            if (is_graphic_console()) {
 
437
                                if (keycode & 0x80) //check bit for e0 in front
 
438
                                    kbd_put_keycode(0xe0);
 
439
                                kbd_put_keycode(keycode & 0x7f); //remove e0 bit in front
 
440
                            /* handle monitor key events */
 
441
                            } else {
 
442
                                int keysym = 0;
 
443
 
 
444
                                switch([event keyCode]) {
 
445
                                case 115:
 
446
                                    keysym = QEMU_KEY_HOME;
 
447
                                    break;
 
448
                                case 117:
 
449
                                    keysym = QEMU_KEY_DELETE;
 
450
                                    break;
 
451
                                case 119:
 
452
                                    keysym = QEMU_KEY_END;
 
453
                                    break;
 
454
                                case 123:
 
455
                                    keysym = QEMU_KEY_LEFT;
 
456
                                    break;
 
457
                                case 124:
 
458
                                    keysym = QEMU_KEY_RIGHT;
 
459
                                    break;
 
460
                                case 125:
 
461
                                    keysym = QEMU_KEY_DOWN;
 
462
                                    break;
 
463
                                case 126:
 
464
                                    keysym = QEMU_KEY_UP;
 
465
                                    break;
 
466
                                default:
 
467
                                    {
 
468
                                        NSString *ks = [event characters];
 
469
 
 
470
                                        if ([ks length] > 0)
 
471
                                            keysym = [ks characterAtIndex:0];
 
472
                                    }
 
473
                                }
 
474
                                if (keysym)
 
475
                                    kbd_put_keysym(keysym);
 
476
                            }
 
477
                        }
 
478
                    }
 
479
                    break;
 
480
                    
 
481
                case NSKeyUp:
 
482
                    {
 
483
                        int keycode = cocoa_keycode_to_qemu([event keyCode]);   
 
484
                        if (is_graphic_console()) {
 
485
                            if (keycode & 0x80)
 
486
                                kbd_put_keycode(0xe0);
 
487
                            kbd_put_keycode(keycode | 0x80); //add 128 to signal release of key
 
488
                        }
 
489
                    }
 
490
                    break;
 
491
                    
 
492
                case NSMouseMoved:
 
493
                    if (grab) {
 
494
                        int dx = [event deltaX];
 
495
                        int dy = [event deltaY];
 
496
                        int dz = [event deltaZ];
 
497
                        int buttons = 0;
 
498
                        kbd_mouse_event(dx, dy, dz, buttons);
 
499
                    }
 
500
                    break;
 
501
                        
 
502
                case NSLeftMouseDown:
 
503
                    if (grab) {
 
504
                        int buttons = 0;
 
505
                        
 
506
                        /* leftclick+command simulates rightclick */
 
507
                        if ([event modifierFlags] & NSCommandKeyMask) {
 
508
                            buttons |= MOUSE_EVENT_RBUTTON;
 
509
                        } else {
 
510
                            buttons |= MOUSE_EVENT_LBUTTON;
 
511
                        }
 
512
                        kbd_mouse_event(0, 0, 0, buttons);
 
513
                    } else {
 
514
                        [NSApp sendEvent: event];
 
515
                    }
 
516
                    break;
 
517
                        
 
518
                case NSLeftMouseDragged:
 
519
                    if (grab) {
 
520
                        int dx = [event deltaX];
 
521
                        int dy = [event deltaY];
 
522
                        int dz = [event deltaZ];
 
523
                        int buttons = 0;
 
524
                        if ([[NSApp currentEvent] modifierFlags] & NSCommandKeyMask) { //leftclick+command simulates rightclick
 
525
                            buttons |= MOUSE_EVENT_RBUTTON;
 
526
                        } else {
 
527
                            buttons |= MOUSE_EVENT_LBUTTON;
 
528
                        }
 
529
                        kbd_mouse_event(dx, dy, dz, buttons);
 
530
                    }
 
531
                    break;
 
532
                        
 
533
                case NSLeftMouseUp:
 
534
                    if (grab) {
 
535
                        kbd_mouse_event(0, 0, 0, 0);
 
536
                    } else {
 
537
                        [window setTitle: @"QEMU (Press ctrl + alt to release Mouse)"];
591
538
                        [NSCursor hide];
592
 
                        isTabletEnabled = TRUE;
593
 
                    }
594
 
                }
595
 
            }
596
 
            COCOA_MOUSE_EVENT
597
 
            break;
598
 
        case NSLeftMouseDown:
599
 
            if ([event modifierFlags] & NSCommandKeyMask) {
600
 
                buttons |= MOUSE_EVENT_RBUTTON;
601
 
            } else {
602
 
                buttons |= MOUSE_EVENT_LBUTTON;
603
 
            }
604
 
            COCOA_MOUSE_EVENT
605
 
            break;
606
 
        case NSRightMouseDown:
607
 
            buttons |= MOUSE_EVENT_RBUTTON;
608
 
            COCOA_MOUSE_EVENT
609
 
            break;
610
 
        case NSOtherMouseDown:
611
 
            buttons |= MOUSE_EVENT_MBUTTON;
612
 
            COCOA_MOUSE_EVENT
613
 
            break;
614
 
        case NSLeftMouseDragged:
615
 
            if ([event modifierFlags] & NSCommandKeyMask) {
616
 
                buttons |= MOUSE_EVENT_RBUTTON;
617
 
            } else {
618
 
                buttons |= MOUSE_EVENT_LBUTTON;
619
 
            }
620
 
            COCOA_MOUSE_EVENT
621
 
            break;
622
 
        case NSRightMouseDragged:
623
 
            buttons |= MOUSE_EVENT_RBUTTON;
624
 
            COCOA_MOUSE_EVENT
625
 
            break;
626
 
        case NSOtherMouseDragged:
627
 
            buttons |= MOUSE_EVENT_MBUTTON;
628
 
            COCOA_MOUSE_EVENT
629
 
            break;
630
 
        case NSLeftMouseUp:
631
 
            if (isTabletEnabled) {
632
 
                    COCOA_MOUSE_EVENT
633
 
            } else if (!isMouseGrabed) {
634
 
                if (p.x > -1 && p.x < screen.width && p.y > -1 && p.y < screen.height) {
635
 
                    [self grabMouse];
636
 
                } else {
637
 
                    [NSApp sendEvent:event];
638
 
                }
639
 
            } else {
640
 
                COCOA_MOUSE_EVENT
641
 
            }
642
 
            break;
643
 
        case NSRightMouseUp:
644
 
            COCOA_MOUSE_EVENT
645
 
            break;
646
 
        case NSOtherMouseUp:
647
 
            COCOA_MOUSE_EVENT
648
 
            break;
649
 
        case NSScrollWheel:
650
 
            if (isTabletEnabled || isMouseGrabed) {
651
 
                kbd_mouse_event(0, 0, -[event deltaY], 0);
652
 
            } else {
653
 
                [NSApp sendEvent:event];
654
 
            }
655
 
            break;
656
 
        default:
657
 
            [NSApp sendEvent:event];
658
 
    }
659
 
}
660
 
 
661
 
- (void) grabMouse
662
 
{
663
 
    COCOA_DEBUG("QemuCocoaView: grabMouse\n");
664
 
 
665
 
    if (!isFullscreen) {
666
 
        if (qemu_name)
667
 
            [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s - (Press ctrl + alt to release Mouse)", qemu_name]];
668
 
        else
669
 
            [normalWindow setTitle:@"QEMU - (Press ctrl + alt to release Mouse)"];
670
 
    }
671
 
    [NSCursor hide];
672
 
    CGAssociateMouseAndMouseCursorPosition(FALSE);
673
 
    isMouseGrabed = TRUE; // while isMouseGrabed = TRUE, QemuCocoaApp sends all events to [cocoaView handleEvent:]
674
 
}
675
 
 
676
 
- (void) ungrabMouse
677
 
{
678
 
    COCOA_DEBUG("QemuCocoaView: ungrabMouse\n");
679
 
 
680
 
    if (!isFullscreen) {
681
 
        if (qemu_name)
682
 
            [normalWindow setTitle:[NSString stringWithFormat:@"QEMU %s", qemu_name]];
683
 
        else
684
 
            [normalWindow setTitle:@"QEMU"];
685
 
    }
686
 
    [NSCursor unhide];
687
 
    CGAssociateMouseAndMouseCursorPosition(TRUE);
688
 
    isMouseGrabed = FALSE;
689
 
}
690
 
 
691
 
- (void) setAbsoluteEnabled:(BOOL)tIsAbsoluteEnabled {isAbsoluteEnabled = tIsAbsoluteEnabled;}
692
 
- (BOOL) isMouseGrabed {return isMouseGrabed;}
693
 
- (BOOL) isAbsoluteEnabled {return isAbsoluteEnabled;}
694
 
- (float) cdx {return cdx;}
695
 
- (float) cdy {return cdy;}
696
 
- (QEMUScreen) gscreen {return screen;}
 
539
                        CGAssociateMouseAndMouseCursorPosition ( FALSE );
 
540
                        grab = 1;
 
541
                        //[NSApp sendEvent: event];
 
542
                    }
 
543
                    break;
 
544
                        
 
545
                case NSRightMouseDown:
 
546
                    if (grab) {
 
547
                        int buttons = 0;
 
548
                        
 
549
                        buttons |= MOUSE_EVENT_RBUTTON;
 
550
                        kbd_mouse_event(0, 0, 0, buttons);
 
551
                    } else {
 
552
                        [NSApp sendEvent: event];
 
553
                    }
 
554
                    break;
 
555
                    
 
556
                case NSRightMouseDragged:
 
557
                    if (grab) {
 
558
                        int dx = [event deltaX];
 
559
                        int dy = [event deltaY];
 
560
                        int dz = [event deltaZ];
 
561
                        int buttons = 0;
 
562
                        buttons |= MOUSE_EVENT_RBUTTON;
 
563
                        kbd_mouse_event(dx, dy, dz, buttons);
 
564
                    }
 
565
                    break;
 
566
                    
 
567
                case NSRightMouseUp:
 
568
                    if (grab) {
 
569
                        kbd_mouse_event(0, 0, 0, 0);
 
570
                    } else {
 
571
                        [NSApp sendEvent: event];
 
572
                    }
 
573
                    break;
 
574
                        
 
575
                case NSOtherMouseDragged:
 
576
                    if (grab) {
 
577
                        int dx = [event deltaX];
 
578
                        int dy = [event deltaY];
 
579
                        int dz = [event deltaZ];
 
580
                        int buttons = 0;
 
581
                        buttons |= MOUSE_EVENT_MBUTTON;
 
582
                        kbd_mouse_event(dx, dy, dz, buttons);
 
583
                    }
 
584
                    break;
 
585
                    
 
586
                case NSOtherMouseDown:
 
587
                    if (grab) {
 
588
                        int buttons = 0;
 
589
                        buttons |= MOUSE_EVENT_MBUTTON;
 
590
                        kbd_mouse_event(0, 0, 0, buttons);
 
591
                    } else {
 
592
                        [NSApp sendEvent:event];
 
593
                    }
 
594
                    break;
 
595
                        
 
596
                case NSOtherMouseUp:
 
597
                    if (grab) {
 
598
                        kbd_mouse_event(0, 0, 0, 0);
 
599
                    } else {
 
600
                        [NSApp sendEvent: event];
 
601
                    }
 
602
                    break;
 
603
                        
 
604
                case NSScrollWheel:
 
605
                    if (grab) {
 
606
                        int dz = [event deltaY];
 
607
                        kbd_mouse_event(0, 0, -dz, 0);
 
608
                    }
 
609
                    break;
 
610
                
 
611
                default: [NSApp sendEvent:event];
 
612
            }
 
613
        }
 
614
    } while(event != nil);
 
615
}
 
616
 
 
617
/*
 
618
 ------------------------------------------------------
 
619
    cocoa_cleanup
 
620
 ------------------------------------------------------
 
621
*/
 
622
 
 
623
static void cocoa_cleanup(void) 
 
624
{
 
625
 
 
626
}
 
627
 
 
628
/*
 
629
 ------------------------------------------------------
 
630
    cocoa_display_init
 
631
 ------------------------------------------------------
 
632
*/
 
633
 
 
634
void cocoa_display_init(DisplayState *ds, int full_screen)
 
635
{
 
636
    ds->dpy_update = cocoa_update;
 
637
    ds->dpy_resize = cocoa_resize;
 
638
    ds->dpy_refresh = cocoa_refresh;
 
639
    
 
640
    cocoa_resize(ds, 640, 400);
 
641
    
 
642
    atexit(cocoa_cleanup);
 
643
}
 
644
 
 
645
/*
 
646
 ------------------------------------------------------
 
647
    Interface with Cocoa
 
648
 ------------------------------------------------------
 
649
*/
 
650
 
 
651
 
 
652
/*
 
653
 ------------------------------------------------------
 
654
    QemuWindow
 
655
    Some trick from SDL to use miniwindow
 
656
 ------------------------------------------------------
 
657
*/
 
658
static void QZ_SetPortAlphaOpaque ()
 
659
{    
 
660
    /* Assume 32 bit if( bpp == 32 )*/
 
661
    if ( 1 ) {
 
662
    
 
663
        uint32_t    *pixels = (uint32_t*) current_ds.data;
 
664
        uint32_t    rowPixels = current_ds.linesize / 4;
 
665
        uint32_t    i, j;
 
666
        
 
667
        for (i = 0; i < current_ds.height; i++)
 
668
            for (j = 0; j < current_ds.width; j++) {
 
669
        
 
670
                pixels[ (i * rowPixels) + j ] |= 0xFF000000;
 
671
            }
 
672
    }
 
673
}
 
674
 
 
675
@implementation QemuWindow
 
676
- (void)miniaturize:(id)sender
 
677
{
 
678
        
 
679
    /* make the alpha channel opaque so anim won't have holes in it */
 
680
    QZ_SetPortAlphaOpaque ();
 
681
    
 
682
    [ super miniaturize:sender ];
 
683
    
 
684
}
 
685
- (void)display
 
686
{    
 
687
    /* 
 
688
        This method fires just before the window deminaturizes from the Dock.
 
689
        
 
690
        We'll save the current visible surface, let the window manager redraw any
 
691
        UI elements, and restore the SDL surface. This way, no expose event 
 
692
        is required, and the deminiaturize works perfectly.
 
693
    */
 
694
    
 
695
    /* make sure pixels are fully opaque */
 
696
    QZ_SetPortAlphaOpaque ();
 
697
    
 
698
    /* save current visible SDL surface */
 
699
    [ self cacheImageInRect:[ qd_view frame ] ];
 
700
    
 
701
    /* let the window manager redraw controls, border, etc */
 
702
    [ super display ];
 
703
    
 
704
    /* restore visible SDL surface */
 
705
    [ self restoreCachedImage ];
 
706
}
 
707
 
697
708
@end
698
709
 
699
710
 
700
 
 
701
711
/*
702
712
 ------------------------------------------------------
703
 
    QemuCocoaAppController
 
713
    QemuCocoaGUIController
 
714
    NSApp's delegate - indeed main object
704
715
 ------------------------------------------------------
705
716
*/
706
 
@interface QemuCocoaAppController : NSObject
 
717
 
 
718
@interface QemuCocoaGUIController : NSObject
707
719
{
708
720
}
 
721
- (void)applicationDidFinishLaunching: (NSNotification *) note;
 
722
- (void)applicationWillTerminate:(NSNotification *)aNotification;
 
723
 
 
724
- (void)openPanelDidEnd:(NSOpenPanel *)sheet returnCode:(int)returnCode contextInfo:(void *)contextInfo;
 
725
 
709
726
- (void)startEmulationWithArgc:(int)argc argv:(char**)argv;
710
 
- (void)openPanelDidEnd:(NSOpenPanel *)sheet returnCode:(int)returnCode contextInfo:(void *)contextInfo;
711
 
- (void)toggleFullScreen:(id)sender;
712
 
- (void)showQEMUDoc:(id)sender;
713
 
- (void)showQEMUTec:(id)sender;
714
727
@end
715
728
 
716
 
@implementation QemuCocoaAppController
717
 
- (id) init
718
 
{
719
 
    COCOA_DEBUG("QemuCocoaAppController: init\n");
720
 
 
721
 
    self = [super init];
722
 
    if (self) {
723
 
 
724
 
        // create a view and add it to the window
725
 
        cocoaView = [[QemuCocoaView alloc] initWithFrame:NSMakeRect(0.0, 0.0, 640.0, 480.0)];
726
 
        if(!cocoaView) {
727
 
            fprintf(stderr, "(cocoa) can't create a view\n");
728
 
            exit(1);
729
 
        }
730
 
 
731
 
        // create a window
732
 
        normalWindow = [[NSWindow alloc] initWithContentRect:[cocoaView frame]
733
 
            styleMask:NSTitledWindowMask|NSMiniaturizableWindowMask|NSClosableWindowMask
734
 
            backing:NSBackingStoreBuffered defer:NO];
735
 
        if(!normalWindow) {
736
 
            fprintf(stderr, "(cocoa) can't create window\n");
737
 
            exit(1);
738
 
        }
739
 
        [normalWindow setAcceptsMouseMovedEvents:YES];
740
 
        [normalWindow setTitle:[NSString stringWithFormat:@"QEMU"]];
741
 
        [normalWindow setContentView:cocoaView];
742
 
        [normalWindow makeKeyAndOrderFront:self];
743
 
 
744
 
    }
745
 
    return self;
746
 
}
747
 
 
748
 
- (void) dealloc
749
 
{
750
 
    COCOA_DEBUG("QemuCocoaAppController: dealloc\n");
751
 
 
752
 
    if (cocoaView)
753
 
        [cocoaView release];
754
 
    [super dealloc];
755
 
}
756
 
 
 
729
@implementation QemuCocoaGUIController
 
730
/* Called when the internal event loop has just started running */
757
731
- (void)applicationDidFinishLaunching: (NSNotification *) note
758
732
{
759
 
    COCOA_DEBUG("QemuCocoaAppController: applicationDidFinishLaunching\n");
760
 
 
761
 
    // Display an open dialog box if no argument were passed or
762
 
    // if qemu was launched from the finder ( the Finder passes "-psn" )
763
 
    if( gArgc <= 1 || strncmp ((char *)gArgv[1], "-psn", 4) == 0) {
 
733
 
 
734
    /* Display an open dialog box if no argument were passed or
 
735
       if qemu was launched from the finder ( the Finder passes "-psn" ) */
 
736
 
 
737
    if( gArgc <= 1 || strncmp (gArgv[1], "-psn", 4) == 0)
 
738
    {
764
739
        NSOpenPanel *op = [[NSOpenPanel alloc] init];
 
740
        
 
741
        cocoa_resize(&current_ds, 640, 400);
 
742
        
765
743
        [op setPrompt:@"Boot image"];
 
744
        
766
745
        [op setMessage:@"Select the disk image you want to boot.\n\nHit the \"Cancel\" button to quit"];
 
746
        
767
747
        [op beginSheetForDirectory:nil file:nil types:[NSArray arrayWithObjects:@"img",@"iso",@"dmg",@"qcow",@"cow",@"cloop",@"vmdk",nil]
768
 
              modalForWindow:normalWindow modalDelegate:self
 
748
              modalForWindow:window modalDelegate:self
769
749
              didEndSelector:@selector(openPanelDidEnd:returnCode:contextInfo:) contextInfo:NULL];
770
 
    } else {
771
 
        // or Launch Qemu, with the global args
772
 
        [self startEmulationWithArgc:gArgc argv:(char **)gArgv];
 
750
    }
 
751
    else
 
752
    {
 
753
        /* or Launch Qemu, with the global args */
 
754
        [self startEmulationWithArgc:gArgc argv:gArgv];
773
755
    }
774
756
}
775
757
 
776
758
- (void)applicationWillTerminate:(NSNotification *)aNotification
777
759
{
778
 
    COCOA_DEBUG("QemuCocoaAppController: applicationWillTerminate\n");
779
 
 
 
760
    printf("Application will terminate\n");
780
761
    qemu_system_shutdown_request();
 
762
    /* In order to avoid a crash */
781
763
    exit(0);
782
764
}
783
765
 
784
 
- (void)startEmulationWithArgc:(int)argc argv:(char**)argv
785
 
{
786
 
    COCOA_DEBUG("QemuCocoaAppController: startEmulationWithArgc\n");
787
 
 
788
 
    int status;
789
 
    status = qemu_main(argc, argv);
790
 
    exit(status);
791
 
}
792
 
 
793
766
- (void)openPanelDidEnd:(NSOpenPanel *)sheet returnCode:(int)returnCode contextInfo:(void *)contextInfo
794
767
{
795
 
    COCOA_DEBUG("QemuCocoaAppController: openPanelDidEnd\n");
796
 
 
797
 
    if(returnCode == NSCancelButton) {
 
768
    if(returnCode == NSCancelButton)
 
769
    {
798
770
        exit(0);
799
 
    } else if(returnCode == NSOKButton) {
 
771
    }
 
772
    
 
773
    if(returnCode == NSOKButton)
 
774
    {
800
775
        char *bin = "qemu";
801
 
        char *img = (char*)[ [ sheet filename ] cStringUsingEncoding:NSASCIIStringEncoding];
802
 
 
 
776
        char *img = (char*)[ [ sheet filename ] cString];
 
777
        
803
778
        char **argv = (char**)malloc( sizeof(char*)*3 );
804
 
 
 
779
        
805
780
        asprintf(&argv[0], "%s", bin);
806
781
        asprintf(&argv[1], "-hda");
807
782
        asprintf(&argv[2], "%s", img);
808
 
 
 
783
        
809
784
        printf("Using argc %d argv %s -hda %s\n", 3, bin, img);
810
 
 
 
785
        
811
786
        [self startEmulationWithArgc:3 argv:(char**)argv];
812
787
    }
813
788
}
814
 
- (void)toggleFullScreen:(id)sender
815
 
{
816
 
    COCOA_DEBUG("QemuCocoaAppController: toggleFullScreen\n");
817
 
 
818
 
    [cocoaView toggleFullScreen:sender];
819
 
}
820
 
 
821
 
- (void)showQEMUDoc:(id)sender
822
 
{
823
 
    COCOA_DEBUG("QemuCocoaAppController: showQEMUDoc\n");
824
 
 
825
 
    [[NSWorkspace sharedWorkspace] openFile:[NSString stringWithFormat:@"%@/../doc/qemu/qemu-doc.html",
826
 
        [[NSBundle mainBundle] resourcePath]] withApplication:@"Help Viewer"];
827
 
}
828
 
 
829
 
- (void)showQEMUTec:(id)sender
830
 
{
831
 
    COCOA_DEBUG("QemuCocoaAppController: showQEMUTec\n");
832
 
 
833
 
    [[NSWorkspace sharedWorkspace] openFile:[NSString stringWithFormat:@"%@/../doc/qemu/qemu-tech.html",
834
 
        [[NSBundle mainBundle] resourcePath]] withApplication:@"Help Viewer"];
 
789
 
 
790
- (void)startEmulationWithArgc:(int)argc argv:(char**)argv
 
791
{
 
792
    int status;
 
793
    /* Launch Qemu */
 
794
    printf("starting qemu...\n");
 
795
    status = qemu_main (argc, argv);
 
796
    exit(status);
835
797
}
836
798
@end
837
799
 
838
 
 
839
 
 
840
 
// Dock Connection
 
800
/*
 
801
 ------------------------------------------------------
 
802
    Application Creation
 
803
 ------------------------------------------------------
 
804
*/
 
805
 
 
806
/* Dock Connection */
841
807
typedef struct CPSProcessSerNum
842
808
{
843
809
        UInt32                lo;
848
814
extern OSErr    CPSEnableForegroundOperation( CPSProcessSerNum *psn, UInt32 _arg2, UInt32 _arg3, UInt32 _arg4, UInt32 _arg5);
849
815
extern OSErr    CPSSetFrontProcess( CPSProcessSerNum *psn);
850
816
 
851
 
int main (int argc, const char * argv[]) {
852
 
 
853
 
    gArgc = argc;
854
 
    gArgv = (char **)argv;
 
817
/* Menu Creation */
 
818
static void setApplicationMenu(void)
 
819
{
 
820
    /* warning: this code is very odd */
 
821
    NSMenu *appleMenu;
 
822
    NSMenuItem *menuItem;
 
823
    NSString *title;
 
824
    NSString *appName;
 
825
    
 
826
    appName = @"Qemu";
 
827
    appleMenu = [[NSMenu alloc] initWithTitle:@""];
 
828
    
 
829
    /* Add menu items */
 
830
    title = [@"About " stringByAppendingString:appName];
 
831
    [appleMenu addItemWithTitle:title action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""];
 
832
 
 
833
    [appleMenu addItem:[NSMenuItem separatorItem]];
 
834
 
 
835
    title = [@"Hide " stringByAppendingString:appName];
 
836
    [appleMenu addItemWithTitle:title action:@selector(hide:) keyEquivalent:@"h"];
 
837
 
 
838
    menuItem = (NSMenuItem *)[appleMenu addItemWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"];
 
839
    [menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask|NSCommandKeyMask)];
 
840
 
 
841
    [appleMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""];
 
842
 
 
843
    [appleMenu addItem:[NSMenuItem separatorItem]];
 
844
 
 
845
    title = [@"Quit " stringByAppendingString:appName];
 
846
    [appleMenu addItemWithTitle:title action:@selector(terminate:) keyEquivalent:@"q"];
 
847
 
 
848
    
 
849
    /* Put menu into the menubar */
 
850
    menuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
 
851
    [menuItem setSubmenu:appleMenu];
 
852
    [[NSApp mainMenu] addItem:menuItem];
 
853
 
 
854
    /* Tell the application object that this is now the application menu */
 
855
    [NSApp setAppleMenu:appleMenu];
 
856
 
 
857
    /* Finally give up our references to the objects */
 
858
    [appleMenu release];
 
859
    [menuItem release];
 
860
}
 
861
 
 
862
/* Create a window menu */
 
863
static void setupWindowMenu(void)
 
864
{
 
865
    NSMenu      *windowMenu;
 
866
    NSMenuItem  *windowMenuItem;
 
867
    NSMenuItem  *menuItem;
 
868
 
 
869
    windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
 
870
    
 
871
    /* "Minimize" item */
 
872
    menuItem = [[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"];
 
873
    [windowMenu addItem:menuItem];
 
874
    [menuItem release];
 
875
    
 
876
    /* Put menu into the menubar */
 
877
    windowMenuItem = [[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""];
 
878
    [windowMenuItem setSubmenu:windowMenu];
 
879
    [[NSApp mainMenu] addItem:windowMenuItem];
 
880
    
 
881
    /* Tell the application object that this is now the window menu */
 
882
    [NSApp setWindowsMenu:windowMenu];
 
883
 
 
884
    /* Finally give up our references to the objects */
 
885
    [windowMenu release];
 
886
    [windowMenuItem release];
 
887
}
 
888
 
 
889
static void CustomApplicationMain(void)
 
890
{
 
891
    NSAutoreleasePool   *pool = [[NSAutoreleasePool alloc] init];
 
892
    QemuCocoaGUIController *gui_controller;
855
893
    CPSProcessSerNum PSN;
856
 
 
857
 
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
894
    
858
895
    [NSApplication sharedApplication];
859
 
 
 
896
    
860
897
    if (!CPSGetCurrentProcess(&PSN))
861
898
        if (!CPSEnableForegroundOperation(&PSN,0x03,0x3C,0x2C,0x1103))
862
899
            if (!CPSSetFrontProcess(&PSN))
863
900
                [NSApplication sharedApplication];
864
 
 
865
 
    // Add menus
866
 
    NSMenu      *menu;
867
 
    NSMenuItem  *menuItem;
868
 
 
 
901
                
 
902
    /* Set up the menubar */
869
903
    [NSApp setMainMenu:[[NSMenu alloc] init]];
870
 
 
871
 
    // Application menu
872
 
    menu = [[NSMenu alloc] initWithTitle:@""];
873
 
    [menu addItemWithTitle:@"About QEMU" action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""]; // About QEMU
874
 
    [menu addItem:[NSMenuItem separatorItem]]; //Separator
875
 
    [menu addItemWithTitle:@"Hide QEMU" action:@selector(hide:) keyEquivalent:@"h"]; //Hide QEMU
876
 
    menuItem = (NSMenuItem *)[menu addItemWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"]; // Hide Others
877
 
    [menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask|NSCommandKeyMask)];
878
 
    [menu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""]; // Show All
879
 
    [menu addItem:[NSMenuItem separatorItem]]; //Separator
880
 
    [menu addItemWithTitle:@"Quit QEMU" action:@selector(terminate:) keyEquivalent:@"q"];
881
 
    menuItem = [[NSMenuItem alloc] initWithTitle:@"Apple" action:nil keyEquivalent:@""];
882
 
    [menuItem setSubmenu:menu];
883
 
    [[NSApp mainMenu] addItem:menuItem];
884
 
    [NSApp performSelector:@selector(setAppleMenu:) withObject:menu]; // Workaround (this method is private since 10.4+)
885
 
 
886
 
    // View menu
887
 
    menu = [[NSMenu alloc] initWithTitle:@"View"];
888
 
    [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"Enter Fullscreen" action:@selector(toggleFullScreen:) keyEquivalent:@"f"] autorelease]]; // Fullscreen
889
 
    menuItem = [[[NSMenuItem alloc] initWithTitle:@"View" action:nil keyEquivalent:@""] autorelease];
890
 
    [menuItem setSubmenu:menu];
891
 
    [[NSApp mainMenu] addItem:menuItem];
892
 
 
893
 
    // Window menu
894
 
    menu = [[NSMenu alloc] initWithTitle:@"Window"];
895
 
    [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"] autorelease]]; // Miniaturize
896
 
    menuItem = [[[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""] autorelease];
897
 
    [menuItem setSubmenu:menu];
898
 
    [[NSApp mainMenu] addItem:menuItem];
899
 
    [NSApp setWindowsMenu:menu];
900
 
 
901
 
    // Help menu
902
 
    menu = [[NSMenu alloc] initWithTitle:@"Help"];
903
 
    [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"QEMU Documentation" action:@selector(showQEMUDoc:) keyEquivalent:@"?"] autorelease]]; // QEMU Help
904
 
    [menu addItem: [[[NSMenuItem alloc] initWithTitle:@"QEMU Technology" action:@selector(showQEMUTec:) keyEquivalent:@""] autorelease]]; // QEMU Help
905
 
    menuItem = [[[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""] autorelease];
906
 
    [menuItem setSubmenu:menu];
907
 
    [[NSApp mainMenu] addItem:menuItem];
908
 
 
909
 
    // Create an Application controller
910
 
    QemuCocoaAppController *appController = [[QemuCocoaAppController alloc] init];
911
 
    [NSApp setDelegate:appController];
912
 
 
913
 
    // Start the main event loop
 
904
    setApplicationMenu();
 
905
    setupWindowMenu();
 
906
 
 
907
    /* Create SDLMain and make it the app delegate */
 
908
    gui_controller = [[QemuCocoaGUIController alloc] init];
 
909
    [NSApp setDelegate:gui_controller];
 
910
    
 
911
    /* Start the main event loop */
914
912
    [NSApp run];
915
 
 
916
 
    [appController release];
 
913
    
 
914
    [gui_controller release];
917
915
    [pool release];
 
916
}
 
917
 
 
918
/* Real main of qemu-cocoa */
 
919
int main(int argc, char **argv)
 
920
{
 
921
    gArgc = argc;
 
922
    gArgv = argv;
 
923
 
 
924
    CustomApplicationMain();
918
925
 
919
926
    return 0;
920
927
}
921
 
 
922
 
 
923
 
 
924
 
#pragma mark qemu
925
 
static void cocoa_update(DisplayState *ds, int x, int y, int w, int h)
926
 
{
927
 
    COCOA_DEBUG("qemu_cocoa: cocoa_update\n");
928
 
 
929
 
    NSRect rect;
930
 
    if ([cocoaView cdx] == 1.0) {
931
 
        rect = NSMakeRect(x, [cocoaView gscreen].height - y - h, w, h);
932
 
    } else {
933
 
        rect = NSMakeRect(
934
 
            x * [cocoaView cdx],
935
 
            ([cocoaView gscreen].height - y - h) * [cocoaView cdy],
936
 
            w * [cocoaView cdx],
937
 
            h * [cocoaView cdy]);
938
 
    }
939
 
    [cocoaView displayRect:rect];
940
 
}
941
 
 
942
 
static void cocoa_resize(DisplayState *ds, int w, int h)
943
 
{
944
 
    COCOA_DEBUG("qemu_cocoa: cocoa_resize\n");
945
 
 
946
 
    [cocoaView resizeContentToWidth:w height:h displayState:ds];
947
 
}
948
 
 
949
 
static void cocoa_refresh(DisplayState *ds)
950
 
{
951
 
    COCOA_DEBUG("qemu_cocoa: cocoa_refresh\n");
952
 
 
953
 
    if (kbd_mouse_is_absolute()) {
954
 
        if (![cocoaView isAbsoluteEnabled]) {
955
 
            if ([cocoaView isMouseGrabed]) {
956
 
                [cocoaView ungrabMouse];
957
 
            }
958
 
        }
959
 
        [cocoaView setAbsoluteEnabled:YES];
960
 
    }
961
 
 
962
 
    NSDate *distantPast;
963
 
    NSEvent *event;
964
 
    distantPast = [NSDate distantPast];
965
 
    do {
966
 
        event = [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:distantPast
967
 
                        inMode: NSDefaultRunLoopMode dequeue:YES];
968
 
        if (event != nil) {
969
 
            [cocoaView handleEvent:event];
970
 
        }
971
 
    } while(event != nil);
972
 
    vga_hw_update();
973
 
}
974
 
 
975
 
static void cocoa_cleanup(void)
976
 
{
977
 
    COCOA_DEBUG("qemu_cocoa: cocoa_cleanup\n");
978
 
 
979
 
}
980
 
 
981
 
void cocoa_display_init(DisplayState *ds, int full_screen)
982
 
{
983
 
    COCOA_DEBUG("qemu_cocoa: cocoa_display_init\n");
984
 
 
985
 
    // register vga outpu callbacks
986
 
    ds->dpy_update = cocoa_update;
987
 
    ds->dpy_resize = cocoa_resize;
988
 
    ds->dpy_refresh = cocoa_refresh;
989
 
 
990
 
    // give window a initial Size
991
 
    cocoa_resize(ds, 640, 400);
992
 
 
993
 
    // register cleanup function
994
 
    atexit(cocoa_cleanup);
995
 
}