/*

SDL - Simple DirectMedia Layer

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

#include "SDL_QuartzVideo.h"

/*

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

@interface SDLTranslatorResponder : NSTextView

{

}

- (void) doCommandBySelector:(SEL)myselector;

@end

@implementation SDLTranslatorResponder

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

@end

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

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

static int QZ_LockWindow (_THIS, SDL_Surface *surface);

static void QZ_UnlockWindow (_THIS, SDL_Surface *surface);

static void QZ_UpdateRects (_THIS, int num_rects, SDL_Rect *rects);

static void QZ_VideoQuit (_THIS);

/* Hardware surface functions (for fullscreen mode only) */

#if 0 /* Not used (apparently, it's really slow) */

static int QZ_FillHWRect (_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);

#endif

static int QZ_LockHWSurface(_THIS, SDL_Surface *surface);

static void QZ_UnlockHWSurface(_THIS, SDL_Surface *surface);

static void QZ_FreeHWSurface (_THIS, SDL_Surface *surface);

/* static int QZ_FlipHWSurface (_THIS, SDL_Surface *surface); */

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

VideoBootStrap QZ_bootstrap = {

};

/* Bootstrap functions */

static int QZ_Available () {

return 1;

}

static SDL_VideoDevice* QZ_CreateDevice (int 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->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->FreeHWSurface = QZ_FreeHWSurface;

/* device->FlipHWSurface = QZ_FlipHWSurface */;

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;

device->CreateYUVOverlay = QZ_CreateYUVOverlay;

device->free = QZ_DeleteDevice;

return device;

}

static void QZ_DeleteDevice (SDL_VideoDevice *device) {

SDL_free (device->hidden);

SDL_free (device);

}

static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format) {

const char *env = NULL;

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

display_id = kCGDirectMainDisplay;

save_mode = CGDisplayCurrentMode (display_id);

mode_list = CGDisplayAvailableModes (display_id);

palette = CGPaletteCreateDefaultColorPalette ();

env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");

allow_screensaver = ( env && SDL_atoi(env) ) ? YES : NO;

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

CFNumberGetValue (CFDictionaryGetValue (save_mode, kCGDisplayBitsPerPixel),

kCFNumberSInt32Type, &device_bpp);

CFNumberGetValue (CFDictionaryGetValue (save_mode, kCGDisplayWidth),

kCFNumberSInt32Type, &device_width);

CFNumberGetValue (CFDictionaryGetValue (save_mode, kCGDisplayHeight),

kCFNumberSInt32Type, &device_height);

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

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

system_version = 0;

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

}

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

CFIndex i;

int list_size = 0;

/* Any windowed mode is acceptable */

if ( (flags & SDL_FULLSCREEN) == 0 )

return (SDL_Rect**)-1;

num_modes = CFArrayGetCount (mode_list);

CFDictionaryRef onemode;

CFNumberRef number;

int bpp;

onemode = CFArrayGetValueAtIndex (mode_list, i);

number = CFDictionaryGetValue (onemode, kCGDisplayBitsPerPixel);

CFNumberGetValue (number, kCFNumberSInt32Type, &bpp);

if (bpp == format->BitsPerPixel) {

int intvalue;

int hasMode;

int width, height;

number = CFDictionaryGetValue (onemode, kCGDisplayWidth);

CFNumberGetValue (number, kCFNumberSInt32Type, &intvalue);

width = (Uint16) intvalue;

number = CFDictionaryGetValue (onemode, kCGDisplayHeight);

CFNumberGetValue (number, kCFNumberSInt32Type, &intvalue);

height = (Uint16) intvalue;

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

{

int i;

hasMode = SDL_FALSE;

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

return NULL;

}

rect->w = width;

rect->h = height;

client_mode_list[list_size-1] = rect;

client_mode_list[list_size] = NULL;

}

}

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

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

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

SDL_Rect *tmp = client_mode_list[j];

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

client_mode_list[j+1] = tmp;

}

}

}

}

}

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;

}

/* Reset values that may change between switches */

this->info.blit_fill = 0;

this->FillHWRect = NULL;

this->UpdateRects = NULL;

this->LockHWSurface = NULL;

this->UnlockHWSurface = NULL;

NSRect screen_rect;

quit_thread = YES;

SDL_SemPost (sem1);

SDL_WaitThread (thread, NULL);

SDL_DestroySemaphore (sem1);

SDL_DestroySemaphore (sem2);

}

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

CGLSetFullScreen (NULL);

}

/* Restore original screen resolution/bpp */

CGDisplaySwitchToMode (display_id, save_mode);

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

[ [ NSScreen mainScreen ] setFrame:screen_rect ];

}

id delegate = [ qz_window delegate ];

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

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

/* Release the OpenGL context */

if ( mode_flags & SDL_OPENGL )

QZ_TearDownOpenGL (this);

/* Signal successful teardown */

video_set = SDL_FALSE;

}

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

int height, int bpp, Uint32 flags) {

NSRect contentRect;

BOOL isCustom = NO;

CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;

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

mode = CGDisplayBestModeForParameters (display_id, bpp, width,

height, &exact_match);

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

if ( ! exact_match ) {

goto ERR_NO_MATCH;

}

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 != CGDisplaySwitchToMode (display_id, mode) ) {

SDL_SetError ("Failed switching display resolution");

goto ERR_NO_SWITCH;

}

current->pixels = (Uint32*) CGDisplayBaseAddress (display_id);

current->pitch = CGDisplayBytesPerRow (display_id);

current->w = width;

current->h = height;

current->flags |= SDL_PREALLOC;

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;

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;

/* The code below checks for any valid custom windows and views. If none are

available, then we create new ones. Window/View code was added in FULLSCREEN

so that special events like the changing of the cursor image would be handled

( only the front-most and active application can change the cursor appearance

and with no valid window/view in FULLSCREEN, SDL wouldn't update its cursor. )

*/

/* Check for user-specified window and view */

{

char *windowPtrString = getenv ("SDL_NSWindowPointer");

char *viewPtrString = getenv ("SDL_NSQuickDrawViewPointer");

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

if (windowPtrString && viewPtrString) {

/* Release any previous window */

if ( qz_window ) {

[ qz_window release ];

qz_window = nil;

}

qz_window = (NSWindow*)atoi(windowPtrString);

window_view = (NSQuickDrawView*)atoi(viewPtrString);

isCustom = YES;

/*

Retain reference to window because we

might release it in QZ_UnsetVideoMode

*/

[ qz_window retain ];

}

}

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

backing:NSBackingStoreBuffered

defer:NO ];

if (qz_window != nil) {

[ qz_window setAcceptsMouseMovedEvents:YES ];

[ qz_window setViewsNeedDisplay:NO ];

}

}

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

else {

if (!isCustom) {

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

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

[ [ qz_window contentView ] addSubview:window_view ];

[ window_view release ];

ctx = [ gl_context cglContext ];

err = CGLSetFullScreen (ctx);

goto ERR_NO_GL;

}

glClear (GL_COLOR_BUFFER_BIT);

[ gl_context flushBuffer ];

current->flags |= SDL_OPENGL;

}

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

[ [ NSScreen mainScreen ] setFrame: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;

ERR_NO_GL:

ERR_DOUBLEBUF: CGDisplaySwitchToMode (display_id, save_mode);

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 center_window = 1;

int origin_x, origin_y;