/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997, 1998, 1999, 2000, 2001  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_QuartzVideo.h"

/* Some variables to share among files, put in device structure eventually */

static SDL_GrabMode currentGrabMode = SDL_GRAB_OFF;

static BOOL   inForeground = YES;

static char QZ_Error[255]; /* Global error buffer to temporarily store more informative error messages */

/* Include files into one compile unit...break apart eventually */

#include "SDL_QuartzWM.m"

#include "SDL_QuartzEvents.m"

#include "SDL_QuartzWindow.m"

/* 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*) malloc (sizeof (*device) );

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

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

        SDL_OutOfMemory ();

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

    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->free = QZ_DeleteDevice;

    return device;

}

static void QZ_DeleteDevice (SDL_VideoDevice *device) {

    free (device->hidden);

    free (device);

}

static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format) {

}

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

    CFIndex i;

    static SDL_Rect **list = NULL;

    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 ( list != NULL ) {

      int i;

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

	free (list[i]);

      free (list);

      list = NULL;

    }

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

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

        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 (list[i]->w == width && list[i]->h == height) {

                    hasMode = SDL_TRUE;

                    break;

                }

            }

          }

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

          if ( ! hasMode ) {

            SDL_Rect *rect;

            list_size++;

            else

            rect = (SDL_Rect*) malloc (sizeof(**list));

                SDL_OutOfMemory ();

            rect->w = width;

            rect->h = height;

            list[list_size-1] = rect;

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

                int area1, area2;

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

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

                if (area1 < area2) {

                    SDL_Rect *tmp = list[j];

                    list[j] = list[j+1];

                    list[j+1] = tmp;

                }

            }

        }

    }

    return list;

}

static void QZ_UnsetVideoMode (_THIS) {

    /* Reset values that may change between switches */

    this->info.blit_fill = 0;

    this->FillHWRect     = NULL;

    this->UpdateRects    = NULL;

    if ( mode_flags & SDL_FULLSCREEN ) {

        if (mode_flags & SDL_OPENGL)

            CGLSetFullScreen(NULL);

        CGDisplaySwitchToMode (display_id, save_mode);

        CGDisplayRelease (display_id);

    }

    else { 

        if ( (mode_flags & SDL_OPENGL) == 0 ) {

        }

        [ qz_window setContentView:nil ];

        [ qz_window setDelegate:nil ];

        [ qz_window close ];

    }

    /* Set pixels to null (so other code doesn't try to free it) */

    if (this->screen != NULL)

        this->screen->pixels = NULL;

    /* Ensure the cursor will be visible and working when we quit */

    CGDisplayShowCursor (display_id);

    CGAssociateMouseAndMouseCursorPosition (1);

    /* Signal successful teardown */

    video_set = SDL_FALSE;

}

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

                                           int height, int bpp, Uint32 flags) {

    int exact_match;

    /* See if requested mode exists */

    mode = CGDisplayBestModeForParameters (display_id, bpp, width, 

					   height, &exact_match);

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

    if ( ! exact_match ) {

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

        SDL_SetError (QZ_Error);

        goto ERR_NO_MATCH;

    }

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

    if ( CGDisplayNoErr != CGDisplayCapture (display_id) ) {

        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->flags = 0;

    current->w = width;

    current->h = height;

    current->flags |= SDL_FULLSCREEN;  

    current->flags |= SDL_HWSURFACE;

    this->UpdateRects = QZ_DirectUpdate;

    /* Setup some mode-dependant info */

    if ( CGSDisplayCanHWFill (display_id) ) {

         this->info.blit_fill = 1;

         this->FillHWRect = QZ_FillHWRect;

    }

    if ( CGDisplayCanSetPalette (display_id) )

        current->flags |= SDL_HWPALETTE;

    /* Setup OpenGL for a fullscreen context */

    if (flags & SDL_OPENGL) {

        CGLError err;

        CGLContextObj ctx;

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

        }

        ctx = [ gl_context cglContext ];

        err = CGLSetFullScreen (ctx);

        if (err) {

            sprintf (QZ_Error, "Error setting OpenGL fullscreen: %s", CGLErrorString(err));

            SDL_SetError (QZ_Error);

            goto ERR_NO_GL;

        }

        [ gl_context makeCurrentContext];

        current->flags |= SDL_OPENGL;

    }

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

    HideMenuBar ();

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

    mode_flags = current->flags;

    return current;

 ERR_NO_GL:      CGDisplaySwitchToMode (display_id, save_mode);

 ERR_NO_SWITCH:  CGDisplayRelease (display_id);

 ERR_NO_MATCH:	return NULL;

}

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

                                           int height, int bpp, Uint32 flags) {    

    unsigned int style;

    NSRect rect;    

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

#if 1 // FIXME - the resize button doesn't show?  Also need resize events...

    flags &= ~SDL_RESIZABLE;

#endif

    /* Set the window style based on input flags */