/*

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

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

};

#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

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

                }