sdl-ios-xcode: src/video/SDL_video.c comparison

comparison src/video/SDL_video.c @ 1895:c121d94672cb

SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.

author	Sam Lantinga <slouken@libsdl.org>
date	Mon, 10 Jul 2006 21:04:37 +0000
parents	eacc5bc01d1c
children	c2a27da60b18

comparison

equal deleted inserted replaced

-:c69cee13dd76
+:c121d94672cb
 #include "SDL.h"
 #include "SDL_sysvideo.h"
 #include "SDL_blit.h"
 #include "SDL_pixels_c.h"
-#include "SDL_cursor_c.h"
+#include "SDL_renderer_sw.h"
 #include "../events/SDL_sysevents.h"
 #include "../events/SDL_events_c.h"
 /* Available video drivers */
 static VideoBootStrap *bootstrap[] = {
 #if SDL_VIDEO_DRIVER_QUARTZ
-	&QZ_bootstrap,
+&QZ_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_X11
-	&X11_bootstrap,
+&X11_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_DGA
-	&DGA_bootstrap,
+&DGA_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_NANOX
-	&NX_bootstrap,
+&NX_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_IPOD
-	&iPod_bootstrap,
+&iPod_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_QTOPIA
-	&Qtopia_bootstrap,
+&Qtopia_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_WSCONS
-	&WSCONS_bootstrap,
+&WSCONS_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_FBCON
-	&FBCON_bootstrap,
+&FBCON_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_DIRECTFB
-	&DirectFB_bootstrap,
+&DirectFB_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_PS2GS
-	&PS2GS_bootstrap,
+&PS2GS_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_GGI
-	&GGI_bootstrap,
+&GGI_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_VGL
-	&VGL_bootstrap,
+&VGL_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_SVGALIB
-	&SVGALIB_bootstrap,
+&SVGALIB_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_GAPI
-	&GAPI_bootstrap,
+&GAPI_bootstrap,
 #endif
-#if SDL_VIDEO_DRIVER_WINDIB
+#if SDL_VIDEO_DRIVER_WIN32
-	&WINDIB_bootstrap,
+&WIN32_bootstrap,
-#endif
-#if SDL_VIDEO_DRIVER_DDRAW
-	&DIRECTX_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_BWINDOW
-	&BWINDOW_bootstrap,
+&BWINDOW_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_TOOLBOX
-	&TOOLBOX_bootstrap,
+&TOOLBOX_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_DRAWSPROCKET
-	&DSp_bootstrap,
+&DSp_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_CYBERGRAPHICS
-	&CGX_bootstrap,
+&CGX_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_PHOTON
-	&ph_bootstrap,
+&ph_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_EPOC
-	&EPOC_bootstrap,
+&EPOC_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_XBIOS
-	&XBIOS_bootstrap,
+&XBIOS_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_GEM
-	&GEM_bootstrap,
+&GEM_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_PICOGUI
-	&PG_bootstrap,
+&PG_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_DC
-	&DC_bootstrap,
+&DC_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_RISCOS
-	&RISCOS_bootstrap,
+&RISCOS_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_OS2FS
-	&OS2FSLib_bootstrap,
+&OS2FSLib_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_AALIB
-	&AALIB_bootstrap,
+&AALIB_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_DUMMY
-	&DUMMY_bootstrap,
+&DUMMY_bootstrap,
 #endif
-	NULL
+#if SDL_VIDEO_DRIVER_GLSDL
+&glSDL_bootstrap,
+#endif
+NULL
 };
-SDL_VideoDevice *current_video = NULL;
+static SDL_VideoDevice *_this = NULL;
 /* Various local functions */
 int SDL_VideoInit(const char *driver_name, Uint32 flags);
 void SDL_VideoQuit(void);
-void SDL_GL_UpdateRectsLock(SDL_VideoDevice* this, int numrects, SDL_Rect* rects);
+static int
-static SDL_GrabMode SDL_WM_GrabInputOff(void);
+cmpmodes(const void *A, const void *B)
-#if SDL_VIDEO_OPENGL
+{
-static int lock_count = 0;
+SDL_DisplayMode a = *(const SDL_DisplayMode *) A;
-#endif
+SDL_DisplayMode b = *(const SDL_DisplayMode *) B;
+if (a.w != b.w) {
+return b.w - a.w;
+}
+if (a.h != b.h) {
+return b.h - a.h;
+}
+if (SDL_BITSPERPIXEL(a.format) != SDL_BITSPERPIXEL(b.format)) {
+return SDL_BITSPERPIXEL(b.format) - SDL_BITSPERPIXEL(a.format);
+}
+if (a.refresh_rate != b.refresh_rate) {
+return b.refresh_rate - a.refresh_rate;
+}
+return 0;
+}
+int
+SDL_GetNumVideoDrivers(void)
+{
+return SDL_arraysize(bootstrap) - 1;
+}
+const char *
+SDL_GetVideoDriver(int index)
+{
+if (index >= 0 && index < SDL_GetNumVideoDrivers()) {
+return bootstrap[index]->name;
+}
+return NULL;
+}
 /*
 * Initialize the video and event subsystems -- determine native pixel format
 */
-int SDL_VideoInit (const char *driver_name, Uint32 flags)
+int
-{
+SDL_VideoInit(const char *driver_name, Uint32 flags)
-	SDL_VideoDevice *video;
+{
-	int index;
+SDL_VideoDevice *video;
-	int i;
+int index;
-	SDL_PixelFormat vformat;
+int i;
-	Uint32 video_flags;
+/* Toggle the event thread flags, based on OS requirements */
-	/* Toggle the event thread flags, based on OS requirements */
 #if defined(MUST_THREAD_EVENTS)
-	flags |= SDL_INIT_EVENTTHREAD;
+flags |= SDL_INIT_EVENTTHREAD;
 #elif defined(CANT_THREAD_EVENTS)
-	if ( (flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD ) {
+if ((flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD) {
-		SDL_SetError("OS doesn't support threaded events");
+SDL_SetError("OS doesn't support threaded events");
-		return(-1);
+return -1;
-	}
+}
 #endif
-	/* Check to make sure we don't overwrite 'current_video' */
+/* Start the event loop */
-	if ( current_video != NULL ) {
+if (SDL_StartEventLoop(flags) < 0) {
-		SDL_VideoQuit();
+return -1;
-	}
+}
-	/* Select the proper video driver */
+/* Check to make sure we don't overwrite '_this' */
-	index = 0;
+if (_this != NULL) {
-	video = NULL;
+SDL_VideoQuit();
-	if ( driver_name != NULL ) {
+}
-#if 0	/* This will be replaced with a better driver selection API */
-		if ( SDL_strrchr(driver_name, ':') != NULL ) {
+/* Select the proper video driver */
-			index = atoi(SDL_strrchr(driver_name, ':')+1);
+index = 0;
-		}
+video = NULL;
-#endif
+if (driver_name != NULL) {
-		for ( i=0; bootstrap[i]; ++i ) {
+for (i = 0; bootstrap[i]; ++i) {
-			if ( SDL_strncmp(bootstrap[i]->name, driver_name,
+if (SDL_strncmp(bootstrap[i]->name, driver_name,
-			             SDL_strlen(bootstrap[i]->name)) == 0 ) {
+SDL_strlen(bootstrap[i]->name)) == 0) {
-				if ( bootstrap[i]->available() ) {
+if (bootstrap[i]->available()) {
-					video = bootstrap[i]->create(index);
+video = bootstrap[i]->create(index);
-					break;
+}
-				}
+break;
-			}
+}
-		}
+}
-	} else {
+} else {
-		for ( i=0; bootstrap[i]; ++i ) {
+for (i = 0; bootstrap[i]; ++i) {
-			if ( bootstrap[i]->available() ) {
+if (bootstrap[i]->available()) {
-				video = bootstrap[i]->create(index);
+video = bootstrap[i]->create(index);
-				if ( video != NULL ) {
+if (video != NULL) {
-					break;
+break;
-				}
+}
-			}
+}
-		}
+}
-	}
+}
-	if ( video == NULL ) {
+if (video == NULL) {
-		SDL_SetError("No available video device");
+if (driver_name) {
-		return(-1);
+SDL_SetError("%s not available", driver_name);
-	}
+} else {
-	current_video = video;
+SDL_SetError("No available video device");
-	current_video->name = bootstrap[i]->name;
+}
+return -1;
-	/* Do some basic variable initialization */
+}
-	video->screen = NULL;
+_this = video;
-	video->shadow = NULL;
+_this->name = bootstrap[i]->name;
-	video->visible = NULL;
+_this->next_object_id = 1;
-	video->physpal = NULL;
-	video->gammacols = NULL;
-	video->gamma = NULL;
+/* Set some very sane GL defaults */
-	video->wm_title = NULL;
+_this->gl_config.driver_loaded = 0;
-	video->wm_icon  = NULL;
+_this->gl_config.dll_handle = NULL;
-	video->offset_x = 0;
+_this->gl_config.red_size = 3;
-	video->offset_y = 0;
+_this->gl_config.green_size = 3;
-	SDL_memset(&video->info, 0, (sizeof video->info));
+_this->gl_config.blue_size = 2;
+_this->gl_config.alpha_size = 0;
-	video->displayformatalphapixel = NULL;
+_this->gl_config.buffer_size = 0;
+_this->gl_config.depth_size = 16;
-	/* Set some very sane GL defaults */
+_this->gl_config.stencil_size = 0;
-	video->gl_config.driver_loaded = 0;
+_this->gl_config.double_buffer = 1;
-	video->gl_config.dll_handle = NULL;
+_this->gl_config.accum_red_size = 0;
-	video->gl_config.red_size = 3;
+_this->gl_config.accum_green_size = 0;
-	video->gl_config.green_size = 3;
+_this->gl_config.accum_blue_size = 0;
-	video->gl_config.blue_size = 2;
+_this->gl_config.accum_alpha_size = 0;
-	video->gl_config.alpha_size = 0;
+_this->gl_config.stereo = 0;
-	video->gl_config.buffer_size = 0;
+_this->gl_config.multisamplebuffers = 0;
-	video->gl_config.depth_size = 16;
+_this->gl_config.multisamplesamples = 0;
-	video->gl_config.stencil_size = 0;
+_this->gl_config.accelerated = -1;  /* not known, don't set */
-	video->gl_config.double_buffer = 1;
-	video->gl_config.accum_red_size = 0;
+/* Initialize the video subsystem */
-	video->gl_config.accum_green_size = 0;
+if (_this->VideoInit(_this) < 0) {
-	video->gl_config.accum_blue_size = 0;
+SDL_VideoQuit();
-	video->gl_config.accum_alpha_size = 0;
+return -1;
-	video->gl_config.stereo = 0;
+}
-	video->gl_config.multisamplebuffers = 0;
-	video->gl_config.multisamplesamples = 0;
+/* Make sure some displays were added */
-	video->gl_config.accelerated = -1; /* not known, don't set */
+if (_this->num_displays == 0) {
-	video->gl_config.swap_control = -1; /* not known, don't set */
+SDL_SetError("The video driver did not add any displays");
+SDL_VideoQuit();
-	/* Initialize the video subsystem */
+return (-1);
-	SDL_memset(&vformat, 0, sizeof(vformat));
+}
-	if ( video->VideoInit(video, &vformat) < 0 ) {
-		SDL_VideoQuit();
+/* The software renderer is always available */
-		return(-1);
+for (i = 0; i < _this->num_displays; ++i) {
-	}
+if (_this->displays[i].num_render_drivers > 0) {
+SDL_AddRenderDriver(i, &SDL_SW_RenderDriver);
-	/* Create a zero sized video surface of the appropriate format */
+}
-	video_flags = SDL_SWSURFACE;
+}
-	SDL_VideoSurface = SDL_CreateRGBSurface(video_flags, 0, 0,
-				vformat.BitsPerPixel,
+/* We're ready to go! */
-				vformat.Rmask, vformat.Gmask, vformat.Bmask, 0);
+return 0;
-	if ( SDL_VideoSurface == NULL ) {
+}
-		SDL_VideoQuit();
-		return(-1);
+const char *
-	}
+SDL_GetCurrentVideoDriver()
-	SDL_PublicSurface = NULL;	/* Until SDL_SetVideoMode() */
+{
+if (!_this) {
-#if 0 /* Don't change the current palette - may be used by other programs.
+return NULL;
-* The application can't do anything with the display surface until
+}
-* a video mode has been set anyway. :)
+return _this->name;
-*/
+}
-	/* If we have a palettized surface, create a default palette */
-	if ( SDL_VideoSurface->format->palette ) {
+SDL_VideoDevice *
-		SDL_PixelFormat *vf = SDL_VideoSurface->format;
+SDL_GetVideoDevice()
-		SDL_DitherColors(vf->palette->colors, vf->BitsPerPixel);
+{
-		video->SetColors(video,
+return _this;
-				 0, vf->palette->ncolors, vf->palette->colors);
+}
-	}
-#endif
+int
-	video->info.vfmt = SDL_VideoSurface->format;
+SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode)
+{
-	/* Start the event loop */
+SDL_VideoDisplay display;
-	if ( SDL_StartEventLoop(flags) < 0 ) {
-		SDL_VideoQuit();
+SDL_zero(display);
-		return(-1);
+if (desktop_mode) {
-	}
+display.desktop_mode = *desktop_mode;
-	SDL_CursorInit(flags & SDL_INIT_EVENTTHREAD);
+}
+display.current_mode = display.desktop_mode;
-	/* We're ready to go! */
-	return(0);
+return SDL_AddVideoDisplay(&display);
 }
-char *SDL_VideoDriverName(char *namebuf, int maxlen)
+int
-{
+SDL_AddVideoDisplay(const SDL_VideoDisplay * display)
-	if ( current_video != NULL ) {
+{
-		SDL_strlcpy(namebuf, current_video->name, maxlen);
+SDL_VideoDisplay *displays;
-		return(namebuf);
+int index = -1;
-	}
-	return(NULL);
+displays =
-}
+SDL_realloc(_this->displays,
+(_this->num_displays + 1) * sizeof(*displays));
-/*
+if (displays) {
-* Get the current display surface
+index = _this->num_displays++;
-*/
+displays[index] = *display;
-SDL_Surface *SDL_GetVideoSurface(void)
+displays[index].device = _this;
-{
+_this->displays = displays;
-	SDL_Surface *visible;
+} else {
+SDL_OutOfMemory();
-	visible = NULL;
+}
-	if ( current_video ) {
+return index;
-		visible = current_video->visible;
+}
-	}
-	return(visible);
+int
-}
+SDL_GetNumVideoDisplays(void)
+{
-/*
+if (!_this) {
-* Get the current information about the video hardware
+return 0;
-*/
+}
-const SDL_VideoInfo *SDL_GetVideoInfo(void)
+return _this->num_displays;
-{
+}
-	const SDL_VideoInfo *info;
+int
-	info = NULL;
+SDL_SelectVideoDisplay(int index)
-	if ( current_video ) {
+{
-		info = &current_video->info;
+if (!_this) {
-	}
+SDL_SetError("Video subsystem has not been initialized");
-	return(info);
+return (-1);
 }
+if (index >= 0) {
-/*
+if (index >= _this->num_displays) {
-* Return a pointer to an array of available screen dimensions for the
+SDL_SetError("index must be in the range 0 - %d",
-* given format, sorted largest to smallest.  Returns NULL if there are
+_this->num_displays - 1);
-* no dimensions available for a particular format, or (SDL_Rect **)-1
+return -1;
-* if any dimension is okay for the given format.  If 'format' is NULL,
+}
-* the mode list will be for the format given by SDL_GetVideoInfo()->vfmt
+_this->current_display = index;
-*/
+}
-SDL_Rect ** SDL_ListModes (SDL_PixelFormat *format, Uint32 flags)
+return _this->current_display;
-{
+}
-	SDL_VideoDevice *video = current_video;
-	SDL_VideoDevice *this  = current_video;
+SDL_bool
-	SDL_Rect **modes;
+SDL_AddDisplayMode(int displayIndex, const SDL_DisplayMode * mode)
+{
-	modes = NULL;
+SDL_VideoDisplay *display = &_this->displays[displayIndex];
-	if ( SDL_VideoSurface ) {
+SDL_DisplayMode *modes;
-		if ( format == NULL ) {
+int i, nmodes;
-			format = SDL_VideoSurface->format;
-		}
+/* Make sure we don't already have the mode in the list */
-		modes = video->ListModes(this, format, flags);
+modes = display->display_modes;
-	}
+nmodes = display->num_display_modes;
-	return(modes);
+for (i = nmodes; i--;) {
-}
+if (SDL_memcmp(mode, &modes[i], sizeof(*mode)) == 0) {
+return SDL_FALSE;
-/*
+}
-* Check to see if a particular video mode is supported.
+}
-* It returns 0 if the requested mode is not supported under any bit depth,
-* or returns the bits-per-pixel of the closest available mode with the
+/* Go ahead and add the new mode */
-* given width and height.  If this bits-per-pixel is different from the
+if (nmodes == display->max_display_modes) {
-* one used when setting the video mode, SDL_SetVideoMode() will succeed,
+modes =
-* but will emulate the requested bits-per-pixel with a shadow surface.
+SDL_realloc(modes,
-*/
+(display->max_display_modes + 32) * sizeof(*modes));
-static Uint8 SDL_closest_depths[4][8] = {
+if (!modes) {
-	/* 8 bit closest depth ordering */
+return SDL_FALSE;
-	{ 0, 8, 16, 15, 32, 24, 0, 0 },
+}
-	/* 15,16 bit closest depth ordering */
+display->display_modes = modes;
-	{ 0, 16, 15, 32, 24, 8, 0, 0 },
+display->max_display_modes += 32;
-	/* 24 bit closest depth ordering */
+}
-	{ 0, 24, 32, 16, 15, 8, 0, 0 },
+modes[nmodes] = *mode;
-	/* 32 bit closest depth ordering */
+display->num_display_modes++;
-	{ 0, 32, 16, 15, 24, 8, 0, 0 }
-};
+return SDL_TRUE;
+}
-#ifdef __MACOS__ /* MPW optimization bug? */
+int
-#define NEGATIVE_ONE 0xFFFFFFFF
+SDL_GetNumDisplayModes()
-#else
+{
-#define NEGATIVE_ONE -1
+if (_this) {
-#endif
+SDL_VideoDisplay *display = &SDL_CurrentDisplay;
+if (!display->num_display_modes && _this->GetDisplayModes) {
-int SDL_VideoModeOK (int width, int height, int bpp, Uint32 flags)
+_this->GetDisplayModes(_this);
-{
+SDL_qsort(display->display_modes, display->num_display_modes,
-	int table, b, i;
+sizeof(SDL_DisplayMode), cmpmodes);
-	int supported;
+}
-	SDL_PixelFormat format;
+return display->num_display_modes;
-	SDL_Rect **sizes;
+}
+return 0;
-	/* Currently 1 and 4 bpp are not supported */
+}
-	if ( bpp < 8 || bpp > 32 ) {
-		return(0);
+const SDL_DisplayMode *
-	}
+SDL_GetDisplayMode(int index)
-	if ( (width <= 0) || (height <= 0) ) {
+{
-		return(0);
+if (index < 0 || index >= SDL_GetNumDisplayModes()) {
-	}
+SDL_SetError("index must be in the range of 0 - %d",
+SDL_GetNumDisplayModes() - 1);
-	/* Search through the list valid of modes */
+return NULL;
-	SDL_memset(&format, 0, sizeof(format));
+}
-	supported = 0;
+return &SDL_CurrentDisplay.display_modes[index];
-	table = ((bpp+7)/8)-1;
+}
-	SDL_closest_depths[table][0] = bpp;
-	SDL_closest_depths[table][7] = 0;
+const SDL_DisplayMode *
-	for ( b = 0; !supported && SDL_closest_depths[table][b]; ++b ) {
+SDL_GetDesktopDisplayMode(void)
-		format.BitsPerPixel = SDL_closest_depths[table][b];
+{
-		sizes = SDL_ListModes(&format, flags);
+if (_this) {
-		if ( sizes == (SDL_Rect **)0 ) {
+return &SDL_CurrentDisplay.desktop_mode;
-			/* No sizes supported at this bit-depth */
+}
-			continue;
+return NULL;
-		} else
+}
-		if (sizes == (SDL_Rect **)NEGATIVE_ONE) {
-			/* Any size supported at this bit-depth */
+const SDL_DisplayMode *
-			supported = 1;
+SDL_GetCurrentDisplayMode(void)
-			continue;
+{
-		} else if (current_video->handles_any_size) {
+if (_this) {
-			/* Driver can center a smaller surface to simulate fullscreen */
+return &SDL_CurrentDisplay.current_mode;
-			for ( i=0; sizes[i]; ++i ) {
+}
-				if ((sizes[i]->w >= width) && (sizes[i]->h >= height)) {
+return NULL;
-					supported = 1; /* this mode can fit the centered window. */
+}
-					break;
-				}
+SDL_DisplayMode *
-			}
+SDL_GetClosestDisplayMode(const SDL_DisplayMode * mode,
-		} else
+SDL_DisplayMode * closest)
-		for ( i=0; sizes[i]; ++i ) {
+{
-			if ((sizes[i]->w == width) && (sizes[i]->h == height)) {
+Uint32 target_format;
-				supported = 1;
+int target_refresh_rate;
-				break;
+int i;
-			}
+SDL_DisplayMode *current, *match;
-		}
-	}
+if (!_this || !mode || !closest) {
-	if ( supported ) {
+return NULL;
-		--b;
+}
-		return(SDL_closest_depths[table][b]);
-	} else {
+/* Default to the desktop format */
-		return(0);
+if (mode->format) {
-	}
+target_format = mode->format;
-}
+} else {
+target_format = SDL_CurrentDisplay.desktop_mode.format;
-/*
+}
-* Get the closest non-emulated video mode to the one requested
-*/
+/* Default to the desktop refresh rate */
-static int SDL_GetVideoMode (int *w, int *h, int *BitsPerPixel, Uint32 flags)
+if (mode->refresh_rate) {
-{
+target_refresh_rate = mode->refresh_rate;
-	int table, b, i;
+} else {
-	int supported;
+target_refresh_rate = SDL_CurrentDisplay.desktop_mode.refresh_rate;
-	int native_bpp;
+}
-	SDL_PixelFormat format;
-	SDL_Rect **sizes;
+match = NULL;
+for (i = 0; i < SDL_GetNumDisplayModes(); ++i) {
-	/* Check parameters */
+current = &SDL_CurrentDisplay.display_modes[i];
-	if ( *BitsPerPixel < 8 || *BitsPerPixel > 32 ) {
-		SDL_SetError("Invalid bits per pixel (range is {8...32})");
+if ((current->w && current->h) &&
-		return(0);
+(current->w < mode->w || current->h < mode->h)) {
-	}
+/* Out of sorted modes large enough here */
-	if ((*w <= 0) || (*h <= 0)) {
+break;
-		SDL_SetError("Invalid width or height");
+}
-		return(0);
+if (!match || current->w < match->w || current->h < match->h) {
-	}
+match = current;
+continue;
-	/* Try the original video mode, get the closest depth */
+}
-	native_bpp = SDL_VideoModeOK(*w, *h, *BitsPerPixel, flags);
+if (current->format != match->format) {
-	if ( native_bpp == *BitsPerPixel ) {
+/* Sorted highest depth to lowest */
-		return(1);
+if (current->format == target_format ||
-	}
+(SDL_BITSPERPIXEL(current->format) >=
-	if ( native_bpp > 0 ) {
+SDL_BITSPERPIXEL(target_format)
-		*BitsPerPixel = native_bpp;
+&& SDL_PIXELTYPE(current->format) ==
-		return(1);
+SDL_PIXELTYPE(target_format))) {
-	}
+match = current;
+}
-	/* No exact size match at any depth, look for closest match */
+continue;
-	SDL_memset(&format, 0, sizeof(format));
+}
-	supported = 0;
+if (current->refresh_rate != match->refresh_rate) {
-	table = ((*BitsPerPixel+7)/8)-1;
+/* Sorted highest refresh to lowest */
-	SDL_closest_depths[table][0] = *BitsPerPixel;
+if (current->refresh_rate >= target_refresh_rate) {
-	SDL_closest_depths[table][7] = SDL_VideoSurface->format->BitsPerPixel;
+match = current;
-	for ( b = 0; !supported && SDL_closest_depths[table][b]; ++b ) {
+}
-		int best;
+}
+}
-		format.BitsPerPixel = SDL_closest_depths[table][b];
+if (match) {
-		sizes = SDL_ListModes(&format, flags);
+if (match->format) {
-		if ( sizes == (SDL_Rect **)0 ) {
+closest->format = match->format;
-			/* No sizes supported at this bit-depth */
+} else {
-			continue;
+closest->format = mode->format;
-		}
+}
-		best=0;
+if (match->w && match->h) {
-		for ( i=0; sizes[i]; ++i ) {
+closest->w = match->w;
-			/* Mode with both dimensions bigger or equal than asked ? */
+closest->h = match->h;
-			if ((sizes[i]->w >= *w) && (sizes[i]->h >= *h)) {
+} else {
-				/* Mode with any dimension smaller or equal than current best ? */
+closest->w = mode->w;
-				if ((sizes[i]->w <= sizes[best]->w) || (sizes[i]->h <= sizes[best]->h)) {
+closest->h = mode->h;
-					/* Now choose the mode that has less pixels */
+}
-					if ((sizes[i]->w * sizes[i]->h) <= (sizes[best]->w * sizes[best]->h)) {
+if (match->refresh_rate) {
-						best=i;
+closest->refresh_rate = match->refresh_rate;
-						supported = 1;
+} else {
-					}
+closest->refresh_rate = mode->refresh_rate;
-				}
+}
-			}
+closest->driverdata = match->driverdata;
-		}
-		if (supported) {
+/* Pick some reasonable defaults if the app and driver don't care */
-			*w=sizes[best]->w;
+if (!closest->format) {
-			*h=sizes[best]->h;
+closest->format = SDL_PixelFormat_RGB888;
-			*BitsPerPixel = SDL_closest_depths[table][b];
+}
-		}
+if (!closest->w) {
-	}
+closest->w = 640;
-	if ( ! supported ) {
+}
-		SDL_SetError("No video mode large enough for %dx%d", *w, *h);
+if (!closest->h) {
-	}
+closest->h = 480;
-	return(supported);
+}
-}
+return closest;
+}
-/* This should probably go somewhere else -- like SDL_surface.c */
+return NULL;
-static void SDL_ClearSurface(SDL_Surface *surface)
+}
-{
-	Uint32 black;
+int
+SDL_SetDisplayMode(const SDL_DisplayMode * mode)
-	black = SDL_MapRGB(surface->format, 0, 0, 0);
+{
-	SDL_FillRect(surface, NULL, black);
+SDL_VideoDisplay *display;
-	if ((surface->flags&SDL_HWSURFACE) && (surface->flags&SDL_DOUBLEBUF)) {
+SDL_DisplayMode display_mode;
-		SDL_Flip(surface);
+int i, ncolors;
-		SDL_FillRect(surface, NULL, black);
-	}
+if (!_this) {
-	SDL_Flip(surface);
+SDL_SetError("Video subsystem has not been initialized");
-}
+return -1;
+}
-/*
-* Create a shadow surface suitable for fooling the app. :-)
+if (!mode) {
-*/
+mode = SDL_GetDesktopDisplayMode();
-static void SDL_CreateShadowSurface(int depth)
+}
-{
+display = &SDL_CurrentDisplay;
-	Uint32 Rmask, Gmask, Bmask;
+display_mode = *mode;
-	/* Allocate the shadow surface */
+/* Default to the current mode */
-	if ( depth == (SDL_VideoSurface->format)->BitsPerPixel ) {
+if (!display_mode.format) {
-		Rmask = (SDL_VideoSurface->format)->Rmask;
+display_mode.format = display->current_mode.format;
-		Gmask = (SDL_VideoSurface->format)->Gmask;
+}
-		Bmask = (SDL_VideoSurface->format)->Bmask;
+if (!display_mode.w) {
-	} else {
+display_mode.w = display->current_mode.w;
-		Rmask = Gmask = Bmask = 0;
+}
-	}
+if (!display_mode.h) {
-	SDL_ShadowSurface = SDL_CreateRGBSurface(SDL_SWSURFACE,
+display_mode.h = display->current_mode.h;
-				SDL_VideoSurface->w, SDL_VideoSurface->h,
+}
-						depth, Rmask, Gmask, Bmask, 0);
+if (!display_mode.refresh_rate) {
-	if ( SDL_ShadowSurface == NULL ) {
+display_mode.refresh_rate = display->current_mode.refresh_rate;
-		return;
+}
-	}
+/* Get a good video mode, the closest one possible */
-	/* 8-bit shadow surfaces report that they have exclusive palette */
+if (!SDL_GetClosestDisplayMode(&display_mode, &display_mode)) {
-	if ( SDL_ShadowSurface->format->palette ) {
+SDL_SetError("No video mode large enough for %dx%d",
-		SDL_ShadowSurface->flags |= SDL_HWPALETTE;
+display_mode.w, display_mode.h);
-		if ( depth == (SDL_VideoSurface->format)->BitsPerPixel ) {
+return -1;
-			SDL_memcpy(SDL_ShadowSurface->format->palette->colors,
+}
-				SDL_VideoSurface->format->palette->colors,
-				SDL_VideoSurface->format->palette->ncolors*
+/* See if there's anything left to do */
-							sizeof(SDL_Color));
+if (SDL_memcmp
-		} else {
+(&display_mode, SDL_GetCurrentDisplayMode(),
-			SDL_DitherColors(
+sizeof(display_mode)) == 0) {
-			SDL_ShadowSurface->format->palette->colors, depth);
+return 0;
-		}
+}
-	}
+/* Actually change the display mode */
-	/* If the video surface is resizable, the shadow should say so */
+if (_this->SetDisplayMode(_this, &display_mode) < 0) {
-	if ( (SDL_VideoSurface->flags & SDL_RESIZABLE) == SDL_RESIZABLE ) {
+return -1;
-		SDL_ShadowSurface->flags |= SDL_RESIZABLE;
+}
-	}
+display->current_mode = display_mode;
-	/* If the video surface has no frame, the shadow should say so */
-	if ( (SDL_VideoSurface->flags & SDL_NOFRAME) == SDL_NOFRAME ) {
+/* Set up a palette, if necessary */
-		SDL_ShadowSurface->flags |= SDL_NOFRAME;
+if (SDL_ISPIXELFORMAT_INDEXED(display_mode.format)) {
-	}
+ncolors = (1 << SDL_BITSPERPIXEL(display_mode.format));
-	/* If the video surface is fullscreen, the shadow should say so */
+} else {
-	if ( (SDL_VideoSurface->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
+ncolors = 0;
-		SDL_ShadowSurface->flags |= SDL_FULLSCREEN;
+}
-	}
+if ((!ncolors && display->palette) || (ncolors && !display->palette)
-	/* If the video surface is flippable, the shadow should say so */
+|| (ncolors && ncolors != display->palette->ncolors)) {
-	if ( (SDL_VideoSurface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
+if (display->palette) {
-		SDL_ShadowSurface->flags |= SDL_DOUBLEBUF;
+SDL_FreePalette(display->palette);
-	}
+display->palette = NULL;
-	return;
+}
-}
+if (ncolors) {
+display->palette = SDL_AllocPalette(ncolors);
-#ifdef __QNXNTO__
+if (!display->palette) {
-#include <sys/neutrino.h>
+return -1;
-#endif /* __QNXNTO__ */
+}
+SDL_DitherColors(display->palette->colors,
-/*
+SDL_BITSPERPIXEL(display_mode.format));
-* Set the requested video mode, allocating a shadow buffer if necessary.
+}
-*/
+}
-SDL_Surface * SDL_SetVideoMode (int width, int height, int bpp, Uint32 flags)
-{
+/* Move any fullscreen windows into position */
-	SDL_VideoDevice *video, *this;
+for (i = 0; i < display->num_windows; ++i) {
-	SDL_Surface *prev_mode, *mode;
+SDL_Window *window = &display->windows[i];
-	int video_w;
+if (FULLSCREEN_VISIBLE(window)) {
-	int video_h;
+SDL_SetWindowPosition(window->id,
-	int video_bpp;
+((display_mode.w - window->w) / 2),
-	int is_opengl;
+((display_mode.h - window->h) / 2));
-	SDL_GrabMode saved_grab;
+}
+}
-	/* Start up the video driver, if necessary..
-	   WARNING: This is the only function protected this way!
+return 0;
-	 */
+}
-	if ( ! current_video ) {
-		if ( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE) < 0 ) {
+int
-			return(NULL);
+SDL_SetFullscreenDisplayMode(const SDL_DisplayMode * mode)
-		}
+{
-	}
+SDL_VideoDisplay *display;
-	this = video = current_video;
+int i;
-	/* Default to the current width and height */
+if (!_this) {
-	if ( width == 0 ) {
+SDL_SetError("Video subsystem has not been initialized");
-		width = video->info.current_w;
+return -1;
-	}
+}
-	if ( height == 0 ) {
-		height = video->info.current_h;
+display = &SDL_CurrentDisplay;
-	}
+if (mode) {
-	/* Default to the current video bpp */
+SDL_GetClosestDisplayMode(mode, &display->desired_mode);
-	if ( bpp == 0 ) {
+display->fullscreen_mode = &display->desired_mode;
-		flags |= SDL_ANYFORMAT;
+} else {
-		bpp = SDL_VideoSurface->format->BitsPerPixel;
+display->fullscreen_mode = NULL;
-	}
+}
-	/* Get a good video mode, the closest one possible */
+/* Actually set the mode if we have a fullscreen window visible */
-	video_w = width;
+for (i = 0; i < display->num_windows; ++i) {
-	video_h = height;
+SDL_Window *window = &display->windows[i];
-	video_bpp = bpp;
+if (FULLSCREEN_VISIBLE(window)) {
-	if ( ! SDL_GetVideoMode(&video_w, &video_h, &video_bpp, flags) ) {
+return SDL_SetDisplayMode(display->fullscreen_mode);
-		return(NULL);
+}
-	}
+}
+return 0;
-	/* Check the requested flags */
+}
-	/* There's no palette in > 8 bits-per-pixel mode */
-	if ( video_bpp > 8 ) {
+const SDL_DisplayMode *
-		flags &= ~SDL_HWPALETTE;
+SDL_GetFullscreenDisplayMode(void)
-	}
+{
-#if 0
+if (_this) {
-	if ( (flags&SDL_FULLSCREEN) != SDL_FULLSCREEN ) {
+return SDL_CurrentDisplay.fullscreen_mode;
-		/* There's no windowed double-buffering */
+}
-		flags &= ~SDL_DOUBLEBUF;
+return NULL;
-	}
+}
-#endif
-	if ( (flags&SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
+int
-		/* Use hardware surfaces when double-buffering */
+SDL_SetDisplayPalette(const SDL_Color * colors, int firstcolor, int ncolors)
-		flags |= SDL_HWSURFACE;
+{
-	}
+SDL_Palette *palette;
+int status = 0;
-	is_opengl = ( ( flags & SDL_OPENGL ) == SDL_OPENGL );
-	if ( is_opengl ) {
+if (!_this) {
-		/* These flags are for 2D video modes only */
+SDL_SetError("Video subsystem has not been initialized");
-		flags &= ~(SDL_HWSURFACE|SDL_DOUBLEBUF);
+return -1;
-	}
+}
+palette = SDL_CurrentDisplay.palette;
-	/* Reset the keyboard here so event callbacks can run */
+if (!palette) {
-	SDL_ResetKeyboard();
+SDL_SetError("Display mode does not have a palette");
-	SDL_ResetMouse();
+return -1;
-	SDL_cursorstate &= ~CURSOR_USINGSW;
+}
-	/* Clean up any previous video mode */
+status = SDL_SetPaletteColors(palette, colors, firstcolor, ncolors);
-	if ( SDL_PublicSurface != NULL ) {
-		SDL_PublicSurface = NULL;
+if (_this->SetDisplayPalette) {
-	}
+if (_this->SetDisplayPalette(_this, palette) < 0) {
-	if ( SDL_ShadowSurface != NULL ) {
+status = -1;
-		SDL_Surface *ready_to_go;
+}
-		ready_to_go = SDL_ShadowSurface;
+}
-		SDL_ShadowSurface = NULL;
+return status;
-		SDL_FreeSurface(ready_to_go);
+}
-	}
-	if ( video->physpal ) {
+int
-		SDL_free(video->physpal->colors);
+SDL_GetDisplayPalette(SDL_Color * colors, int firstcolor, int ncolors)
-		SDL_free(video->physpal);
+{
-		video->physpal = NULL;
+SDL_Palette *palette;
-	}
-	if( video->gammacols) {
+if (!_this) {
-		SDL_free(video->gammacols);
+SDL_SetError("Video subsystem has not been initialized");
-		video->gammacols = NULL;
+return -1;
-	}
+}
-	/* Save the previous grab state and turn off grab for mode switch */
+palette = SDL_CurrentDisplay.palette;
-	saved_grab = SDL_WM_GrabInputOff();
+if (!palette->ncolors) {
+SDL_SetError("Display mode does not have a palette");
-	/* Try to set the video mode, along with offset and clipping */
+return -1;
-	prev_mode = SDL_VideoSurface;
+}
-	SDL_LockCursor();
-	SDL_VideoSurface = NULL;	/* In case it's freed by driver */
+if (firstcolor < 0 || (firstcolor + ncolors) > palette->ncolors) {
-	mode = video->SetVideoMode(this, prev_mode,video_w,video_h,video_bpp,flags);
+SDL_SetError("Palette indices are out of range");
-	if ( mode ) { /* Prevent resize events from mode change */
+return -1;
-/* But not on OS/2 */
+}
-#ifndef __OS2__
-	    SDL_PrivateResize(mode->w, mode->h);
+SDL_memcpy(colors, &palette->colors[firstcolor],
-#endif
+ncolors * sizeof(*colors));
+return 0;
-	    /* Sam - If we asked for OpenGL mode, and didn't get it, fail */
+}
-	    if ( is_opengl && !(mode->flags & SDL_OPENGL) ) {
-		mode = NULL;
+SDL_WindowID
-		SDL_SetError("OpenGL not available");
+SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
-	    }
+{
-	}
+const Uint32 allowed_flags = (SDL_WINDOW_FULLSCREEN |
-	/*
+SDL_WINDOW_OPENGL |
-	 * rcg11292000
+SDL_WINDOW_SHOWN |
-	 * If you try to set an SDL_OPENGL surface, and fail to find a
+SDL_WINDOW_BORDERLESS |
-	 * matching  visual, then the next call to SDL_SetVideoMode()
+SDL_WINDOW_RESIZABLE |
-	 * will segfault, since  we no longer point to a dummy surface,
+SDL_WINDOW_MAXIMIZED |
-	 * but rather NULL.
+SDL_WINDOW_MINIMIZED |
-	 * Sam 11/29/00
+SDL_WINDOW_INPUT_GRABBED);
-	 * WARNING, we need to make sure that the previous mode hasn't
+SDL_VideoDisplay *display;
-	 * already been freed by the video driver.  What do we do in
+SDL_Window window;
-	 * that case?  Should we call SDL_VideoInit() again?
+int num_windows;
-	 */
+SDL_Window *windows;
-	SDL_VideoSurface = (mode != NULL) ? mode : prev_mode;
+if (!_this) {
-	if ( (mode != NULL) && (!is_opengl) ) {
+SDL_SetError("Video subsystem has not been initialized");
-		/* Sanity check */
+return 0;
-		if ( (mode->w < width) || (mode->h < height) ) {
+}
-			SDL_SetError("Video mode smaller than requested");
-			return(NULL);
+SDL_zero(window);
-		}
+window.id = _this->next_object_id++;
+window.title = title ? SDL_strdup(title) : NULL;
-		/* If we have a palettized surface, create a default palette */
+window.x = x;
-		if ( mode->format->palette ) {
+window.y = y;
-			SDL_PixelFormat *vf = mode->format;
+window.w = w;
-			SDL_DitherColors(vf->palette->colors, vf->BitsPerPixel);
+window.h = h;
-			video->SetColors(this, 0, vf->palette->ncolors,
+window.flags = (flags & allowed_flags);
-			                           vf->palette->colors);
+window.display = _this->current_display;
-		}
+if (_this->CreateWindow && _this->CreateWindow(_this, &window) < 0) {
-		/* Clear the surface to black */
+if (window.title) {
-		video->offset_x = 0;
+SDL_free(window.title);
-		video->offset_y = 0;
+}
-		mode->offset = 0;
+return 0;
-		SDL_SetClipRect(mode, NULL);
+}
-		SDL_ClearSurface(mode);
+display = &SDL_CurrentDisplay;
-		/* Now adjust the offsets to match the desired mode */
+num_windows = display->num_windows;
-		video->offset_x = (mode->w-width)/2;
+windows =
-		video->offset_y = (mode->h-height)/2;
+SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
-		mode->offset = video->offset_y*mode->pitch +
+if (!windows) {
-				video->offset_x*mode->format->BytesPerPixel;
+if (_this->DestroyWindow) {
-#ifdef DEBUG_VIDEO
+_this->DestroyWindow(_this, &window);
-fprintf(stderr,
+}
-	"Requested mode: %dx%dx%d, obtained mode %dx%dx%d (offset %d)\n",
+if (window.title) {
-		width, height, bpp,
+SDL_free(window.title);
-		mode->w, mode->h, mode->format->BitsPerPixel, mode->offset);
+}
-#endif
+return 0;
-		mode->w = width;
+}
-		mode->h = height;
+windows[num_windows] = window;
-		SDL_SetClipRect(mode, NULL);
+display->windows = windows;
-	}
+display->num_windows++;
-	SDL_ResetCursor();
-	SDL_UnlockCursor();
+if (FULLSCREEN_VISIBLE(&window)) {
+/* Hide any other fullscreen windows */
-	/* If we failed setting a video mode, return NULL... (Uh Oh!) */
+int i;
-	if ( mode == NULL ) {
+for (i = 0; i < display->num_windows; ++i) {
-		return(NULL);
+SDL_Window *other = &display->windows[i];
-	}
+if (other->id != window.id && FULLSCREEN_VISIBLE(other)) {
+SDL_MinimizeWindow(other->id);
-	/* If there is no window manager, set the SDL_NOFRAME flag */
+}
-	if ( ! video->info.wm_available ) {
+}
-		mode->flags |= SDL_NOFRAME;
+SDL_SetDisplayMode(display->fullscreen_mode);
-	}
+}
-	/* Reset the mouse cursor and grab for new video mode */
+return window.id;
-	SDL_SetCursor(NULL);
+}
-	if ( video->UpdateMouse ) {
-		video->UpdateMouse(this);
+SDL_WindowID
-	}
+SDL_CreateWindowFrom(const void *data)
-	SDL_WM_GrabInput(saved_grab);
+{
-	SDL_GetRelativeMouseState(NULL, NULL); /* Clear first large delta */
+SDL_VideoDisplay *display;
+SDL_Window window;
-#if SDL_VIDEO_OPENGL
+int num_windows;
-	/* Load GL symbols (before MakeCurrent, where we need glGetString). */
+SDL_Window *windows;
-	if ( flags & (SDL_OPENGL | SDL_OPENGLBLIT) ) {
+if (!_this) {
-#if defined(__QNXNTO__) && (_NTO_VERSION < 630)
+SDL_SetError("Video subsystem has not been initialized");
-#define __SDL_NOGETPROCADDR__
+return (0);
-#elif defined(__MINT__)
+}
-#define __SDL_NOGETPROCADDR__
-#endif
+SDL_zero(window);
-#ifdef __SDL_NOGETPROCADDR__
+window.id = _this->next_object_id++;
-#define SDL_PROC(ret,func,params) video->func=func;
+window.display = _this->current_display;
-#else
-#define SDL_PROC(ret,func,params) \
+if (!_this->CreateWindowFrom ||
-do { \
+_this->CreateWindowFrom(_this, &window, data) < 0) {
-video->func = SDL_GL_GetProcAddress(#func); \
+return 0;
-if ( ! video->func ) { \
+}
-SDL_SetError("Couldn't load GL function %s: %s\n", #func, SDL_GetError()); \
-return(NULL); \
+display = &SDL_CurrentDisplay;
-} \
+num_windows = display->num_windows;
-} while ( 0 );
+windows =
+SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
-#endif /* __SDL_NOGETPROCADDR__ */
+if (!windows) {
+if (_this->DestroyWindow) {
-#include "SDL_glfuncs.h"
+_this->DestroyWindow(_this, &window);
-#undef SDL_PROC
+}
-	}
+if (window.title) {
-#endif /* SDL_VIDEO_OPENGL */
+SDL_free(window.title);
+}
-	/* If we're running OpenGL, make the context current */
+return 0;
-	if ( (video->screen->flags & SDL_OPENGL) &&
+}
-	      video->GL_MakeCurrent ) {
+windows[num_windows] = window;
-		if ( video->GL_MakeCurrent(this) < 0 ) {
+display->windows = windows;
-			return(NULL);
+display->num_windows++;
-		}
-	}
+return window.id;
+}
-	/* Set up a fake SDL surface for OpenGL "blitting" */
-	if ( (flags & SDL_OPENGLBLIT) == SDL_OPENGLBLIT ) {
+SDL_Window *
-		/* Load GL functions for performing the texture updates */
+SDL_GetWindowFromID(SDL_WindowID windowID)
-#if SDL_VIDEO_OPENGL
+{
+int i, j;
-		/* Create a software surface for blitting */
-#ifdef GL_VERSION_1_2
+if (!_this) {
-		/* If the implementation either supports the packed pixels
+return NULL;
-		   extension, or implements the core OpenGL 1.2 API, it will
+}
-		   support the GL_UNSIGNED_SHORT_5_6_5 texture format.
-		 */
+for (i = 0; i < _this->num_displays; ++i) {
-		if ( (bpp == 16) &&
+SDL_VideoDisplay *display = &_this->displays[i];
-		     (SDL_strstr((const char *)video->glGetString(GL_EXTENSIONS), "GL_EXT_packed_pixels") ||
+for (j = 0; j < display->num_windows; ++j) {
-		     (SDL_atof((const char *)video->glGetString(GL_VERSION)) >= 1.2f))
+SDL_Window *window = &display->windows[j];
-		   ) {
+if (window->id == windowID) {
-			video->is_32bit = 0;
+return window;
-			SDL_VideoSurface = SDL_CreateRGBSurface(
+}
-				flags,
+}
-				width,
+}
-				height,
+return NULL;
-				16,
+}
-				31 << 11,
-				63 << 5,
+SDL_VideoDisplay *
-				31,
+SDL_GetDisplayFromWindow(SDL_Window * window)
-				0
+{
-				);
+if (!_this) {
-		}
+return NULL;
-		else
+}
-#endif /* OpenGL 1.2 */
+return &_this->displays[window->display];
-		{
+}
-			video->is_32bit = 1;
-			SDL_VideoSurface = SDL_CreateRGBSurface(
+Uint32
-				flags,
+SDL_GetWindowFlags(SDL_WindowID windowID)
-				width,
+{
-				height,
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-				32,
-#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+if (!window) {
-				0x000000FF,
+return 0;
-				0x0000FF00,
+}
-				0x00FF0000,
+return window->flags;
-				0xFF000000
+}
-#else
-				0xFF000000,
+void
-				0x00FF0000,
+SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)
-				0x0000FF00,
+{
-				0x000000FF
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-#endif
-				);
+if (!window) {
-		}
+return;
-		if ( ! SDL_VideoSurface ) {
+}
-			return(NULL);
+if (window->title) {
-		}
+SDL_free(window->title);
-		SDL_VideoSurface->flags = mode->flags | SDL_OPENGLBLIT;
+}
+window->title = SDL_strdup(title);
-		/* Free the original video mode surface (is this safe?) */
-		SDL_FreeSurface(mode);
+if (_this->SetWindowTitle) {
+_this->SetWindowTitle(_this, window);
-		/* Set the surface completely opaque & white by default */
+}
-		SDL_memset( SDL_VideoSurface->pixels, 255, SDL_VideoSurface->h * SDL_VideoSurface->pitch );
+}
-		video->glGenTextures( 1, &video->texture );
-		video->glBindTexture( GL_TEXTURE_2D, video->texture );
+const char *
-		video->glTexImage2D(
+SDL_GetWindowTitle(SDL_WindowID windowID)
-			GL_TEXTURE_2D,
+{
-			0,
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-			video->is_32bit ? GL_RGBA : GL_RGB,
-			256,
+if (!window) {
-			256,
+return NULL;
-			0,
+}
-			video->is_32bit ? GL_RGBA : GL_RGB,
+return window->title;
-#ifdef GL_VERSION_1_2
+}
-			video->is_32bit ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5,
-#else
+void
-			GL_UNSIGNED_BYTE,
+SDL_SetWindowData(SDL_WindowID windowID, void *userdata)
-#endif
+{
-			NULL);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-		video->UpdateRects = SDL_GL_UpdateRectsLock;
+if (!window) {
-#else
+return;
-		SDL_SetError("Somebody forgot to #define SDL_VIDEO_OPENGL");
+}
-		return(NULL);
+window->userdata = userdata;
-#endif
+}
-	}
+void *
-	/* Create a shadow surface if necessary */
+SDL_GetWindowData(SDL_WindowID windowID)
-	/* There are three conditions under which we create a shadow surface:
+{
-		1.  We need a particular bits-per-pixel that we didn't get.
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-		2.  We need a hardware palette and didn't get one.
-		3.  We need a software surface and got a hardware surface.
+if (!window) {
-	*/
+return NULL;
-	if ( !(SDL_VideoSurface->flags & SDL_OPENGL) &&
+}
-	     (
+return window->userdata;
-	     (  !(flags&SDL_ANYFORMAT) &&
+}
-			(SDL_VideoSurface->format->BitsPerPixel != bpp)) ||
-	     (   (flags&SDL_HWPALETTE) &&
+void
-				!(SDL_VideoSurface->flags&SDL_HWPALETTE)) ||
+SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)
-		/* If the surface is in hardware, video writes are visible
+{
-		   as soon as they are performed, so we need to buffer them
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-		 */
-	     (   ((flags&SDL_HWSURFACE) == SDL_SWSURFACE) &&
+if (!window) {
-				(SDL_VideoSurface->flags&SDL_HWSURFACE)) ||
+return;
-	     (   (flags&SDL_DOUBLEBUF) &&
+}
-				(SDL_VideoSurface->flags&SDL_HWSURFACE) &&
-				!(SDL_VideoSurface->flags&SDL_DOUBLEBUF))
+if (x != SDL_WINDOWPOS_UNDEFINED) {
-	     ) ) {
+window->x = x;
-		SDL_CreateShadowSurface(bpp);
+}
-		if ( SDL_ShadowSurface == NULL ) {
+if (y != SDL_WINDOWPOS_UNDEFINED) {
-			SDL_SetError("Couldn't create shadow surface");
+window->y = y;
-			return(NULL);
+}
-		}
-		SDL_PublicSurface = SDL_ShadowSurface;
+if (_this->SetWindowPosition) {
-	} else {
+_this->SetWindowPosition(_this, window);
-		SDL_PublicSurface = SDL_VideoSurface;
+}
-	}
+}
-	video->info.vfmt = SDL_VideoSurface->format;
-	video->info.current_w = SDL_VideoSurface->w;
+void
-	video->info.current_h = SDL_VideoSurface->h;
+SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)
+{
-	/* We're done! */
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	return(SDL_PublicSurface);
-}
+if (!window) {
+return;
-/*
+}
-* Convert a surface into the video pixel format.
+if (x) {
-*/
+*x = window->x;
-SDL_Surface * SDL_DisplayFormat (SDL_Surface *surface)
+}
-{
+if (y) {
-	Uint32 flags;
+*y = window->y;
+}
-	if ( ! SDL_PublicSurface ) {
+}
-		SDL_SetError("No video mode has been set");
-		return(NULL);
+void
-	}
+SDL_SetWindowSize(SDL_WindowID windowID, int w, int h)
-	/* Set the flags appropriate for copying to display surface */
+{
-	if (((SDL_PublicSurface->flags&SDL_HWSURFACE) == SDL_HWSURFACE) && current_video->info.blit_hw)
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-		flags = SDL_HWSURFACE;
-	else
+if (!window) {
-		flags = SDL_SWSURFACE;
+return;
-#ifdef AUTORLE_DISPLAYFORMAT
+}
-	flags |= (surface->flags & (SDL_SRCCOLORKEY|SDL_SRCALPHA));
-	flags |= SDL_RLEACCELOK;
+window->w = w;
-#else
+window->h = h;
-	flags |= surface->flags & (SDL_SRCCOLORKEY|SDL_SRCALPHA|SDL_RLEACCELOK);
-#endif
+if (_this->SetWindowSize) {
-	return(SDL_ConvertSurface(surface, SDL_PublicSurface->format, flags));
+_this->SetWindowSize(_this, window);
 }
+}
-/*
-* Convert a surface into a format that's suitable for blitting to
+void
-* the screen, but including an alpha channel.
+SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *h)
-*/
+{
-SDL_Surface *SDL_DisplayFormatAlpha(SDL_Surface *surface)
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-{
-	SDL_PixelFormat *vf;
+if (!window) {
-	SDL_PixelFormat *format;
+return;
-	SDL_Surface *converted;
+}
-	Uint32 flags;
+if (w) {
-	/* default to ARGB8888 */
+*w = window->w;
-	Uint32 amask = 0xff000000;
+}
-	Uint32 rmask = 0x00ff0000;
+if (h) {
-	Uint32 gmask = 0x0000ff00;
+*h = window->h;
-	Uint32 bmask = 0x000000ff;
+}
+}
-	if ( ! SDL_PublicSurface ) {
-		SDL_SetError("No video mode has been set");
+void
-		return(NULL);
+SDL_ShowWindow(SDL_WindowID windowID)
-	}
+{
-	vf = SDL_PublicSurface->format;
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	switch(vf->BytesPerPixel) {
+if (!window || (window->flags & SDL_WINDOW_SHOWN)) {
-	    case 2:
+return;
-		/* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}.
+}
-		   For anything else (like ARGB4444) it doesn't matter
-		   since we have no special code for it anyway */
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);
-		if ( (vf->Rmask == 0x1f) &&
-		     (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) {
+if (_this->ShowWindow) {
-			rmask = 0xff;
+_this->ShowWindow(_this, window);
-			bmask = 0xff0000;
+}
-		}
+}
-		break;
+void
-	    case 3:
+SDL_HideWindow(SDL_WindowID windowID)
-	    case 4:
+{
-		/* Keep the video format, as long as the high 8 bits are
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-		   unused or alpha */
-		if ( (vf->Rmask == 0xff) && (vf->Bmask == 0xff0000) ) {
+if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
-			rmask = 0xff;
+return;
-			bmask = 0xff0000;
+}
-		}
-		break;
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_HIDDEN, 0, 0);
-	    default:
+if (_this->HideWindow) {
-		/* We have no other optimised formats right now. When/if a new
+_this->HideWindow(_this, window);
-		   optimised alpha format is written, add the converter here */
+}
-		break;
+}
-	}
-	format = SDL_AllocFormat(32, rmask, gmask, bmask, amask);
+void
-	flags = SDL_PublicSurface->flags & SDL_HWSURFACE;
+SDL_RaiseWindow(SDL_WindowID windowID)
-	flags |= surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
+{
-	converted = SDL_ConvertSurface(surface, format, flags);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	SDL_FreeFormat(format);
-	return(converted);
+if (!window) {
-}
+return;
+}
-/*
-* Update a specific portion of the physical screen
+if (_this->RaiseWindow) {
-*/
+_this->RaiseWindow(_this, window);
-void SDL_UpdateRect(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h)
+}
-{
+}
-	if ( screen ) {
-		SDL_Rect rect;
+void
+SDL_MaximizeWindow(SDL_WindowID windowID)
-		/* Perform some checking */
+{
-		if ( w == 0 )
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-			w = screen->w;
-		if ( h == 0 )
+if (!window || (window->flags & SDL_WINDOW_MAXIMIZED)) {
-			h = screen->h;
+return;
-		if ( (int)(x+w) > screen->w )
+}
-			return;
-		if ( (int)(y+h) > screen->h )
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
-			return;
+if (_this->MaximizeWindow) {
-		/* Fill the rectangle */
+_this->MaximizeWindow(_this, window);
-		rect.x = (Sint16)x;
+}
-		rect.y = (Sint16)y;
+}
-		rect.w = (Uint16)w;
-		rect.h = (Uint16)h;
+void
-		SDL_UpdateRects(screen, 1, &rect);
+SDL_MinimizeWindow(SDL_WindowID windowID)
-	}
+{
-}
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-void SDL_UpdateRects (SDL_Surface *screen, int numrects, SDL_Rect *rects)
-{
+if (!window || (window->flags & SDL_WINDOW_MINIMIZED)) {
-	int i;
+return;
-	SDL_VideoDevice *video = current_video;
+}
-	SDL_VideoDevice *this = current_video;
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
-	if ( (screen->flags & (SDL_OPENGL | SDL_OPENGLBLIT)) == SDL_OPENGL ) {
-		SDL_SetError("OpenGL active, use SDL_GL_SwapBuffers()");
+if (_this->MinimizeWindow) {
-		return;
+_this->MinimizeWindow(_this, window);
-	}
+}
-	if ( screen == SDL_ShadowSurface ) {
+}
-		/* Blit the shadow surface using saved mapping */
-		SDL_Palette *pal = screen->format->palette;
+void
-		SDL_Color *saved_colors = NULL;
+SDL_RestoreWindow(SDL_WindowID windowID)
-		if ( pal && !(SDL_VideoSurface->flags & SDL_HWPALETTE) ) {
+{
-			/* simulated 8bpp, use correct physical palette */
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-			saved_colors = pal->colors;
-			if ( video->gammacols ) {
+if (!window
-				/* gamma-corrected palette */
+|| (window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {
-				pal->colors = video->gammacols;
+return;
-			} else if ( video->physpal ) {
+}
-				/* physical palette different from logical */
-				pal->colors = video->physpal->colors;
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESTORED, 0, 0);
-			}
-		}
+if (_this->RestoreWindow) {
-		if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) {
+_this->RestoreWindow(_this, window);
-			SDL_LockCursor();
+}
-			SDL_DrawCursor(SDL_ShadowSurface);
+}
-			for ( i=0; i<numrects; ++i ) {
-				SDL_LowerBlit(SDL_ShadowSurface, &rects[i],
+int
-						SDL_VideoSurface, &rects[i]);
+SDL_SetWindowFullscreen(SDL_WindowID windowID, int fullscreen)
-			}
+{
-			SDL_EraseCursor(SDL_ShadowSurface);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-			SDL_UnlockCursor();
-		} else {
+if (!window) {
-			for ( i=0; i<numrects; ++i ) {
+return -1;
-				SDL_LowerBlit(SDL_ShadowSurface, &rects[i],
+}
-						SDL_VideoSurface, &rects[i]);
-			}
+if (fullscreen) {
-		}
+fullscreen = SDL_WINDOW_FULLSCREEN;
-		if ( saved_colors ) {
+}
-			pal->colors = saved_colors;
+if ((window->flags & SDL_WINDOW_FULLSCREEN) == fullscreen) {
-		}
+return 0;
+}
-		/* Fall through to video surface update */
-		screen = SDL_VideoSurface;
+if (fullscreen) {
-	}
+window->flags |= SDL_WINDOW_FULLSCREEN;
-	if ( screen == SDL_VideoSurface ) {
-		/* Update the video surface */
+if (FULLSCREEN_VISIBLE(window)) {
-		if ( screen->offset ) {
+SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-			for ( i=0; i<numrects; ++i ) {
-				rects[i].x += video->offset_x;
+/* Hide any other fullscreen windows */
-				rects[i].y += video->offset_y;
+int i;
-			}
+for (i = 0; i < display->num_windows; ++i) {
-			video->UpdateRects(this, numrects, rects);
+SDL_Window *other = &display->windows[i];
-			for ( i=0; i<numrects; ++i ) {
+if (other->id != windowID && FULLSCREEN_VISIBLE(other)) {
-				rects[i].x -= video->offset_x;
+SDL_MinimizeWindow(other->id);
-				rects[i].y -= video->offset_y;
+}
-			}
+}
-		} else {
-			video->UpdateRects(this, numrects, rects);
+SDL_SetDisplayMode(display->fullscreen_mode);
-		}
+}
-	}
+} else {
-}
+window->flags &= ~SDL_WINDOW_FULLSCREEN;
-/*
+if (FULLSCREEN_VISIBLE(window)) {
-* Performs hardware double buffering, if possible, or a full update if not.
+SDL_SetDisplayMode(NULL);
-*/
+}
-int SDL_Flip(SDL_Surface *screen)
+}
-{
+return 0;
-	SDL_VideoDevice *video = current_video;
+}
-	/* Copy the shadow surface to the video surface */
-	if ( screen == SDL_ShadowSurface ) {
+void
-		SDL_Rect rect;
+SDL_SetWindowGrab(SDL_WindowID windowID, int mode)
-		SDL_Palette *pal = screen->format->palette;
+{
-		SDL_Color *saved_colors = NULL;
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-		if ( pal && !(SDL_VideoSurface->flags & SDL_HWPALETTE) ) {
-			/* simulated 8bpp, use correct physical palette */
+if (!window || (!!mode == !!(window->flags & SDL_WINDOW_INPUT_GRABBED))) {
-			saved_colors = pal->colors;
+return;
-			if ( video->gammacols ) {
+}
-				/* gamma-corrected palette */
-				pal->colors = video->gammacols;
+if (mode) {
-			} else if ( video->physpal ) {
+window->flags |= SDL_WINDOW_INPUT_GRABBED;
-				/* physical palette different from logical */
+} else {
-				pal->colors = video->physpal->colors;
+window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
-			}
+}
-		}
+if ((window->flags & SDL_WINDOW_INPUT_FOCUS) && _this->SetWindowGrab) {
-		rect.x = 0;
+_this->SetWindowGrab(_this, window);
-		rect.y = 0;
+}
-		rect.w = screen->w;
+}
-		rect.h = screen->h;
-		if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) {
+int
-			SDL_LockCursor();
+SDL_GetWindowGrab(SDL_WindowID windowID)
-			SDL_DrawCursor(SDL_ShadowSurface);
+{
-			SDL_LowerBlit(SDL_ShadowSurface, &rect,
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-					SDL_VideoSurface, &rect);
-			SDL_EraseCursor(SDL_ShadowSurface);
+if (!window) {
-			SDL_UnlockCursor();
+return 0;
-		} else {
+}
-			SDL_LowerBlit(SDL_ShadowSurface, &rect,
-					SDL_VideoSurface, &rect);
+return ((window->flags & SDL_WINDOW_INPUT_GRABBED) != 0);
-		}
+}
-		if ( saved_colors ) {
-			pal->colors = saved_colors;
+void
-		}
+SDL_OnWindowShown(SDL_Window * window)
+{
-		/* Fall through to video surface update */
+}
-		screen = SDL_VideoSurface;
-	}
+void
-	if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
+SDL_OnWindowHidden(SDL_Window * window)
-		SDL_VideoDevice *this  = current_video;
+{
-		return(video->FlipHWSurface(this, SDL_VideoSurface));
+}
-	} else {
-		SDL_UpdateRect(screen, 0, 0, 0, 0);
+void
-	}
+SDL_OnWindowFocusGained(SDL_Window * window)
-	return(0);
+{
-}
+SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-static void SetPalette_logical(SDL_Surface *screen, SDL_Color *colors,
+if (window->flags & SDL_WINDOW_FULLSCREEN) {
-			       int firstcolor, int ncolors)
+SDL_SetDisplayMode(display->fullscreen_mode);
-{
+}
-	SDL_Palette *pal = screen->format->palette;
+if (display->gamma && _this->SetDisplayGammaRamp) {
-	SDL_Palette *vidpal;
+_this->SetDisplayGammaRamp(_this, display->gamma);
+}
-	if ( colors != (pal->colors + firstcolor) ) {
+if ((window->flags & SDL_WINDOW_INPUT_GRABBED) && _this->SetWindowGrab) {
-		SDL_memcpy(pal->colors + firstcolor, colors,
+_this->SetWindowGrab(_this, window);
-		       ncolors * sizeof(*colors));
+}
-	}
+}
-	vidpal = SDL_VideoSurface->format->palette;
+void
-	if ( (screen == SDL_ShadowSurface) && vidpal ) {
+SDL_OnWindowFocusLost(SDL_Window * window)
-		/*
+{
-		 * This is a shadow surface, and the physical
+SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-		 * framebuffer is also indexed. Propagate the
-		 * changes to its logical palette so that
+if (window->flags & SDL_WINDOW_FULLSCREEN) {
-		 * updates are always identity blits
+SDL_MinimizeWindow(window->id);
-		 */
+SDL_SetDisplayMode(NULL);
-		SDL_memcpy(vidpal->colors + firstcolor, colors,
+}
-		       ncolors * sizeof(*colors));
+if (display->gamma && _this->SetDisplayGammaRamp) {
-	}
+_this->SetDisplayGammaRamp(_this, display->saved_gamma);
-	SDL_FormatChanged(screen);
+}
-}
+if ((window->flags & SDL_WINDOW_INPUT_GRABBED) && _this->SetWindowGrab) {
+_this->SetWindowGrab(_this, window);
-static int SetPalette_physical(SDL_Surface *screen,
+}
-SDL_Color *colors, int firstcolor, int ncolors)
+}
-{
-	SDL_VideoDevice *video = current_video;
+SDL_WindowID
-	int gotall = 1;
+SDL_GetFocusWindow(void)
+{
-	if ( video->physpal ) {
+SDL_VideoDisplay *display;
-		/* We need to copy the new colors, since we haven't
+int i;
-		 * already done the copy in the logical set above.
-		 */
+if (!_this) {
-		SDL_memcpy(video->physpal->colors + firstcolor,
+return 0;
-		       colors, ncolors * sizeof(*colors));
+}
-	}
-	if ( screen == SDL_ShadowSurface ) {
+display = &SDL_CurrentDisplay;
-		if ( SDL_VideoSurface->flags & SDL_HWPALETTE ) {
+for (i = 0; i < display->num_windows; ++i) {
-			/*
+SDL_Window *window = &display->windows[i];
-			 * The real screen is also indexed - set its physical
-			 * palette. The physical palette does not include the
+if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
-			 * gamma modification, we apply it directly instead,
+return window->id;
-			 * but this only happens if we have hardware palette.
+}
-			 */
+}
-			screen = SDL_VideoSurface;
+return 0;
-		} else {
+}
-			/*
-			 * The video surface is not indexed - invalidate any
+void
-			 * active shadow-to-video blit mappings.
+SDL_DestroyWindow(SDL_WindowID windowID)
-			 */
+{
-			if ( screen->map->dst == SDL_VideoSurface ) {
+int i, j;
-				SDL_InvalidateMap(screen->map);
-			}
+if (!_this) {
-			if ( video->gamma ) {
+return;
-				if( ! video->gammacols ) {
+}
-					SDL_Palette *pp = video->physpal;
-					if(!pp)
+/* Restore video mode, etc. */
-						pp = screen->format->palette;
+SDL_SendWindowEvent(windowID, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
-					video->gammacols = SDL_malloc(pp->ncolors
-							  * sizeof(SDL_Color));
+for (i = 0; i < _this->num_displays; ++i) {
-					SDL_ApplyGamma(video->gamma,
+SDL_VideoDisplay *display = &_this->displays[i];
-						       pp->colors,
+for (j = 0; j < display->num_windows; ++j) {
-						       video->gammacols,
+SDL_Window *window = &display->windows[j];
-						       pp->ncolors);
+if (window->id != windowID) {
-				} else {
+continue;
-					SDL_ApplyGamma(video->gamma, colors,
+}
-						       video->gammacols
+if (window->renderer) {
-						       + firstcolor,
+SDL_DestroyRenderer(window->id);
-						       ncolors);
+}
-				}
+if (_this->DestroyWindow) {
-			}
+_this->DestroyWindow(_this, window);
-			SDL_UpdateRect(screen, 0, 0, 0, 0);
+}
-		}
+if (window->title) {
-	}
+SDL_free(window->title);
+}
-	if ( screen == SDL_VideoSurface ) {
+if (j != display->num_windows - 1) {
-		SDL_Color gcolors[256];
+SDL_memcpy(&display->windows[i],
+&display->windows[i + 1],
-		if ( video->gamma ) {
+(display->num_windows - i - 1) * sizeof(*window));
-			SDL_ApplyGamma(video->gamma, colors, gcolors, ncolors);
+}
-			colors = gcolors;
+--display->num_windows;
-		}
+return;
-		gotall = video->SetColors(video, firstcolor, ncolors, colors);
+}
-		if ( ! gotall ) {
+}
-			/* The video flags shouldn't have SDL_HWPALETTE, and
+}
-			   the video driver is responsible for copying back the
-			   correct colors into the video surface palette.
+void
-			*/
+SDL_AddRenderDriver(int displayIndex, const SDL_RenderDriver * driver)
-			;
+{
-		}
+SDL_VideoDisplay *display = &_this->displays[displayIndex];
-		SDL_CursorPaletteChanged();
+SDL_RenderDriver *render_drivers;
-	}
-	return gotall;
+render_drivers =
-}
+SDL_realloc(display->render_drivers,
+(display->num_render_drivers +
-/*
+1) * sizeof(*render_drivers));
-* Set the physical and/or logical colormap of a surface:
+if (render_drivers) {
-* Only the screen has a physical colormap. It determines what is actually
+render_drivers[display->num_render_drivers] = *driver;
-* sent to the display.
+display->render_drivers = render_drivers;
-* The logical colormap is used to map blits to/from the surface.
+display->num_render_drivers++;
-* 'which' is one or both of SDL_LOGPAL, SDL_PHYSPAL
+}
-*
+}
-* Return nonzero if all colours were set as requested, or 0 otherwise.
-*/
+int
-int SDL_SetPalette(SDL_Surface *screen, int which,
+SDL_GetNumRenderers(void)
-		   SDL_Color *colors, int firstcolor, int ncolors)
+{
-{
+if (_this) {
-	SDL_Palette *pal;
+return SDL_CurrentDisplay.num_render_drivers;
-	int gotall;
+}
-	int palsize;
+return 0;
+}
-	if ( ! current_video ) {
-		return 0;
+int
-	}
+SDL_GetRendererInfo(int index, SDL_RendererInfo * info)
-	if ( screen != SDL_PublicSurface ) {
+{
-		/* only screens have physical palettes */
+if (index < 0 || index >= SDL_GetNumRenderers()) {
-		which &= ~SDL_PHYSPAL;
+SDL_SetError("index must be in the range of 0 - %d",
-	} else if( (screen->flags & SDL_HWPALETTE) != SDL_HWPALETTE ) {
+SDL_GetNumRenderers() - 1);
-		/* hardware palettes required for split colormaps */
+return -1;
-		which |= SDL_PHYSPAL | SDL_LOGPAL;
+}
-	}
+*info = SDL_CurrentDisplay.render_drivers[index].info;
+return 0;
-	/* Verify the parameters */
+}
-	pal = screen->format->palette;
-	if( !pal ) {
+int
-		return 0;	/* not a palettized surface */
+SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags)
-	}
+{
-	gotall = 1;
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	palsize = 1 << screen->format->BitsPerPixel;
-	if ( ncolors > (palsize - firstcolor) ) {
+if (!window) {
-		ncolors = (palsize - firstcolor);
+return 0;
-		gotall = 0;
+}
-	}
+if (index < 0) {
-	if ( which & SDL_LOGPAL ) {
+int n = SDL_GetNumRenderers();
-		/*
+for (index = 0; index < n; ++index) {
-		 * Logical palette change: The actual screen isn't affected,
+SDL_RenderDriver *driver =
-		 * but the internal colormap is altered so that the
+&SDL_CurrentDisplay.render_drivers[index];
-		 * interpretation of the pixel values (for blits etc) is
-		 * changed.
+/* Skip minimal drivers in automatic scans */
-		 */
+if (!(flags & SDL_Renderer_Minimal)
-		SetPalette_logical(screen, colors, firstcolor, ncolors);
+&& (driver->info.flags & SDL_Renderer_Minimal)) {
-	}
+continue;
-	if ( which & SDL_PHYSPAL ) {
+}
-		SDL_VideoDevice *video = current_video;
+if ((driver->info.flags & flags) == flags) {
-		/*
+break;
-		 * Physical palette change: This doesn't affect the
+}
-		 * program's idea of what the screen looks like, but changes
+}
-		 * its actual appearance.
+if (index == n) {
-		 */
+SDL_SetError("Couldn't find matching render driver");
-		if(!video)
+return -1;
-			return gotall;	/* video not yet initialized */
+}
-		if(!video->physpal && !(which & SDL_LOGPAL) ) {
+}
-			/* Lazy physical palette allocation */
-			int size;
+if (index >= SDL_GetNumRenderers()) {
-			SDL_Palette *pp = SDL_malloc(sizeof(*pp));
+SDL_SetError("index must be -1 or in the range of 0 - %d",
-			if ( !pp ) {
+SDL_GetNumRenderers() - 1);
-				return 0;
+return -1;
-			}
+}
-			current_video->physpal = pp;
-			pp->ncolors = pal->ncolors;
+/* Free any existing renderer */
-			size = pp->ncolors * sizeof(SDL_Color);
+SDL_DestroyRenderer(windowID);
-			pp->colors = SDL_malloc(size);
-			if ( !pp->colors ) {
+/* Create a new renderer instance */
-				return 0;
+window->renderer =
-			}
+SDL_CurrentDisplay.render_drivers[index].CreateRenderer(window,
-			SDL_memcpy(pp->colors, pal->colors, size);
+flags);
-		}
+if (!window->renderer) {
-		if ( ! SetPalette_physical(screen,
+return -1;
-		                           colors, firstcolor, ncolors) ) {
+}
-			gotall = 0;
+SDL_CurrentDisplay.current_renderer = window->renderer;
-		}
-	}
+return 0;
-	return gotall;
+}
-}
+int
-int SDL_SetColors(SDL_Surface *screen, SDL_Color *colors, int firstcolor,
+SDL_SelectRenderer(SDL_WindowID windowID)
-		  int ncolors)
+{
-{
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	return SDL_SetPalette(screen, SDL_LOGPAL | SDL_PHYSPAL,
-			      colors, firstcolor, ncolors);
+if (!window || !window->renderer) {
-}
+return -1;
+}
-/*
+SDL_CurrentDisplay.current_renderer = window->renderer;
-* Clean up the video subsystem
+return 0;
-*/
+}
-void SDL_VideoQuit (void)
-{
+SDL_TextureID
-	SDL_Surface *ready_to_go;
+SDL_CreateTexture(Uint32 format, int access, int w, int h)
+{
-	if ( current_video ) {
+int hash;
-		SDL_VideoDevice *video = current_video;
+SDL_Renderer *renderer;
-		SDL_VideoDevice *this  = current_video;
+SDL_Texture *texture;
-		/* Halt event processing before doing anything else */
+if (!_this) {
-		SDL_StopEventLoop();
+return 0;
+}
-		/* Clean up allocated window manager items */
-		if ( SDL_PublicSurface ) {
+renderer = SDL_CurrentDisplay.current_renderer;
-			SDL_PublicSurface = NULL;
+if (!renderer || !renderer->CreateTexture) {
-		}
+return 0;
-		SDL_CursorQuit();
+}
-		/* Just in case... */
+texture = (SDL_Texture *) SDL_malloc(sizeof(*texture));
-		SDL_WM_GrabInputOff();
+if (!texture) {
+SDL_OutOfMemory();
-		/* Clean up the system video */
+return 0;
-		video->VideoQuit(this);
+}
-		/* Free any lingering surfaces */
+SDL_zerop(texture);
-		ready_to_go = SDL_ShadowSurface;
+texture->id = _this->next_object_id++;
-		SDL_ShadowSurface = NULL;
+texture->format = format;
-		SDL_FreeSurface(ready_to_go);
+texture->access = access;
-		if ( SDL_VideoSurface != NULL ) {
+texture->w = w;
-			ready_to_go = SDL_VideoSurface;
+texture->h = h;
-			SDL_VideoSurface = NULL;
+texture->renderer = renderer;
-			SDL_FreeSurface(ready_to_go);
-		}
+if (renderer->CreateTexture(renderer, texture) < 0) {
-		SDL_PublicSurface = NULL;
+SDL_free(texture);
+return 0;
-		/* Clean up miscellaneous memory */
+}
-		if ( video->physpal ) {
-			SDL_free(video->physpal->colors);
+hash = (texture->id % SDL_arraysize(SDL_CurrentDisplay.textures));
-			SDL_free(video->physpal);
+texture->next = SDL_CurrentDisplay.textures[hash];
-			video->physpal = NULL;
+SDL_CurrentDisplay.textures[hash] = texture;
-		}
-		if ( video->gammacols ) {
+return texture->id;
-			SDL_free(video->gammacols);
+}
-			video->gammacols = NULL;
-		}
+SDL_TextureID
-		if ( video->gamma ) {
+SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface * surface)
-			SDL_free(video->gamma);
+{
-			video->gamma = NULL;
+SDL_TextureID textureID;
-		}
+Uint32 surface_flags = surface->flags;
-		if ( video->wm_title != NULL ) {
+SDL_PixelFormat *fmt = surface->format;
-			SDL_free(video->wm_title);
+Uint8 alpha;
-			video->wm_title = NULL;
+SDL_Rect bounds;
-		}
+SDL_Surface dst;
-		if ( video->wm_icon != NULL ) {
+int bpp;
-			SDL_free(video->wm_icon);
+Uint32 Rmask, Gmask, Bmask, Amask;
-			video->wm_icon = NULL;
-		}
+if (!surface) {
+SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
-		/* Finish cleaning up video subsystem */
+return 0;
-		video->free(this);
+}
-		current_video = NULL;
-	}
+if (format) {
-	return;
+if (!SDL_PixelFormatEnumToMasks
+(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
+SDL_SetError("Unknown pixel format");
+return 0;
+}
+} else {
+if (fmt->Amask || !(surface_flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA))) {
+bpp = fmt->BitsPerPixel;
+Rmask = fmt->Rmask;
+Gmask = fmt->Gmask;
+Bmask = fmt->Bmask;
+Amask = fmt->Amask;
+} else {
+/* Need a format with alpha */
+bpp = 32;
+Rmask = 0x00FF0000;
+Gmask = 0x0000FF00;
+Bmask = 0x000000FF;
+Amask = 0xFF000000;
+}
+format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);
+if (!format) {
+SDL_SetError("Unknown pixel format");
+return 0;
+}
+}
+textureID = SDL_CreateTexture(format, access, surface->w, surface->h);
+if (!textureID) {
+return 0;
+}
+/* Set up a destination surface for the texture update */
+SDL_zero(dst);
+dst.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask);
+if (!dst.format) {
+SDL_DestroyTexture(textureID);
+return 0;
+}
+dst.w = surface->w;
+dst.h = surface->h;
+if (SDL_LockTexture(textureID, NULL, 1, &dst.pixels, &dst.pitch) == 0) {
+dst.flags |= SDL_PREALLOC;
+} else {
+dst.pitch = SDL_CalculatePitch(&dst);
+dst.pixels = SDL_malloc(dst.h * dst.pitch);
+if (!dst.pixels) {
+SDL_DestroyTexture(textureID);
+SDL_FreeFormat(dst.format);
+SDL_OutOfMemory();
+return 0;
+}
+}
+/* Copy the palette if any */
+if (SDL_ISPIXELFORMAT_INDEXED(format)) {
+if (fmt->palette) {
+SDL_SetTexturePalette(textureID, fmt->palette->colors, 0,
+fmt->palette->ncolors);
+SDL_SetSurfacePalette(&dst, fmt->palette);
+} else {
+dst.format->palette =
+SDL_AllocPalette((1 << SDL_BITSPERPIXEL(format)));
+if (!dst.format->palette) {
+SDL_DestroyTexture(textureID);
+SDL_FreeFormat(dst.format);
+return 0;
+}
+SDL_DitherColors(dst.format->palette->colors,
+SDL_BITSPERPIXEL(format));
+}
+}
+/* Make the texture transparent if the surface has colorkey */
+if (surface_flags & SDL_SRCCOLORKEY) {
+int row;
+int length = dst.w * dst.format->BytesPerPixel;
+Uint8 *p = (Uint8 *) dst.pixels;
+for (row = 0; row < dst.h; ++row) {
+SDL_memset(p, 0, length);
+p += dst.pitch;
+}
+}
+/* Copy over the alpha channel */
+if (surface_flags & SDL_SRCALPHA) {
+if (fmt->Amask) {
+surface->flags &= ~SDL_SRCALPHA;
+} else {
+/* FIXME: Need to make sure the texture has an alpha channel
+*        and copy 'alpha' into the texture alpha channel.
+*/
+alpha = surface->format->alpha;
+SDL_SetAlpha(surface, 0, 0);
+}
+}
+/* Copy over the image data */
+bounds.x = 0;
+bounds.y = 0;
+bounds.w = surface->w;
+bounds.h = surface->h;
+SDL_LowerBlit(surface, &bounds, &dst, &bounds);
+/* Clean up the original surface */
+if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+Uint32 aflags = surface_flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
+if (fmt->Amask) {
+surface->flags |= SDL_SRCALPHA;
+} else {
+SDL_SetAlpha(surface, aflags, alpha);
+}
+}
+/* Update the texture */
+if (dst.flags & SDL_PREALLOC) {
+SDL_UnlockTexture(textureID);
+} else {
+SDL_UpdateTexture(textureID, NULL, dst.pixels, dst.pitch);
+SDL_free(dst.pixels);
+}
+SDL_FreeFormat(dst.format);
+return textureID;
+}
+static __inline__ SDL_Texture *
+SDL_GetTextureFromID(SDL_TextureID textureID)
+{
+int hash;
+SDL_Texture *texture;
+if (!_this) {
+return NULL;
+}
+hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
+for (texture = SDL_CurrentDisplay.textures[hash]; texture;
+texture = texture->next) {
+if (texture->id == textureID) {
+return texture;
+}
+}
+return NULL;
+}
+int
+SDL_QueryTexture(SDL_TextureID textureID, Uint32 * format, int *access,
+int *w, int *h)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+if (!texture) {
+return -1;
+}
+if (format) {
+*format = texture->format;
+}
+if (access) {
+*access = texture->access;
+}
+if (w) {
+*w = texture->w;
+}
+if (h) {
+*h = texture->h;
+}
+return 0;
+}
+int
+SDL_QueryTexturePixels(SDL_TextureID textureID, void **pixels, int *pitch)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+if (!texture) {
+return -1;
+}
+renderer = texture->renderer;
+if (!renderer->QueryTexturePixels) {
+return -1;
+}
+return renderer->QueryTexturePixels(renderer, texture, pixels, pitch);
+}
+int
+SDL_SetTexturePalette(SDL_TextureID textureID, const SDL_Color * colors,
+int firstcolor, int ncolors)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+if (!texture) {
+return -1;
+}
+renderer = texture->renderer;
+if (!renderer->SetTexturePalette) {
+return -1;
+}
+return renderer->SetTexturePalette(renderer, texture, colors, firstcolor,
+ncolors);
+}
+int
+SDL_GetTexturePalette(SDL_TextureID textureID, SDL_Color * colors,
+int firstcolor, int ncolors)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+if (!texture) {
+return -1;
+}
+renderer = texture->renderer;
+if (!renderer->GetTexturePalette) {
+return -1;
+}
+return renderer->GetTexturePalette(renderer, texture, colors, firstcolor,
+ncolors);
+}
+int
+SDL_UpdateTexture(SDL_TextureID textureID, const SDL_Rect * rect,
+const void *pixels, int pitch)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+SDL_Rect full_rect;
+if (!texture) {
+return -1;
+}
+renderer = texture->renderer;
+if (!renderer->UpdateTexture) {
+return -1;
+}
+if (!rect) {
+full_rect.x = 0;
+full_rect.y = 0;
+full_rect.w = texture->w;
+full_rect.h = texture->h;
+rect = &full_rect;
+}
+return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
+}
+int
+SDL_LockTexture(SDL_TextureID textureID, const SDL_Rect * rect, int markDirty,
+void **pixels, int *pitch)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+SDL_Rect full_rect;
+if (!texture) {
+return -1;
+}
+renderer = texture->renderer;
+if (!renderer->LockTexture) {
+return -1;
+}
+if (!rect) {
+full_rect.x = 0;
+full_rect.y = 0;
+full_rect.w = texture->w;
+full_rect.h = texture->h;
+rect = &full_rect;
+}
+return renderer->LockTexture(renderer, texture, rect, markDirty, pixels,
+pitch);
+}
+void
+SDL_UnlockTexture(SDL_TextureID textureID)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+if (!texture) {
+return;
+}
+renderer = texture->renderer;
+if (!renderer->UnlockTexture) {
+return;
+}
+renderer->UnlockTexture(renderer, texture);
+}
+void
+SDL_DirtyTexture(SDL_TextureID textureID, int numrects,
+const SDL_Rect * rects)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+if (!texture) {
+return;
+}
+renderer = texture->renderer;
+if (!renderer->DirtyTexture) {
+return;
+}
+renderer->DirtyTexture(renderer, texture, numrects, rects);
+}
+void
+SDL_SelectRenderTexture(SDL_TextureID textureID)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+if (!texture || texture->access != SDL_TextureAccess_Render) {
+return;
+}
+renderer = texture->renderer;
+if (!renderer->SelectRenderTexture) {
+return;
+}
+renderer->SelectRenderTexture(renderer, texture);
+}
+int
+SDL_RenderFill(const SDL_Rect * rect, Uint32 color)
+{
+SDL_Renderer *renderer;
+SDL_Window *window;
+SDL_Rect real_rect;
+if (!_this) {
+return -1;
+}
+renderer = SDL_CurrentDisplay.current_renderer;
+if (!renderer || !renderer->RenderFill) {
+return -1;
+}
+window = SDL_GetWindowFromID(renderer->window);
+real_rect.x = 0;
+real_rect.y = 0;
+real_rect.w = window->w;
+real_rect.h = window->h;
+if (rect) {
+if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
+return 0;
+}
+}
+rect = &real_rect;
+return renderer->RenderFill(renderer, rect, color);
+}
+int
+SDL_RenderCopy(SDL_TextureID textureID, const SDL_Rect * srcrect,
+const SDL_Rect * dstrect, int blendMode, int scaleMode)
+{
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
+SDL_Renderer *renderer;
+SDL_Window *window;
+SDL_Rect real_srcrect;
+SDL_Rect real_dstrect;
+if (!texture || texture->renderer != SDL_CurrentDisplay.current_renderer) {
+return -1;
+}
+renderer = SDL_CurrentDisplay.current_renderer;
+if (!renderer || !renderer->RenderCopy) {
+return -1;
+}
+/* FIXME: implement clipping */
+window = SDL_GetWindowFromID(renderer->window);
+real_srcrect.x = 0;
+real_srcrect.y = 0;
+real_srcrect.w = texture->w;
+real_srcrect.h = texture->h;
+real_dstrect.x = 0;
+real_dstrect.y = 0;
+real_dstrect.w = window->w;
+real_dstrect.h = window->h;
+if (!srcrect) {
+srcrect = &real_srcrect;
+}
+if (!dstrect) {
+dstrect = &real_dstrect;
+}
+return renderer->RenderCopy(renderer, texture, srcrect, dstrect,
+blendMode, scaleMode);
+}
+int
+SDL_RenderReadPixels(const SDL_Rect * rect, void *pixels, int pitch)
+{
+SDL_Renderer *renderer;
+SDL_Rect full_rect;
+if (!_this) {
+return -1;
+}
+renderer = SDL_CurrentDisplay.current_renderer;
+if (!renderer || !renderer->RenderReadPixels) {
+return -1;
+}
+if (!rect) {
+SDL_Window *window = SDL_GetWindowFromID(renderer->window);
+full_rect.x = 0;
+full_rect.y = 0;
+full_rect.w = window->w;
+full_rect.h = window->h;
+rect = &full_rect;
+}
+return renderer->RenderReadPixels(renderer, rect, pixels, pitch);
+}
+int
+SDL_RenderWritePixels(const SDL_Rect * rect, const void *pixels, int pitch)
+{
+SDL_Renderer *renderer;
+SDL_Rect full_rect;
+if (!_this) {
+return -1;
+}
+renderer = SDL_CurrentDisplay.current_renderer;
+if (!renderer || !renderer->RenderWritePixels) {
+return -1;
+}
+if (!rect) {
+SDL_Window *window = SDL_GetWindowFromID(renderer->window);
+full_rect.x = 0;
+full_rect.y = 0;
+full_rect.w = window->w;
+full_rect.h = window->h;
+rect = &full_rect;
+}
+return renderer->RenderWritePixels(renderer, rect, pixels, pitch);
+}
+void
+SDL_RenderPresent(void)
+{
+SDL_Renderer *renderer;
+if (!_this) {
+return;
+}
+renderer = SDL_CurrentDisplay.current_renderer;
+if (!renderer || !renderer->RenderPresent) {
+return;
+}
+renderer->RenderPresent(renderer);
+}
+void
+SDL_DestroyTexture(SDL_TextureID textureID)
+{
+int hash;
+SDL_Texture *prev, *texture;
+SDL_Renderer *renderer;
+if (!_this) {
+return;
+}
+/* Look up the texture in the hash table */
+hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
+prev = NULL;
+for (texture = SDL_CurrentDisplay.textures[hash]; texture;
+prev = texture, texture = texture->next) {
+if (texture->id == textureID) {
+break;
+}
+}
+if (!texture) {
+return;
+}
+/* Unlink the texture from the list */
+if (prev) {
+prev->next = texture->next;
+} else {
+SDL_CurrentDisplay.textures[hash] = texture->next;
+}
+/* Free the texture */
+renderer = texture->renderer;
+renderer->DestroyTexture(renderer, texture);
+SDL_free(texture);
+}
+void
+SDL_DestroyRenderer(SDL_WindowID windowID)
+{
+SDL_Window *window = SDL_GetWindowFromID(windowID);
+SDL_Renderer *renderer;
+int i;
+if (!window) {
+return;
+}
+renderer = window->renderer;
+if (!renderer) {
+return;
+}
+/* Free existing textures for this renderer */
+for (i = 0; i < SDL_arraysize(SDL_CurrentDisplay.textures); ++i) {
+SDL_Texture *texture;
+SDL_Texture *prev = NULL;
+SDL_Texture *next;
+for (texture = SDL_CurrentDisplay.textures[i]; texture;
+texture = next) {
+next = texture->next;
+if (texture->renderer == renderer) {
+if (prev) {
+prev->next = next;
+} else {
+SDL_CurrentDisplay.textures[i] = next;
+}
+renderer->DestroyTexture(renderer, texture);
+SDL_free(texture);
+} else {
+prev = texture;
+}
+}
+}
+/* Free the renderer instance */
+renderer->DestroyRenderer(renderer);
+/* Clear references */
+window->renderer = NULL;
+if (SDL_CurrentDisplay.current_renderer == renderer) {
+SDL_CurrentDisplay.current_renderer = NULL;
+}
+}
+void
+SDL_VideoQuit(void)
+{
+int i, j;
+if (!_this) {
+return;
+}
+/* Halt event processing before doing anything else */
+SDL_StopEventLoop();
+/* Clean up the system video */
+for (i = _this->num_displays; i--;) {
+SDL_VideoDisplay *display = &_this->displays[i];
+for (j = display->num_windows; j--;) {
+SDL_DestroyWindow(display->windows[i].id);
+}
+if (display->windows) {
+SDL_free(display->windows);
+display->windows = NULL;
+}
+display->num_windows = 0;
+}
+_this->VideoQuit(_this);
+for (i = _this->num_displays; i--;) {
+SDL_VideoDisplay *display = &_this->displays[i];
+for (j = display->num_display_modes; j--;) {
+if (display->display_modes[j].driverdata) {
+SDL_free(display->display_modes[j].driverdata);
+display->display_modes[j].driverdata = NULL;
+}
+}
+if (display->display_modes) {
+SDL_free(display->display_modes);
+display->display_modes = NULL;
+}
+if (display->desktop_mode.driverdata) {
+SDL_free(display->desktop_mode.driverdata);
+display->desktop_mode.driverdata = NULL;
+}
+if (display->palette) {
+SDL_FreePalette(display->palette);
+display->palette = NULL;
+}
+if (display->gamma) {
+SDL_free(display->gamma);
+}
+if (display->driverdata) {
+SDL_free(display->driverdata);
+}
+}
+if (_this->displays) {
+SDL_free(_this->displays);
+_this->displays = NULL;
+}
+_this->free(_this);
+_this = NULL;
 }
 /* Load the GL driver library */
-int SDL_GL_LoadLibrary(const char *path)
+int
-{
+SDL_GL_LoadLibrary(const char *path)
-	SDL_VideoDevice *video = current_video;
+{
-	SDL_VideoDevice *this = current_video;
+int retval;
-	int retval;
+retval = -1;
-	retval = -1;
+if (_this == NULL) {
-	if ( video == NULL ) {
+SDL_SetError("Video subsystem has not been initialized");
-		SDL_SetError("Video subsystem has not been initialized");
+} else {
-	} else {
+if (_this->GL_LoadLibrary) {
-		if ( video->GL_LoadLibrary ) {
+retval = _this->GL_LoadLibrary(_this, path);
-			retval = video->GL_LoadLibrary(this, path);
+} else {
-		} else {
+SDL_SetError("No dynamic GL support in video driver");
-			SDL_SetError("No dynamic GL support in video driver");
+}
-		}
+}
-	}
+return (retval);
-	return(retval);
+}
-}
+void *
-void *SDL_GL_GetProcAddress(const char* proc)
+SDL_GL_GetProcAddress(const char *proc)
 {
-	SDL_VideoDevice *video = current_video;
+void *func;
-	SDL_VideoDevice *this = current_video;
-	void *func;
+func = NULL;
+if (_this->GL_GetProcAddress) {
-	func = NULL;
+if (_this->gl_config.driver_loaded) {
-	if ( video->GL_GetProcAddress ) {
+func = _this->GL_GetProcAddress(_this, proc);
-		if ( video->gl_config.driver_loaded ) {
+} else {
-			func = video->GL_GetProcAddress(this, proc);
+SDL_SetError("No GL driver has been loaded");
-		} else {
+}
-			SDL_SetError("No GL driver has been loaded");
+} else {
-		}
+SDL_SetError("No dynamic GL support in video driver");
-	} else {
+}
-		SDL_SetError("No dynamic GL support in video driver");
+return func;
-	}
-	return func;
 }
 /* Set the specified GL attribute for setting up a GL video mode */
-int SDL_GL_SetAttribute( SDL_GLattr attr, int value )
+int
-{
+SDL_GL_SetAttribute(SDL_GLattr attr, int value)
-	int retval;
+{
-	SDL_VideoDevice *video = current_video;
+int retval;
-	retval = 0;
+retval = 0;
-	switch (attr) {
+switch (attr) {
-		case SDL_GL_RED_SIZE:
+case SDL_GL_RED_SIZE:
-			video->gl_config.red_size = value;
+_this->gl_config.red_size = value;
-			break;
+break;
-		case SDL_GL_GREEN_SIZE:
+case SDL_GL_GREEN_SIZE:
-			video->gl_config.green_size = value;
+_this->gl_config.green_size = value;
-			break;
+break;
-		case SDL_GL_BLUE_SIZE:
+case SDL_GL_BLUE_SIZE:
-			video->gl_config.blue_size = value;
+_this->gl_config.blue_size = value;
-			break;
+break;
-		case SDL_GL_ALPHA_SIZE:
+case SDL_GL_ALPHA_SIZE:
-			video->gl_config.alpha_size = value;
+_this->gl_config.alpha_size = value;
-			break;
+break;
-		case SDL_GL_DOUBLEBUFFER:
+case SDL_GL_DOUBLEBUFFER:
-			video->gl_config.double_buffer = value;
+_this->gl_config.double_buffer = value;
-			break;
+break;
-		case SDL_GL_BUFFER_SIZE:
+case SDL_GL_BUFFER_SIZE:
-			video->gl_config.buffer_size = value;
+_this->gl_config.buffer_size = value;
-			break;
+break;
-		case SDL_GL_DEPTH_SIZE:
+case SDL_GL_DEPTH_SIZE:
-			video->gl_config.depth_size = value;
+_this->gl_config.depth_size = value;
-			break;
+break;
-		case SDL_GL_STENCIL_SIZE:
+case SDL_GL_STENCIL_SIZE:
-			video->gl_config.stencil_size = value;
+_this->gl_config.stencil_size = value;
-			break;
+break;
-		case SDL_GL_ACCUM_RED_SIZE:
+case SDL_GL_ACCUM_RED_SIZE:
-			video->gl_config.accum_red_size = value;
+_this->gl_config.accum_red_size = value;
-			break;
+break;
-		case SDL_GL_ACCUM_GREEN_SIZE:
+case SDL_GL_ACCUM_GREEN_SIZE:
-			video->gl_config.accum_green_size = value;
+_this->gl_config.accum_green_size = value;
-			break;
+break;
-		case SDL_GL_ACCUM_BLUE_SIZE:
+case SDL_GL_ACCUM_BLUE_SIZE:
-			video->gl_config.accum_blue_size = value;
+_this->gl_config.accum_blue_size = value;
-			break;
+break;
-		case SDL_GL_ACCUM_ALPHA_SIZE:
+case SDL_GL_ACCUM_ALPHA_SIZE:
-			video->gl_config.accum_alpha_size = value;
+_this->gl_config.accum_alpha_size = value;
-			break;
+break;
-		case SDL_GL_STEREO:
+case SDL_GL_STEREO:
-			video->gl_config.stereo = value;
+_this->gl_config.stereo = value;
-			break;
+break;
-		case SDL_GL_MULTISAMPLEBUFFERS:
+case SDL_GL_MULTISAMPLEBUFFERS:
-			video->gl_config.multisamplebuffers = value;
+_this->gl_config.multisamplebuffers = value;
-			break;
+break;
-		case SDL_GL_MULTISAMPLESAMPLES:
+case SDL_GL_MULTISAMPLESAMPLES:
-			video->gl_config.multisamplesamples = value;
+_this->gl_config.multisamplesamples = value;
-			break;
+break;
-		case SDL_GL_ACCELERATED_VISUAL:
+case SDL_GL_ACCELERATED_VISUAL:
-			video->gl_config.accelerated = value;
+_this->gl_config.accelerated = value;
-			break;
+break;
-		case SDL_GL_SWAP_CONTROL:
+default:
-			video->gl_config.swap_control = value;
+SDL_SetError("Unknown OpenGL attribute");
-			break;
+retval = -1;
-		default:
+break;
-			SDL_SetError("Unknown OpenGL attribute");
+}
-			retval = -1;
+return (retval);
-			break;
-	}
-	return(retval);
 }
 /* Retrieve an attribute value from the windowing system. */
-int SDL_GL_GetAttribute(SDL_GLattr attr, int* value)
+int
-{
+SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
-	int retval = -1;
+{
-	SDL_VideoDevice* video = current_video;
+int retval = -1;
-	SDL_VideoDevice* this = current_video;
+if (_this->GL_GetAttribute) {
-	if ( video->GL_GetAttribute ) {
+retval = _this->GL_GetAttribute(_this, attr, value);
-		retval = this->GL_GetAttribute(this, attr, value);
+} else {
-	} else {
+*value = 0;
-		*value = 0;
+SDL_SetError("GL_GetAttribute not supported");
-		SDL_SetError("GL_GetAttribute not supported");
+}
-	}
+return retval;
-	return retval;
 }
 /* Perform a GL buffer swap on the current GL context */
-void SDL_GL_SwapBuffers(void)
+void
-{
+SDL_GL_SwapBuffers(void)
-	SDL_VideoDevice *video = current_video;
+{
-	SDL_VideoDevice *this = current_video;
+// FIXME: Track the current window context - do we provide N contexts, and match them to M windows, or is there a one-to-one mapping?
+_this->GL_SwapBuffers(_this);
-	if ( video->screen->flags & SDL_OPENGL ) {
+}
-		video->GL_SwapBuffers(this);
-	} else {
+#if 0                           // FIXME
-		SDL_SetError("OpenGL video mode has not been set");
-	}
-}
-/* Update rects with locking */
-void SDL_GL_UpdateRectsLock(SDL_VideoDevice* this, int numrects, SDL_Rect *rects)
-{
-	SDL_GL_Lock();
-	SDL_GL_UpdateRects(numrects, rects);
-	SDL_GL_Unlock();
-}
-/* Update rects without state setting and changing (the caller is responsible for it) */
-void SDL_GL_UpdateRects(int numrects, SDL_Rect *rects)
-{
-#if SDL_VIDEO_OPENGL
-	SDL_VideoDevice *this = current_video;
-	SDL_Rect update, tmp;
-	int x, y, i;
-	for ( i = 0; i < numrects; i++ )
-	{
-		tmp.y = rects[i].y;
-		tmp.h = rects[i].h;
-		for ( y = 0; y <= rects[i].h / 256; y++ )
-		{
-			tmp.x = rects[i].x;
-			tmp.w = rects[i].w;
-			for ( x = 0; x <= rects[i].w / 256; x++ )
-			{
-				update.x = tmp.x;
-				update.y = tmp.y;
-				update.w = tmp.w;
-				update.h = tmp.h;
-				if ( update.w > 256 )
-					update.w = 256;
-				if ( update.h > 256 )
-					update.h = 256;
-				this->glFlush();
-				this->glTexSubImage2D(
-					GL_TEXTURE_2D,
-					0,
-					0,
-					0,
-					update.w,
-					update.h,
-					this->is_32bit? GL_RGBA : GL_RGB,
-#ifdef GL_VERSION_1_2
-					this->is_32bit ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5,
-#else
-					GL_UNSIGNED_BYTE,
-#endif
-					(Uint8 *)this->screen->pixels +
-						this->screen->format->BytesPerPixel * update.x +
-						update.y * this->screen->pitch );
-				this->glFlush();
-				/*
-				* Note the parens around the function name:
-				* This is because some OpenGL implementations define glTexCoord etc
-				* as macros, and we don't want them expanded here.
-				*/
-				this->glBegin(GL_TRIANGLE_STRIP);
-					(this->glTexCoord2f)( 0.0, 0.0 );
-					(this->glVertex2i)( update.x, update.y );
-					(this->glTexCoord2f)( (float)(update.w / 256.0), 0.0 );
-					(this->glVertex2i)( update.x + update.w, update.y );
-					(this->glTexCoord2f)( 0.0, (float)(update.h / 256.0) );
-					(this->glVertex2i)( update.x, update.y + update.h );
-					(this->glTexCoord2f)( (float)(update.w / 256.0), (float)(update.h / 256.0) );
-					(this->glVertex2i)( update.x + update.w	, update.y + update.h );
-				this->glEnd();
-				tmp.x += 256;
-				tmp.w -= 256;
-			}
-			tmp.y += 256;
-			tmp.h -= 256;
-		}
-	}
-#endif
-}
-/* Lock == save current state */
-void SDL_GL_Lock()
-{
-#if SDL_VIDEO_OPENGL
-	lock_count--;
-	if (lock_count==-1)
-	{
-		SDL_VideoDevice *this = current_video;
-		this->glPushAttrib( GL_ALL_ATTRIB_BITS );	/* TODO: narrow range of what is saved */
-#ifdef GL_CLIENT_PIXEL_STORE_BIT
-		this->glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
-#endif
-		this->glEnable(GL_TEXTURE_2D);
-		this->glEnable(GL_BLEND);
-		this->glDisable(GL_FOG);
-		this->glDisable(GL_ALPHA_TEST);
-		this->glDisable(GL_DEPTH_TEST);
-		this->glDisable(GL_SCISSOR_TEST);
-		this->glDisable(GL_STENCIL_TEST);
-		this->glDisable(GL_CULL_FACE);
-		this->glBindTexture( GL_TEXTURE_2D, this->texture );
-		this->glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
-		this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
-		this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
-		this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
-		this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
-		this->glPixelStorei( GL_UNPACK_ROW_LENGTH, this->screen->pitch / this->screen->format->BytesPerPixel );
-		this->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		(this->glColor4f)(1.0, 1.0, 1.0, 1.0);		/* Solaris workaround */
-		this->glViewport(0, 0, this->screen->w, this->screen->h);
-		this->glMatrixMode(GL_PROJECTION);
-		this->glPushMatrix();
-		this->glLoadIdentity();
-		this->glOrtho(0.0, (GLdouble) this->screen->w, (GLdouble) this->screen->h, 0.0, 0.0, 1.0);
-		this->glMatrixMode(GL_MODELVIEW);
-		this->glPushMatrix();
-		this->glLoadIdentity();
-	}
-#endif
-}
-/* Unlock == restore saved state */
-void SDL_GL_Unlock()
-{
-#if SDL_VIDEO_OPENGL
-	lock_count++;
-	if (lock_count==0)
-	{
-		SDL_VideoDevice *this = current_video;
-		this->glPopMatrix();
-		this->glMatrixMode(GL_PROJECTION);
-		this->glPopMatrix();
-		this->glPopClientAttrib();
-		this->glPopAttrib();
-	}
-#endif
-}
-/*
-* Sets/Gets the title and icon text of the display window, if any.
-*/
-void SDL_WM_SetCaption (const char *title, const char *icon)
-{
-	SDL_VideoDevice *video = current_video;
-	SDL_VideoDevice *this  = current_video;
-	if ( video ) {
-		if ( title ) {
-			if ( video->wm_title ) {
-				SDL_free(video->wm_title);
-			}
-			video->wm_title = SDL_strdup(title);
-		}
-		if ( icon ) {
-			if ( video->wm_icon ) {
-				SDL_free(video->wm_icon);
-			}
-			video->wm_icon = SDL_strdup(icon);
-		}
-		if ( (title || icon) && (video->SetCaption != NULL) ) {
-			video->SetCaption(this, video->wm_title,video->wm_icon);
-		}
-	}
-}
-void SDL_WM_GetCaption (char **title, char **icon)
-{
-	SDL_VideoDevice *video = current_video;
-	if ( video ) {
-		if ( title ) {
-			*title = video->wm_title;
-		}
-		if ( icon ) {
-			*icon = video->wm_icon;
-		}
-	}
-}
 /* Utility function used by SDL_WM_SetIcon();
 * flags & 1 for color key, flags & 2 for alpha channel. */
-static void CreateMaskFromColorKeyOrAlpha(SDL_Surface *icon, Uint8 *mask, int flags)
+static void
-{
+CreateMaskFromColorKeyOrAlpha(SDL_Surface * icon, Uint8 * mask, int flags)
-	int x, y;
+{
-	Uint32 colorkey;
+int x, y;
+Uint32 colorkey;
 #define SET_MASKBIT(icon, x, y, mask) \
 	mask[(y*((icon->w+7)/8))+(x/8)] &= ~(0x01<<(7-(x%8)))
-	colorkey = icon->format->colorkey;
+colorkey = icon->format->colorkey;
-	switch (icon->format->BytesPerPixel) {
+switch (icon->format->BytesPerPixel) {
-		case 1: { Uint8 *pixels;
+case 1:
-			for ( y=0; y<icon->h; ++y ) {
+{
-				pixels = (Uint8 *)icon->pixels + y*icon->pitch;
+Uint8 *pixels;
-				for ( x=0; x<icon->w; ++x ) {
+for (y = 0; y < icon->h; ++y) {
-					if ( *pixels++ == colorkey ) {
+pixels = (Uint8 *) icon->pixels + y * icon->pitch;
-						SET_MASKBIT(icon, x, y, mask);
+for (x = 0; x < icon->w; ++x) {
-					}
+if (*pixels++ == colorkey) {
-				}
+SET_MASKBIT(icon, x, y, mask);
-			}
+}
-		}
+}
-		break;
+}
+}
-		case 2: { Uint16 *pixels;
+break;
-			for ( y=0; y<icon->h; ++y ) {
-				pixels = (Uint16 *)icon->pixels +
+case 2:
-				                   y*icon->pitch/2;
+{
-				for ( x=0; x<icon->w; ++x ) {
+Uint16 *pixels;
-					if ( (flags & 1) && *pixels == colorkey ) {
+for (y = 0; y < icon->h; ++y) {
-						SET_MASKBIT(icon, x, y, mask);
+pixels = (Uint16 *) icon->pixels + y * icon->pitch / 2;
-					} else if((flags & 2) && (*pixels & icon->format->Amask) == 0) {
+for (x = 0; x < icon->w; ++x) {
-						SET_MASKBIT(icon, x, y, mask);
+if ((flags & 1) && *pixels == colorkey) {
-					}
+SET_MASKBIT(icon, x, y, mask);
-					pixels++;
+} else if ((flags & 2)
-				}
+&& (*pixels & icon->format->Amask) == 0) {
-			}
+SET_MASKBIT(icon, x, y, mask);
-		}
+}
-		break;
+pixels++;
+}
-		case 4: { Uint32 *pixels;
+}
-			for ( y=0; y<icon->h; ++y ) {
+}
-				pixels = (Uint32 *)icon->pixels +
+break;
-				                   y*icon->pitch/4;
-				for ( x=0; x<icon->w; ++x ) {
+case 4:
-					if ( (flags & 1) && *pixels == colorkey ) {
+{
-						SET_MASKBIT(icon, x, y, mask);
+Uint32 *pixels;
-					} else if((flags & 2) && (*pixels & icon->format->Amask) == 0) {
+for (y = 0; y < icon->h; ++y) {
-						SET_MASKBIT(icon, x, y, mask);
+pixels = (Uint32 *) icon->pixels + y * icon->pitch / 4;
-					}
+for (x = 0; x < icon->w; ++x) {
-					pixels++;
+if ((flags & 1) && *pixels == colorkey) {
-				}
+SET_MASKBIT(icon, x, y, mask);
-			}
+} else if ((flags & 2)
-		}
+&& (*pixels & icon->format->Amask) == 0) {
-		break;
+SET_MASKBIT(icon, x, y, mask);
-	}
+}
+pixels++;
+}
+}
+}
+break;
+}
 }
 /*
 * Sets the window manager icon for the display window.
 */
-void SDL_WM_SetIcon (SDL_Surface *icon, Uint8 *mask)
+void
-{
+SDL_WM_SetIcon(SDL_Surface * icon, Uint8 * mask)
-	SDL_VideoDevice *video = current_video;
+{
-	SDL_VideoDevice *this  = current_video;
+if (icon && _this->SetIcon) {
+/* Generate a mask if necessary, and create the icon! */
-	if ( icon && video->SetIcon ) {
+if (mask == NULL) {
-		/* Generate a mask if necessary, and create the icon! */
+int mask_len = icon->h * (icon->w + 7) / 8;
-		if ( mask == NULL ) {
+int flags = 0;
-			int mask_len = icon->h*(icon->w+7)/8;
+mask = (Uint8 *) SDL_malloc(mask_len);
-			int flags = 0;
+if (mask == NULL) {
-			mask = (Uint8 *)SDL_malloc(mask_len);
+return;
-			if ( mask == NULL ) {
+}
-				return;
+SDL_memset(mask, ~0, mask_len);
-			}
+if (icon->flags & SDL_SRCCOLORKEY)
-			SDL_memset(mask, ~0, mask_len);
+flags |= 1;
-			if ( icon->flags & SDL_SRCCOLORKEY ) flags |= 1;
+if (icon->flags & SDL_SRCALPHA)
-			if ( icon->flags & SDL_SRCALPHA ) flags |= 2;
+flags |= 2;
-			if( flags ) {
+if (flags) {
-				CreateMaskFromColorKeyOrAlpha(icon, mask, flags);
+CreateMaskFromColorKeyOrAlpha(icon, mask, flags);
-			}
+}
-			video->SetIcon(video, icon, mask);
+_this->SetIcon(_this, icon, mask);
-			SDL_free(mask);
+SDL_free(mask);
-		} else {
+} else {
-			video->SetIcon(this, icon, mask);
+_this->SetIcon(_this, icon, mask);
-		}
+}
-	}
+}
 }
+#endif
-/*
-* Grab or ungrab the keyboard and mouse input.
+SDL_bool
-* This function returns the final grab mode after calling the
+SDL_GetWindowWMInfo(SDL_WindowID windowID, struct SDL_SysWMinfo *info)
-* driver dependent function.
+{
-*/
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-static SDL_GrabMode SDL_WM_GrabInputRaw(SDL_GrabMode mode)
-{
+if (!window || !_this->GetWindowWMInfo) {
-	SDL_VideoDevice *video = current_video;
+return SDL_FALSE;
-	SDL_VideoDevice *this  = current_video;
+}
+return (_this->GetWindowWMInfo(_this, window, info));
-	/* Only do something if we have support for grabs */
+}
-	if ( video->GrabInput == NULL ) {
-		return(video->input_grab);
+/* vi: set ts=4 sw=4 expandtab: */
-	}
-	/* If the final grab mode if off, only then do we actually grab */
-#ifdef DEBUG_GRAB
-printf("SDL_WM_GrabInputRaw(%d) ... ", mode);
-#endif
-	if ( mode == SDL_GRAB_OFF ) {
-		if ( video->input_grab != SDL_GRAB_OFF ) {
-			mode = video->GrabInput(this, mode);
-		}
-	} else {
-		if ( video->input_grab == SDL_GRAB_OFF ) {
-			mode = video->GrabInput(this, mode);
-		}
-	}
-	if ( mode != video->input_grab ) {
-		video->input_grab = mode;
-		if ( video->CheckMouseMode ) {
-			video->CheckMouseMode(this);
-		}
-	}
-#ifdef DEBUG_GRAB
-printf("Final mode %d\n", video->input_grab);
-#endif
-	/* Return the final grab state */
-	if ( mode >= SDL_GRAB_FULLSCREEN ) {
-		mode -= SDL_GRAB_FULLSCREEN;
-	}
-	return(mode);
-}
-SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode)
-{
-	SDL_VideoDevice *video = current_video;
-	/* If the video isn't initialized yet, we can't do anything */
-	if ( ! video ) {
-		return SDL_GRAB_OFF;
-	}
-	/* Return the current mode on query */
-	if ( mode == SDL_GRAB_QUERY ) {
-		mode = video->input_grab;
-		if ( mode >= SDL_GRAB_FULLSCREEN ) {
-			mode -= SDL_GRAB_FULLSCREEN;
-		}
-		return(mode);
-	}
-#ifdef DEBUG_GRAB
-printf("SDL_WM_GrabInput(%d) ... ", mode);
-#endif
-	/* If the video surface is fullscreen, we always grab */
-	if ( mode >= SDL_GRAB_FULLSCREEN ) {
-		mode -= SDL_GRAB_FULLSCREEN;
-	}
-	if ( SDL_VideoSurface && (SDL_VideoSurface->flags & SDL_FULLSCREEN) ) {
-		mode += SDL_GRAB_FULLSCREEN;
-	}
-	return(SDL_WM_GrabInputRaw(mode));
-}
-static SDL_GrabMode SDL_WM_GrabInputOff(void)
-{
-	SDL_GrabMode mode;
-	/* First query the current grab state */
-	mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
-	/* Now explicitly turn off input grab */
-	SDL_WM_GrabInputRaw(SDL_GRAB_OFF);
-	/* Return the old state */
-	return(mode);
-}
-/*
-* Iconify the window in window managed environments.
-* A successful iconification will result in an SDL_APPACTIVE loss event.
-*/
-int SDL_WM_IconifyWindow(void)
-{
-	SDL_VideoDevice *video = current_video;
-	SDL_VideoDevice *this  = current_video;
-	int retval;
-	retval = 0;
-	if ( video->IconifyWindow ) {
-		retval = video->IconifyWindow(this);
-	}
-	return(retval);
-}
-/*
-* Toggle fullscreen mode
-*/
-int SDL_WM_ToggleFullScreen(SDL_Surface *surface)
-{
-	SDL_VideoDevice *video = current_video;
-	SDL_VideoDevice *this  = current_video;
-	int toggled;
-	toggled = 0;
-	if ( SDL_PublicSurface && (surface == SDL_PublicSurface) &&
-	     video->ToggleFullScreen ) {
-		if ( surface->flags & SDL_FULLSCREEN ) {
-			toggled = video->ToggleFullScreen(this, 0);
-			if ( toggled ) {
-				SDL_VideoSurface->flags &= ~SDL_FULLSCREEN;
-				SDL_PublicSurface->flags &= ~SDL_FULLSCREEN;
-			}
-		} else {
-			toggled = video->ToggleFullScreen(this, 1);
-			if ( toggled ) {
-				SDL_VideoSurface->flags |= SDL_FULLSCREEN;
-				SDL_PublicSurface->flags |= SDL_FULLSCREEN;
-			}
-		}
-		/* Double-check the grab state inside SDL_WM_GrabInput() */
-		if ( toggled ) {
-			SDL_WM_GrabInput(video->input_grab);
-		}
-	}
-	return(toggled);
-}
-/*
-* Get some platform dependent window manager information
-*/
-int SDL_GetWMInfo (SDL_SysWMinfo *info)
-{
-	SDL_VideoDevice *video = current_video;
-	SDL_VideoDevice *this  = current_video;
-	if ( video && video->GetWMInfo ) {
-		return(video->GetWMInfo(this, info));
-	} else {
-		return(0);
-	}
-}

Mercurial > sdl-ios-xcode

comparison src/video/SDL_video.c @ 1895:c121d94672cb