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
110
/* !!! FIXME: clean out pre-10.6 code when (if!) it makes sense to do so. */
111
112
113
114
#define FORCE_OLD_API 0 || (MAC_OS_X_VERSION_MAX_ALLOWED < 1060)
#if FORCE_OLD_API
#undef MAC_OS_X_VERSION_MIN_REQUIRED
115
#define MAC_OS_X_VERSION_MIN_REQUIRED 1050
116
117
#endif
118
119
120
121
122
123
124
125
126
127
/* Disable compiler warnings we can't avoid. */
#if (defined(__GNUC__) && (__GNUC__ >= 4))
# if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
/* use ==, not >=, so we see future warnings. */
# if (MAC_OS_X_VERSION_MAX_ALLOWED == 1070)
# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# endif
# endif
#endif
128
129
130
131
132
133
134
135
136
static inline BOOL IS_LION_OR_LATER(_THIS)
{
#if FORCE_OLD_API
return NO;
#else
return (system_version >= 0x1070);
#endif
}
137
138
139
140
141
142
143
144
145
146
147
148
static inline BOOL IS_SNOW_LEOPARD_OR_LATER(_THIS)
{
#if FORCE_OLD_API
return NO;
#else
return (system_version >= 0x1060);
#endif
}
static void QZ_ReleaseDisplayMode(_THIS, const void *moderef)
{
/* we only own these references in the 10.6+ API. */
149
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
150
151
152
153
154
155
156
157
158
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. */
159
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
160
161
162
163
164
165
166
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
CFRelease(mode_list);
}
#endif
}
167
/* Bootstrap functions */
168
169
static int QZ_Available ()
{
170
171
172
return 1;
}
173
174
static SDL_VideoDevice* QZ_CreateDevice (int device_index)
{
175
#pragma unused (device_index)
176
177
178
179
SDL_VideoDevice *device;
SDL_PrivateVideoData *hidden;
180
181
device = (SDL_VideoDevice*) SDL_malloc (sizeof (*device) );
hidden = (SDL_PrivateVideoData*) SDL_malloc (sizeof (*hidden) );
182
183
184
185
if (device == NULL || hidden == NULL)
SDL_OutOfMemory ();
186
187
SDL_memset (device, 0, sizeof (*device) );
SDL_memset (hidden, 0, sizeof (*hidden) );
189
190
191
192
193
194
device->hidden = hidden;
device->VideoInit = QZ_VideoInit;
device->ListModes = QZ_ListModes;
device->SetVideoMode = QZ_SetVideoMode;
device->ToggleFullScreen = QZ_ToggleFullScreen;
195
device->UpdateMouse = QZ_UpdateMouse;
196
device->SetColors = QZ_SetColors;
197
/* device->UpdateRects = QZ_UpdateRects; this is determined by SetVideoMode() */
198
device->VideoQuit = QZ_VideoQuit;
200
201
device->LockHWSurface = QZ_LockHWSurface;
device->UnlockHWSurface = QZ_UnlockHWSurface;
202
device->AllocHWSurface = QZ_AllocHWSurface;
203
204
205
206
207
208
209
210
211
212
213
214
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;
216
217
218
219
220
221
222
223
224
225
226
227
228
229
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;
231
232
233
234
235
236
237
238
/*
* 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;*/
239
240
device->free = QZ_DeleteDevice;
242
243
244
return device;
}
245
246
static void QZ_DeleteDevice (SDL_VideoDevice *device)
{
247
_THIS = device;
248
249
QZ_ReleaseDisplayMode(this, save_mode);
QZ_ReleaseDisplayMode(this, mode);
250
251
SDL_free (device->hidden);
SDL_free (device);
254
255
256
257
258
259
260
static void QZ_GetModeInfo(_THIS, const void *_mode, Uint32 *w, Uint32 *h, Uint32 *bpp)
{
*w = *h = *bpp = 0;
if (_mode == NULL) {
return;
}
261
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
262
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
263
264
265
266
267
268
269
270
271
272
273
274
275
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);
279
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
280
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
281
282
283
284
285
286
287
288
289
290
291
292
293
CFDictionaryRef vidmode = (CFDictionaryRef) _mode;
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayBitsPerPixel),
kCFNumberSInt32Type, bpp);
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayWidth),
kCFNumberSInt32Type, w);
CFNumberGetValue (
CFDictionaryGetValue (vidmode, kCGDisplayHeight),
kCFNumberSInt32Type, h);
}
295
296
297
298
299
300
301
/* we only care about the 32-bit modes... */
if (*bpp != 32) {
*bpp = 0;
}
}
302
303
static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format)
{
304
NSRect r = NSMakeRect(0.0, 0.0, 0.0, 0.0);
305
const char *env = NULL;
306
307
308
309
if ( Gestalt(gestaltSystemVersion, &system_version) != noErr )
system_version = 0;
310
311
/* Initialize the video settings; this data persists between mode switches */
display_id = kCGDirectMainDisplay;
313
314
315
316
317
318
319
320
321
322
323
324
325
#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
326
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
327
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
328
329
330
331
save_mode = CGDisplayCopyDisplayMode(display_id);
}
#endif
332
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
333
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
334
335
336
337
save_mode = CGDisplayCurrentMode(display_id);
}
#endif
338
339
340
341
342
343
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)
if (!IS_LION_OR_LATER(this)) {
palette = CGPaletteCreateDefaultColorPalette();
}
#endif
344
345
346
347
if (save_mode == NULL) {
SDL_SetError("Couldn't figure out current display mode.");
return -1;
}
349
/* Allow environment override of screensaver disable. */
350
env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
351
352
353
354
355
356
357
358
359
if ( env ) {
allow_screensaver = SDL_atoi(env);
} else {
#ifdef SDL_VIDEO_DISABLE_SCREENSAVER
allow_screensaver = 0;
#else
allow_screensaver = 1;
#endif
}
361
/* Gather some information that is useful to know about the display */
362
363
QZ_GetModeInfo(this, save_mode, &device_width, &device_height, &device_bpp);
if (device_bpp == 0) {
364
QZ_ReleaseDisplayMode(this, save_mode);
365
366
367
368
save_mode = NULL;
SDL_SetError("Unsupported display mode");
return -1;
}
370
371
372
373
374
/* Determine the current screen size */
this->info.current_w = device_width;
this->info.current_h = device_height;
/* Determine the default screen depth */
375
376
video_format->BitsPerPixel = device_bpp;
377
378
/* Set misc globals */
current_grab_mode = SDL_GRAB_OFF;
379
cursor_should_be_visible = YES;
380
cursor_visible = YES;
381
current_mods = 0;
382
field_edit = [[SDLTranslatorResponder alloc] initWithFrame:r];
384
385
386
/* register for sleep notifications so wake from sleep generates SDL_VIDEOEXPOSE */
QZ_RegisterForSleepNotifications (this);
387
388
389
/* Fill in some window manager capabilities */
this->info.wm_available = 1;
390
return 0;
393
394
static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format, Uint32 flags)
{
395
CFArrayRef mode_list = NULL; /* list of available fullscreen modes */
396
CFIndex num_modes;
397
398
399
CFIndex i;
int list_size = 0;
401
402
403
/* Any windowed mode is acceptable */
if ( (flags & SDL_FULLSCREEN) == 0 )
return (SDL_Rect**)-1;
405
/* Free memory from previous call, if any */
406
if ( client_mode_list != NULL ) {
407
int i;
409
for (i = 0; client_mode_list[i] != NULL; i++)
410
SDL_free (client_mode_list[i]);
412
SDL_free (client_mode_list);
413
client_mode_list = NULL;
416
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
417
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
418
mode_list = CGDisplayCopyAllDisplayModes(display_id, NULL);
422
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
423
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
424
425
mode_list = CGDisplayAvailableModes(display_id);
}
428
429
num_modes = CFArrayGetCount (mode_list);
430
/* Build list of modes with the requested bpp */
431
for (i = 0; i < num_modes; i++) {
432
433
Uint32 width, height, bpp;
const void *onemode = CFArrayGetValueAtIndex(mode_list, i);
435
QZ_GetModeInfo(this, onemode, &width, &height, &bpp);
437
438
439
if (bpp && (bpp == format->BitsPerPixel)) {
int hasMode = SDL_FALSE;
int i;
440
441
/* Check if mode is already in the list */
442
443
444
for (i = 0; i < list_size; i++) {
if (client_mode_list[i]->w == width &&
client_mode_list[i]->h == height) {
445
446
hasMode = SDL_TRUE;
break;
449
450
451
452
453
454
455
/* Grow the list and add mode to the list */
if ( ! hasMode ) {
SDL_Rect *rect;
list_size++;
456
457
if (client_mode_list == NULL)
client_mode_list = (SDL_Rect**)
458
SDL_malloc (sizeof(*client_mode_list) * (list_size+1) );
459
460
461
else {
/* !!! FIXME: this leaks memory if SDL_realloc() fails! */
client_mode_list = (SDL_Rect**)
462
SDL_realloc (client_mode_list, sizeof(*client_mode_list) * (list_size+1));
465
rect = (SDL_Rect*) SDL_malloc (sizeof(**client_mode_list));
467
if (client_mode_list == NULL || rect == NULL) {
468
QZ_ReleaseDisplayModeList(this, mode_list);
469
470
471
472
SDL_OutOfMemory ();
return NULL;
}
473
rect->x = rect->y = 0;
474
475
476
rect->w = width;
rect->h = height;
477
478
client_mode_list[list_size-1] = rect;
client_mode_list[list_size] = NULL;
483
QZ_ReleaseDisplayModeList(this, mode_list);
485
486
487
488
489
/* 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++) {
491
int area1, area2;
492
493
area1 = client_mode_list[j]->w * client_mode_list[j]->h;
area2 = client_mode_list[j+1]->w * client_mode_list[j+1]->h;
495
if (area1 < area2) {
496
497
498
SDL_Rect *tmp = client_mode_list[j];
client_mode_list[j] = client_mode_list[j+1];
client_mode_list[j+1] = tmp;
499
500
501
502
}
}
}
}
504
return client_mode_list;
507
508
509
510
511
512
513
514
515
516
517
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;
}
518
519
static CGError QZ_SetDisplayMode(_THIS, const void *vidmode)
{
520
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
521
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
522
return CGDisplaySetDisplayMode(display_id, (CGDisplayModeRef) vidmode, NULL);
526
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
527
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
528
529
return CGDisplaySwitchToMode(display_id, (CFDictionaryRef) vidmode);
}
531
532
533
534
535
536
537
538
539
return kCGErrorFailure;
}
static inline CGError QZ_RestoreDisplayMode(_THIS)
{
return QZ_SetDisplayMode(this, save_mode);
}
540
541
static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop)
{
542
/* Reset values that may change between switches */
543
this->info.blit_fill = 0;
544
545
546
547
this->FillHWRect = NULL;
this->UpdateRects = NULL;
this->LockHWSurface = NULL;
this->UnlockHWSurface = NULL;
549
550
551
552
553
554
if (cg_context) {
CGContextFlush (cg_context);
CGContextRelease (cg_context);
cg_context = nil;
}
555
/* Release fullscreen resources */
556
if ( mode_flags & SDL_FULLSCREEN ) {
558
NSRect screen_rect;
560
561
562
563
564
565
566
567
568
569
570
571
/* 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
574
575
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] */
579
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
QZ_TearDownOpenGL (this);
586
#ifdef __powerpc__ /* we only use this for pre-10.3 compatibility. */
587
CGLSetFullScreen (NULL);
590
if (to_desktop) {
592
/* Restore original screen resolution/bpp */
593
QZ_RestoreDisplayMode (this);
594
595
596
597
598
599
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);
600
QZ_SetFrame([ NSScreen mainScreen ], screen_rect);
603
/* Release window mode resources */
604
else {
605
606
607
id delegate = [ qz_window delegate ];
[ qz_window close ]; /* includes release because [qz_window isReleasedWhenClosed] */
if (delegate != nil) [ delegate release ];
608
qz_window = nil;
609
window_view = nil;
611
612
613
/* Release the OpenGL context */
if ( mode_flags & SDL_OPENGL )
QZ_TearDownOpenGL (this);
616
617
/* Signal successful teardown */
video_set = SDL_FALSE;
620
621
622
623
624
625
626
627
static const void *QZ_BestMode(_THIS, const int bpp, const int w, const int h)
{
const void *best = NULL;
if (bpp == 0) {
return NULL;
}
628
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)
629
if (IS_SNOW_LEOPARD_OR_LATER(this)) {
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
/* 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);
}
652
#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)
653
if (!IS_SNOW_LEOPARD_OR_LATER(this)) {
654
655
656
657
658
659
boolean_t exact = 0;
best = CGDisplayBestModeForParameters(display_id, bpp, w, h, &exact);
if (!exact) {
best = NULL;
}
}
660
661
#endif
662
663
664
return best;
}
665
static SDL_Surface* QZ_SetVideoFullScreen (_THIS, SDL_Surface *current, int width,
666
667
int height, int bpp, Uint32 flags)
{
668
const BOOL isLion = IS_LION_OR_LATER(this);
669
NSRect screen_rect;
670
CGError error;
672
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
674
675
676
677
current->flags = SDL_FULLSCREEN;
current->w = width;
current->h = height;
678
679
contentRect = NSMakeRect (0, 0, width, height);
680
681
682
683
684
/* 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);
}
686
687
/* Destroy any previous mode */
if (video_set == SDL_TRUE)
688
QZ_UnsetVideoMode (this, FALSE);
690
691
692
693
694
695
/* 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;
}
696
QZ_ReleaseDisplayMode(this, mode); /* NULL is okay. */
698
/* See if requested mode exists */
699
mode = QZ_BestMode(this, bpp, width, height);
701
/* Require an exact match to the requested mode */
702
if ( mode == NULL ) {
703
SDL_SetError ("Failed to find display resolution: %dx%dx%d", width, height, bpp);
704
705
goto ERR_NO_MATCH;
}
707
/* Put up the blanking window (a window above all other windows) */
708
709
710
711
712
713
if (getenv ("SDL_SINGLEDISPLAY"))
error = CGDisplayCapture (display_id);
else
error = CGCaptureAllDisplays ();
if ( CGDisplayNoErr != error ) {
714
715
716
SDL_SetError ("Failed capturing display");
goto ERR_NO_CAPTURE;
}
718
/* Do the physical switch */
719
if ( CGDisplayNoErr != QZ_SetDisplayMode(this, mode) ) {
720
721
722
SDL_SetError ("Failed switching display resolution");
goto ERR_NO_SWITCH;
}
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
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
#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
778
779
780
781
782
/* 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
783
styleMask:(isLion ? NSBorderlessWindowMask : 0)
784
785
786
787
788
789
backing:NSBackingStoreBuffered
defer:NO ];
if (qz_window != nil) {
[ qz_window setAcceptsMouseMovedEvents:YES ];
[ qz_window setViewsNeedDisplay:NO ];
790
791
792
793
794
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
if (isLion) {
[ qz_window setContentView: [ [ [ SDL_QuartzView alloc ] init ] autorelease ] ];
}
#endif
799
800
801
[ qz_window setContentSize:contentRect.size ];
current->flags |= (SDL_NOFRAME|SDL_RESIZABLE) & mode_flags;
[ window_view setFrameSize:contentRect.size ];
804
805
806
807
808
/* Setup OpenGL for a fullscreen context */
if (flags & SDL_OPENGL) {
CGLError err;
CGLContextObj ctx;
810
if ( ! QZ_SetupOpenGL (this, bpp, flags) ) {
811
goto ERR_NO_GL;
814
815
816
817
/* 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 ];
818
819
820
821
822
823
824
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
if ( isLion ) {
[ window_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
}
#endif
[ [ qz_window contentView ] addSubview:window_view ];
826
827
828
829
830
831
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
if ( isLion ) {
[ qz_window setLevel:CGShieldingWindowLevel() ];
[ gl_context setView: window_view ];
[ gl_context setFullScreen ];
[ gl_context update ];
835
836
837
838
839
840
841
842
843
844
845
846
847
848
#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 ];
849
[ gl_context makeCurrentContext];
850
851
852
853
glClear (GL_COLOR_BUFFER_BIT);
[ gl_context flushBuffer ];
855
current->flags |= SDL_OPENGL;
856
857
} else if (isLion) { /* For 2D, we build a CGBitmapContext */
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
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() ];
883
884
885
886
887
this->UpdateRects = QZ_UpdateRects;
this->LockHWSurface = QZ_LockHWSurface;
this->UnlockHWSurface = QZ_UnlockHWSurface;
#endif
890
891
892
893
894
895
896
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
if (isLion) {
[ qz_window setHasShadow:NO];
[ qz_window setOpaque:YES];
[ qz_window makeKeyAndOrderFront:nil ];
}
#endif
897
898
899
/* If we don't hide menu bar, it will get events and interrupt the program */
HideMenuBar ();
901
902
903
904
905
/* 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);
}
908
909
910
911
912
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.
913
914
*/
screen_rect = NSMakeRect(0,0,width,height);
915
QZ_SetFrame([ NSScreen mainScreen ], screen_rect);
917
918
/* Save the flags to ensure correct tear-down */
mode_flags = current->flags;
923
924
return current;
925
/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */
926
927
ERR_NO_GL:
ERR_DOUBLEBUF: QZ_RestoreDisplayMode(this);
928
ERR_NO_SWITCH: CGReleaseAllDisplays ();
929
930
931
932
933
934
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;
935
936
937
}
static SDL_Surface* QZ_SetVideoWindowed (_THIS, SDL_Surface *current, int width,
938
939
int height, int *bpp, Uint32 flags)
{
940
unsigned int style;
941
NSRect contentRect;
942
943
int center_window = 1;
int origin_x, origin_y;
944
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
946
947
current->flags = 0;
current->w = width;
948
current->h = height;
949
950
contentRect = NSMakeRect (0, 0, width, height);
952
953
954
955
956
957
958
/*
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
*/
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
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);
}
}
975
976
977
978
979
980
/* 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);
982
return NULL;
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
/* 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;
}
}