src/video/gtk/SDL_gtkvideo.c - third_party/sdl - Git at Google

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