SDL_QuartzVideo.m
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2012 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
28
29
30
31
32
33
34
35
36
37
38
/* These APIs aren't just deprecated; they're gone from the headers in the
10.7 SDK. If we're using a >= 10.7 SDK, but targeting < 10.7, then we
force these function declarations. */
#if ((MAC_OS_X_VERSION_MIN_REQUIRED < 1070) && (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070))
CG_EXTERN void *CGDisplayBaseAddress(CGDirectDisplayID display)
CG_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_6,
__IPHONE_NA, __IPHONE_NA);
CG_EXTERN size_t CGDisplayBytesPerRow(CGDirectDisplayID display)
CG_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_6,
__IPHONE_NA, __IPHONE_NA);
#endif
39
40
41
42
43
44
45
46
47
48
49
50
static inline BOOL IS_LION_OR_LATER(_THIS)
{
return (system_version >= 0x1070);
}
static inline BOOL IS_SNOW_LEOPARD_OR_LATER(_THIS)
{
return (system_version >= 0x1060);
}
#if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) && !defined(__LP64__) /* Fixed in Snow Leopard */
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
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
68
static inline void QZ_SetFrame(_THIS, NSScreen *nsscreen, NSRect frame)
70
71
72
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
[nsscreen setFrame:frame];
}
75
static inline void QZ_SetFrame(_THIS, NSScreen *nsscreen, NSRect frame)
76
77
78
{
}
#endif
80
81
82
83
84
85
86
87
88
89
@interface SDLTranslatorResponder : NSTextView
{
}
- (void) doCommandBySelector:(SEL)myselector;
@end
@implementation SDLTranslatorResponder
- (void) doCommandBySelector:(SEL) myselector {}
@end
90
91
/* absent in 10.3.9. */
CG_EXTERN CGImageRef CGBitmapContextCreateImage (CGContextRef);
92
93
94
95
96
97
98
99
100
101
102
/* 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);
103
static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop, BOOL save_gl);
104
105
106
107
108
109
110
111
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);
112
113
114
115
116
117
118
119
120
#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
121
122
123
124
125
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);
126
static int QZ_AllocHWSurface(_THIS, SDL_Surface *surface);
127
static void QZ_FreeHWSurface (_THIS, SDL_Surface *surface);
128
129
130
/* Bootstrap binding, enables entry point into the driver */
VideoBootStrap QZ_bootstrap = {
131
"Quartz", "Mac OS X CoreGraphics", QZ_Available, QZ_CreateDevice
134
135
/* Disable compiler warnings we can't avoid. */
#if (defined(__GNUC__) && (__GNUC__ >= 4))
136
137
# if (MAC_OS_X_VERSION_MAX_ALLOWED <= 1070)
# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
138
139
140
# endif
#endif
141
142
143
static void QZ_ReleaseDisplayMode(_THIS, const void *moderef)
{
/* we only own these references in the 10.6+ API. */
144
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
145
if (use_new_mode_apis) {
146
147
148
149
150
151
152
153
CGDisplayModeRelease((CGDisplayModeRef) moderef);
}
#endif
}
static void QZ_ReleaseDisplayModeList(_THIS, CFArrayRef mode_list)
{
/* we only own these references in the 10.6+ API. */
154
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
155
if (use_new_mode_apis) {
156
157
158
159
160
161
CFRelease(mode_list);
}
#endif
}
162
/* Bootstrap functions */
163
164
static int QZ_Available ()
{
165
166
167
return 1;
}
168
169
static SDL_VideoDevice* QZ_CreateDevice (int device_index)
{
170
#pragma unused (device_index)
171
172
173
174
SDL_VideoDevice *device;
SDL_PrivateVideoData *hidden;
175
176
device = (SDL_VideoDevice*) SDL_malloc (sizeof (*device) );
hidden = (SDL_PrivateVideoData*) SDL_malloc (sizeof (*hidden) );
177
178
179
180
if (device == NULL || hidden == NULL)
SDL_OutOfMemory ();
181
182
SDL_memset (device, 0, sizeof (*device) );
SDL_memset (hidden, 0, sizeof (*hidden) );
184
185
186
187
188
189
device->hidden = hidden;
device->VideoInit = QZ_VideoInit;
device->ListModes = QZ_ListModes;
device->SetVideoMode = QZ_SetVideoMode;
device->ToggleFullScreen = QZ_ToggleFullScreen;
190
device->UpdateMouse = QZ_UpdateMouse;
191
device->SetColors = QZ_SetColors;
192
/* device->UpdateRects = QZ_UpdateRects; this is determined by SetVideoMode() */
193
device->VideoQuit = QZ_VideoQuit;
195
196
device->LockHWSurface = QZ_LockHWSurface;
device->UnlockHWSurface = QZ_UnlockHWSurface;
197
device->AllocHWSurface = QZ_AllocHWSurface;
198
199
200
201
202
203
204
205
206
207
208
209
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;
211
212
213
214
215
216
217
218
219
220
221
222
223
224
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;
226
227
228
229
230
231
232
233
/*
* 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;*/
234
235
device->free = QZ_DeleteDevice;
237
238
239
return device;
}
240
241
static void QZ_DeleteDevice (SDL_VideoDevice *device)
{
242
_THIS = device;
243
244
QZ_ReleaseDisplayMode(this, save_mode);
QZ_ReleaseDisplayMode(this, mode);
245
246
SDL_free (device->hidden);
SDL_free (device);
249
250
251
252
253
254
255
static void QZ_GetModeInfo(_THIS, const void *_mode, Uint32 *w, Uint32 *h, Uint32 *bpp)
{
*w = *h = *bpp = 0;
if (_mode == NULL) {
return;
}
256
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
257
if (use_new_mode_apis) {
258
259
260
261
262
263
264
265
266
267
268
269
270
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);
274
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
275
if (!use_new_mode_apis) {
276
277
278
279
280
281
282
283
284
285
286
287
288
CFDictionaryRef vidmode = (CFDictionaryRef) _mode;
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayBitsPerPixel),
kCFNumberSInt32Type, bpp);
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayWidth),
kCFNumberSInt32Type, w);
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayHeight),
kCFNumberSInt32Type, h);
}
290
291
292
293
294
295
296
/* we only care about the 32-bit modes... */
if (*bpp != 32) {
*bpp = 0;
}
}
297
298
static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format)
{
299
NSRect r = NSMakeRect(0.0, 0.0, 0.0, 0.0);
300
const char *env = NULL;
301
302
303
304
if ( Gestalt(gestaltSystemVersion, &system_version) != noErr )
system_version = 0;
305
306
307
308
309
310
use_new_mode_apis = NO;
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
use_new_mode_apis = IS_SNOW_LEOPARD_OR_LATER(this);
#endif
311
312
/* Initialize the video settings; this data persists between mode switches */
display_id = kCGDirectMainDisplay;
314
315
316
317
318
319
320
321
322
323
324
325
326
#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
327
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
328
if (use_new_mode_apis) {
329
330
331
332
save_mode = CGDisplayCopyDisplayMode(display_id);
}
#endif
333
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
334
if (!use_new_mode_apis) {
335
336
337
338
save_mode = CGDisplayCurrentMode(display_id);
}
#endif
339
340
341
342
343
344
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
if (!IS_LION_OR_LATER(this)) {
palette = CGPaletteCreateDefaultColorPalette();
}
#endif
345
346
347
348
if (save_mode == NULL) {
SDL_SetError("Couldn't figure out current display mode.");
return -1;
}
350
/* Allow environment override of screensaver disable. */
351
env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
352
353
354
355
356
357
358
359
360
if ( env ) {
allow_screensaver = SDL_atoi(env);
} else {
#ifdef SDL_VIDEO_DISABLE_SCREENSAVER
allow_screensaver = 0;
#else
allow_screensaver = 1;
#endif
}
362
/* Gather some information that is useful to know about the display */
363
364
QZ_GetModeInfo(this, save_mode, &device_width, &device_height, &device_bpp);
if (device_bpp == 0) {
365
QZ_ReleaseDisplayMode(this, save_mode);
366
367
368
369
save_mode = NULL;
SDL_SetError("Unsupported display mode");
return -1;
}
371
372
373
374
375
/* Determine the current screen size */
this->info.current_w = device_width;
this->info.current_h = device_height;
/* Determine the default screen depth */
376
377
video_format->BitsPerPixel = device_bpp;
378
379
/* Set misc globals */
current_grab_mode = SDL_GRAB_OFF;
380
cursor_should_be_visible = YES;
381
cursor_visible = YES;
382
current_mods = 0;
383
field_edit = [[SDLTranslatorResponder alloc] initWithFrame:r];
385
386
387
/* register for sleep notifications so wake from sleep generates SDL_VIDEOEXPOSE */
QZ_RegisterForSleepNotifications (this);
388
389
390
/* Fill in some window manager capabilities */
this->info.wm_available = 1;
391
return 0;
394
395
static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format, Uint32 flags)
{
396
CFArrayRef mode_list = NULL; /* list of available fullscreen modes */
397
CFIndex num_modes;
398
399
400
CFIndex i;
int list_size = 0;
402
403
404
/* Any windowed mode is acceptable */
if ( (flags & SDL_FULLSCREEN) == 0 )
return (SDL_Rect**)-1;
406
/* Free memory from previous call, if any */
407
if ( client_mode_list != NULL ) {
408
int i;
410
for (i = 0; client_mode_list[i] != NULL; i++)
411
SDL_free (client_mode_list[i]);
413
SDL_free (client_mode_list);
414
client_mode_list = NULL;
417
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
418
if (use_new_mode_apis) {
419
mode_list = CGDisplayCopyAllDisplayModes(display_id, NULL);
423
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
424
if (!use_new_mode_apis) {
425
426
mode_list = CGDisplayAvailableModes(display_id);
}
429
430
num_modes = CFArrayGetCount (mode_list);
431
/* Build list of modes with the requested bpp */
432
for (i = 0; i < num_modes; i++) {
433
434
Uint32 width, height, bpp;
const void *onemode = CFArrayGetValueAtIndex(mode_list, i);
436
QZ_GetModeInfo(this, onemode, &width, &height, &bpp);
438
439
440
if (bpp && (bpp == format->BitsPerPixel)) {
int hasMode = SDL_FALSE;
int i;
441
442
/* Check if mode is already in the list */
443
444
445
for (i = 0; i < list_size; i++) {
if (client_mode_list[i]->w == width &&
client_mode_list[i]->h == height) {
446
447
hasMode = SDL_TRUE;
break;
450
451
452
453
454
455
456
/* Grow the list and add mode to the list */
if ( ! hasMode ) {
SDL_Rect *rect;
list_size++;
457
458
if (client_mode_list == NULL)
client_mode_list = (SDL_Rect**)
459
SDL_malloc (sizeof(*client_mode_list) * (list_size+1) );
460
461
462
else {
/* !!! FIXME: this leaks memory if SDL_realloc() fails! */
client_mode_list = (SDL_Rect**)
463
SDL_realloc (client_mode_list, sizeof(*client_mode_list) * (list_size+1));
466
rect = (SDL_Rect*) SDL_malloc (sizeof(**client_mode_list));
468
if (client_mode_list == NULL || rect == NULL) {
469
QZ_ReleaseDisplayModeList(this, mode_list);
470
471
472
473
SDL_OutOfMemory ();
return NULL;
}
474
rect->x = rect->y = 0;
475
476
477
rect->w = width;
rect->h = height;
478
479
client_mode_list[list_size-1] = rect;
client_mode_list[list_size] = NULL;
484
QZ_ReleaseDisplayModeList(this, mode_list);
486
487
488
489
490
/* 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++) {
492
int area1, area2;
493
494
area1 = client_mode_list[j]->w * client_mode_list[j]->h;
area2 = client_mode_list[j+1]->w * client_mode_list[j+1]->h;
496
if (area1 < area2) {
497
498
499
SDL_Rect *tmp = client_mode_list[j];
client_mode_list[j] = client_mode_list[j+1];
client_mode_list[j+1] = tmp;
500
501
502
503
}
}
}
}
505
return client_mode_list;
508
509
510
511
512
513
514
515
516
517
518
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;
}
519
520
static CGError QZ_SetDisplayMode(_THIS, const void *vidmode)
{
521
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
522
if (use_new_mode_apis) {
523
return CGDisplaySetDisplayMode(display_id, (CGDisplayModeRef) vidmode, NULL);
527
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
528
if (!use_new_mode_apis) {
529
530
return CGDisplaySwitchToMode(display_id, (CFDictionaryRef) vidmode);
}
532
533
534
535
536
537
538
539
540
return kCGErrorFailure;
}
static inline CGError QZ_RestoreDisplayMode(_THIS)
{
return QZ_SetDisplayMode(this, save_mode);
}
541
static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop, BOOL save_gl)
543
/* Reset values that may change between switches */
544
this->info.blit_fill = 0;
545
546
547
548
this->FillHWRect = NULL;
this->UpdateRects = NULL;
this->LockHWSurface = NULL;
this->UnlockHWSurface = NULL;
550
551
552
553
554
555
if (cg_context) {
CGContextFlush (cg_context);
CGContextRelease (cg_context);
cg_context = nil;
}
556
/* Release fullscreen resources */
557
if ( mode_flags & SDL_FULLSCREEN ) {
559
NSRect screen_rect;
561
562
563
564
565
566
567
568
569
570
571
572
/* 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
575
576
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] */
580
581
582
583
584
/*
Release the OpenGL context
Do this first to avoid trash on the display before fade
*/
if ( mode_flags & SDL_OPENGL ) {
585
586
587
588
if (!save_gl) {
QZ_TearDownOpenGL (this);
}
589
#ifdef __powerpc__ /* we only use this for pre-10.3 compatibility. */
590
CGLSetFullScreen (NULL);
593
if (to_desktop) {
594
595
596
597
598
599
600
601
602
603
604
/* !!! FIXME: keep an eye on this.
* This API is officially unavailable for 64-bit binaries.
* It happens to work, as of 10.7, but we're going to see if
* we can just simply do without it on newer OSes...
*/
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070) && !defined(__LP64__)
if ( !IS_LION_OR_LATER(this) ) {
ShowMenuBar ();
}
#endif
605
/* Restore original screen resolution/bpp */
606
QZ_RestoreDisplayMode (this);
607
608
609
610
611
612
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);
613
QZ_SetFrame(this, [ NSScreen mainScreen ], screen_rect);
616
/* Release window mode resources */
617
else {
618
619
620
id delegate = [ qz_window delegate ];
[ qz_window close ]; /* includes release because [qz_window isReleasedWhenClosed] */
if (delegate != nil) [ delegate release ];
621
qz_window = nil;
622
window_view = nil;
624
/* Release the OpenGL context */
625
626
627
628
629
if ( mode_flags & SDL_OPENGL ) {
if (!save_gl) {
QZ_TearDownOpenGL (this);
}
}
632
633
/* Signal successful teardown */
video_set = SDL_FALSE;
636
637
638
639
640
641
642
643
static const void *QZ_BestMode(_THIS, const int bpp, const int w, const int h)
{
const void *best = NULL;
if (bpp == 0) {
return NULL;
}
644
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
645
if (use_new_mode_apis) {
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
/* 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);
}
668
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
669
if (!use_new_mode_apis) {
670
671
672
673
674
675
boolean_t exact = 0;
best = CGDisplayBestModeForParameters(display_id, bpp, w, h, &exact);
if (!exact) {
best = NULL;
}
}
676
677
#endif
678
679
680
return best;
}
681
static SDL_Surface* QZ_SetVideoFullScreen (_THIS, SDL_Surface *current, int width,
682
683
int height, int bpp, Uint32 flags,
const BOOL save_gl)
685
const BOOL isLion = IS_LION_OR_LATER(this);
686
NSRect screen_rect;
687
CGError error;
689
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
691
692
693
694
current->flags = SDL_FULLSCREEN;
current->w = width;
current->h = height;
695
696
contentRect = NSMakeRect (0, 0, width, height);
697
698
699
700
701
/* 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);
}
703
704
/* Destroy any previous mode */
if (video_set == SDL_TRUE)
705
QZ_UnsetVideoMode (this, FALSE, save_gl);
707
708
709
710
711
712
/* 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;
}
713
QZ_ReleaseDisplayMode(this, mode); /* NULL is okay. */
715
/* See if requested mode exists */
716
mode = QZ_BestMode(this, bpp, width, height);
718
/* Require an exact match to the requested mode */
719
if ( mode == NULL ) {
720
SDL_SetError ("Failed to find display resolution: %dx%dx%d", width, height, bpp);
721
722
goto ERR_NO_MATCH;
}
724
/* Put up the blanking window (a window above all other windows) */
725
726
727
728
729
730
if (getenv ("SDL_SINGLEDISPLAY"))
error = CGDisplayCapture (display_id);
else
error = CGCaptureAllDisplays ();
if ( CGDisplayNoErr != error ) {
731
732
733
SDL_SetError ("Failed capturing display");
goto ERR_NO_CAPTURE;
}
735
/* Do the physical switch */
736
if ( CGDisplayNoErr != QZ_SetDisplayMode(this, mode) ) {
737
738
739
SDL_SetError ("Failed switching display resolution");
goto ERR_NO_SWITCH;
}
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
#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
795
796
797
798
799
/* 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
800
styleMask:(isLion ? NSBorderlessWindowMask : 0)
801
802
803
804
805
806
backing:NSBackingStoreBuffered
defer:NO ];
if (qz_window != nil) {
[ qz_window setAcceptsMouseMovedEvents:YES ];
[ qz_window setViewsNeedDisplay:NO ];
807
808
809
if (isLion) {
[ qz_window setContentView: [ [ [ SDL_QuartzView alloc ] init ] autorelease ] ];
}
814
815
816
[ qz_window setContentSize:contentRect.size ];
current->flags |= (SDL_NOFRAME|SDL_RESIZABLE) & mode_flags;
[ window_view setFrameSize:contentRect.size ];
819
820
821
/* Setup OpenGL for a fullscreen context */
if (flags & SDL_OPENGL) {
822
823
824
825
if ( ! save_gl ) {
if ( ! QZ_SetupOpenGL (this, bpp, flags) ) {
goto ERR_NO_GL;
}
828
829
830
831
/* 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 ];
832
833
834
835
836
if ( isLion ) {
[ window_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
}
[ [ qz_window contentView ] addSubview:window_view ];
838
839
/* Apparently Lion checks some version flag set by the linker
and changes API behavior. Annoying. */
840
if ( isLion ) {
841
842
[ qz_window setLevel:CGShieldingWindowLevel() ];
[ gl_context setView: window_view ];
843
//[ gl_context setFullScreen ];
844
845
846
847
848
[ gl_context update ];
}
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
if ( !isLion ) {
849
850
851
852
853
854
CGLError err;
CGLContextObj ctx;
[ qz_window setLevel:NSNormalWindowLevel ];
ctx = QZ_GetCGLContextObj (gl_context);
err = CGLSetFullScreen (ctx);
856
857
858
859
if (err) {
SDL_SetError ("Error setting OpenGL fullscreen: %s", CGLErrorString(err));
goto ERR_NO_GL;
}
860
861
}
#endif
862
863
[ window_view release ];
864
[ gl_context makeCurrentContext];
865
866
867
868
glClear (GL_COLOR_BUFFER_BIT);
[ gl_context flushBuffer ];
870
current->flags |= SDL_OPENGL;
871
} else if (isLion) { /* For 2D, we build a CGBitmapContext */
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
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() ];
897
898
899
900
this->UpdateRects = QZ_UpdateRects;
this->LockHWSurface = QZ_LockHWSurface;
this->UnlockHWSurface = QZ_UnlockHWSurface;
903
904
905
if (isLion) {
[ qz_window setHasShadow:NO];
[ qz_window setOpaque:YES];
906
[ qz_window makeKeyAndOrderFront:nil ];
909
910
911
912
913
914
/* !!! FIXME: keep an eye on this.
* This API is officially unavailable for 64-bit binaries.
* It happens to work, as of 10.7, but we're going to see if
* we can just simply do without it on newer OSes...
*/
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070) && !defined(__LP64__)
915
if ( !isLion ) {
916
917
918
919
/* If we don't hide menu bar, it will get events and interrupt the program */
HideMenuBar ();
}
#endif
921
922
923
924
925
/* 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);
}
928
929
930
931
932
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.
933
934
*/
screen_rect = NSMakeRect(0,0,width,height);
935
QZ_SetFrame(this, [ NSScreen mainScreen ], screen_rect);
937
938
/* Save the flags to ensure correct tear-down */
mode_flags = current->flags;
943
944
return current;
945
/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */
946
ERR_NO_GL: goto ERR_DOUBLEBUF; /* this goto is to stop a compiler warning on newer SDKs. */
947
ERR_DOUBLEBUF: QZ_RestoreDisplayMode(this);
948
ERR_NO_SWITCH: CGReleaseAllDisplays ();
949
950
951
952
953
954
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;
955
956
957
}
static SDL_Surface* QZ_SetVideoWindowed (_THIS, SDL_Surface *current, int width,
958
959
int height, int *bpp, Uint32 flags,
const BOOL save_gl)
961
unsigned int style;
962
NSRect contentRect;
963
964
int center_window = 1;
int origin_x, origin_y;
965
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
967
968
current->flags = 0;
current->w = width;
969
current->h = height;
970
971
contentRect = NSMakeRect (0, 0, width, height);
973
974
975
976
977
978
979
/*
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
*/
980
981
982
983
984
985
986
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);
}
987
QZ_UnsetVideoMode (this, TRUE, save_gl);
988
989
990
991
}
else if ( ((mode_flags ^ flags) & (SDL_NOFRAME|SDL_RESIZABLE)) ||
(mode_flags & SDL_OPENGL) ||
(flags & SDL_OPENGL) ) {
992
QZ_UnsetVideoMode (this, TRUE, save_gl);
996
997
998
999
1000
/* 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);