/*

SDL - Simple DirectMedia Layer

Copyright (C) 1997-2006 Sam Lantinga

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 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

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

*/

#include "SDL_config.h"

/*

* GTK+ SDL video driver implementation; this is a little like a pared-down

* version of the X11 driver. You almost certainly do NOT want this target

* on a desktop machine. This was written for the One Laptop Per Child

* project so they wouldn't need to use the SDL_WINDOWID hack with the X11

* driver and compete for the event queue.

*

* Initial work by Ryan C. Gordon (icculus@icculus.org). A good portion

* of this was cut-and-pasted from the dummy video target just to have a

* starting point for the bare minimum to fill in, and some was lifted from

* the x11 target.

*/

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "../SDL_sysvideo.h"

#include "../SDL_pixels_c.h"

#include "../../events/SDL_events_c.h"

#include "SDL_gtkvideo.h"

#include "SDL_gtkevents_c.h"

#include "SDL_gtkmouse_c.h"

#define GTKPLUSVID_DRIVER_NAME "gtk"

/* Initialization/Query functions */

static int GTKPLUS_VideoInit(_THIS, SDL_PixelFormat *vformat);

static SDL_Rect **GTKPLUS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);

static SDL_Surface *GTKPLUS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);

static int GTKPLUS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);

static void GTKPLUS_VideoQuit(_THIS);

/* Hardware surface functions */

static int GTKPLUS_AllocHWSurface(_THIS, SDL_Surface *surface);

static int GTKPLUS_LockHWSurface(_THIS, SDL_Surface *surface);

static void GTKPLUS_UnlockHWSurface(_THIS, SDL_Surface *surface);

static void GTKPLUS_FreeHWSurface(_THIS, SDL_Surface *surface);

static void GTKPLUS_SetCaption(_THIS, const char *title, const char *icon);

/* etc. */

static void GTKPLUS_UpdateRects(_THIS, int numrects, SDL_Rect *rects);

/* GTKPLUS driver bootstrap functions */

static int do_gtk_init(void)

{

static int initted = 0;

if (!initted) { /* !!! FIXME: I can't see a way to deinit gtk... */

int tmpargc = 0;

char *args[] = { NULL, NULL };

char **tmpargv = args;

initted = (gtk_init_check(&tmpargc, &tmpargv));

}

return initted;

}

static int GTKPLUS_Available(void)

{

return 1; /* !!! FIXME */

}

static void GTKPLUS_DeleteDevice(SDL_VideoDevice *device)

{

SDL_free(device->hidden);

SDL_free(device);

}

static SDL_VideoDevice *GTKPLUS_CreateDevice(int devindex)

{

SDL_VideoDevice *device;

/* Initialize all variables that we clean on shutdown */

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

if ( device ) {

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

device->hidden = (struct SDL_PrivateVideoData *)

SDL_malloc((sizeof *device->hidden));

}

if ( (device == NULL) || (device->hidden == NULL) ) {

SDL_OutOfMemory();

if ( device ) {

SDL_free(device);

}

return(0);

}

SDL_memset(device->hidden, 0, (sizeof *device->hidden));

device->handles_any_size = 1;

/* Set the function pointers */

device->VideoInit = GTKPLUS_VideoInit;

device->ListModes = GTKPLUS_ListModes;

device->SetVideoMode = GTKPLUS_SetVideoMode;

device->CreateYUVOverlay = NULL;

device->SetColors = GTKPLUS_SetColors;

device->UpdateRects = GTKPLUS_UpdateRects;

device->VideoQuit = GTKPLUS_VideoQuit;

device->AllocHWSurface = GTKPLUS_AllocHWSurface;

device->CheckHWBlit = NULL;

device->FillHWRect = NULL;

device->SetHWColorKey = NULL;

device->SetHWAlpha = NULL;

device->LockHWSurface = GTKPLUS_LockHWSurface;

device->UnlockHWSurface = GTKPLUS_UnlockHWSurface;

device->FlipHWSurface = NULL;

device->FreeHWSurface = GTKPLUS_FreeHWSurface;

device->SetCaption = GTKPLUS_SetCaption;

device->SetIcon = NULL;

device->IconifyWindow = NULL;

device->GrabInput = NULL;

device->GetWMInfo = NULL;

device->InitOSKeymap = GTKPLUS_InitOSKeymap;

device->PumpEvents = GTKPLUS_PumpEvents;

device->free = GTKPLUS_DeleteDevice;

return device;

}

VideoBootStrap GTKPLUS_bootstrap = {

GTKPLUSVID_DRIVER_NAME, "SDL GTK+ video driver",

GTKPLUS_Available, GTKPLUS_CreateDevice

};

static int add_visual(_THIS, int depth, GdkVisualType vistype)

{

GdkVisual *vi = gdk_visual_get_best_with_both(depth, vistype);

if(vi != NULL) {

g_object_ref(vi);

this->hidden->visuals[this->hidden->nvisuals++] = vi;

}

return(this->hidden->nvisuals);

}

static int GTKPLUS_GetVideoModes(_THIS)

{

const gint screen_w = gdk_screen_width();

const gint screen_h = gdk_screen_height();

int i, n;

{

/* It's interesting to note that if we allow 32 bit depths (on X11),

we get a visual with an alpha mask on composite servers.

static int depth_list[] = { 32, 24, 16, 15, 8 };

*/

static int depth_list[] = { 24, 16, 15, 8 };

int use_directcolor = 1;

/* Search for the visuals in deepest-first order, so that the first

will be the richest one */

if ( SDL_getenv("SDL_VIDEO_GTK_NODIRECTCOLOR") ) {

use_directcolor = 0;

}

this->hidden->nvisuals = 0;

for ( i=0; i<SDL_arraysize(depth_list); ++i ) {

if ( depth_list[i] > 8 ) {

if ( use_directcolor ) {

add_visual(this, depth_list[i], GDK_VISUAL_DIRECT_COLOR);

}

add_visual(this, depth_list[i], GDK_VISUAL_TRUE_COLOR);

} else {

add_visual(this, depth_list[i], GDK_VISUAL_PSEUDO_COLOR);

add_visual(this, depth_list[i], GDK_VISUAL_STATIC_COLOR);

}

}

if ( this->hidden->nvisuals == 0 ) {

SDL_SetError("Found no sufficiently capable GTK+ visuals");

return -1;

}

}

return 0;

}

int GTKPLUS_VideoInit(_THIS, SDL_PixelFormat *vformat)

{

GdkVisual *sysvis = NULL;

int i;

if (!do_gtk_init()) {

return -1;

}

/* Get the available video modes */

if(GTKPLUS_GetVideoModes(this) < 0)

return -1;

/* Determine the current screen size */

this->info.current_w = gdk_screen_width();

this->info.current_h = gdk_screen_height();

/* Determine the default screen depth:

Use the default visual (or at least one with the same depth) */

this->hidden->display_colormap = gdk_colormap_get_system(); /* !!! FIXME: refcount? */

sysvis = gdk_visual_get_system(); /* !!! FIXME: refcount? */

for(i = 0; i < this->hidden->nvisuals; i++) {

if(this->hidden->visuals[i]->depth == sysvis->depth)

break;

}

if(i == this->hidden->nvisuals) {

/* default visual was useless, take the deepest one instead */

i = 0;

}

this->hidden->visual = this->hidden->visuals[i];

if ( this->hidden->visual == sysvis ) { /* !!! FIXME: same pointer? */

this->hidden->colormap = this->hidden->display_colormap;

g_object_ref(this->hidden->colormap);

} else {

this->hidden->colormap = gdk_colormap_new(this->hidden->visual, FALSE);

}

// !!! FIXME: this is not a public GDK symbol!!

vformat->BitsPerPixel = _gdk_windowing_get_bits_for_depth(

gdk_display_get_default(),

this->hidden->visuals[i]->depth);

this->hidden->depth = vformat->BitsPerPixel;

if ( vformat->BitsPerPixel > 8 ) {

vformat->Rmask = this->hidden->visual->red_mask;

vformat->Gmask = this->hidden->visual->green_mask;

vformat->Bmask = this->hidden->visual->blue_mask;

}

if ( this->hidden->depth == 32 ) {

vformat->Amask = (0xFFFFFFFF & ~(vformat->Rmask|vformat->Gmask|vformat->Bmask));

}

#if 0

/* Create the fullscreen and managed windows */

create_aux_windows(this);

/* Create the blank cursor */

SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,

BLANK_CWIDTH, BLANK_CHEIGHT,

BLANK_CHOTX, BLANK_CHOTY);

/* Allow environment override of screensaver disable. */

env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");

this->hidden->allow_screensaver = ( (env && SDL_atoi(env)) ? 1 : 0 );

#endif

/* We're done! */

gdk_flush(); /* just in case. */

/* Fill in some window manager capabilities */

this->info.wm_available = 1;

return(0);

}

static GdkVisual *find_visual(_THIS, int bpp)

{

GdkDisplay *display = gdk_display_get_default();

int i;

for ( i = 0; i < this->hidden->nvisuals; i++ ) {

const int videpth = this->hidden->visuals[i]->depth;

// !!! FIXME: this is not a public GDK symbol!!

const int depth = _gdk_windowing_get_bits_for_depth(display, videpth);

if ( depth == bpp )

break;

}

if ( i == this->hidden->nvisuals ) {

SDL_SetError("No matching visual for requested depth");

return NULL; /* should never happen */

}

return this->hidden->visuals[i];

}

SDL_Rect **GTKPLUS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)

{

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

if (find_visual(this, format->BitsPerPixel) != NULL) {

return (SDL_Rect **) -1; /* !!! FIXME: maybe not right. */

}

}

return NULL; /* unsupported. */

}

SDL_Surface *GTKPLUS_SetVideoMode(_THIS, SDL_Surface *current,

int width, int height, int bpp, Uint32 flags)

{

Uint32 Amask = 0;

int vis_change = 0;

GtkWindow *win = NULL;

GdkImage *img = NULL;

GdkVisual *sysvis = gdk_visual_get_system(); /* !!! FIXME: refcount? */

GdkVisual *vis = find_visual(this, bpp);

if (vis == NULL) {

return(NULL);

}

if (flags & SDL_OPENGL) {

SDL_SetError("No OpenGL support in the GTK+ target");

return(NULL);

}

/* These are the only flags we allow here... */

flags &= /*SDL_FULLSCREEN |*/ SDL_RESIZABLE | SDL_NOFRAME | SDL_HWPALETTE;

vis_change = (vis != this->hidden->visual);

this->hidden->visual = vis;

this->hidden->depth = vis->depth;

/* Allocate the new pixel format for this video mode */

if ( this->hidden->depth == 32 ) {

Amask = (0xFFFFFFFF & ~(vis->red_mask|vis->green_mask|vis->blue_mask));

} else {

Amask = 0;

}

if ( ! SDL_ReallocFormat(current, bpp,

vis->red_mask, vis->green_mask, vis->blue_mask, Amask) ) {

return NULL;

}

/* Create the appropriate colormap */

g_object_unref(this->hidden->colormap);

this->hidden->colormap = NULL;

if ( this->hidden->visual->type == GDK_VISUAL_PSEUDO_COLOR ) {

int ncolors;

/* Allocate the pixel flags */

ncolors = this->hidden->visual->colormap_size;

#if 0

SDL_XPixels = SDL_malloc(ncolors * sizeof(int));

if(SDL_XPixels == NULL) {

SDL_OutOfMemory();

return -1;

}

SDL_memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels));

#endif

/* always allocate a private colormap on non-default visuals */

if ( this->hidden->visual != sysvis ) {

flags |= SDL_HWPALETTE;

}

if ( flags & SDL_HWPALETTE ) {

current->flags |= SDL_HWPALETTE;

this->hidden->colormap = gdk_colormap_new(this->hidden->visual, TRUE);

} else {

this->hidden->colormap = this->hidden->display_colormap;

g_object_ref(this->hidden->colormap);

}

} else if ( this->hidden->visual->type == GDK_VISUAL_DIRECT_COLOR ) {

/* Create a colormap which we can manipulate for gamma */

this->hidden->colormap = gdk_colormap_new(this->hidden->visual, TRUE);

gdk_flush();

/* Initialize the colormap to the identity mapping */

SDL_GetGammaRamp(0, 0, 0);

this->screen = current;

#if 0 // !!! FIXME

GTKPLUS_SetGammaRamp(this, this->gamma);

#endif

this->screen = NULL;

} else {

/* Create a read-only colormap for our window */

this->hidden->colormap = gdk_colormap_new(this->hidden->visual, FALSE);

}

#if 0 // !!! FIXME

/* Recreate the auxiliary windows, if needed (required for GL) */

if ( vis_change )

create_aux_windows(this);

if(current->flags & SDL_HWPALETTE) {

/* Since the full-screen window might have got a nonzero background

colour (0 is white on some displays), we should reset the

background to 0 here since that is what the user expects

with a private colormap */

XSetWindowBackground(SDL_Display, FSwindow, 0);

XClearWindow(SDL_Display, FSwindow);

}

/* resize the (possibly new) window manager window */

if( !SDL_windowid ) {

X11_SetSizeHints(this, w, h, flags);

window_w = w;

window_h = h;

XResizeWindow(SDL_Display, WMwindow, w, h);

}

#endif

if ( this->hidden->gdkimage ) {

g_object_unref(this->hidden->gdkimage);

this->hidden->gdkimage = NULL;

}

img = this->hidden->gdkimage = gdk_image_new(GDK_IMAGE_FASTEST,

vis, width, height);

if (img == NULL) {

SDL_SetError("Couldn't allocate buffer for requested mode");

return(NULL);

}

gdk_image_set_colormap(this->hidden->gdkimage, this->hidden->colormap);

SDL_memset(img->mem, 0, height * img->bpl);

if ( this->hidden->gtkwindow == NULL ) {

this->hidden->gtkdrawingarea = gtk_drawing_area_new();

if ( this->hidden->gtkdrawingarea == NULL ) {

SDL_SetError("Couldn't create drawing area for requested mode");

g_object_unref(this->hidden->gdkimage);

this->hidden->gdkimage = NULL;

return(NULL);

}

this->hidden->gtkwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);

if ( this->hidden->gtkwindow == NULL ) {

SDL_SetError("Couldn't create window for requested mode");

g_object_unref(this->hidden->gdkimage);

g_object_unref(this->hidden->gtkdrawingarea);

this->hidden->gdkimage = NULL;

this->hidden->gtkdrawingarea = NULL;

return(NULL);

}

gtk_window_set_title(GTK_WINDOW(this->hidden->gtkwindow), "");

gtk_widget_set_app_paintable(this->hidden->gtkwindow, TRUE);

gtk_widget_set_app_paintable(this->hidden->gtkdrawingarea, TRUE);

gtk_widget_set_double_buffered(this->hidden->gtkwindow, FALSE);

gtk_widget_set_double_buffered(this->hidden->gtkdrawingarea, FALSE);

GTKPLUS_ConnectSignals(this);

gtk_container_add(GTK_CONTAINER(this->hidden->gtkwindow),

this->hidden->gtkdrawingarea);

}

win = GTK_WINDOW(this->hidden->gtkwindow);

gtk_widget_set_colormap(this->hidden->gtkdrawingarea, this->hidden->colormap);

// !!! FIXME

#if 0

/* Cache the window in the server, when possible */

{

Screen *xscreen;

XSetWindowAttributes a;

xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen);

a.backing_store = DoesBackingStore(xscreen);

if ( a.backing_store != NotUseful ) {

XChangeWindowAttributes(SDL_Display, SDL_Window,

CWBackingStore, &a);

}

}

/* Update the internal keyboard state */

X11_SetKeyboardState(SDL_Display, NULL);

/* When the window is first mapped, ignore non-modifier keys */

{

Uint8 *keys = SDL_GetKeyState(NULL);

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

switch (i) {

case SDLK_NUMLOCK:

case SDLK_CAPSLOCK:

case SDLK_LCTRL:

case SDLK_RCTRL:

case SDLK_LSHIFT:

case SDLK_RSHIFT:

case SDLK_LALT:

case SDLK_RALT:

case SDLK_LMETA:

case SDLK_RMETA:

case SDLK_MODE:

break;

default:

keys[i] = SDL_RELEASED;

break;

}

}

}

/* Map them both and go fullscreen, if requested */

if ( ! SDL_windowid ) {

XMapWindow(SDL_Display, SDL_Window);

XMapWindow(SDL_Display, WMwindow);

X11_WaitMapped(this, WMwindow);

if ( flags & SDL_FULLSCREEN ) {

current->flags |= SDL_FULLSCREEN;

X11_EnterFullScreen(this);

} else {

current->flags &= ~SDL_FULLSCREEN;

}

}

#endif

if ((flags & SDL_FULLSCREEN) == 0) {

gtk_window_unfullscreen(win);

} else {

gtk_window_fullscreen(win);

flags &= ~SDL_RESIZABLE;

flags |= SDL_NOFRAME;

}

gtk_window_set_resizable(win, (flags & SDL_RESIZABLE) ? TRUE : FALSE);

gtk_window_set_decorated(win, (flags & SDL_NOFRAME) ? FALSE : TRUE);

gtk_window_resize(win, width, height);

gtk_widget_set_size_request(this->hidden->gtkdrawingarea, width, height);

gtk_widget_show(this->hidden->gtkdrawingarea);

gtk_widget_show(this->hidden->gtkwindow);

/* Set up the new mode framebuffer */

current->w = width;

current->h = height;

//current->format->depth = vis->bits_per_rgb;

current->flags = flags | SDL_PREALLOC;

current->pitch = img->bpl;

current->pixels = this->hidden->gdkimage->mem;

/* We're done */

return(current);

}

static void GTKPLUS_SetCaption(_THIS, const char *title, const char *icon)

{

gtk_window_set_title(GTK_WINDOW(this->hidden->gtkwindow),

(const gchar *) title);

}

/* We don't actually allow hardware surfaces. */

static int GTKPLUS_AllocHWSurface(_THIS, SDL_Surface *surface)

{

return(-1);

}

static void GTKPLUS_FreeHWSurface(_THIS, SDL_Surface *surface)

{

}

/* We need to wait for vertical retrace on page flipped displays */

static int GTKPLUS_LockHWSurface(_THIS, SDL_Surface *surface)

{

return(0);

}

static void GTKPLUS_UnlockHWSurface(_THIS, SDL_Surface *surface)

{

}

static void GTKPLUS_UpdateRects(_THIS, int numrects, SDL_Rect *rects)

{

if ( (this->hidden->gtkdrawingarea != NULL) &&

(GTK_WIDGET_DRAWABLE(this->hidden->gtkdrawingarea)) &&

(numrects > 0) ) {

GdkDrawable *draw = GDK_DRAWABLE(this->hidden->gtkdrawingarea->window);

if (this->hidden->gc == NULL) {

this->hidden->gc = gdk_gc_new(draw);

}

if (this->hidden->gc != NULL) {

GdkImage *img = this->hidden->gdkimage;

const SDL_Rect *r = rects;

int i;

for (i = 0; i < numrects; i++, r++) {

const gint x = r->x;

const gint y = r->y;

gdk_draw_image(draw, this->hidden->gc, img,

x, y, x, y, r->w, r->h);

}

gdk_flush(); /* transfer the GdkImage so we can make changes. */

}

}

}

int GTKPLUS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)

{

/* !!! FIXME */

return(0);

}

/* Note: If we are terminated, this could be called in the middle of

another SDL video routine -- notably UpdateRects.

*/

void GTKPLUS_VideoQuit(_THIS)

{

int i;

gdk_flush();

if (this->hidden->gc != NULL) {

g_object_unref(this->hidden->gc);

this->hidden->gc = NULL;

}

if ( this->hidden->gtkwindow ) {

/* this deletes the drawing area widget, too. */

gtk_widget_destroy(this->hidden->gtkwindow);

this->hidden->gtkwindow = NULL;

}

if ( this->hidden->gdkimage ) {

g_object_unref(this->hidden->gdkimage);

this->hidden->gdkimage = NULL;

}

for (i = 0; i < this->hidden->nvisuals; i++) {

g_object_unref(this->hidden->visuals[i]);

this->hidden->visuals[i] = NULL;

}

this->hidden->nvisuals = 0;

g_object_unref(this->hidden->colormap);

this->hidden->colormap = NULL;

gdk_flush();

}