/*

SDL - Simple DirectMedia Layer

Copyright (C) 1997-2009 Sam Lantinga

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

slouken@libsdl.org

*/

#include "SDL_config.h"

#include "SDL_QuartzVideo.h"

#include "SDL_QuartzWindow.h"

#if __MAC_OS_X_VERSION_MIN_REQUIRED < 1060 /* Fixed in Snow Leopard */

/*

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

static inline void QZ_SetFrame(NSScreen *nsscreen, NSRect frame)

{

[nsscreen setFrame:frame];

}

#else

static inline void QZ_SetFrame(NSScreen *nsscreen, NSRect frame)

{

}

#endif

@interface SDLTranslatorResponder : NSTextView

{

}

- (void) doCommandBySelector:(SEL)myselector;

@end

@implementation SDLTranslatorResponder

- (void) doCommandBySelector:(SEL) myselector {}

@end

/* absent in 10.3.9. */

CG_EXTERN CGImageRef CGBitmapContextCreateImage (CGContextRef);

/* 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);

static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop);

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);

#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

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);

static int QZ_AllocHWSurface(_THIS, SDL_Surface *surface);

static void QZ_FreeHWSurface (_THIS, SDL_Surface *surface);

/* Bootstrap binding, enables entry point into the driver */

VideoBootStrap QZ_bootstrap = {

"Quartz", "Mac OS X CoreGraphics", QZ_Available, QZ_CreateDevice

};

/* !!! FIXME: clean out pre-10.6 code when (if!) it makes sense to do so. */

#define FORCE_OLD_API 0 || (MAC_OS_X_VERSION_MAX_ALLOWED < 1060)

#if FORCE_OLD_API

#undef MAC_OS_X_VERSION_MIN_REQUIRED

#define MAC_OS_X_VERSION_MIN_REQUIRED 1050

#endif

/* Disable compiler warnings we can't avoid. */

#if (defined(__GNUC__) && (__GNUC__ >= 4))

# if (MAC_OS_X_VERSION_MAX_ALLOWED <= 1070)

# pragma GCC diagnostic ignored "-Wdeprecated-declarations"

# endif

#endif

static inline BOOL IS_LION_OR_LATER(_THIS)

{

#if FORCE_OLD_API

return NO;

#else

return (system_version >= 0x1070);

#endif

}

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. */

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)

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. */

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)

if (IS_SNOW_LEOPARD_OR_LATER(this)) {

CFRelease(mode_list);

}

#endif

}

/* Bootstrap functions */

static int QZ_Available ()

{

return 1;

}

static SDL_VideoDevice* QZ_CreateDevice (int device_index)

{

#pragma unused (device_index)

SDL_VideoDevice *device;

SDL_PrivateVideoData *hidden;

device = (SDL_VideoDevice*) SDL_malloc (sizeof (*device) );

hidden = (SDL_PrivateVideoData*) SDL_malloc (sizeof (*hidden) );

if (device == NULL || hidden == NULL)

SDL_OutOfMemory ();

SDL_memset (device, 0, sizeof (*device) );

SDL_memset (hidden, 0, sizeof (*hidden) );

device->hidden = hidden;

device->VideoInit = QZ_VideoInit;

device->ListModes = QZ_ListModes;

device->SetVideoMode = QZ_SetVideoMode;

device->ToggleFullScreen = QZ_ToggleFullScreen;

device->UpdateMouse = QZ_UpdateMouse;

device->SetColors = QZ_SetColors;

/* device->UpdateRects = QZ_UpdateRects; this is determined by SetVideoMode() */

device->VideoQuit = QZ_VideoQuit;

device->LockHWSurface = QZ_LockHWSurface;

device->UnlockHWSurface = QZ_UnlockHWSurface;

device->AllocHWSurface = QZ_AllocHWSurface;

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;

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;

/*

* 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;*/

device->free = QZ_DeleteDevice;

return device;

}

static void QZ_DeleteDevice (SDL_VideoDevice *device)

{

_THIS = device;

QZ_ReleaseDisplayMode(this, save_mode);

QZ_ReleaseDisplayMode(this, mode);

SDL_free (device->hidden);

SDL_free (device);

}

static void QZ_GetModeInfo(_THIS, const void *_mode, Uint32 *w, Uint32 *h, Uint32 *bpp)

{

*w = *h = *bpp = 0;

if (_mode == NULL) {

return;

}

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)

if (IS_SNOW_LEOPARD_OR_LATER(this)) {

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);

}

#endif

#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)

if (!IS_SNOW_LEOPARD_OR_LATER(this)) {

CFDictionaryRef vidmode = (CFDictionaryRef) _mode;

CFNumberGetValue (

CFDictionaryGetValue (vidmode, kCGDisplayBitsPerPixel),

kCFNumberSInt32Type, bpp);

CFNumberGetValue (

CFDictionaryGetValue (vidmode, kCGDisplayWidth),

kCFNumberSInt32Type, w);

CFNumberGetValue (

CFDictionaryGetValue (vidmode, kCGDisplayHeight),

kCFNumberSInt32Type, h);

}

#endif

/* we only care about the 32-bit modes... */

if (*bpp != 32) {

*bpp = 0;

}

}

static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format)

{

NSRect r = NSMakeRect(0.0, 0.0, 0.0, 0.0);

const char *env = NULL;

if ( Gestalt(gestaltSystemVersion, &system_version) != noErr )

system_version = 0;

/* Initialize the video settings; this data persists between mode switches */

display_id = kCGDirectMainDisplay;

#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

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)

if (IS_SNOW_LEOPARD_OR_LATER(this)) {

save_mode = CGDisplayCopyDisplayMode(display_id);

}

#endif

#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)

if (!IS_SNOW_LEOPARD_OR_LATER(this)) {

save_mode = CGDisplayCurrentMode(display_id);

}

#endif

#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070)

if (!IS_LION_OR_LATER(this)) {

palette = CGPaletteCreateDefaultColorPalette();

}

#endif

if (save_mode == NULL) {

SDL_SetError("Couldn't figure out current display mode.");

return -1;

}

/* Allow environment override of screensaver disable. */

env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");

if ( env ) {

allow_screensaver = SDL_atoi(env);

} else {

#ifdef SDL_VIDEO_DISABLE_SCREENSAVER

allow_screensaver = 0;

#else

allow_screensaver = 1;

#endif

}

/* Gather some information that is useful to know about the display */

QZ_GetModeInfo(this, save_mode, &device_width, &device_height, &device_bpp);

if (device_bpp == 0) {

QZ_ReleaseDisplayMode(this, save_mode);

save_mode = NULL;

SDL_SetError("Unsupported display mode");

return -1;

}

/* Determine the current screen size */

this->info.current_w = device_width;

this->info.current_h = device_height;

/* Determine the default screen depth */

video_format->BitsPerPixel = device_bpp;

/* Set misc globals */

current_grab_mode = SDL_GRAB_OFF;

cursor_should_be_visible = YES;

cursor_visible = YES;

current_mods = 0;

field_edit = [[SDLTranslatorResponder alloc] initWithFrame:r];

/* register for sleep notifications so wake from sleep generates SDL_VIDEOEXPOSE */

QZ_RegisterForSleepNotifications (this);

/* Fill in some window manager capabilities */

this->info.wm_available = 1;

return 0;

}

static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format, Uint32 flags)

{

CFArrayRef mode_list = NULL; /* list of available fullscreen modes */

CFIndex num_modes;

CFIndex i;

int list_size = 0;

/* Any windowed mode is acceptable */

if ( (flags & SDL_FULLSCREEN) == 0 )

return (SDL_Rect**)-1;

/* Free memory from previous call, if any */

if ( client_mode_list != NULL ) {

int i;

for (i = 0; client_mode_list[i] != NULL; i++)

SDL_free (client_mode_list[i]);

SDL_free (client_mode_list);

client_mode_list = NULL;

}

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)

if (IS_SNOW_LEOPARD_OR_LATER(this)) {

mode_list = CGDisplayCopyAllDisplayModes(display_id, NULL);

}

#endif

#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)

if (!IS_SNOW_LEOPARD_OR_LATER(this)) {

mode_list = CGDisplayAvailableModes(display_id);

}

#endif

num_modes = CFArrayGetCount (mode_list);

/* Build list of modes with the requested bpp */

for (i = 0; i < num_modes; i++) {

Uint32 width, height, bpp;

const void *onemode = CFArrayGetValueAtIndex(mode_list, i);

QZ_GetModeInfo(this, onemode, &width, &height, &bpp);

if (bpp && (bpp == format->BitsPerPixel)) {

int hasMode = SDL_FALSE;

int i;

/* Check if mode is already in the list */

for (i = 0; i < list_size; i++) {

if (client_mode_list[i]->w == width &&

client_mode_list[i]->h == height) {

hasMode = SDL_TRUE;

break;

}

}

/* Grow the list and add mode to the list */

if ( ! hasMode ) {

SDL_Rect *rect;

list_size++;

if (client_mode_list == NULL)

client_mode_list = (SDL_Rect**)

SDL_malloc (sizeof(*client_mode_list) * (list_size+1) );

else {

/* !!! FIXME: this leaks memory if SDL_realloc() fails! */

client_mode_list = (SDL_Rect**)

SDL_realloc (client_mode_list, sizeof(*client_mode_list) * (list_size+1));

}

rect = (SDL_Rect*) SDL_malloc (sizeof(**client_mode_list));

if (client_mode_list == NULL || rect == NULL) {

QZ_ReleaseDisplayModeList(this, mode_list);

SDL_OutOfMemory ();

return NULL;

}

rect->x = rect->y = 0;

rect->w = width;

rect->h = height;

client_mode_list[list_size-1] = rect;

client_mode_list[list_size] = NULL;

}

}

}

QZ_ReleaseDisplayModeList(this, mode_list);

/* 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++) {

int area1, area2;

area1 = client_mode_list[j]->w * client_mode_list[j]->h;

area2 = client_mode_list[j+1]->w * client_mode_list[j+1]->h;

if (area1 < area2) {

SDL_Rect *tmp = client_mode_list[j];

client_mode_list[j] = client_mode_list[j+1];

client_mode_list[j+1] = tmp;

}

}

}

}

return client_mode_list;

}

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;

}

static CGError QZ_SetDisplayMode(_THIS, const void *vidmode)

{

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)

if (IS_SNOW_LEOPARD_OR_LATER(this)) {

return CGDisplaySetDisplayMode(display_id, (CGDisplayModeRef) vidmode, NULL);

}

#endif

#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)

if (!IS_SNOW_LEOPARD_OR_LATER(this)) {

return CGDisplaySwitchToMode(display_id, (CFDictionaryRef) vidmode);

}

#endif

return kCGErrorFailure;

}

static inline CGError QZ_RestoreDisplayMode(_THIS)

{

return QZ_SetDisplayMode(this, save_mode);

}

static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop)

{

/* Reset values that may change between switches */

this->info.blit_fill = 0;

this->FillHWRect = NULL;

this->UpdateRects = NULL;

this->LockHWSurface = NULL;

this->UnlockHWSurface = NULL;

if (cg_context) {

CGContextFlush (cg_context);

CGContextRelease (cg_context);

cg_context = nil;

}

/* Release fullscreen resources */

if ( mode_flags & SDL_FULLSCREEN ) {

NSRect screen_rect;

/* 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

/* If we still have a valid window, close it. */

if ( qz_window ) {

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] */

qz_window = nil;

window_view = nil;

}

/*

Release the OpenGL context

Do this first to avoid trash on the display before fade

*/

if ( mode_flags & SDL_OPENGL ) {

QZ_TearDownOpenGL (this);

#ifdef __powerpc__ /* we only use this for pre-10.3 compatibility. */

CGLSetFullScreen (NULL);

#endif

}

if (to_desktop) {

ShowMenuBar ();

/* Restore original screen resolution/bpp */

QZ_RestoreDisplayMode (this);

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);

QZ_SetFrame([ NSScreen mainScreen ], screen_rect);

}

}

/* Release window mode resources */

else {

id delegate = [ qz_window delegate ];

[ qz_window close ]; /* includes release because [qz_window isReleasedWhenClosed] */

if (delegate != nil) [ delegate release ];

qz_window = nil;

window_view = nil;

/* Release the OpenGL context */

if ( mode_flags & SDL_OPENGL )

QZ_TearDownOpenGL (this);

}

/* Signal successful teardown */

video_set = SDL_FALSE;

}

static const void *QZ_BestMode(_THIS, const int bpp, const int w, const int h)

{

const void *best = NULL;

if (bpp == 0) {

return NULL;

}

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)

if (IS_SNOW_LEOPARD_OR_LATER(this)) {

/* 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);

}

}

#endif

#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1060)

if (!IS_SNOW_LEOPARD_OR_LATER(this)) {

boolean_t exact = 0;

best = CGDisplayBestModeForParameters(display_id, bpp, w, h, &exact);

if (!exact) {

best = NULL;

}

}

#endif

return best;

}

static SDL_Surface* QZ_SetVideoFullScreen (_THIS, SDL_Surface *current, int width,

int height, int bpp, Uint32 flags)

{

const BOOL isLion = IS_LION_OR_LATER(this);

NSRect screen_rect;

CGError error;

NSRect contentRect;

CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;

current->flags = SDL_FULLSCREEN;

current->w = width;

current->h = height;

contentRect = NSMakeRect (0, 0, width, height);

/* 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);

}

/* Destroy any previous mode */

if (video_set == SDL_TRUE)

QZ_UnsetVideoMode (this, FALSE);

/* 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;

}

QZ_ReleaseDisplayMode(this, mode); /* NULL is okay. */

/* See if requested mode exists */

mode = QZ_BestMode(this, bpp, width, height);

/* Require an exact match to the requested mode */

if ( mode == NULL ) {

SDL_SetError ("Failed to find display resolution: %dx%dx%d", width, height, bpp);

goto ERR_NO_MATCH;

}

/* Put up the blanking window (a window above all other windows) */

if (getenv ("SDL_SINGLEDISPLAY"))

error = CGDisplayCapture (display_id);

else

error = CGCaptureAllDisplays ();

if ( CGDisplayNoErr != error ) {

SDL_SetError ("Failed capturing display");

goto ERR_NO_CAPTURE;

}

/* Do the physical switch */

if ( CGDisplayNoErr != QZ_SetDisplayMode(this, mode) ) {

SDL_SetError ("Failed switching display resolution");

goto ERR_NO_SWITCH;

}

#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

/* 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

styleMask:(isLion ? NSBorderlessWindowMask : 0)

backing:NSBackingStoreBuffered

defer:NO ];

if (qz_window != nil) {

[ qz_window setAcceptsMouseMovedEvents:YES ];

[ qz_window setViewsNeedDisplay:NO ];

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)

if (isLion) {

[ qz_window setContentView: [ [ [ SDL_QuartzView alloc ] init ] autorelease ] ];

}

#endif

}

}

/* We already have a window, just change its size */

else {

[ qz_window setContentSize:contentRect.size ];

current->flags |= (SDL_NOFRAME|SDL_RESIZABLE) & mode_flags;

[ window_view setFrameSize:contentRect.size ];

}

/* Setup OpenGL for a fullscreen context */

if (flags & SDL_OPENGL) {

CGLError err;

CGLContextObj ctx;

if ( ! QZ_SetupOpenGL (this, bpp, flags) ) {

goto ERR_NO_GL;

}

/* 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 ];

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)

if ( isLion ) {

[ window_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];

}

#endif

[ [ qz_window contentView ] addSubview:window_view ];

#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 ];

}

#endif

#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 ];

[ gl_context makeCurrentContext];

glClear (GL_COLOR_BUFFER_BIT);

[ gl_context flushBuffer ];

current->flags |= SDL_OPENGL;

} else if (isLion) { /* For 2D, we build a CGBitmapContext */

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)

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() ];

this->UpdateRects = QZ_UpdateRects;

this->LockHWSurface = QZ_LockHWSurface;

this->UnlockHWSurface = QZ_UnlockHWSurface;

#endif

}

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)

if (isLion) {

[ qz_window setHasShadow:NO];

[ qz_window setOpaque:YES];

[ qz_window makeKeyAndOrderFront:nil ];

}

#endif

/* If we don't hide menu bar, it will get events and interrupt the program */

HideMenuBar ();

/* 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);

}

/*

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.

*/

screen_rect = NSMakeRect(0,0,width,height);

QZ_SetFrame([ NSScreen mainScreen ], screen_rect);

/* Save the flags to ensure correct tear-down */

mode_flags = current->flags;

/* Set app state, hide cursor if necessary, ... */

QZ_DoActivate(this);

return current;

/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */

ERR_NO_GL:

ERR_DOUBLEBUF: QZ_RestoreDisplayMode(this);

ERR_NO_SWITCH: CGReleaseAllDisplays ();

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;

}

static SDL_Surface* QZ_SetVideoWindowed (_THIS, SDL_Surface *current, int width,

int height, int *bpp, Uint32 flags)

{

unsigned int style;

NSRect contentRect;

int center_window = 1;

int origin_x, origin_y;

CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;

current->flags = 0;

current->w = width;

current->h = height;

contentRect = NSMakeRect (0, 0, width, height);

/*

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

*/

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);

}

}

/* 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);

}

return NULL;

}

/* 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;

}

}

/* Manually create a window, avoids having a nib file resource */

qz_window = [ [ SDL_QuartzWindow alloc ]

initWithContentRect:contentRect