SDL_QuartzVideo.m
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2009 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
20
slouken@libsdl.org
22
#include "SDL_config.h"
23
24
#include "SDL_QuartzVideo.h"
25
#include "SDL_QuartzWindow.h"
27
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060) /* Fixed in Snow Leopard */
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
Add methods to get at private members of NSScreen.
Since there is a bug in Apple's screen switching code
that does not update this variable when switching
to fullscreen, we'll set it manually (but only for the
main screen).
*/
@interface NSScreen (NSScreenAccess)
- (void) setFrame:(NSRect)frame;
@end
@implementation NSScreen (NSScreenAccess)
- (void) setFrame:(NSRect)frame;
{
_frame = frame;
}
@end
45
46
47
48
49
50
51
52
53
static inline void QZ_SetFrame(NSScreen *nsscreen, NSRect frame)
{
[nsscreen setFrame:frame];
}
#else
static inline void QZ_SetFrame(NSScreen *nsscreen, NSRect frame)
{
}
#endif
55
56
57
58
59
60
61
62
63
64
@interface SDLTranslatorResponder : NSTextView
{
}
- (void) doCommandBySelector:(SEL)myselector;
@end
@implementation SDLTranslatorResponder
- (void) doCommandBySelector:(SEL) myselector {}
@end
65
66
/* absent in 10.3.9. */
CG_EXTERN CGImageRef CGBitmapContextCreateImage (CGContextRef);
67
68
69
70
71
72
73
74
75
76
77
/* Bootstrap functions */
static int QZ_Available ();
static SDL_VideoDevice* QZ_CreateDevice (int device_index);
static void QZ_DeleteDevice (SDL_VideoDevice *device);
/* Initialization, Query, Setup, and Redrawing functions */
static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format);
static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format,
Uint32 flags);
78
static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop);
79
80
81
82
83
84
85
86
static SDL_Surface* QZ_SetVideoMode (_THIS, SDL_Surface *current,
int width, int height, int bpp,
Uint32 flags);
static int QZ_ToggleFullScreen (_THIS, int on);
static int QZ_SetColors (_THIS, int first_color,
int num_colors, SDL_Color *colors);
87
88
89
90
91
92
93
94
95
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
static int QZ_LockDoubleBuffer (_THIS, SDL_Surface *surface);
static void QZ_UnlockDoubleBuffer (_THIS, SDL_Surface *surface);
static int QZ_ThreadFlip (_THIS);
static int QZ_FlipDoubleBuffer (_THIS, SDL_Surface *surface);
static void QZ_DoubleBufferUpdate (_THIS, int num_rects, SDL_Rect *rects);
static void QZ_DirectUpdate (_THIS, int num_rects, SDL_Rect *rects);
#endif
96
97
98
99
100
static void QZ_UpdateRects (_THIS, int num_rects, SDL_Rect *rects);
static void QZ_VideoQuit (_THIS);
static int QZ_LockHWSurface(_THIS, SDL_Surface *surface);
static void QZ_UnlockHWSurface(_THIS, SDL_Surface *surface);
101
static int QZ_AllocHWSurface(_THIS, SDL_Surface *surface);
102
static void QZ_FreeHWSurface (_THIS, SDL_Surface *surface);
103
104
105
/* Bootstrap binding, enables entry point into the driver */
VideoBootStrap QZ_bootstrap = {
106
"Quartz", "Mac OS X CoreGraphics", QZ_Available, QZ_CreateDevice
109
110
/* Disable compiler warnings we can't avoid. */
#if (defined(__GNUC__) && (__GNUC__ >= 4))
111
112
# if (MAC_OS_X_VERSION_MAX_ALLOWED <= 1070)
# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
113
114
115
# endif
#endif
116
117
118
119
120
static inline BOOL IS_LION_OR_LATER(_THIS)
{
return (system_version >= 0x1070);
}
121
122
123
124
125
126
127
128
static inline BOOL IS_SNOW_LEOPARD_OR_LATER(_THIS)
{
return (system_version >= 0x1060);
}
static void QZ_ReleaseDisplayMode(_THIS, const void *moderef)
{
/* we only own these references in the 10.6+ API. */
129
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
130
131
132
133
134
135
136
137
138
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
CGDisplayModeRelease((CGDisplayModeRef) moderef);
}
#endif
}
static void QZ_ReleaseDisplayModeList(_THIS, CFArrayRef mode_list)
{
/* we only own these references in the 10.6+ API. */
139
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
140
141
142
143
144
145
146
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
CFRelease(mode_list);
}
#endif
}
147
/* Bootstrap functions */
148
149
static int QZ_Available ()
{
150
151
152
return 1;
}
153
154
static SDL_VideoDevice* QZ_CreateDevice (int device_index)
{
155
#pragma unused (device_index)
156
157
158
159
SDL_VideoDevice *device;
SDL_PrivateVideoData *hidden;
160
161
device = (SDL_VideoDevice*) SDL_malloc (sizeof (*device) );
hidden = (SDL_PrivateVideoData*) SDL_malloc (sizeof (*hidden) );
162
163
164
165
if (device == NULL || hidden == NULL)
SDL_OutOfMemory ();
166
167
SDL_memset (device, 0, sizeof (*device) );
SDL_memset (hidden, 0, sizeof (*hidden) );
169
170
171
172
173
174
device->hidden = hidden;
device->VideoInit = QZ_VideoInit;
device->ListModes = QZ_ListModes;
device->SetVideoMode = QZ_SetVideoMode;
device->ToggleFullScreen = QZ_ToggleFullScreen;
175
device->UpdateMouse = QZ_UpdateMouse;
176
device->SetColors = QZ_SetColors;
177
/* device->UpdateRects = QZ_UpdateRects; this is determined by SetVideoMode() */
178
device->VideoQuit = QZ_VideoQuit;
180
181
device->LockHWSurface = QZ_LockHWSurface;
device->UnlockHWSurface = QZ_UnlockHWSurface;
182
device->AllocHWSurface = QZ_AllocHWSurface;
183
184
185
186
187
188
189
190
191
192
193
194
device->FreeHWSurface = QZ_FreeHWSurface;
device->SetGamma = QZ_SetGamma;
device->GetGamma = QZ_GetGamma;
device->SetGammaRamp = QZ_SetGammaRamp;
device->GetGammaRamp = QZ_GetGammaRamp;
device->GL_GetProcAddress = QZ_GL_GetProcAddress;
device->GL_GetAttribute = QZ_GL_GetAttribute;
device->GL_MakeCurrent = QZ_GL_MakeCurrent;
device->GL_SwapBuffers = QZ_GL_SwapBuffers;
device->GL_LoadLibrary = QZ_GL_LoadLibrary;
196
197
198
199
200
201
202
203
204
205
206
207
208
209
device->FreeWMCursor = QZ_FreeWMCursor;
device->CreateWMCursor = QZ_CreateWMCursor;
device->ShowWMCursor = QZ_ShowWMCursor;
device->WarpWMCursor = QZ_WarpWMCursor;
device->MoveWMCursor = QZ_MoveWMCursor;
device->CheckMouseMode = QZ_CheckMouseMode;
device->InitOSKeymap = QZ_InitOSKeymap;
device->PumpEvents = QZ_PumpEvents;
device->SetCaption = QZ_SetCaption;
device->SetIcon = QZ_SetIcon;
device->IconifyWindow = QZ_IconifyWindow;
/*device->GetWMInfo = QZ_GetWMInfo;*/
device->GrabInput = QZ_GrabInput;
211
212
213
214
215
216
217
218
/*
* This is a big hassle, needing QuickDraw and QuickTime on older
* systems, and god knows what on 10.6, so we immediately fail here,
* which causes SDL to make an RGB surface and manage the YUV overlay
* in software. Sorry. Use SDL 1.3 if you want YUV rendering in a pixel
* shader. :)
*/
/*device->CreateYUVOverlay = QZ_CreateYUVOverlay;*/
219
220
device->free = QZ_DeleteDevice;
222
223
224
return device;
}
225
226
static void QZ_DeleteDevice (SDL_VideoDevice *device)
{
227
_THIS = device;
228
229
QZ_ReleaseDisplayMode(this, save_mode);
QZ_ReleaseDisplayMode(this, mode);
230
231
SDL_free (device->hidden);
SDL_free (device);
234
235
236
237
238
239
240
static void QZ_GetModeInfo(_THIS, const void *_mode, Uint32 *w, Uint32 *h, Uint32 *bpp)
{
*w = *h = *bpp = 0;
if (_mode == NULL) {
return;
}
241
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
242
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
243
244
245
246
247
248
249
250
251
252
253
254
255
CGDisplayModeRef vidmode = (CGDisplayModeRef) _mode;
CFStringRef fmt = CGDisplayModeCopyPixelEncoding(vidmode);
*w = (Uint32) CGDisplayModeGetWidth(vidmode);
*h = (Uint32) CGDisplayModeGetHeight(vidmode);
/* we only care about the 32-bit modes... */
if (CFStringCompare(fmt, CFSTR(IO32BitDirectPixels),
kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
*bpp = 32;
}
CFRelease(fmt);
259
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
260
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
261
262
263
264
265
266
267
268
269
270
271
272
273
CFDictionaryRef vidmode = (CFDictionaryRef) _mode;
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayBitsPerPixel),
kCFNumberSInt32Type, bpp);
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayWidth),
kCFNumberSInt32Type, w);
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayHeight),
kCFNumberSInt32Type, h);
}
275
276
277
278
279
280
281
/* we only care about the 32-bit modes... */
if (*bpp != 32) {
*bpp = 0;
}
}
282
283
static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format)
{
284
NSRect r = NSMakeRect(0.0, 0.0, 0.0, 0.0);
285
const char *env = NULL;
286
287
288
289
if ( Gestalt(gestaltSystemVersion, &system_version) != noErr )
system_version = 0;
290
291
/* Initialize the video settings; this data persists between mode switches */
display_id = kCGDirectMainDisplay;
293
294
295
296
297
298
299
300
301
302
303
304
305
#if 0 /* The mouse event code needs to take this into account... */
env = getenv("SDL_VIDEO_FULLSCREEN_DISPLAY");
if ( env ) {
int monitor = SDL_atoi(env);
CGDirectDisplayID activeDspys [3];
CGDisplayCount dspyCnt;
CGGetActiveDisplayList (3, activeDspys, &dspyCnt);
if ( monitor >= 0 && monitor < dspyCnt ) {
display_id = activeDspys[monitor];
}
}
#endif
306
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
307
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
308
309
310
311
save_mode = CGDisplayCopyDisplayMode(display_id);
}
#endif
312
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
313
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
314
315
316
317
save_mode = CGDisplayCurrentMode(display_id);
}
#endif
318
319
320
321
322
323
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
if (!IS_LION_OR_LATER(this)) {
palette = CGPaletteCreateDefaultColorPalette();
}
#endif
324
325
326
327
if (save_mode == NULL) {
SDL_SetError("Couldn't figure out current display mode.");
return -1;
}
329
/* Allow environment override of screensaver disable. */
330
env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
331
332
333
334
335
336
337
338
339
if ( env ) {
allow_screensaver = SDL_atoi(env);
} else {
#ifdef SDL_VIDEO_DISABLE_SCREENSAVER
allow_screensaver = 0;
#else
allow_screensaver = 1;
#endif
}
341
/* Gather some information that is useful to know about the display */
342
343
QZ_GetModeInfo(this, save_mode, &device_width, &device_height, &device_bpp);
if (device_bpp == 0) {
344
QZ_ReleaseDisplayMode(this, save_mode);
345
346
347
348
save_mode = NULL;
SDL_SetError("Unsupported display mode");
return -1;
}
350
351
352
353
354
/* Determine the current screen size */
this->info.current_w = device_width;
this->info.current_h = device_height;
/* Determine the default screen depth */
355
356
video_format->BitsPerPixel = device_bpp;
357
358
/* Set misc globals */
current_grab_mode = SDL_GRAB_OFF;
359
cursor_should_be_visible = YES;
360
cursor_visible = YES;
361
current_mods = 0;
362
field_edit = [[SDLTranslatorResponder alloc] initWithFrame:r];
364
365
366
/* register for sleep notifications so wake from sleep generates SDL_VIDEOEXPOSE */
QZ_RegisterForSleepNotifications (this);
367
368
369
/* Fill in some window manager capabilities */
this->info.wm_available = 1;
370
return 0;
373
374
static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format, Uint32 flags)
{
375
CFArrayRef mode_list = NULL; /* list of available fullscreen modes */
376
CFIndex num_modes;
377
378
379
CFIndex i;
int list_size = 0;
381
382
383
/* Any windowed mode is acceptable */
if ( (flags & SDL_FULLSCREEN) == 0 )
return (SDL_Rect**)-1;
385
/* Free memory from previous call, if any */
386
if ( client_mode_list != NULL ) {
387
int i;
389
for (i = 0; client_mode_list[i] != NULL; i++)
390
SDL_free (client_mode_list[i]);
392
SDL_free (client_mode_list);
393
client_mode_list = NULL;
396
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
397
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
398
mode_list = CGDisplayCopyAllDisplayModes(display_id, NULL);
402
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
403
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
404
405
mode_list = CGDisplayAvailableModes(display_id);
}
408
409
num_modes = CFArrayGetCount (mode_list);
410
/* Build list of modes with the requested bpp */
411
for (i = 0; i < num_modes; i++) {
412
413
Uint32 width, height, bpp;
const void *onemode = CFArrayGetValueAtIndex(mode_list, i);
415
QZ_GetModeInfo(this, onemode, &width, &height, &bpp);
417
418
419
if (bpp && (bpp == format->BitsPerPixel)) {
int hasMode = SDL_FALSE;
int i;
420
421
/* Check if mode is already in the list */
422
423
424
for (i = 0; i < list_size; i++) {
if (client_mode_list[i]->w == width &&
client_mode_list[i]->h == height) {
425
426
hasMode = SDL_TRUE;
break;
429
430
431
432
433
434
435
/* Grow the list and add mode to the list */
if ( ! hasMode ) {
SDL_Rect *rect;
list_size++;
436
437
if (client_mode_list == NULL)
client_mode_list = (SDL_Rect**)
438
SDL_malloc (sizeof(*client_mode_list) * (list_size+1) );
439
440
441
else {
/* !!! FIXME: this leaks memory if SDL_realloc() fails! */
client_mode_list = (SDL_Rect**)
442
SDL_realloc (client_mode_list, sizeof(*client_mode_list) * (list_size+1));
445
rect = (SDL_Rect*) SDL_malloc (sizeof(**client_mode_list));
447
if (client_mode_list == NULL || rect == NULL) {
448
QZ_ReleaseDisplayModeList(this, mode_list);
449
450
451
452
SDL_OutOfMemory ();
return NULL;
}
453
rect->x = rect->y = 0;
454
455
456
rect->w = width;
rect->h = height;
457
458
client_mode_list[list_size-1] = rect;
client_mode_list[list_size] = NULL;
463
QZ_ReleaseDisplayModeList(this, mode_list);
465
466
467
468
469
/* Sort list largest to smallest (by area) */
{
int i, j;
for (i = 0; i < list_size; i++) {
for (j = 0; j < list_size-1; j++) {
471
int area1, area2;
472
473
area1 = client_mode_list[j]->w * client_mode_list[j]->h;
area2 = client_mode_list[j+1]->w * client_mode_list[j+1]->h;
475
if (area1 < area2) {
476
477
478
SDL_Rect *tmp = client_mode_list[j];
client_mode_list[j] = client_mode_list[j+1];
client_mode_list[j+1] = tmp;
479
480
481
482
}
}
}
}
484
return client_mode_list;
487
488
489
490
491
492
493
494
495
496
497
static SDL_bool QZ_WindowPosition(_THIS, int *x, int *y)
{
const char *window = getenv("SDL_VIDEO_WINDOW_POS");
if ( window ) {
if ( sscanf(window, "%d,%d", x, y) == 2 ) {
return SDL_TRUE;
}
}
return SDL_FALSE;
}
498
499
static CGError QZ_SetDisplayMode(_THIS, const void *vidmode)
{
500
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
501
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
502
return CGDisplaySetDisplayMode(display_id, (CGDisplayModeRef) vidmode, NULL);
506
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
507
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
508
509
return CGDisplaySwitchToMode(display_id, (CFDictionaryRef) vidmode);
}
511
512
513
514
515
516
517
518
519
return kCGErrorFailure;
}
static inline CGError QZ_RestoreDisplayMode(_THIS)
{
return QZ_SetDisplayMode(this, save_mode);
}
520
521
static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop)
{
522
/* Reset values that may change between switches */
523
this->info.blit_fill = 0;
524
525
526
527
this->FillHWRect = NULL;
this->UpdateRects = NULL;
this->LockHWSurface = NULL;
this->UnlockHWSurface = NULL;
529
530
531
532
533
534
if (cg_context) {
CGContextFlush (cg_context);
CGContextRelease (cg_context);
cg_context = nil;
}
535
/* Release fullscreen resources */
536
if ( mode_flags & SDL_FULLSCREEN ) {
538
NSRect screen_rect;
540
541
542
543
544
545
546
547
548
549
550
551
/* Release double buffer stuff */
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
if ( !IS_LION_OR_LATER(this) && (mode_flags & SDL_DOUBLEBUF) ) {
quit_thread = YES;
SDL_SemPost (sem1);
SDL_WaitThread (thread, NULL);
SDL_DestroySemaphore (sem1);
SDL_DestroySemaphore (sem2);
SDL_free (sw_buffers[0]);
}
#endif
554
555
NSCAssert([ qz_window delegate ] == nil, @"full screen window shouldn't have a delegate"); /* if that should ever change, we'd have to release it here */
[ qz_window close ]; /* includes release because [qz_window isReleasedWhenClosed] */
559
560
561
562
563
564
/*
Release the OpenGL context
Do this first to avoid trash on the display before fade
*/
if ( mode_flags & SDL_OPENGL ) {
565
QZ_TearDownOpenGL (this);
566
#ifdef __powerpc__ /* we only use this for pre-10.3 compatibility. */
567
CGLSetFullScreen (NULL);
570
if (to_desktop) {
572
/* Restore original screen resolution/bpp */
573
QZ_RestoreDisplayMode (this);
574
575
576
577
578
579
CGReleaseAllDisplays ();
/*
Reset the main screen's rectangle
See comment in QZ_SetVideoFullscreen for why we do this
*/
screen_rect = NSMakeRect(0,0,device_width,device_height);
580
QZ_SetFrame([ NSScreen mainScreen ], screen_rect);
583
/* Release window mode resources */
584
else {
585
586
587
id delegate = [ qz_window delegate ];
[ qz_window close ]; /* includes release because [qz_window isReleasedWhenClosed] */
if (delegate != nil) [ delegate release ];
588
qz_window = nil;
589
window_view = nil;
591
592
593
/* Release the OpenGL context */
if ( mode_flags & SDL_OPENGL )
QZ_TearDownOpenGL (this);
596
597
/* Signal successful teardown */
video_set = SDL_FALSE;
600
601
602
603
604
605
606
607
static const void *QZ_BestMode(_THIS, const int bpp, const int w, const int h)
{
const void *best = NULL;
if (bpp == 0) {
return NULL;
}
608
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
609
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
/* apparently, we have to roll our own now. :/ */
CFArrayRef mode_list = CGDisplayCopyAllDisplayModes(display_id, NULL);
if (mode_list != NULL) {
const CFIndex num_modes = CFArrayGetCount(mode_list);
CFIndex i;
for (i = 0; i < num_modes; i++) {
const void *vidmode = CFArrayGetValueAtIndex(mode_list, i);
Uint32 thisw, thish, thisbpp;
QZ_GetModeInfo(this, vidmode, &thisw, &thish, &thisbpp);
/* We only care about exact matches, apparently. */
if ((thisbpp == bpp) && (thisw == w) && (thish == h)) {
best = vidmode;
break; /* got it! */
}
}
CGDisplayModeRetain((CGDisplayModeRef) best); /* NULL is ok */
CFRelease(mode_list);
}
632
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
633
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
634
635
636
637
638
639
boolean_t exact = 0;
best = CGDisplayBestModeForParameters(display_id, bpp, w, h, &exact);
if (!exact) {
best = NULL;
}
}
640
641
#endif
642
643
644
return best;
}
645
static SDL_Surface* QZ_SetVideoFullScreen (_THIS, SDL_Surface *current, int width,
646
647
int height, int bpp, Uint32 flags)
{
648
const BOOL isLion = IS_LION_OR_LATER(this);
649
NSRect screen_rect;
650
CGError error;
652
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
654
655
656
657
current->flags = SDL_FULLSCREEN;
current->w = width;
current->h = height;
658
659
contentRect = NSMakeRect (0, 0, width, height);
660
661
662
663
664
/* Fade to black to hide resolution-switching flicker (and garbage
that is displayed by a destroyed OpenGL context, if applicable) */
if ( CGAcquireDisplayFadeReservation (5, &fade_token) == kCGErrorSuccess ) {
CGDisplayFade (fade_token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
}
666
667
/* Destroy any previous mode */
if (video_set == SDL_TRUE)
668
QZ_UnsetVideoMode (this, FALSE);
670
671
672
673
674
675
/* Sorry, QuickDraw was ripped out. */
if (getenv("SDL_NSWindowPointer") || getenv("SDL_NSQuickDrawViewPointer")) {
SDL_SetError ("Embedded QuickDraw windows are no longer supported");
goto ERR_NO_MATCH;
}
676
QZ_ReleaseDisplayMode(this, mode); /* NULL is okay. */
678
/* See if requested mode exists */
679
mode = QZ_BestMode(this, bpp, width, height);
681
/* Require an exact match to the requested mode */
682
if ( mode == NULL ) {
683
SDL_SetError ("Failed to find display resolution: %dx%dx%d", width, height, bpp);
684
685
goto ERR_NO_MATCH;
}
687
/* Put up the blanking window (a window above all other windows) */
688
689
690
691
692
693
if (getenv ("SDL_SINGLEDISPLAY"))
error = CGDisplayCapture (display_id);
else
error = CGCaptureAllDisplays ();
if ( CGDisplayNoErr != error ) {
694
695
696
SDL_SetError ("Failed capturing display");
goto ERR_NO_CAPTURE;
}
698
/* Do the physical switch */
699
if ( CGDisplayNoErr != QZ_SetDisplayMode(this, mode) ) {
700
701
702
SDL_SetError ("Failed switching display resolution");
goto ERR_NO_SWITCH;
}
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
if ( !isLion ) {
current->pixels = (Uint32*) CGDisplayBaseAddress (display_id);
current->pitch = CGDisplayBytesPerRow (display_id);
current->flags |= SDL_HWSURFACE;
current->flags |= SDL_PREALLOC;
/* current->hwdata = (void *) CGDisplayGetDrawingContext (display_id); */
this->UpdateRects = QZ_DirectUpdate;
this->LockHWSurface = QZ_LockHWSurface;
this->UnlockHWSurface = QZ_UnlockHWSurface;
/* Setup double-buffer emulation */
if ( flags & SDL_DOUBLEBUF ) {
/*
Setup a software backing store for reasonable results when
double buffering is requested (since a single-buffered hardware
surface looks hideous).
The actual screen blit occurs in a separate thread to allow
other blitting while waiting on the VBL (and hence results in higher framerates).
*/
this->LockHWSurface = NULL;
this->UnlockHWSurface = NULL;
this->UpdateRects = NULL;
current->flags |= (SDL_HWSURFACE|SDL_DOUBLEBUF);
this->UpdateRects = QZ_DoubleBufferUpdate;
this->LockHWSurface = QZ_LockDoubleBuffer;
this->UnlockHWSurface = QZ_UnlockDoubleBuffer;
this->FlipHWSurface = QZ_FlipDoubleBuffer;
current->pixels = SDL_malloc (current->pitch * current->h * 2);
if (current->pixels == NULL) {
SDL_OutOfMemory ();
goto ERR_DOUBLEBUF;
}
sw_buffers[0] = current->pixels;
sw_buffers[1] = (Uint8*)current->pixels + current->pitch * current->h;
quit_thread = NO;
sem1 = SDL_CreateSemaphore (0);
sem2 = SDL_CreateSemaphore (1);
thread = SDL_CreateThread ((int (*)(void *))QZ_ThreadFlip, this);
}
if ( CGDisplayCanSetPalette (display_id) )
current->flags |= SDL_HWPALETTE;
}
#endif
758
759
760
761
762
/* Check if we should recreate the window */
if (qz_window == nil) {
/* Manually create a window, avoids having a nib file resource */
qz_window = [ [ SDL_QuartzWindow alloc ]
initWithContentRect:contentRect
763
styleMask:(isLion ? NSBorderlessWindowMask : 0)
764
765
766
767
768
769
backing:NSBackingStoreBuffered
defer:NO ];
if (qz_window != nil) {
[ qz_window setAcceptsMouseMovedEvents:YES ];
[ qz_window setViewsNeedDisplay:NO ];
770
771
772
if (isLion) {
[ qz_window setContentView: [ [ [ SDL_QuartzView alloc ] init ] autorelease ] ];
}
777
778
779
[ qz_window setContentSize:contentRect.size ];
current->flags |= (SDL_NOFRAME|SDL_RESIZABLE) & mode_flags;
[ window_view setFrameSize:contentRect.size ];
782
783
784
785
786
/* Setup OpenGL for a fullscreen context */
if (flags & SDL_OPENGL) {
CGLError err;
CGLContextObj ctx;
788
if ( ! QZ_SetupOpenGL (this, bpp, flags) ) {
789
goto ERR_NO_GL;
792
793
794
795
/* Initialize the NSView and add it to our window. The presence of a valid window and
view allow the cursor to be changed whilst in fullscreen.*/
window_view = [ [ NSView alloc ] initWithFrame:contentRect ];
796
797
798
799
800
if ( isLion ) {
[ window_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
}
[ [ qz_window contentView ] addSubview:window_view ];
802
803
804
805
806
if ( isLion ) {
[ qz_window setLevel:CGShieldingWindowLevel() ];
[ gl_context setView: window_view ];
[ gl_context setFullScreen ];
[ gl_context update ];
809
810
811
812
813
814
815
816
817
818
819
820
821
822
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
if ( !isLion) {
[ qz_window setLevel:NSNormalWindowLevel ];
ctx = QZ_GetCGLContextObj (gl_context);
err = CGLSetFullScreen (ctx);
if (err) {
SDL_SetError ("Error setting OpenGL fullscreen: %s", CGLErrorString(err));
goto ERR_NO_GL;
}
}
#endif
[ window_view release ];
823
[ gl_context makeCurrentContext];
824
825
826
827
glClear (GL_COLOR_BUFFER_BIT);
[ gl_context flushBuffer ];
829
current->flags |= SDL_OPENGL;
830
} else if (isLion) { /* For 2D, we build a CGBitmapContext */
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
CGColorSpaceRef cgColorspace;
/* Only recreate the view if it doesn't already exist */
if (window_view == nil) {
window_view = [ [ NSView alloc ] initWithFrame:contentRect ];
[ window_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
[ [ qz_window contentView ] addSubview:window_view ];
[ window_view release ];
}
cgColorspace = CGColorSpaceCreateDeviceRGB();
current->pitch = 4 * current->w;
current->pixels = SDL_malloc (current->h * current->pitch);
cg_context = CGBitmapContextCreate (current->pixels, current->w, current->h,
8, current->pitch, cgColorspace,
kCGImageAlphaNoneSkipFirst);
CGColorSpaceRelease (cgColorspace);
current->flags |= SDL_SWSURFACE;
current->flags |= SDL_ASYNCBLIT;
current->hwdata = (void *) cg_context;
/* Force this window to draw above _everything_. */
[ qz_window setLevel:CGShieldingWindowLevel() ];
856
857
858
859
this->UpdateRects = QZ_UpdateRects;
this->LockHWSurface = QZ_LockHWSurface;
this->UnlockHWSurface = QZ_UnlockHWSurface;
862
863
864
865
866
if (isLion) {
[ qz_window setHasShadow:NO];
[ qz_window setOpaque:YES];
[ qz_window makeKeyAndOrderFront:nil ];
}
867
868
869
/* If we don't hide menu bar, it will get events and interrupt the program */
HideMenuBar ();
871
872
873
874
875
/* Fade in again (asynchronously) */
if ( fade_token != kCGDisplayFadeReservationInvalidToken ) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation(fade_token);
}
878
879
880
881
882
There is a bug in Cocoa where NSScreen doesn't synchronize
with CGDirectDisplay, so the main screen's frame is wrong.
As a result, coordinate translation produces incorrect results.
We can hack around this bug by setting the screen rect
ourselves. This hack should be removed if/when the bug is fixed.
883
884
*/
screen_rect = NSMakeRect(0,0,width,height);
885
QZ_SetFrame([ NSScreen mainScreen ], screen_rect);
887
888
/* Save the flags to ensure correct tear-down */
mode_flags = current->flags;
893
894
return current;
895
/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */
896
897
ERR_NO_GL:
ERR_DOUBLEBUF: QZ_RestoreDisplayMode(this);
898
ERR_NO_SWITCH: CGReleaseAllDisplays ();
899
900
901
902
903
904
ERR_NO_CAPTURE:
ERR_NO_MATCH: if ( fade_token != kCGDisplayFadeReservationInvalidToken ) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
}
return NULL;
905
906
907
}
static SDL_Surface* QZ_SetVideoWindowed (_THIS, SDL_Surface *current, int width,
908
909
int height, int *bpp, Uint32 flags)
{
910
unsigned int style;
911
NSRect contentRect;
912
913
int center_window = 1;
int origin_x, origin_y;
914
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
916
917
current->flags = 0;
current->w = width;
918
current->h = height;
919
920
contentRect = NSMakeRect (0, 0, width, height);
922
923
924
925
926
927
928
/*
Check if we should completely destroy the previous mode
- If it is fullscreen
- If it has different noframe or resizable attribute
- If it is OpenGL (since gl attributes could be different)
- If new mode is OpenGL, but previous mode wasn't
*/
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
if (video_set == SDL_TRUE) {
if (mode_flags & SDL_FULLSCREEN) {
/* Fade to black to hide resolution-switching flicker (and garbage
that is displayed by a destroyed OpenGL context, if applicable) */
if (CGAcquireDisplayFadeReservation (5, &fade_token) == kCGErrorSuccess) {
CGDisplayFade (fade_token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
}
QZ_UnsetVideoMode (this, TRUE);
}
else if ( ((mode_flags ^ flags) & (SDL_NOFRAME|SDL_RESIZABLE)) ||
(mode_flags & SDL_OPENGL) ||
(flags & SDL_OPENGL) ) {
QZ_UnsetVideoMode (this, TRUE);
}
}
945
946
947
948
949
950
/* Sorry, QuickDraw was ripped out. */
if (getenv("SDL_NSWindowPointer") || getenv("SDL_NSQuickDrawViewPointer")) {
SDL_SetError ("Embedded QuickDraw windows are no longer supported");
if (fade_token != kCGDisplayFadeReservationInvalidToken) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
952
return NULL;
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
/* Check if we should recreate the window */
if (qz_window == nil) {
/* Set the window style based on input flags */
if ( flags & SDL_NOFRAME ) {
style = NSBorderlessWindowMask;
current->flags |= SDL_NOFRAME;
} else {
style = NSTitledWindowMask;
style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);
if ( flags & SDL_RESIZABLE ) {
style |= NSResizableWindowMask;
current->flags |= SDL_RESIZABLE;
}
}
971
972
973
974
975
976
977
978
979
/* Manually create a window, avoids having a nib file resource */
qz_window = [ [ SDL_QuartzWindow alloc ]
initWithContentRect:contentRect
styleMask:style
backing:NSBackingStoreBuffered
defer:NO ];
if (qz_window == nil) {
SDL_SetError ("Could not create the Cocoa window");
980
981
982
983
if (fade_token != kCGDisplayFadeReservationInvalidToken) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
}
984
985
return NULL;
}
987
/*[ qz_window setReleasedWhenClosed:YES ];*/ /* no need to set this as it's the default for NSWindows */
988
989
990
QZ_SetCaption(this, this->wm_title, this->wm_icon);
[ qz_window setAcceptsMouseMovedEvents:YES ];
[ qz_window setViewsNeedDisplay:NO ];
991
992
993
994
995
if ( QZ_WindowPosition(this, &origin_x, &origin_y) ) {
/* have to flip the Y value (NSPoint is lower left corner origin) */
[ qz_window setFrameTopLeftPoint:NSMakePoint((float) origin_x, (float) (this->info.current_h - origin_y))];
center_window = 0;
996
} else if ( center_window ) {
997
998
[ qz_window center ];
}
1000
[ qz_window setDelegate: