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

comparison src/video/SDL_video.c @ 2753:0969758c8809

indent

author	Sam Lantinga <slouken@libsdl.org>
date	Mon, 15 Sep 2008 04:32:36 +0000
parents	587d2b5fb805
children	fa1095d42a5b

comparison

equal deleted inserted replaced

-:edd2839b36f7
+:0969758c8809
 #include "../events/SDL_sysevents.h"
 #include "../events/SDL_events_c.h"
 #if SDL_VIDEO_OPENGL_ES
 #include "SDL_opengles.h"
-#endif				/* SDL_VIDEO_OPENGL_ES */
+#endif /* SDL_VIDEO_OPENGL_ES */
 #if SDL_VIDEO_OPENGL
 #include "SDL_opengl.h"
 /* On Windows, windows.h defines CreateWindow */
 #ifdef CreateWindow
 #undef CreateWindow
 #endif
-#endif				/* SDL_VIDEO_OPENGL */
+#endif /* SDL_VIDEO_OPENGL */
 /* Available video drivers */
 static VideoBootStrap *bootstrap[] = {
 #if SDL_VIDEO_DRIVER_COCOA
-	&COCOA_bootstrap,
+&COCOA_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_X11
-	&X11_bootstrap,
+&X11_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_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_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_WIN32
-	&WIN32_bootstrap,
+&WIN32_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_BWINDOW
-	&BWINDOW_bootstrap,
+&BWINDOW_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_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_NDS
-	&NDS_bootstrap,
+&NDS_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_UIKIT
-	&UIKIT_bootstrap,
+&UIKIT_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_DUMMY
-	&DUMMY_bootstrap,
+&DUMMY_bootstrap,
 #endif
-	NULL
+NULL
 };
 static SDL_VideoDevice *_this = NULL;
 /* Various local functions */
-int             SDL_VideoInit(const char *driver_name, Uint32 flags);
+int SDL_VideoInit(const char *driver_name, Uint32 flags);
-void            SDL_VideoQuit(void);
+void SDL_VideoQuit(void);
 static int
 cmpmodes(const void *A, const void *B)
 {
-	SDL_DisplayMode a = *(const SDL_DisplayMode *) A;
+SDL_DisplayMode a = *(const SDL_DisplayMode *) A;
-	SDL_DisplayMode b = *(const SDL_DisplayMode *) B;
+SDL_DisplayMode b = *(const SDL_DisplayMode *) B;
-	if (a.w != b.w) {
+if (a.w != b.w) {
-		return b.w - a.w;
+return b.w - a.w;
-	}
+}
-	if (a.h != b.h) {
+if (a.h != b.h) {
-		return b.h - a.h;
+return b.h - a.h;
-	}
+}
-	if (SDL_BITSPERPIXEL(a.format) != SDL_BITSPERPIXEL(b.format)) {
+if (SDL_BITSPERPIXEL(a.format) != SDL_BITSPERPIXEL(b.format)) {
-		return SDL_BITSPERPIXEL(b.format) - SDL_BITSPERPIXEL(a.format);
+return SDL_BITSPERPIXEL(b.format) - SDL_BITSPERPIXEL(a.format);
-	}
+}
-	if (a.refresh_rate != b.refresh_rate) {
+if (a.refresh_rate != b.refresh_rate) {
-		return b.refresh_rate - a.refresh_rate;
+return b.refresh_rate - a.refresh_rate;
-	}
+}
-	return 0;
+return 0;
 }
 static void
 SDL_UninitializedVideo()
 {
-	SDL_SetError("Video subsystem has not been initialized");
+SDL_SetError("Video subsystem has not been initialized");
 }
 int
 SDL_GetNumVideoDrivers(void)
 {
-	return SDL_arraysize(bootstrap) - 1;
+return SDL_arraysize(bootstrap) - 1;
 }
-const char     *
+const char *
 SDL_GetVideoDriver(int index)
 {
-	if (index >= 0 && index < SDL_GetNumVideoDrivers()) {
+if (index >= 0 && index < SDL_GetNumVideoDrivers()) {
-		return bootstrap[index]->name;
+return bootstrap[index]->name;
-	}
+}
-	return NULL;
+return NULL;
 }
 /*
 * Initialize the video and event subsystems -- determine native pixel format
 */
 int
 SDL_VideoInit(const char *driver_name, Uint32 flags)
 {
-	SDL_VideoDevice *video;
+SDL_VideoDevice *video;
-	int             index;
+int index;
-	int             i;
+int i;
-	/* 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
-	/* Start the event loop */
+/* Start the event loop */
-	if (SDL_StartEventLoop(flags) < 0) {
+if (SDL_StartEventLoop(flags) < 0) {
-		return -1;
+return -1;
-	}
+}
-	/* Check to make sure we don't overwrite '_this' */
+/* Check to make sure we don't overwrite '_this' */
-	if (_this != NULL) {
+if (_this != NULL) {
-		SDL_VideoQuit();
+SDL_VideoQuit();
-	}
+}
-	/* Select the proper video driver */
+/* Select the proper video driver */
-	index = 0;
+index = 0;
-	video = NULL;
+video = NULL;
-	if (driver_name == NULL) {
+if (driver_name == NULL) {
-		driver_name = SDL_getenv("SDL_VIDEODRIVER");
+driver_name = SDL_getenv("SDL_VIDEODRIVER");
-	}
+}
-	if (driver_name != NULL) {
+if (driver_name != NULL) {
-		for (i = 0; bootstrap[i]; ++i) {
+for (i = 0; bootstrap[i]; ++i) {
-			if (SDL_strcasecmp(bootstrap[i]->name, driver_name) == 0) {
+if (SDL_strcasecmp(bootstrap[i]->name, driver_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) {
-		if (driver_name) {
+if (driver_name) {
-			SDL_SetError("%s not available", driver_name);
+SDL_SetError("%s not available", driver_name);
-		} else {
+} else {
-			SDL_SetError("No available video device");
+SDL_SetError("No available video device");
-		}
+}
-		return -1;
+return -1;
-	}
+}
-	_this = video;
+_this = video;
-	_this->name = bootstrap[i]->name;
+_this->name = bootstrap[i]->name;
-	_this->next_object_id = 1;
+_this->next_object_id = 1;
-	/* Set some very sane GL defaults */
+/* Set some very sane GL defaults */
-	_this->gl_config.driver_loaded = 0;
+_this->gl_config.driver_loaded = 0;
-	_this->gl_config.dll_handle = NULL;
+_this->gl_config.dll_handle = NULL;
-	_this->gl_config.red_size = 3;
+_this->gl_config.red_size = 3;
-	_this->gl_config.green_size = 3;
+_this->gl_config.green_size = 3;
-	_this->gl_config.blue_size = 2;
+_this->gl_config.blue_size = 2;
-	_this->gl_config.alpha_size = 0;
+_this->gl_config.alpha_size = 0;
-	_this->gl_config.buffer_size = 0;
+_this->gl_config.buffer_size = 0;
-	_this->gl_config.depth_size = 16;
+_this->gl_config.depth_size = 16;
-	_this->gl_config.stencil_size = 0;
+_this->gl_config.stencil_size = 0;
-	_this->gl_config.double_buffer = 1;
+_this->gl_config.double_buffer = 1;
-	_this->gl_config.accum_red_size = 0;
+_this->gl_config.accum_red_size = 0;
-	_this->gl_config.accum_green_size = 0;
+_this->gl_config.accum_green_size = 0;
-	_this->gl_config.accum_blue_size = 0;
+_this->gl_config.accum_blue_size = 0;
-	_this->gl_config.accum_alpha_size = 0;
+_this->gl_config.accum_alpha_size = 0;
-	_this->gl_config.stereo = 0;
+_this->gl_config.stereo = 0;
-	_this->gl_config.multisamplebuffers = 0;
+_this->gl_config.multisamplebuffers = 0;
-	_this->gl_config.multisamplesamples = 0;
+_this->gl_config.multisamplesamples = 0;
-	_this->gl_config.retained_backing = 1;
+_this->gl_config.retained_backing = 1;
-	_this->gl_config.accelerated = -1;	/* not known, don't set */
+_this->gl_config.accelerated = -1;  /* not known, don't set */
-	/* Initialize the video subsystem */
+/* Initialize the video subsystem */
-	if (_this->VideoInit(_this) < 0) {
+if (_this->VideoInit(_this) < 0) {
-		SDL_VideoQuit();
+SDL_VideoQuit();
-		return -1;
+return -1;
-	}
+}
-	/* Make sure some displays were added */
+/* Make sure some displays were added */
-	if (_this->num_displays == 0) {
+if (_this->num_displays == 0) {
-		SDL_SetError("The video driver did not add any displays");
+SDL_SetError("The video driver did not add any displays");
-		SDL_VideoQuit();
+SDL_VideoQuit();
-		return (-1);
+return (-1);
-	}
+}
-	/* The software renderer is always available */
+/* The software renderer is always available */
-	for (i = 0; i < _this->num_displays; ++i) {
+for (i = 0; i < _this->num_displays; ++i) {
 #if SDL_VIDEO_RENDER_OGL
-		SDL_AddRenderDriver(i, &GL_RenderDriver);
+SDL_AddRenderDriver(i, &GL_RenderDriver);
 #endif
 #if SDL_VIDEO_RENDER_OGL_ES
-		SDL_AddRenderDriver(i, &GL_ES_RenderDriver);
+SDL_AddRenderDriver(i, &GL_ES_RenderDriver);
 #endif
-		if (_this->displays[i].num_render_drivers > 0) {
+if (_this->displays[i].num_render_drivers > 0) {
-			SDL_AddRenderDriver(i, &SW_RenderDriver);
+SDL_AddRenderDriver(i, &SW_RenderDriver);
-		}
+}
-	}
+}
-	/* We're ready to go! */
+/* We're ready to go! */
-	return 0;
+return 0;
 }
-const char     *
+const char *
 SDL_GetCurrentVideoDriver()
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return NULL;
+return NULL;
-	}
+}
-	return _this->name;
+return _this->name;
 }
 SDL_VideoDevice *
 SDL_GetVideoDevice()
 {
-	return _this;
+return _this;
 }
 int
 SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode)
 {
-	SDL_VideoDisplay display;
+SDL_VideoDisplay display;
-	SDL_zero(display);
+SDL_zero(display);
-	if (desktop_mode) {
+if (desktop_mode) {
-		display.desktop_mode = *desktop_mode;
+display.desktop_mode = *desktop_mode;
-	}
+}
-	display.current_mode = display.desktop_mode;
+display.current_mode = display.desktop_mode;
-	return SDL_AddVideoDisplay(&display);
+return SDL_AddVideoDisplay(&display);
 }
 int
 SDL_AddVideoDisplay(const SDL_VideoDisplay * display)
 {
-	SDL_VideoDisplay *displays;
+SDL_VideoDisplay *displays;
-	int             index = -1;
+int index = -1;
-	displays =
+displays =
-		SDL_realloc(_this->displays,
+SDL_realloc(_this->displays,
-			    (_this->num_displays + 1) * sizeof(*displays));
+(_this->num_displays + 1) * sizeof(*displays));
-	if (displays) {
+if (displays) {
-		index = _this->num_displays++;
+index = _this->num_displays++;
-		displays[index] = *display;
+displays[index] = *display;
-		displays[index].device = _this;
+displays[index].device = _this;
-		_this->displays = displays;
+_this->displays = displays;
-	} else {
+} else {
-		SDL_OutOfMemory();
+SDL_OutOfMemory();
-	}
+}
-	return index;
+return index;
 }
 int
 SDL_GetNumVideoDisplays(void)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return 0;
+return 0;
-	}
+}
-	return _this->num_displays;
+return _this->num_displays;
 }
 int
 SDL_SelectVideoDisplay(int index)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return (-1);
+return (-1);
-	}
+}
-	if (index < 0 || index >= _this->num_displays) {
+if (index < 0 || index >= _this->num_displays) {
-		SDL_SetError("index must be in the range 0 - %d",
+SDL_SetError("index must be in the range 0 - %d",
-			     _this->num_displays - 1);
+_this->num_displays - 1);
-		return -1;
+return -1;
-	}
+}
-	_this->current_display = index;
+_this->current_display = index;
-	return 0;
+return 0;
 }
 int
 SDL_GetCurrentVideoDisplay(void)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return (-1);
+return (-1);
-	}
+}
-	return _this->current_display;
+return _this->current_display;
 }
 SDL_bool
 SDL_AddDisplayMode(int displayIndex, const SDL_DisplayMode * mode)
 {
-	SDL_VideoDisplay *display = &_this->displays[displayIndex];
+SDL_VideoDisplay *display = &_this->displays[displayIndex];
-	SDL_DisplayMode *modes;
+SDL_DisplayMode *modes;
-	int             i, nmodes;
+int i, nmodes;
-	/* Make sure we don't already have the mode in the list */
+/* Make sure we don't already have the mode in the list */
-	modes = display->display_modes;
+modes = display->display_modes;
-	nmodes = display->num_display_modes;
+nmodes = display->num_display_modes;
-	for (i = nmodes; i--;) {
+for (i = nmodes; i--;) {
-		if (SDL_memcmp(mode, &modes[i], sizeof(*mode)) == 0) {
+if (SDL_memcmp(mode, &modes[i], sizeof(*mode)) == 0) {
-			return SDL_FALSE;
+return SDL_FALSE;
-		}
+}
-	}
+}
-	/* Go ahead and add the new mode */
+/* Go ahead and add the new mode */
-	if (nmodes == display->max_display_modes) {
+if (nmodes == display->max_display_modes) {
-		modes =
+modes =
-			SDL_realloc(modes,
+SDL_realloc(modes,
-			(display->max_display_modes + 32) * sizeof(*modes));
+(display->max_display_modes + 32) * sizeof(*modes));
-		if (!modes) {
+if (!modes) {
-			return SDL_FALSE;
+return SDL_FALSE;
-		}
+}
-		display->display_modes = modes;
+display->display_modes = modes;
-		display->max_display_modes += 32;
+display->max_display_modes += 32;
-	}
+}
-	modes[nmodes] = *mode;
+modes[nmodes] = *mode;
-	display->num_display_modes++;
+display->num_display_modes++;
-	return SDL_TRUE;
+return SDL_TRUE;
 }
 int
 SDL_GetNumDisplayModes()
 {
-	if (_this) {
+if (_this) {
-		SDL_VideoDisplay *display = &SDL_CurrentDisplay;
+SDL_VideoDisplay *display = &SDL_CurrentDisplay;
-		if (!display->num_display_modes && _this->GetDisplayModes) {
+if (!display->num_display_modes && _this->GetDisplayModes) {
-			_this->GetDisplayModes(_this);
+_this->GetDisplayModes(_this);
-			SDL_qsort(display->display_modes, display->num_display_modes,
+SDL_qsort(display->display_modes, display->num_display_modes,
-				  sizeof(SDL_DisplayMode), cmpmodes);
+sizeof(SDL_DisplayMode), cmpmodes);
-		}
+}
-		return display->num_display_modes;
+return display->num_display_modes;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_GetDisplayMode(int index, SDL_DisplayMode * mode)
 {
-	if (index < 0 || index >= SDL_GetNumDisplayModes()) {
+if (index < 0 || index >= SDL_GetNumDisplayModes()) {
-		SDL_SetError("index must be in the range of 0 - %d",
+SDL_SetError("index must be in the range of 0 - %d",
-			     SDL_GetNumDisplayModes() - 1);
+SDL_GetNumDisplayModes() - 1);
-		return -1;
+return -1;
-	}
+}
-	if (mode) {
+if (mode) {
-		*mode = SDL_CurrentDisplay.display_modes[index];
+*mode = SDL_CurrentDisplay.display_modes[index];
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_GetDesktopDisplayMode(SDL_DisplayMode * mode)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (mode) {
+if (mode) {
-		*mode = SDL_CurrentDisplay.desktop_mode;
+*mode = SDL_CurrentDisplay.desktop_mode;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_GetCurrentDisplayMode(SDL_DisplayMode * mode)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (mode) {
+if (mode) {
-		*mode = SDL_CurrentDisplay.current_mode;
+*mode = SDL_CurrentDisplay.current_mode;
-	}
+}
-	return 0;
+return 0;
 }
 SDL_DisplayMode *
 SDL_GetClosestDisplayMode(const SDL_DisplayMode * mode,
-			  SDL_DisplayMode * closest)
+SDL_DisplayMode * closest)
 {
-	Uint32          target_format;
+Uint32 target_format;
-	int             target_refresh_rate;
+int target_refresh_rate;
-	int             i;
+int i;
-	SDL_DisplayMode *current, *match;
+SDL_DisplayMode *current, *match;
-	if (!_this || !mode || !closest) {
+if (!_this || !mode || !closest) {
-		return NULL;
+return NULL;
-	}
+}
-	/* Default to the desktop format */
+/* Default to the desktop format */
-	if (mode->format) {
+if (mode->format) {
-		target_format = mode->format;
+target_format = mode->format;
-	} else {
+} else {
-		target_format = SDL_CurrentDisplay.desktop_mode.format;
+target_format = SDL_CurrentDisplay.desktop_mode.format;
-	}
+}
-	/* Default to the desktop refresh rate */
+/* Default to the desktop refresh rate */
-	if (mode->refresh_rate) {
+if (mode->refresh_rate) {
-		target_refresh_rate = mode->refresh_rate;
+target_refresh_rate = mode->refresh_rate;
-	} else {
+} else {
-		target_refresh_rate = SDL_CurrentDisplay.desktop_mode.refresh_rate;
+target_refresh_rate = SDL_CurrentDisplay.desktop_mode.refresh_rate;
-	}
+}
-	match = NULL;
+match = NULL;
-	for (i = 0; i < SDL_GetNumDisplayModes(); ++i) {
+for (i = 0; i < SDL_GetNumDisplayModes(); ++i) {
-		current = &SDL_CurrentDisplay.display_modes[i];
+current = &SDL_CurrentDisplay.display_modes[i];
-		if ((current->w && current->h) &&
+if ((current->w && current->h) &&
-		    (current->w < mode->w || current->h < mode->h)) {
+(current->w < mode->w || current->h < mode->h)) {
-			/* Out of sorted modes large enough here */
+/* Out of sorted modes large enough here */
-			break;
+break;
-		}
+}
-		if (!match || current->w < match->w || current->h < match->h) {
+if (!match || current->w < match->w || current->h < match->h) {
-			match = current;
+match = current;
-			continue;
+continue;
-		}
+}
-		if (current->format != match->format) {
+if (current->format != match->format) {
-			/* Sorted highest depth to lowest */
+/* Sorted highest depth to lowest */
-			if (current->format == target_format ||
+if (current->format == target_format ||
-			    (SDL_BITSPERPIXEL(current->format) >=
+(SDL_BITSPERPIXEL(current->format) >=
-			     SDL_BITSPERPIXEL(target_format)
+SDL_BITSPERPIXEL(target_format)
-			     && SDL_PIXELTYPE(current->format) ==
+&& SDL_PIXELTYPE(current->format) ==
-			     SDL_PIXELTYPE(target_format))) {
+SDL_PIXELTYPE(target_format))) {
-				match = current;
+match = current;
-			}
+}
-			continue;
+continue;
-		}
+}
-		if (current->refresh_rate != match->refresh_rate) {
+if (current->refresh_rate != match->refresh_rate) {
-			/* Sorted highest refresh to lowest */
+/* Sorted highest refresh to lowest */
-			if (current->refresh_rate >= target_refresh_rate) {
+if (current->refresh_rate >= target_refresh_rate) {
-				match = current;
+match = current;
-			}
+}
-		}
+}
-	}
+}
-	if (match) {
+if (match) {
-		if (match->format) {
+if (match->format) {
-			closest->format = match->format;
+closest->format = match->format;
-		} else {
+} else {
-			closest->format = mode->format;
+closest->format = mode->format;
-		}
+}
-		if (match->w && match->h) {
+if (match->w && match->h) {
-			closest->w = match->w;
+closest->w = match->w;
-			closest->h = match->h;
+closest->h = match->h;
-		} else {
+} else {
-			closest->w = mode->w;
+closest->w = mode->w;
-			closest->h = mode->h;
+closest->h = mode->h;
-		}
+}
-		if (match->refresh_rate) {
+if (match->refresh_rate) {
-			closest->refresh_rate = match->refresh_rate;
+closest->refresh_rate = match->refresh_rate;
-		} else {
+} else {
-			closest->refresh_rate = mode->refresh_rate;
+closest->refresh_rate = mode->refresh_rate;
-		}
+}
-		closest->driverdata = match->driverdata;
+closest->driverdata = match->driverdata;
-		/*
+/*
-		 * Pick some reasonable defaults if the app and driver don't
+* Pick some reasonable defaults if the app and driver don't
-		 * care
+* care
-		 */
+*/
-		if (!closest->format) {
+if (!closest->format) {
-			closest->format = SDL_PIXELFORMAT_RGB888;
+closest->format = SDL_PIXELFORMAT_RGB888;
-		}
+}
-		if (!closest->w) {
+if (!closest->w) {
-			closest->w = 640;
+closest->w = 640;
-		}
+}
-		if (!closest->h) {
+if (!closest->h) {
-			closest->h = 480;
+closest->h = 480;
-		}
+}
-		return closest;
+return closest;
-	}
+}
-	return NULL;
+return NULL;
 }
 int
 SDL_SetDisplayMode(const SDL_DisplayMode * mode)
 {
-	SDL_VideoDisplay *display;
+SDL_VideoDisplay *display;
-	SDL_DisplayMode display_mode;
+SDL_DisplayMode display_mode;
-	SDL_DisplayMode current_mode;
+SDL_DisplayMode current_mode;
-	int             i, ncolors;
+int i, ncolors;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	display = &SDL_CurrentDisplay;
+display = &SDL_CurrentDisplay;
-	if (!mode) {
+if (!mode) {
-		mode = &display->desktop_mode;
+mode = &display->desktop_mode;
-	}
+}
-	display_mode = *mode;
+display_mode = *mode;
-	/* Default to the current mode */
+/* Default to the current mode */
-	if (!display_mode.format) {
+if (!display_mode.format) {
-		display_mode.format = display->current_mode.format;
+display_mode.format = display->current_mode.format;
-	}
+}
-	if (!display_mode.w) {
+if (!display_mode.w) {
-		display_mode.w = display->current_mode.w;
+display_mode.w = display->current_mode.w;
-	}
+}
-	if (!display_mode.h) {
+if (!display_mode.h) {
-		display_mode.h = display->current_mode.h;
+display_mode.h = display->current_mode.h;
-	}
+}
-	if (!display_mode.refresh_rate) {
+if (!display_mode.refresh_rate) {
-		display_mode.refresh_rate = display->current_mode.refresh_rate;
+display_mode.refresh_rate = display->current_mode.refresh_rate;
-	}
+}
-	/* Get a good video mode, the closest one possible */
+/* Get a good video mode, the closest one possible */
-	if (!SDL_GetClosestDisplayMode(&display_mode, &display_mode)) {
+if (!SDL_GetClosestDisplayMode(&display_mode, &display_mode)) {
-		SDL_SetError("No video mode large enough for %dx%d",
+SDL_SetError("No video mode large enough for %dx%d",
-			     display_mode.w, display_mode.h);
+display_mode.w, display_mode.h);
-		return -1;
+return -1;
-	}
+}
-	/* See if there's anything left to do */
+/* See if there's anything left to do */
-	SDL_GetCurrentDisplayMode(&current_mode);
+SDL_GetCurrentDisplayMode(&current_mode);
-	if (SDL_memcmp(&display_mode, &current_mode, sizeof(display_mode)) == 0) {
+if (SDL_memcmp(&display_mode, &current_mode, sizeof(display_mode)) == 0) {
-		return 0;
+return 0;
-	}
+}
-	/* Actually change the display mode */
+/* Actually change the display mode */
-	if (_this->SetDisplayMode(_this, &display_mode) < 0) {
+if (_this->SetDisplayMode(_this, &display_mode) < 0) {
-		return -1;
+return -1;
-	}
+}
-	display->current_mode = display_mode;
+display->current_mode = display_mode;
-	/* Set up a palette, if necessary */
+/* Set up a palette, if necessary */
-	if (SDL_ISPIXELFORMAT_INDEXED(display_mode.format)) {
+if (SDL_ISPIXELFORMAT_INDEXED(display_mode.format)) {
-		ncolors = (1 << SDL_BITSPERPIXEL(display_mode.format));
+ncolors = (1 << SDL_BITSPERPIXEL(display_mode.format));
-	} else {
+} else {
-		ncolors = 0;
+ncolors = 0;
-	}
+}
-	if ((!ncolors && display->palette) || (ncolors && !display->palette)
+if ((!ncolors && display->palette) || (ncolors && !display->palette)
-	    || (ncolors && ncolors != display->palette->ncolors)) {
+|| (ncolors && ncolors != display->palette->ncolors)) {
-		if (display->palette) {
+if (display->palette) {
-			SDL_FreePalette(display->palette);
+SDL_FreePalette(display->palette);
-			display->palette = NULL;
+display->palette = NULL;
-		}
+}
-		if (ncolors) {
+if (ncolors) {
-			display->palette = SDL_AllocPalette(ncolors);
+display->palette = SDL_AllocPalette(ncolors);
-			if (!display->palette) {
+if (!display->palette) {
-				return -1;
+return -1;
-			}
+}
-			SDL_DitherColors(display->palette->colors,
+SDL_DitherColors(display->palette->colors,
-				     SDL_BITSPERPIXEL(display_mode.format));
+SDL_BITSPERPIXEL(display_mode.format));
-		}
+}
-	}
+}
-	/* Move any fullscreen windows into position */
+/* Move any fullscreen windows into position */
-	for (i = 0; i < display->num_windows; ++i) {
+for (i = 0; i < display->num_windows; ++i) {
-		SDL_Window     *window = &display->windows[i];
+SDL_Window *window = &display->windows[i];
-		if (FULLSCREEN_VISIBLE(window)) {
+if (FULLSCREEN_VISIBLE(window)) {
-			SDL_SetWindowPosition(window->id, SDL_WINDOWPOS_CENTERED,
+SDL_SetWindowPosition(window->id, SDL_WINDOWPOS_CENTERED,
-					      SDL_WINDOWPOS_CENTERED);
+SDL_WINDOWPOS_CENTERED);
-		}
+}
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_SetFullscreenDisplayMode(const SDL_DisplayMode * mode)
 {
-	SDL_VideoDisplay *display;
+SDL_VideoDisplay *display;
-	SDL_DisplayMode fullscreen_mode;
+SDL_DisplayMode fullscreen_mode;
-	int             i;
+int i;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	display = &SDL_CurrentDisplay;
+display = &SDL_CurrentDisplay;
-	if (!mode) {
+if (!mode) {
-		mode = &display->desktop_mode;
+mode = &display->desktop_mode;
-	}
+}
-	SDL_GetClosestDisplayMode(mode, &fullscreen_mode);
+SDL_GetClosestDisplayMode(mode, &fullscreen_mode);
-	if (SDL_memcmp
+if (SDL_memcmp
-	    (&fullscreen_mode, &display->fullscreen_mode,
+(&fullscreen_mode, &display->fullscreen_mode,
-	     sizeof(fullscreen_mode)) == 0) {
+sizeof(fullscreen_mode)) == 0) {
-		/* Nothing to do... */
+/* Nothing to do... */
-		return 0;
+return 0;
-	}
+}
-	display->fullscreen_mode = fullscreen_mode;
+display->fullscreen_mode = fullscreen_mode;
-	/* Actually set the mode if we have a fullscreen window visible */
+/* Actually set the mode if we have a fullscreen window visible */
-	for (i = 0; i < display->num_windows; ++i) {
+for (i = 0; i < display->num_windows; ++i) {
-		SDL_Window     *window = &display->windows[i];
+SDL_Window *window = &display->windows[i];
-		if (FULLSCREEN_VISIBLE(window)) {
+if (FULLSCREEN_VISIBLE(window)) {
-			if (SDL_SetDisplayMode(&display->fullscreen_mode) < 0) {
+if (SDL_SetDisplayMode(&display->fullscreen_mode) < 0) {
-				return -1;
+return -1;
-			}
+}
-		}
+}
-		if (window->flags & SDL_WINDOW_FULLSCREEN) {
+if (window->flags & SDL_WINDOW_FULLSCREEN) {
-			SDL_OnWindowResized(window);
+SDL_OnWindowResized(window);
-		}
+}
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_GetFullscreenDisplayMode(SDL_DisplayMode * mode)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (mode) {
+if (mode) {
-		*mode = SDL_CurrentDisplay.fullscreen_mode;
+*mode = SDL_CurrentDisplay.fullscreen_mode;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_SetDisplayPalette(const SDL_Color * colors, int firstcolor, int ncolors)
 {
-	SDL_Palette    *palette;
+SDL_Palette *palette;
-	int             status = 0;
+int status = 0;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	palette = SDL_CurrentDisplay.palette;
+palette = SDL_CurrentDisplay.palette;
-	if (!palette) {
+if (!palette) {
-		SDL_SetError("Display mode does not have a palette");
+SDL_SetError("Display mode does not have a palette");
-		return -1;
+return -1;
-	}
+}
-	status = SDL_SetPaletteColors(palette, colors, firstcolor, ncolors);
+status = SDL_SetPaletteColors(palette, colors, firstcolor, ncolors);
-	if (_this->SetDisplayPalette) {
+if (_this->SetDisplayPalette) {
-		if (_this->SetDisplayPalette(_this, palette) < 0) {
+if (_this->SetDisplayPalette(_this, palette) < 0) {
-			status = -1;
+status = -1;
-		}
+}
-	}
+}
-	return status;
+return status;
 }
 int
 SDL_GetDisplayPalette(SDL_Color * colors, int firstcolor, int ncolors)
 {
-	SDL_Palette    *palette;
+SDL_Palette *palette;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	palette = SDL_CurrentDisplay.palette;
+palette = SDL_CurrentDisplay.palette;
-	if (!palette->ncolors) {
+if (!palette->ncolors) {
-		SDL_SetError("Display mode does not have a palette");
+SDL_SetError("Display mode does not have a palette");
-		return -1;
+return -1;
-	}
+}
-	if (firstcolor < 0 || (firstcolor + ncolors) > palette->ncolors) {
+if (firstcolor < 0 || (firstcolor + ncolors) > palette->ncolors) {
-		SDL_SetError("Palette indices are out of range");
+SDL_SetError("Palette indices are out of range");
-		return -1;
+return -1;
-	}
+}
-	SDL_memcpy(colors, &palette->colors[firstcolor],
+SDL_memcpy(colors, &palette->colors[firstcolor],
-		   ncolors * sizeof(*colors));
+ncolors * sizeof(*colors));
-	return 0;
+return 0;
 }
 SDL_WindowID
 SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
 {
-	const Uint32    allowed_flags = (SDL_WINDOW_FULLSCREEN |
+const Uint32 allowed_flags = (SDL_WINDOW_FULLSCREEN |
-					 SDL_WINDOW_OPENGL |
+SDL_WINDOW_OPENGL |
-					 SDL_WINDOW_BORDERLESS |
+SDL_WINDOW_BORDERLESS |
-					 SDL_WINDOW_RESIZABLE);
+SDL_WINDOW_RESIZABLE);
-	SDL_VideoDisplay *display;
+SDL_VideoDisplay *display;
-	SDL_Window      window;
+SDL_Window window;
-	int             num_windows;
+int num_windows;
-	SDL_Window     *windows;
+SDL_Window *windows;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return 0;
+return 0;
-	}
+}
-	if ((flags & SDL_WINDOW_OPENGL) && !_this->GL_CreateContext) {
+if ((flags & SDL_WINDOW_OPENGL) && !_this->GL_CreateContext) {
-		SDL_SetError("No OpenGL support in video driver");
+SDL_SetError("No OpenGL support in video driver");
-		return 0;
+return 0;
-	}
+}
-	/* Fullscreen windows don't have any window decorations */
+/* Fullscreen windows don't have any window decorations */
-	if (flags & SDL_WINDOW_FULLSCREEN) {
+if (flags & SDL_WINDOW_FULLSCREEN) {
-		flags |= SDL_WINDOW_BORDERLESS;
+flags |= SDL_WINDOW_BORDERLESS;
-		flags &= ~SDL_WINDOW_RESIZABLE;
+flags &= ~SDL_WINDOW_RESIZABLE;
-	}
+}
-	SDL_zero(window);
+SDL_zero(window);
-	window.id = _this->next_object_id++;
+window.id = _this->next_object_id++;
-	window.x = x;
+window.x = x;
-	window.y = y;
+window.y = y;
-	window.w = w;
+window.w = w;
-	window.h = h;
+window.h = h;
-	window.flags = (flags & allowed_flags);
+window.flags = (flags & allowed_flags);
-	window.display = _this->current_display;
+window.display = _this->current_display;
-	if (_this->CreateWindow && _this->CreateWindow(_this, &window) < 0) {
+if (_this->CreateWindow && _this->CreateWindow(_this, &window) < 0) {
-		return 0;
+return 0;
-	}
+}
-	display = &SDL_CurrentDisplay;
+display = &SDL_CurrentDisplay;
-	num_windows = display->num_windows;
+num_windows = display->num_windows;
-	windows =
+windows =
-		SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
+SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
-	if (!windows) {
+if (!windows) {
-		if (_this->DestroyWindow) {
+if (_this->DestroyWindow) {
-			_this->DestroyWindow(_this, &window);
+_this->DestroyWindow(_this, &window);
-		}
+}
-		return 0;
+return 0;
-	}
+}
-	windows[num_windows] = window;
+windows[num_windows] = window;
-	display->windows = windows;
+display->windows = windows;
-	display->num_windows++;
+display->num_windows++;
-	if (title) {
+if (title) {
-		SDL_SetWindowTitle(window.id, title);
+SDL_SetWindowTitle(window.id, title);
-	}
+}
-	if (flags & SDL_WINDOW_MAXIMIZED) {
+if (flags & SDL_WINDOW_MAXIMIZED) {
-		SDL_MaximizeWindow(window.id);
+SDL_MaximizeWindow(window.id);
-	}
+}
-	if (flags & SDL_WINDOW_MINIMIZED) {
+if (flags & SDL_WINDOW_MINIMIZED) {
-		SDL_MinimizeWindow(window.id);
+SDL_MinimizeWindow(window.id);
-	}
+}
-	if (flags & SDL_WINDOW_SHOWN) {
+if (flags & SDL_WINDOW_SHOWN) {
-		SDL_ShowWindow(window.id);
+SDL_ShowWindow(window.id);
-	}
+}
-	if (flags & SDL_WINDOW_INPUT_GRABBED) {
+if (flags & SDL_WINDOW_INPUT_GRABBED) {
-		SDL_SetWindowGrab(window.id, 1);
+SDL_SetWindowGrab(window.id, 1);
-	}
+}
-	return window.id;
+return window.id;
 }
 SDL_WindowID
 SDL_CreateWindowFrom(const void *data)
 {
-	SDL_VideoDisplay *display;
+SDL_VideoDisplay *display;
-	SDL_Window      window;
+SDL_Window window;
-	int             num_windows;
+int num_windows;
-	SDL_Window     *windows;
+SDL_Window *windows;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return (0);
+return (0);
-	}
+}
-	SDL_zero(window);
+SDL_zero(window);
-	window.id = _this->next_object_id++;
+window.id = _this->next_object_id++;
-	window.display = _this->current_display;
+window.display = _this->current_display;
-	if (!_this->CreateWindowFrom ||
+if (!_this->CreateWindowFrom ||
-	    _this->CreateWindowFrom(_this, &window, data) < 0) {
+_this->CreateWindowFrom(_this, &window, data) < 0) {
-		return 0;
+return 0;
-	}
+}
-	display = &SDL_CurrentDisplay;
+display = &SDL_CurrentDisplay;
-	num_windows = display->num_windows;
+num_windows = display->num_windows;
-	windows =
+windows =
-		SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
+SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
-	if (!windows) {
+if (!windows) {
-		if (_this->DestroyWindow) {
+if (_this->DestroyWindow) {
-			_this->DestroyWindow(_this, &window);
+_this->DestroyWindow(_this, &window);
-		}
+}
-		if (window.title) {
+if (window.title) {
-			SDL_free(window.title);
+SDL_free(window.title);
-		}
+}
-		return 0;
+return 0;
-	}
+}
-	windows[num_windows] = window;
+windows[num_windows] = window;
-	display->windows = windows;
+display->windows = windows;
-	display->num_windows++;
+display->num_windows++;
-	return window.id;
+return window.id;
 }
 int
 SDL_RecreateWindow(SDL_Window * window, Uint32 flags)
 {
-	char           *title = window->title;
+char *title = window->title;
-	if ((flags & SDL_WINDOW_OPENGL) && !_this->GL_CreateContext) {
+if ((flags & SDL_WINDOW_OPENGL) && !_this->GL_CreateContext) {
-		SDL_SetError("No OpenGL support in video driver");
+SDL_SetError("No OpenGL support in video driver");
-		return -1;
+return -1;
-	}
+}
-	if (_this->DestroyWindow) {
+if (_this->DestroyWindow) {
-		_this->DestroyWindow(_this, window);
+_this->DestroyWindow(_this, window);
-	}
+}
-	window->title = NULL;
+window->title = NULL;
-	window->flags =
+window->flags =
-		(flags &
+(flags &
-	  ~(SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED | SDL_WINDOW_SHOWN |
+~(SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED | SDL_WINDOW_SHOWN |
-	    SDL_WINDOW_INPUT_GRABBED));
+SDL_WINDOW_INPUT_GRABBED));
-	if (_this->CreateWindow && _this->CreateWindow(_this, window) < 0) {
+if (_this->CreateWindow && _this->CreateWindow(_this, window) < 0) {
-		return -1;
+return -1;
-	}
+}
-	if (title) {
+if (title) {
-		SDL_SetWindowTitle(window->id, title);
+SDL_SetWindowTitle(window->id, title);
-		SDL_free(title);
+SDL_free(title);
-	}
+}
-	if (flags & SDL_WINDOW_MAXIMIZED) {
+if (flags & SDL_WINDOW_MAXIMIZED) {
-		SDL_MaximizeWindow(window->id);
+SDL_MaximizeWindow(window->id);
-	}
+}
-	if (flags & SDL_WINDOW_MINIMIZED) {
+if (flags & SDL_WINDOW_MINIMIZED) {
-		SDL_MinimizeWindow(window->id);
+SDL_MinimizeWindow(window->id);
-	}
+}
-	if (flags & SDL_WINDOW_SHOWN) {
+if (flags & SDL_WINDOW_SHOWN) {
-		SDL_ShowWindow(window->id);
+SDL_ShowWindow(window->id);
-	}
+}
-	if (flags & SDL_WINDOW_INPUT_GRABBED) {
+if (flags & SDL_WINDOW_INPUT_GRABBED) {
-		SDL_SetWindowGrab(window->id, 1);
+SDL_SetWindowGrab(window->id, 1);
-	}
+}
-	return 0;
+return 0;
 }
-SDL_Window     *
+SDL_Window *
 SDL_GetWindowFromID(SDL_WindowID windowID)
 {
-	int             i, j;
+int i, j;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return NULL;
+return NULL;
-	}
+}
-	for (i = 0; i < _this->num_displays; ++i) {
+for (i = 0; i < _this->num_displays; ++i) {
-		SDL_VideoDisplay *display = &_this->displays[i];
+SDL_VideoDisplay *display = &_this->displays[i];
-		for (j = 0; j < display->num_windows; ++j) {
+for (j = 0; j < display->num_windows; ++j) {
-			SDL_Window     *window = &display->windows[j];
+SDL_Window *window = &display->windows[j];
-			if (window->id == windowID) {
+if (window->id == windowID) {
-				return window;
+return window;
-			}
+}
-		}
+}
-	}
+}
-	return NULL;
+return NULL;
 }
 SDL_VideoDisplay *
 SDL_GetDisplayFromWindow(SDL_Window * window)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return NULL;
+return NULL;
-	}
+}
-	if (!window) {
+if (!window) {
-		return NULL;
+return NULL;
-	}
+}
-	return &_this->displays[window->display];
+return &_this->displays[window->display];
 }
 Uint32
 SDL_GetWindowFlags(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return 0;
+return 0;
-	}
+}
-	return window->flags;
+return window->flags;
 }
 void
 SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || title == window->title) {
+if (!window || title == window->title) {
-		return;
+return;
-	}
+}
-	if (window->title) {
+if (window->title) {
-		SDL_free(window->title);
+SDL_free(window->title);
-	}
+}
-	if (title) {
+if (title) {
-		window->title = SDL_strdup(title);
+window->title = SDL_strdup(title);
-	} else {
+} else {
-		window->title = NULL;
+window->title = NULL;
-	}
+}
-	if (_this->SetWindowTitle) {
+if (_this->SetWindowTitle) {
-		_this->SetWindowTitle(_this, window);
+_this->SetWindowTitle(_this, window);
-	}
+}
 }
-const char     *
+const char *
 SDL_GetWindowTitle(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return NULL;
+return NULL;
-	}
+}
-	return window->title;
+return window->title;
 }
 void
 SDL_SetWindowData(SDL_WindowID windowID, void *userdata)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return;
+return;
-	}
+}
-	window->userdata = userdata;
+window->userdata = userdata;
 }
-void           *
+void *
 SDL_GetWindowData(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return NULL;
+return NULL;
-	}
+}
-	return window->userdata;
+return window->userdata;
 }
 void
 SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-	if (!window) {
+if (!window) {
-		return;
+return;
-	}
+}
-	if (x == SDL_WINDOWPOS_CENTERED) {
+if (x == SDL_WINDOWPOS_CENTERED) {
-		window->x = (display->current_mode.w - window->w) / 2;
+window->x = (display->current_mode.w - window->w) / 2;
-	} else if (x != SDL_WINDOWPOS_UNDEFINED) {
+} else if (x != SDL_WINDOWPOS_UNDEFINED) {
-		window->x = x;
+window->x = x;
-	}
+}
-	if (y == SDL_WINDOWPOS_CENTERED) {
+if (y == SDL_WINDOWPOS_CENTERED) {
-		window->y = (display->current_mode.h - window->h) / 2;
+window->y = (display->current_mode.h - window->h) / 2;
-	} else if (y != SDL_WINDOWPOS_UNDEFINED) {
+} else if (y != SDL_WINDOWPOS_UNDEFINED) {
-		window->y = y;
+window->y = y;
-	}
+}
-	if (_this->SetWindowPosition) {
+if (_this->SetWindowPosition) {
-		_this->SetWindowPosition(_this, window);
+_this->SetWindowPosition(_this, window);
-	}
+}
 }
 void
 SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return;
+return;
-	}
+}
-	if (x) {
+if (x) {
-		*x = window->x;
+*x = window->x;
-	}
+}
-	if (y) {
+if (y) {
-		*y = window->y;
+*y = window->y;
-	}
+}
 }
 void
 SDL_SetWindowSize(SDL_WindowID windowID, int w, int h)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return;
+return;
-	}
+}
-	window->w = w;
+window->w = w;
-	window->h = h;
+window->h = h;
-	if (_this->SetWindowSize) {
+if (_this->SetWindowSize) {
-		_this->SetWindowSize(_this, window);
+_this->SetWindowSize(_this, window);
-	}
+}
 }
 void
 SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *h)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return;
+return;
-	}
+}
-	if (w) {
+if (w) {
-		*w = window->w;
+*w = window->w;
-	}
+}
-	if (h) {
+if (h) {
-		*h = window->h;
+*h = window->h;
-	}
+}
 }
 void
 SDL_ShowWindow(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || (window->flags & SDL_WINDOW_SHOWN)) {
+if (!window || (window->flags & SDL_WINDOW_SHOWN)) {
-		return;
+return;
-	}
+}
-	SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);
-	if (_this->ShowWindow) {
+if (_this->ShowWindow) {
-		_this->ShowWindow(_this, window);
+_this->ShowWindow(_this, window);
-	}
+}
 }
 void
 SDL_HideWindow(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
+if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
-		return;
+return;
-	}
+}
-	SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_HIDDEN, 0, 0);
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_HIDDEN, 0, 0);
-	if (_this->HideWindow) {
+if (_this->HideWindow) {
-		_this->HideWindow(_this, window);
+_this->HideWindow(_this, window);
-	}
+}
 }
 void
 SDL_RaiseWindow(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
+if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
-		return;
+return;
-	}
+}
-	if (_this->RaiseWindow) {
+if (_this->RaiseWindow) {
-		_this->RaiseWindow(_this, window);
+_this->RaiseWindow(_this, window);
-	}
+}
 }
 void
 SDL_MaximizeWindow(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || (window->flags & SDL_WINDOW_MAXIMIZED)) {
+if (!window || (window->flags & SDL_WINDOW_MAXIMIZED)) {
-		return;
+return;
-	}
+}
-	SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
-	if (_this->MaximizeWindow) {
+if (_this->MaximizeWindow) {
-		_this->MaximizeWindow(_this, window);
+_this->MaximizeWindow(_this, window);
-	}
+}
 }
 void
 SDL_MinimizeWindow(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || (window->flags & SDL_WINDOW_MINIMIZED)) {
+if (!window || (window->flags & SDL_WINDOW_MINIMIZED)) {
-		return;
+return;
-	}
+}
-	SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
-	if (_this->MinimizeWindow) {
+if (_this->MinimizeWindow) {
-		_this->MinimizeWindow(_this, window);
+_this->MinimizeWindow(_this, window);
-	}
+}
 }
 void
 SDL_RestoreWindow(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window
+if (!window
-	|| (window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {
+|| (window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {
-		return;
+return;
-	}
+}
-	SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESTORED, 0, 0);
+SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESTORED, 0, 0);
-	if (_this->RestoreWindow) {
+if (_this->RestoreWindow) {
-		_this->RestoreWindow(_this, window);
+_this->RestoreWindow(_this, window);
-	}
+}
 }
 int
 SDL_SetWindowFullscreen(SDL_WindowID windowID, int fullscreen)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return -1;
+return -1;
-	}
+}
-	if (fullscreen) {
+if (fullscreen) {
-		fullscreen = SDL_WINDOW_FULLSCREEN;
+fullscreen = SDL_WINDOW_FULLSCREEN;
-	}
+}
-	if ((window->flags & SDL_WINDOW_FULLSCREEN) == fullscreen) {
+if ((window->flags & SDL_WINDOW_FULLSCREEN) == fullscreen) {
-		return 0;
+return 0;
-	}
+}
-	if (fullscreen) {
+if (fullscreen) {
-		window->flags |= SDL_WINDOW_FULLSCREEN;
+window->flags |= SDL_WINDOW_FULLSCREEN;
-		if (FULLSCREEN_VISIBLE(window)) {
+if (FULLSCREEN_VISIBLE(window)) {
-			SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-			/* Hide any other fullscreen windows */
+/* Hide any other fullscreen windows */
-			int             i;
+int i;
-			for (i = 0; i < display->num_windows; ++i) {
+for (i = 0; i < display->num_windows; ++i) {
-				SDL_Window     *other = &display->windows[i];
+SDL_Window *other = &display->windows[i];
-				if (other->id != windowID && FULLSCREEN_VISIBLE(other)) {
+if (other->id != windowID && FULLSCREEN_VISIBLE(other)) {
-					SDL_MinimizeWindow(other->id);
+SDL_MinimizeWindow(other->id);
-				}
+}
-			}
+}
-			SDL_SetDisplayMode(&display->fullscreen_mode);
+SDL_SetDisplayMode(&display->fullscreen_mode);
-		}
+}
-	} else {
+} else {
-		window->flags &= ~SDL_WINDOW_FULLSCREEN;
+window->flags &= ~SDL_WINDOW_FULLSCREEN;
-		if (FULLSCREEN_VISIBLE(window)) {
+if (FULLSCREEN_VISIBLE(window)) {
-			SDL_SetDisplayMode(NULL);
+SDL_SetDisplayMode(NULL);
-		}
+}
-	}
+}
-	return 0;
+return 0;
 }
 void
 SDL_SetWindowGrab(SDL_WindowID windowID, int mode)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || (!!mode == !!(window->flags & SDL_WINDOW_INPUT_GRABBED))) {
+if (!window || (!!mode == !!(window->flags & SDL_WINDOW_INPUT_GRABBED))) {
-		return;
+return;
-	}
+}
-	if (mode) {
+if (mode) {
-		window->flags |= SDL_WINDOW_INPUT_GRABBED;
+window->flags |= SDL_WINDOW_INPUT_GRABBED;
-	} else {
+} else {
-		window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
+window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
-	}
+}
-	if ((window->flags & SDL_WINDOW_INPUT_FOCUS) && _this->SetWindowGrab) {
+if ((window->flags & SDL_WINDOW_INPUT_FOCUS) && _this->SetWindowGrab) {
-		_this->SetWindowGrab(_this, window);
+_this->SetWindowGrab(_this, window);
-	}
+}
 }
 int
 SDL_GetWindowGrab(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return 0;
+return 0;
-	}
+}
-	return ((window->flags & SDL_WINDOW_INPUT_GRABBED) != 0);
+return ((window->flags & SDL_WINDOW_INPUT_GRABBED) != 0);
 }
 void
 SDL_OnWindowShown(SDL_Window * window)
 {
 }
 void
 SDL_OnWindowResized(SDL_Window * window)
 {
-	SDL_Renderer   *renderer = window->renderer;
+SDL_Renderer *renderer = window->renderer;
-	if (renderer && renderer->DisplayModeChanged) {
+if (renderer && renderer->DisplayModeChanged) {
-		renderer->DisplayModeChanged(renderer);
+renderer->DisplayModeChanged(renderer);
-	}
+}
 }
 void
 SDL_OnWindowFocusGained(SDL_Window * window)
 {
-	SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-	if (window->flags & SDL_WINDOW_FULLSCREEN) {
+if (window->flags & SDL_WINDOW_FULLSCREEN) {
-		SDL_SetDisplayMode(&display->fullscreen_mode);
+SDL_SetDisplayMode(&display->fullscreen_mode);
-	}
+}
-	if (display->gamma && _this->SetDisplayGammaRamp) {
+if (display->gamma && _this->SetDisplayGammaRamp) {
-		_this->SetDisplayGammaRamp(_this, display->gamma);
+_this->SetDisplayGammaRamp(_this, display->gamma);
-	}
+}
-	if ((window->flags & SDL_WINDOW_INPUT_GRABBED) && _this->SetWindowGrab) {
+if ((window->flags & SDL_WINDOW_INPUT_GRABBED) && _this->SetWindowGrab) {
-		_this->SetWindowGrab(_this, window);
+_this->SetWindowGrab(_this, window);
-	}
+}
 }
 void
 SDL_OnWindowFocusLost(SDL_Window * window)
 {
-	SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-	if (window->flags & SDL_WINDOW_FULLSCREEN) {
+if (window->flags & SDL_WINDOW_FULLSCREEN) {
-		SDL_MinimizeWindow(window->id);
+SDL_MinimizeWindow(window->id);
-		SDL_SetDisplayMode(NULL);
+SDL_SetDisplayMode(NULL);
-	}
+}
-	if (display->gamma && _this->SetDisplayGammaRamp) {
+if (display->gamma && _this->SetDisplayGammaRamp) {
-		_this->SetDisplayGammaRamp(_this, display->saved_gamma);
+_this->SetDisplayGammaRamp(_this, display->saved_gamma);
-	}
+}
-	if ((window->flags & SDL_WINDOW_INPUT_GRABBED) && _this->SetWindowGrab) {
+if ((window->flags & SDL_WINDOW_INPUT_GRABBED) && _this->SetWindowGrab) {
-		_this->SetWindowGrab(_this, window);
+_this->SetWindowGrab(_this, window);
-	}
+}
 }
 SDL_WindowID
 SDL_GetFocusWindow(void)
 {
-	SDL_VideoDisplay *display;
+SDL_VideoDisplay *display;
-	int             i;
+int i;
-	if (!_this) {
+if (!_this) {
-		return 0;
+return 0;
-	}
+}
-	display = &SDL_CurrentDisplay;
+display = &SDL_CurrentDisplay;
-	for (i = 0; i < display->num_windows; ++i) {
+for (i = 0; i < display->num_windows; ++i) {
-		SDL_Window     *window = &display->windows[i];
+SDL_Window *window = &display->windows[i];
-		if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
+if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
-			return window->id;
+return window->id;
-		}
+}
-	}
+}
-	return 0;
+return 0;
 }
 void
 SDL_DestroyWindow(SDL_WindowID windowID)
 {
-	int             i, j;
+int i, j;
-	if (!_this) {
+if (!_this) {
-		return;
+return;
-	}
+}
-	/* Restore video mode, etc. */
+/* Restore video mode, etc. */
-	SDL_SendWindowEvent(windowID, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
+SDL_SendWindowEvent(windowID, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
-	for (i = 0; i < _this->num_displays; ++i) {
+for (i = 0; i < _this->num_displays; ++i) {
-		SDL_VideoDisplay *display = &_this->displays[i];
+SDL_VideoDisplay *display = &_this->displays[i];
-		for (j = 0; j < display->num_windows; ++j) {
+for (j = 0; j < display->num_windows; ++j) {
-			SDL_Window     *window = &display->windows[j];
+SDL_Window *window = &display->windows[j];
-			if (window->id != windowID) {
+if (window->id != windowID) {
-				continue;
+continue;
-			}
+}
-			if (window->title) {
+if (window->title) {
-				SDL_free(window->title);
+SDL_free(window->title);
-				window->title = NULL;
+window->title = NULL;
-			}
+}
-			if (window->renderer) {
+if (window->renderer) {
-				SDL_DestroyRenderer(window->id);
+SDL_DestroyRenderer(window->id);
-				window->renderer = NULL;
+window->renderer = NULL;
-			}
+}
-			if (_this->DestroyWindow) {
+if (_this->DestroyWindow) {
-				_this->DestroyWindow(_this, window);
+_this->DestroyWindow(_this, window);
-			}
+}
-			if (j != display->num_windows - 1) {
+if (j != display->num_windows - 1) {
-				SDL_memcpy(&display->windows[i],
+SDL_memcpy(&display->windows[i],
-					   &display->windows[i + 1],
+&display->windows[i + 1],
-					   (display->num_windows - i - 1) * sizeof(*window));
+(display->num_windows - i - 1) * sizeof(*window));
-			}
+}
-			--display->num_windows;
+--display->num_windows;
-			return;
+return;
-		}
+}
-	}
+}
 }
 void
 SDL_AddRenderDriver(int displayIndex, const SDL_RenderDriver * driver)
 {
-	SDL_VideoDisplay *display;
+SDL_VideoDisplay *display;
-	SDL_RenderDriver *render_drivers;
+SDL_RenderDriver *render_drivers;
-	if (displayIndex >= _this->num_displays) {
+if (displayIndex >= _this->num_displays) {
-		return;
+return;
-	}
+}
-	display = &_this->displays[displayIndex];
+display = &_this->displays[displayIndex];
-	render_drivers =
+render_drivers =
-		SDL_realloc(display->render_drivers,
+SDL_realloc(display->render_drivers,
-			    (display->num_render_drivers +
+(display->num_render_drivers +
-			     1) * sizeof(*render_drivers));
+1) * sizeof(*render_drivers));
-	if (render_drivers) {
+if (render_drivers) {
-		render_drivers[display->num_render_drivers] = *driver;
+render_drivers[display->num_render_drivers] = *driver;
-		display->render_drivers = render_drivers;
+display->render_drivers = render_drivers;
-		display->num_render_drivers++;
+display->num_render_drivers++;
-	}
+}
 }
 int
 SDL_GetNumRenderDrivers(void)
 {
-	if (_this) {
+if (_this) {
-		return SDL_CurrentDisplay.num_render_drivers;
+return SDL_CurrentDisplay.num_render_drivers;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
+if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
-		SDL_SetError("index must be in the range of 0 - %d",
+SDL_SetError("index must be in the range of 0 - %d",
-			     SDL_GetNumRenderDrivers() - 1);
+SDL_GetNumRenderDrivers() - 1);
-		return -1;
+return -1;
-	}
+}
-	*info = SDL_CurrentDisplay.render_drivers[index].info;
+*info = SDL_CurrentDisplay.render_drivers[index].info;
-	return 0;
+return 0;
 }
 int
 SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return 0;
+return 0;
-	}
+}
-	if (index < 0) {
+if (index < 0) {
-		const char     *override = SDL_getenv("SDL_VIDEO_RENDERER");
+const char *override = SDL_getenv("SDL_VIDEO_RENDERER");
-		int             n = SDL_GetNumRenderDrivers();
+int n = SDL_GetNumRenderDrivers();
-		for (index = 0; index < n; ++index) {
+for (index = 0; index < n; ++index) {
-			SDL_RenderDriver *driver =
+SDL_RenderDriver *driver =
-			&SDL_CurrentDisplay.render_drivers[index];
+&SDL_CurrentDisplay.render_drivers[index];
-			if (override) {
+if (override) {
-				if (SDL_strcasecmp(override, driver->info.name) == 0) {
+if (SDL_strcasecmp(override, driver->info.name) == 0) {
-					break;
+break;
-				}
+}
-			} else {
+} else {
-				if ((driver->info.flags & flags) == flags) {
+if ((driver->info.flags & flags) == flags) {
-					break;
+break;
-				}
+}
-			}
+}
-		}
+}
-		if (index == n) {
+if (index == n) {
-			SDL_SetError("Couldn't find matching render driver");
+SDL_SetError("Couldn't find matching render driver");
-			return -1;
+return -1;
-		}
+}
-	}
+}
-	if (index >= SDL_GetNumRenderDrivers()) {
+if (index >= SDL_GetNumRenderDrivers()) {
-		SDL_SetError("index must be -1 or in the range of 0 - %d",
+SDL_SetError("index must be -1 or in the range of 0 - %d",
-			     SDL_GetNumRenderDrivers() - 1);
+SDL_GetNumRenderDrivers() - 1);
-		return -1;
+return -1;
-	}
+}
-	/* Free any existing renderer */
+/* Free any existing renderer */
-	SDL_DestroyRenderer(windowID);
+SDL_DestroyRenderer(windowID);
-	/* Create a new renderer instance */
+/* Create a new renderer instance */
-	window->renderer = SDL_CurrentDisplay.render_drivers[index]
+window->renderer = SDL_CurrentDisplay.render_drivers[index]
-		.CreateRenderer(window, flags);
+.CreateRenderer(window, flags);
-	SDL_SelectRenderer(window->id);
+SDL_SelectRenderer(window->id);
-	return 0;
+return 0;
 }
 int
 SDL_SelectRenderer(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!window || !window->renderer) {
+if (!window || !window->renderer) {
-		return -1;
+return -1;
-	}
+}
-	renderer = window->renderer;
+renderer = window->renderer;
-	if (renderer && renderer->ActivateRenderer) {
+if (renderer && renderer->ActivateRenderer) {
-		if (renderer->ActivateRenderer(renderer) < 0) {
+if (renderer->ActivateRenderer(renderer) < 0) {
-			return -1;
+return -1;
-		}
+}
-	}
+}
-	SDL_CurrentDisplay.current_renderer = renderer;
+SDL_CurrentDisplay.current_renderer = renderer;
-	return 0;
+return 0;
 }
 int
 SDL_GetRendererInfo(SDL_RendererInfo * info)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (!SDL_CurrentDisplay.current_renderer) {
+if (!SDL_CurrentDisplay.current_renderer) {
-		SDL_SetError("There is no current renderer");
+SDL_SetError("There is no current renderer");
-		return -1;
+return -1;
-	}
+}
-	*info = SDL_CurrentDisplay.current_renderer->info;
+*info = SDL_CurrentDisplay.current_renderer->info;
-	return 0;
+return 0;
 }
 SDL_TextureID
 SDL_CreateTexture(Uint32 format, int access, int w, int h)
 {
-	int             hash;
+int hash;
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	SDL_Texture    *texture;
+SDL_Texture *texture;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return 0;
+return 0;
-	}
+}
-	renderer = SDL_CurrentDisplay.current_renderer;
+renderer = SDL_CurrentDisplay.current_renderer;
-	if (!renderer || !renderer->CreateTexture) {
+if (!renderer || !renderer->CreateTexture) {
-		return 0;
+return 0;
-	}
+}
-	texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
+texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
-	if (!texture) {
+if (!texture) {
-		SDL_OutOfMemory();
+SDL_OutOfMemory();
-		return 0;
+return 0;
-	}
+}
-	texture->id = _this->next_object_id++;
+texture->id = _this->next_object_id++;
-	texture->format = format;
+texture->format = format;
-	texture->access = access;
+texture->access = access;
-	texture->w = w;
+texture->w = w;
-	texture->h = h;
+texture->h = h;
-	texture->r = 255;
+texture->r = 255;
-	texture->g = 255;
+texture->g = 255;
-	texture->b = 255;
+texture->b = 255;
-	texture->a = 255;
+texture->a = 255;
-	texture->renderer = renderer;
+texture->renderer = renderer;
-	if (renderer->CreateTexture(renderer, texture) < 0) {
+if (renderer->CreateTexture(renderer, texture) < 0) {
-		if (renderer->DestroyTexture) {
+if (renderer->DestroyTexture) {
-			renderer->DestroyTexture(renderer, texture);
+renderer->DestroyTexture(renderer, texture);
-		}
+}
-		SDL_free(texture);
+SDL_free(texture);
-		return 0;
+return 0;
-	}
+}
-	hash = (texture->id % SDL_arraysize(SDL_CurrentDisplay.textures));
+hash = (texture->id % SDL_arraysize(SDL_CurrentDisplay.textures));
-	texture->next = SDL_CurrentDisplay.textures[hash];
+texture->next = SDL_CurrentDisplay.textures[hash];
-	SDL_CurrentDisplay.textures[hash] = texture;
+SDL_CurrentDisplay.textures[hash] = texture;
-	return texture->id;
+return texture->id;
 }
 SDL_TextureID
 SDL_CreateTextureFromSurface(Uint32 format, SDL_Surface * surface)
 {
-	SDL_TextureID   textureID;
+SDL_TextureID textureID;
-	SDL_PixelFormat *fmt;
+SDL_PixelFormat *fmt;
-	int             bpp;
+int bpp;
-	Uint32          Rmask, Gmask, Bmask, Amask;
+Uint32 Rmask, Gmask, Bmask, Amask;
-	if (!surface) {
+if (!surface) {
-		SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
+SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
-		return 0;
+return 0;
-	}
+}
-	fmt = surface->format;
+fmt = surface->format;
-	if (format) {
+if (format) {
-		if (!SDL_PixelFormatEnumToMasks
+if (!SDL_PixelFormatEnumToMasks
-		    (format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
+(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
-			SDL_SetError("Unknown pixel format");
+SDL_SetError("Unknown pixel format");
-			return 0;
+return 0;
-		}
+}
-	} else {
+} else {
-		if (surface->format->Amask
+if (surface->format->Amask
-		    || !(surface->map->info.flags &
+|| !(surface->map->info.flags &
-		    (SDL_COPY_COLORKEY | SDL_COPY_MASK | SDL_COPY_BLEND))) {
+(SDL_COPY_COLORKEY | SDL_COPY_MASK | SDL_COPY_BLEND))) {
-			bpp = fmt->BitsPerPixel;
+bpp = fmt->BitsPerPixel;
-			Rmask = fmt->Rmask;
+Rmask = fmt->Rmask;
-			Gmask = fmt->Gmask;
+Gmask = fmt->Gmask;
-			Bmask = fmt->Bmask;
+Bmask = fmt->Bmask;
-			Amask = fmt->Amask;
+Amask = fmt->Amask;
-		} else {
+} else {
-			/* Need a format with alpha */
+/* Need a format with alpha */
-			bpp = 32;
+bpp = 32;
-			Rmask = 0x00FF0000;
+Rmask = 0x00FF0000;
-			Gmask = 0x0000FF00;
+Gmask = 0x0000FF00;
-			Bmask = 0x000000FF;
+Bmask = 0x000000FF;
-			Amask = 0xFF000000;
+Amask = 0xFF000000;
-		}
+}
-		format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);
+format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);
-		if (!format) {
+if (!format) {
-			SDL_SetError("Unknown pixel format");
+SDL_SetError("Unknown pixel format");
-			return 0;
+return 0;
-		}
+}
-	}
+}
-	textureID =
+textureID =
-		SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w,
+SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w,
-				  surface->h);
+surface->h);
-	if (!textureID) {
+if (!textureID) {
-		return 0;
+return 0;
-	}
+}
-	if (bpp == fmt->BitsPerPixel && Rmask == fmt->Rmask && Gmask == fmt->Gmask
+if (bpp == fmt->BitsPerPixel && Rmask == fmt->Rmask && Gmask == fmt->Gmask
-	    && Bmask == fmt->Bmask && Amask == fmt->Amask) {
+&& Bmask == fmt->Bmask && Amask == fmt->Amask) {
-		if (SDL_MUSTLOCK(surface)) {
+if (SDL_MUSTLOCK(surface)) {
-			if (SDL_LockSurface(surface) < 0) {
+if (SDL_LockSurface(surface) < 0) {
-				SDL_DestroyTexture(textureID);
+SDL_DestroyTexture(textureID);
-				return 0;
+return 0;
-			}
+}
-			SDL_UpdateTexture(textureID, NULL, surface->pixels,
+SDL_UpdateTexture(textureID, NULL, surface->pixels,
-					  surface->pitch);
+surface->pitch);
-			SDL_UnlockSurface(surface);
+SDL_UnlockSurface(surface);
-		} else {
+} else {
-			SDL_UpdateTexture(textureID, NULL, surface->pixels,
+SDL_UpdateTexture(textureID, NULL, surface->pixels,
-					  surface->pitch);
+surface->pitch);
-		}
+}
-	} else {
+} else {
-		SDL_PixelFormat *dst_fmt;
+SDL_PixelFormat *dst_fmt;
-		SDL_Surface    *dst = NULL;
+SDL_Surface *dst = NULL;
-		/* Set up a destination surface for the texture update */
+/* Set up a destination surface for the texture update */
-		dst_fmt = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask);
+dst_fmt = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask);
-		if (dst_fmt) {
+if (dst_fmt) {
-			if (SDL_ISPIXELFORMAT_INDEXED(format)) {
+if (SDL_ISPIXELFORMAT_INDEXED(format)) {
-				dst_fmt->palette =
+dst_fmt->palette =
-					SDL_AllocPalette((1 << SDL_BITSPERPIXEL(format)));
+SDL_AllocPalette((1 << SDL_BITSPERPIXEL(format)));
-				if (dst_fmt->palette) {
+if (dst_fmt->palette) {
-					/*
+/*
-					 * FIXME: Should we try to copy
+* FIXME: Should we try to copy
-					 * fmt->palette?
+* fmt->palette?
-					 */
+*/
-					SDL_DitherColors(dst_fmt->palette->colors,
+SDL_DitherColors(dst_fmt->palette->colors,
-						  SDL_BITSPERPIXEL(format));
+SDL_BITSPERPIXEL(format));
-				}
+}
-			}
+}
-			dst = SDL_ConvertSurface(surface, dst_fmt, 0);
+dst = SDL_ConvertSurface(surface, dst_fmt, 0);
-			if (dst) {
+if (dst) {
-				SDL_UpdateTexture(textureID, NULL, dst->pixels, dst->pitch);
+SDL_UpdateTexture(textureID, NULL, dst->pixels, dst->pitch);
-				SDL_FreeSurface(dst);
+SDL_FreeSurface(dst);
-			}
+}
-			if (dst_fmt->palette) {
+if (dst_fmt->palette) {
-				SDL_FreePalette(dst_fmt->palette);
+SDL_FreePalette(dst_fmt->palette);
-			}
+}
-			SDL_FreeFormat(dst_fmt);
+SDL_FreeFormat(dst_fmt);
-		}
+}
-		if (!dst) {
+if (!dst) {
-			SDL_DestroyTexture(textureID);
+SDL_DestroyTexture(textureID);
-			return 0;
+return 0;
-		}
+}
-	}
+}
-	if (SDL_ISPIXELFORMAT_INDEXED(format) && fmt->palette) {
+if (SDL_ISPIXELFORMAT_INDEXED(format) && fmt->palette) {
-		SDL_SetTexturePalette(textureID, fmt->palette->colors, 0,
+SDL_SetTexturePalette(textureID, fmt->palette->colors, 0,
-				      fmt->palette->ncolors);
+fmt->palette->ncolors);
-	}
+}
-	return textureID;
+return textureID;
 }
 static __inline__ SDL_Texture *
 SDL_GetTextureFromID(SDL_TextureID textureID)
 {
-	int             hash;
+int hash;
-	SDL_Texture    *texture;
+SDL_Texture *texture;
-	if (!_this) {
+if (!_this) {
-		return NULL;
+return NULL;
-	}
+}
-	hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
+hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
-	for (texture = SDL_CurrentDisplay.textures[hash]; texture;
+for (texture = SDL_CurrentDisplay.textures[hash]; texture;
-	     texture = texture->next) {
+texture = texture->next) {
-		if (texture->id == textureID) {
+if (texture->id == textureID) {
-			return texture;
+return texture;
-		}
+}
-	}
+}
-	return NULL;
+return NULL;
 }
 int
 SDL_QueryTexture(SDL_TextureID textureID, Uint32 * format, int *access,
-		 int *w, int *h)
+int *w, int *h)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	if (format) {
+if (format) {
-		*format = texture->format;
+*format = texture->format;
-	}
+}
-	if (access) {
+if (access) {
-		*access = texture->access;
+*access = texture->access;
-	}
+}
-	if (w) {
+if (w) {
-		*w = texture->w;
+*w = texture->w;
-	}
+}
-	if (h) {
+if (h) {
-		*h = texture->h;
+*h = texture->h;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_QueryTexturePixels(SDL_TextureID textureID, void **pixels, int *pitch)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->QueryTexturePixels) {
+if (!renderer->QueryTexturePixels) {
-		return -1;
+return -1;
-	}
+}
-	return renderer->QueryTexturePixels(renderer, texture, pixels, pitch);
+return renderer->QueryTexturePixels(renderer, texture, pixels, pitch);
 }
 int
 SDL_SetTexturePalette(SDL_TextureID textureID, const SDL_Color * colors,
-		      int firstcolor, int ncolors)
+int firstcolor, int ncolors)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->SetTexturePalette) {
+if (!renderer->SetTexturePalette) {
-		return -1;
+return -1;
-	}
+}
-	return renderer->SetTexturePalette(renderer, texture, colors, firstcolor,
+return renderer->SetTexturePalette(renderer, texture, colors, firstcolor,
-					   ncolors);
+ncolors);
 }
 int
 SDL_GetTexturePalette(SDL_TextureID textureID, SDL_Color * colors,
-		      int firstcolor, int ncolors)
+int firstcolor, int ncolors)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->GetTexturePalette) {
+if (!renderer->GetTexturePalette) {
-		return -1;
+return -1;
-	}
+}
-	return renderer->GetTexturePalette(renderer, texture, colors, firstcolor,
+return renderer->GetTexturePalette(renderer, texture, colors, firstcolor,
-					   ncolors);
+ncolors);
 }
 int
 SDL_SetTextureColorMod(SDL_TextureID textureID, Uint8 r, Uint8 g, Uint8 b)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->SetTextureColorMod) {
+if (!renderer->SetTextureColorMod) {
-		return -1;
+return -1;
-	}
+}
-	if (r < 255 || g < 255 || b < 255) {
+if (r < 255 || g < 255 || b < 255) {
-		texture->modMode |= SDL_TEXTUREMODULATE_COLOR;
+texture->modMode |= SDL_TEXTUREMODULATE_COLOR;
-	} else {
+} else {
-		texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
+texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
-	}
+}
-	texture->r = r;
+texture->r = r;
-	texture->g = g;
+texture->g = g;
-	texture->b = b;
+texture->b = b;
-	return renderer->SetTextureColorMod(renderer, texture);
+return renderer->SetTextureColorMod(renderer, texture);
 }
 int
 SDL_GetTextureColorMod(SDL_TextureID textureID, Uint8 * r, Uint8 * g,
-		       Uint8 * b)
+Uint8 * b)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (r) {
+if (r) {
-		*r = texture->r;
+*r = texture->r;
-	}
+}
-	if (g) {
+if (g) {
-		*g = texture->g;
+*g = texture->g;
-	}
+}
-	if (b) {
+if (b) {
-		*b = texture->b;
+*b = texture->b;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_SetTextureAlphaMod(SDL_TextureID textureID, Uint8 alpha)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->SetTextureAlphaMod) {
+if (!renderer->SetTextureAlphaMod) {
-		return -1;
+return -1;
-	}
+}
-	if (alpha < 255) {
+if (alpha < 255) {
-		texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;
+texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;
-	} else {
+} else {
-		texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
+texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
-	}
+}
-	texture->a = alpha;
+texture->a = alpha;
-	return renderer->SetTextureAlphaMod(renderer, texture);
+return renderer->SetTextureAlphaMod(renderer, texture);
 }
 int
 SDL_GetTextureAlphaMod(SDL_TextureID textureID, Uint8 * alpha)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	if (alpha) {
+if (alpha) {
-		*alpha = texture->a;
+*alpha = texture->a;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_SetTextureBlendMode(SDL_TextureID textureID, int blendMode)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->SetTextureBlendMode) {
+if (!renderer->SetTextureBlendMode) {
-		return -1;
+return -1;
-	}
+}
-	texture->blendMode = blendMode;
+texture->blendMode = blendMode;
-	return renderer->SetTextureBlendMode(renderer, texture);
+return renderer->SetTextureBlendMode(renderer, texture);
 }
 int
 SDL_GetTextureBlendMode(SDL_TextureID textureID, int *blendMode)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	if (blendMode) {
+if (blendMode) {
-		*blendMode = texture->blendMode;
+*blendMode = texture->blendMode;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_SetTextureScaleMode(SDL_TextureID textureID, int scaleMode)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->SetTextureScaleMode) {
+if (!renderer->SetTextureScaleMode) {
-		return -1;
+return -1;
-	}
+}
-	texture->scaleMode = scaleMode;
+texture->scaleMode = scaleMode;
-	return renderer->SetTextureScaleMode(renderer, texture);
+return renderer->SetTextureScaleMode(renderer, texture);
 }
 int
 SDL_GetTextureScaleMode(SDL_TextureID textureID, int *scaleMode)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	if (scaleMode) {
+if (scaleMode) {
-		*scaleMode = texture->scaleMode;
+*scaleMode = texture->scaleMode;
-	}
+}
-	return 0;
+return 0;
 }
 int
 SDL_UpdateTexture(SDL_TextureID textureID, const SDL_Rect * rect,
-		  const void *pixels, int pitch)
+const void *pixels, int pitch)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	SDL_Rect        full_rect;
+SDL_Rect full_rect;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->UpdateTexture) {
+if (!renderer->UpdateTexture) {
-		return -1;
+return -1;
-	}
+}
-	if (!rect) {
+if (!rect) {
-		full_rect.x = 0;
+full_rect.x = 0;
-		full_rect.y = 0;
+full_rect.y = 0;
-		full_rect.w = texture->w;
+full_rect.w = texture->w;
-		full_rect.h = texture->h;
+full_rect.h = texture->h;
-		rect = &full_rect;
+rect = &full_rect;
-	}
+}
-	return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
+return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
 }
 int
 SDL_LockTexture(SDL_TextureID textureID, const SDL_Rect * rect, int markDirty,
-		void **pixels, int *pitch)
+void **pixels, int *pitch)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	SDL_Rect        full_rect;
+SDL_Rect full_rect;
-	if (!texture) {
+if (!texture) {
-		return -1;
+return -1;
-	}
+}
-	if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
+if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
-		SDL_SetError("SDL_LockTexture(): texture must be streaming");
+SDL_SetError("SDL_LockTexture(): texture must be streaming");
-		return -1;
+return -1;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->LockTexture) {
+if (!renderer->LockTexture) {
-		return -1;
+return -1;
-	}
+}
-	if (!rect) {
+if (!rect) {
-		full_rect.x = 0;
+full_rect.x = 0;
-		full_rect.y = 0;
+full_rect.y = 0;
-		full_rect.w = texture->w;
+full_rect.w = texture->w;
-		full_rect.h = texture->h;
+full_rect.h = texture->h;
-		rect = &full_rect;
+rect = &full_rect;
-	}
+}
-	return renderer->LockTexture(renderer, texture, rect, markDirty, pixels,
+return renderer->LockTexture(renderer, texture, rect, markDirty, pixels,
-				     pitch);
+pitch);
 }
 void
 SDL_UnlockTexture(SDL_TextureID textureID)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return;
+return;
-	}
+}
-	if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
+if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
-		return;
+return;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->UnlockTexture) {
+if (!renderer->UnlockTexture) {
-		return;
+return;
-	}
+}
-	renderer->UnlockTexture(renderer, texture);
+renderer->UnlockTexture(renderer, texture);
 }
 void
 SDL_DirtyTexture(SDL_TextureID textureID, int numrects,
-		 const SDL_Rect * rects)
+const SDL_Rect * rects)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!texture) {
+if (!texture) {
-		return;
+return;
-	}
+}
-	if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
+if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
-		return;
+return;
-	}
+}
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	if (!renderer->DirtyTexture) {
+if (!renderer->DirtyTexture) {
-		return;
+return;
-	}
+}
-	renderer->DirtyTexture(renderer, texture, numrects, rects);
+renderer->DirtyTexture(renderer, texture, numrects, rects);
 }
 int
 SDL_RenderFill(Uint8 r, Uint8 g, Uint8 b, Uint8 a, const SDL_Rect * rect)
 {
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	SDL_Window     *window;
+SDL_Window *window;
-	SDL_Rect        real_rect;
+SDL_Rect real_rect;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	renderer = SDL_CurrentDisplay.current_renderer;
+renderer = SDL_CurrentDisplay.current_renderer;
-	if (!renderer || !renderer->RenderFill) {
+if (!renderer || !renderer->RenderFill) {
-		return -1;
+return -1;
-	}
+}
-	window = SDL_GetWindowFromID(renderer->window);
+window = SDL_GetWindowFromID(renderer->window);
-	real_rect.x = 0;
+real_rect.x = 0;
-	real_rect.y = 0;
+real_rect.y = 0;
-	real_rect.w = window->w;
+real_rect.w = window->w;
-	real_rect.h = window->h;
+real_rect.h = window->h;
-	if (rect) {
+if (rect) {
-		if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
+if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
-			return 0;
+return 0;
-		}
+}
-	}
+}
-	return renderer->RenderFill(renderer, r, g, b, a, &real_rect);
+return renderer->RenderFill(renderer, r, g, b, a, &real_rect);
 }
 int
 SDL_RenderCopy(SDL_TextureID textureID, const SDL_Rect * srcrect,
-	       const SDL_Rect * dstrect)
+const SDL_Rect * dstrect)
 {
-	SDL_Texture    *texture = SDL_GetTextureFromID(textureID);
+SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	SDL_Window     *window;
+SDL_Window *window;
-	SDL_Rect        real_srcrect;
+SDL_Rect real_srcrect;
-	SDL_Rect        real_dstrect;
+SDL_Rect real_dstrect;
-	if (!texture || texture->renderer != SDL_CurrentDisplay.current_renderer) {
+if (!texture || texture->renderer != SDL_CurrentDisplay.current_renderer) {
-		return -1;
+return -1;
-	}
+}
-	renderer = SDL_CurrentDisplay.current_renderer;
+renderer = SDL_CurrentDisplay.current_renderer;
-	if (!renderer || !renderer->RenderCopy) {
+if (!renderer || !renderer->RenderCopy) {
-		return -1;
+return -1;
-	}
+}
-	window = SDL_GetWindowFromID(renderer->window);
+window = SDL_GetWindowFromID(renderer->window);
-	if (srcrect) {
+if (srcrect) {
-		real_srcrect = *srcrect;
+real_srcrect = *srcrect;
-	} else {
+} else {
-		real_srcrect.x = 0;
+real_srcrect.x = 0;
-		real_srcrect.y = 0;
+real_srcrect.y = 0;
-		real_srcrect.w = texture->w;
+real_srcrect.w = texture->w;
-		real_srcrect.h = texture->h;
+real_srcrect.h = texture->h;
-	}
+}
-	if (dstrect) {
+if (dstrect) {
-		real_dstrect = *dstrect;
+real_dstrect = *dstrect;
-	} else {
+} else {
-		real_dstrect.x = 0;
+real_dstrect.x = 0;
-		real_dstrect.y = 0;
+real_dstrect.y = 0;
-		real_dstrect.w = window->w;
+real_dstrect.w = window->w;
-		real_dstrect.h = window->h;
+real_dstrect.h = window->h;
-	}
+}
-	return renderer->RenderCopy(renderer, texture, &real_srcrect,
+return renderer->RenderCopy(renderer, texture, &real_srcrect,
-				    &real_dstrect);
+&real_dstrect);
 }
 void
 SDL_RenderPresent(void)
 {
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return;
+return;
-	}
+}
-	renderer = SDL_CurrentDisplay.current_renderer;
+renderer = SDL_CurrentDisplay.current_renderer;
-	if (!renderer || !renderer->RenderPresent) {
+if (!renderer || !renderer->RenderPresent) {
-		return;
+return;
-	}
+}
-	renderer->RenderPresent(renderer);
+renderer->RenderPresent(renderer);
 }
 void
 SDL_DestroyTexture(SDL_TextureID textureID)
 {
-	int             hash;
+int hash;
-	SDL_Texture    *prev, *texture;
+SDL_Texture *prev, *texture;
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return;
+return;
-	}
+}
-	/* Look up the texture in the hash table */
+/* Look up the texture in the hash table */
-	hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
+hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
-	prev = NULL;
+prev = NULL;
-	for (texture = SDL_CurrentDisplay.textures[hash]; texture;
+for (texture = SDL_CurrentDisplay.textures[hash]; texture;
-	     prev = texture, texture = texture->next) {
+prev = texture, texture = texture->next) {
-		if (texture->id == textureID) {
+if (texture->id == textureID) {
-			break;
+break;
-		}
+}
-	}
+}
-	if (!texture) {
+if (!texture) {
-		return;
+return;
-	}
+}
-	/* Unlink the texture from the list */
+/* Unlink the texture from the list */
-	if (prev) {
+if (prev) {
-		prev->next = texture->next;
+prev->next = texture->next;
-	} else {
+} else {
-		SDL_CurrentDisplay.textures[hash] = texture->next;
+SDL_CurrentDisplay.textures[hash] = texture->next;
-	}
+}
-	/* Free the texture */
+/* Free the texture */
-	renderer = texture->renderer;
+renderer = texture->renderer;
-	renderer->DestroyTexture(renderer, texture);
+renderer->DestroyTexture(renderer, texture);
-	SDL_free(texture);
+SDL_free(texture);
 }
 void
 SDL_DestroyRenderer(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	SDL_Renderer   *renderer;
+SDL_Renderer *renderer;
-	int             i;
+int i;
-	if (!window) {
+if (!window) {
-		return;
+return;
-	}
+}
-	renderer = window->renderer;
+renderer = window->renderer;
-	if (!renderer) {
+if (!renderer) {
-		return;
+return;
-	}
+}
-	/* Free existing textures for this renderer */
+/* Free existing textures for this renderer */
-	for (i = 0; i < SDL_arraysize(SDL_CurrentDisplay.textures); ++i) {
+for (i = 0; i < SDL_arraysize(SDL_CurrentDisplay.textures); ++i) {
-		SDL_Texture    *texture;
+SDL_Texture *texture;
-		SDL_Texture    *prev = NULL;
+SDL_Texture *prev = NULL;
-		SDL_Texture    *next;
+SDL_Texture *next;
-		for (texture = SDL_CurrentDisplay.textures[i]; texture;
+for (texture = SDL_CurrentDisplay.textures[i]; texture;
-		     texture = next) {
+texture = next) {
-			next = texture->next;
+next = texture->next;
-			if (texture->renderer == renderer) {
+if (texture->renderer == renderer) {
-				if (prev) {
+if (prev) {
-					prev->next = next;
+prev->next = next;
-				} else {
+} else {
-					SDL_CurrentDisplay.textures[i] = next;
+SDL_CurrentDisplay.textures[i] = next;
-				}
+}
-				renderer->DestroyTexture(renderer, texture);
+renderer->DestroyTexture(renderer, texture);
-				SDL_free(texture);
+SDL_free(texture);
-			} else {
+} else {
-				prev = texture;
+prev = texture;
-			}
+}
-		}
+}
-	}
+}
-	/* Free the renderer instance */
+/* Free the renderer instance */
-	renderer->DestroyRenderer(renderer);
+renderer->DestroyRenderer(renderer);
-	/* Clear references */
+/* Clear references */
-	window->renderer = NULL;
+window->renderer = NULL;
-	if (SDL_CurrentDisplay.current_renderer == renderer) {
+if (SDL_CurrentDisplay.current_renderer == renderer) {
-		SDL_CurrentDisplay.current_renderer = NULL;
+SDL_CurrentDisplay.current_renderer = NULL;
-	}
+}
 }
 void
 SDL_VideoQuit(void)
 {
-	int             i, j;
+int i, j;
-	if (!_this) {
+if (!_this) {
-		return;
+return;
-	}
+}
-	/* Halt event processing before doing anything else */
+/* Halt event processing before doing anything else */
-	SDL_StopEventLoop();
+SDL_StopEventLoop();
-	/* Clean up the system video */
+/* Clean up the system video */
-	for (i = _this->num_displays; i--;) {
+for (i = _this->num_displays; i--;) {
-		SDL_VideoDisplay *display = &_this->displays[i];
+SDL_VideoDisplay *display = &_this->displays[i];
-		for (j = display->num_windows; j--;) {
+for (j = display->num_windows; j--;) {
-			SDL_DestroyWindow(display->windows[i].id);
+SDL_DestroyWindow(display->windows[i].id);
-		}
+}
-		if (display->windows) {
+if (display->windows) {
-			SDL_free(display->windows);
+SDL_free(display->windows);
-			display->windows = NULL;
+display->windows = NULL;
-		}
+}
-		display->num_windows = 0;
+display->num_windows = 0;
-		if (display->render_drivers) {
+if (display->render_drivers) {
-			SDL_free(display->render_drivers);
+SDL_free(display->render_drivers);
-			display->render_drivers = NULL;
+display->render_drivers = NULL;
-		}
+}
-		display->num_render_drivers = 0;
+display->num_render_drivers = 0;
-	}
+}
-	_this->VideoQuit(_this);
+_this->VideoQuit(_this);
-	for (i = _this->num_displays; i--;) {
+for (i = _this->num_displays; i--;) {
-		SDL_VideoDisplay *display = &_this->displays[i];
+SDL_VideoDisplay *display = &_this->displays[i];
-		for (j = display->num_display_modes; j--;) {
+for (j = display->num_display_modes; j--;) {
-			if (display->display_modes[j].driverdata) {
+if (display->display_modes[j].driverdata) {
-				SDL_free(display->display_modes[j].driverdata);
+SDL_free(display->display_modes[j].driverdata);
-				display->display_modes[j].driverdata = NULL;
+display->display_modes[j].driverdata = NULL;
-			}
+}
-		}
+}
-		if (display->display_modes) {
+if (display->display_modes) {
-			SDL_free(display->display_modes);
+SDL_free(display->display_modes);
-			display->display_modes = NULL;
+display->display_modes = NULL;
-		}
+}
-		if (display->desktop_mode.driverdata) {
+if (display->desktop_mode.driverdata) {
-			SDL_free(display->desktop_mode.driverdata);
+SDL_free(display->desktop_mode.driverdata);
-			display->desktop_mode.driverdata = NULL;
+display->desktop_mode.driverdata = NULL;
-		}
+}
-		if (display->palette) {
+if (display->palette) {
-			SDL_FreePalette(display->palette);
+SDL_FreePalette(display->palette);
-			display->palette = NULL;
+display->palette = NULL;
-		}
+}
-		if (display->gamma) {
+if (display->gamma) {
-			SDL_free(display->gamma);
+SDL_free(display->gamma);
-			display->gamma = NULL;
+display->gamma = NULL;
-		}
+}
-		if (display->driverdata) {
+if (display->driverdata) {
-			SDL_free(display->driverdata);
+SDL_free(display->driverdata);
-			display->driverdata = NULL;
+display->driverdata = NULL;
-		}
+}
-	}
+}
-	if (_this->displays) {
+if (_this->displays) {
-		SDL_free(_this->displays);
+SDL_free(_this->displays);
-		_this->displays = NULL;
+_this->displays = NULL;
-	}
+}
-	_this->free(_this);
+_this->free(_this);
-	_this = NULL;
+_this = NULL;
 }
 int
 SDL_GL_LoadLibrary(const char *path)
 {
-	int             retval;
+int retval;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (_this->GL_LoadLibrary) {
+if (_this->GL_LoadLibrary) {
-		retval = _this->GL_LoadLibrary(_this, path);
+retval = _this->GL_LoadLibrary(_this, path);
-	} else {
+} else {
-		SDL_SetError("No dynamic GL support in video driver");
+SDL_SetError("No dynamic GL support in video driver");
-		retval = -1;
+retval = -1;
-	}
+}
-	return (retval);
+return (retval);
 }
-void           *
+void *
 SDL_GL_GetProcAddress(const char *proc)
 {
-	void           *func;
+void *func;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return NULL;
+return NULL;
-	}
+}
-	func = NULL;
+func = NULL;
-	if (_this->GL_GetProcAddress) {
+if (_this->GL_GetProcAddress) {
-		if (_this->gl_config.driver_loaded) {
+if (_this->gl_config.driver_loaded) {
-			func = _this->GL_GetProcAddress(_this, proc);
+func = _this->GL_GetProcAddress(_this, proc);
-		} else {
+} else {
-			SDL_SetError("No GL driver has been loaded");
+SDL_SetError("No GL driver has been loaded");
-		}
+}
-	} else {
+} else {
-		SDL_SetError("No dynamic GL support in video driver");
+SDL_SetError("No dynamic GL support in video driver");
-	}
+}
-	return func;
+return func;
 }
 SDL_bool
 SDL_GL_ExtensionSupported(const char *extension)
 {
 #if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES
-	const GLubyte  *(APIENTRY * glGetStringFunc) (GLenum);
+const GLubyte *(APIENTRY * glGetStringFunc) (GLenum);
-	const char     *extensions;
+const char *extensions;
-	const char     *start;
+const char *start;
-	const char     *where, *terminator;
+const char *where, *terminator;
-	/* Extension names should not have spaces. */
+/* Extension names should not have spaces. */
-	where = SDL_strchr(extension, ' ');
+where = SDL_strchr(extension, ' ');
-	if (where || *extension == '\0') {
+if (where || *extension == '\0') {
-		return SDL_FALSE;
+return SDL_FALSE;
-	}
+}
-	/* See if there's an environment variable override */
+/* See if there's an environment variable override */
-	start = SDL_getenv(extension);
+start = SDL_getenv(extension);
-	if (start && *start == '0') {
+if (start && *start == '0') {
-		return SDL_FALSE;
+return SDL_FALSE;
-	}
+}
-	/* Lookup the available extensions */
+/* Lookup the available extensions */
-	glGetStringFunc = SDL_GL_GetProcAddress("glGetString");
+glGetStringFunc = SDL_GL_GetProcAddress("glGetString");
-	if (glGetStringFunc) {
+if (glGetStringFunc) {
-		extensions = (const char *) glGetStringFunc(GL_EXTENSIONS);
+extensions = (const char *) glGetStringFunc(GL_EXTENSIONS);
-	} else {
+} else {
-		extensions = NULL;
+extensions = NULL;
-	}
+}
-	if (!extensions) {
+if (!extensions) {
-		return SDL_FALSE;
+return SDL_FALSE;
-	}
+}
-	/*
+/*
-	 * It takes a bit of care to be fool-proof about parsing the OpenGL
+* It takes a bit of care to be fool-proof about parsing the OpenGL
-	 * extensions string. Don't be fooled by sub-strings, etc.
+* extensions string. Don't be fooled by sub-strings, etc.
-	 */
+*/
-	start = extensions;
+start = extensions;
-	for (;;) {
+for (;;) {
-		where = SDL_strstr(start, extension);
+where = SDL_strstr(start, extension);
-		if (!where)
+if (!where)
-			break;
+break;
-		terminator = where + SDL_strlen(extension);
+terminator = where + SDL_strlen(extension);
-		if (where == start || *(where - 1) == ' ')
+if (where == start || *(where - 1) == ' ')
-			if (*terminator == ' ' || *terminator == '\0')
+if (*terminator == ' ' || *terminator == '\0')
-				return SDL_TRUE;
+return SDL_TRUE;
-		start = terminator;
+start = terminator;
-	}
+}
-	return SDL_FALSE;
+return SDL_FALSE;
 #else
-	return SDL_FALSE;
+return SDL_FALSE;
 #endif
 }
 int
 SDL_GL_SetAttribute(SDL_GLattr attr, int value)
 {
 #if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES
-	int             retval;
+int retval;
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	retval = 0;
+retval = 0;
-	switch (attr) {
+switch (attr) {
-	case SDL_GL_RED_SIZE:
+case SDL_GL_RED_SIZE:
-		_this->gl_config.red_size = value;
+_this->gl_config.red_size = value;
-		break;
+break;
-	case SDL_GL_GREEN_SIZE:
+case SDL_GL_GREEN_SIZE:
-		_this->gl_config.green_size = value;
+_this->gl_config.green_size = value;
-		break;
+break;
-	case SDL_GL_BLUE_SIZE:
+case SDL_GL_BLUE_SIZE:
-		_this->gl_config.blue_size = value;
+_this->gl_config.blue_size = value;
-		break;
+break;
-	case SDL_GL_ALPHA_SIZE:
+case SDL_GL_ALPHA_SIZE:
-		_this->gl_config.alpha_size = value;
+_this->gl_config.alpha_size = value;
-		break;
+break;
-	case SDL_GL_DOUBLEBUFFER:
+case SDL_GL_DOUBLEBUFFER:
-		_this->gl_config.double_buffer = value;
+_this->gl_config.double_buffer = value;
-		break;
+break;
-	case SDL_GL_BUFFER_SIZE:
+case SDL_GL_BUFFER_SIZE:
-		_this->gl_config.buffer_size = value;
+_this->gl_config.buffer_size = value;
-		break;
+break;
-	case SDL_GL_DEPTH_SIZE:
+case SDL_GL_DEPTH_SIZE:
-		_this->gl_config.depth_size = value;
+_this->gl_config.depth_size = value;
-		break;
+break;
-	case SDL_GL_STENCIL_SIZE:
+case SDL_GL_STENCIL_SIZE:
-		_this->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:
-		_this->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:
-		_this->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:
-		_this->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:
-		_this->gl_config.accum_alpha_size = value;
+_this->gl_config.accum_alpha_size = value;
-		break;
+break;
-	case SDL_GL_STEREO:
+case SDL_GL_STEREO:
-		_this->gl_config.stereo = value;
+_this->gl_config.stereo = value;
-		break;
+break;
-	case SDL_GL_MULTISAMPLEBUFFERS:
+case SDL_GL_MULTISAMPLEBUFFERS:
-		_this->gl_config.multisamplebuffers = value;
+_this->gl_config.multisamplebuffers = value;
-		break;
+break;
-	case SDL_GL_MULTISAMPLESAMPLES:
+case SDL_GL_MULTISAMPLESAMPLES:
-		_this->gl_config.multisamplesamples = value;
+_this->gl_config.multisamplesamples = value;
-		break;
+break;
-	case SDL_GL_ACCELERATED_VISUAL:
+case SDL_GL_ACCELERATED_VISUAL:
-		_this->gl_config.accelerated = value;
+_this->gl_config.accelerated = value;
-		break;
+break;
-	case SDL_GL_RETAINED_BACKING:
+case SDL_GL_RETAINED_BACKING:
-		_this->gl_config.retained_backing = value;
+_this->gl_config.retained_backing = value;
-		break;
+break;
-	default:
+default:
-		SDL_SetError("Unknown OpenGL attribute");
+SDL_SetError("Unknown OpenGL attribute");
-		retval = -1;
+retval = -1;
-		break;
+break;
-	}
+}
-	return retval;
+return retval;
 #else
-	SDL_Unsupported();
+SDL_Unsupported();
-	return -1;
+return -1;
-#endif				/* SDL_VIDEO_OPENGL */
+#endif /* SDL_VIDEO_OPENGL */
 }
 int
 SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
 {
 #if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES
-	void            (APIENTRY * glGetIntegervFunc) (GLenum pname, GLint * params);
+void (APIENTRY * glGetIntegervFunc) (GLenum pname, GLint * params);
-	GLenum          attrib = 0;
+GLenum attrib = 0;
-	glGetIntegervFunc = SDL_GL_GetProcAddress("glGetIntegerv");
+glGetIntegervFunc = SDL_GL_GetProcAddress("glGetIntegerv");
-	if (!glGetIntegervFunc) {
+if (!glGetIntegervFunc) {
-		return -1;
+return -1;
-	}
+}
-	switch (attr) {
+switch (attr) {
-	case SDL_GL_RETAINED_BACKING:
+case SDL_GL_RETAINED_BACKING:
-		*value = _this->gl_config.retained_backing;
+*value = _this->gl_config.retained_backing;
-		return 0;
+return 0;
-	case SDL_GL_RED_SIZE:
+case SDL_GL_RED_SIZE:
-		attrib = GL_RED_BITS;
+attrib = GL_RED_BITS;
-		break;
+break;
-	case SDL_GL_BLUE_SIZE:
+case SDL_GL_BLUE_SIZE:
-		attrib = GL_BLUE_BITS;
+attrib = GL_BLUE_BITS;
-		break;
+break;
-	case SDL_GL_GREEN_SIZE:
+case SDL_GL_GREEN_SIZE:
-		attrib = GL_GREEN_BITS;
+attrib = GL_GREEN_BITS;
-		break;
+break;
-	case SDL_GL_ALPHA_SIZE:
+case SDL_GL_ALPHA_SIZE:
-		attrib = GL_ALPHA_BITS;
+attrib = GL_ALPHA_BITS;
-		break;
+break;
-	case SDL_GL_DOUBLEBUFFER:
+case SDL_GL_DOUBLEBUFFER:
 #ifndef SDL_VIDEO_OPENGL_ES
-		attrib = GL_DOUBLEBUFFER;
+attrib = GL_DOUBLEBUFFER;
-		break;
+break;
 #else
-		/*
+/*
-		 * I believe double buffering is the only option in OpenGL ES
+* I believe double buffering is the only option in OpenGL ES
-		 * -- in any case, GL_DOUBLEBUFFER doesn't exist
+* -- in any case, GL_DOUBLEBUFFER doesn't exist
-		 */
+*/
-		*value = 1;
+*value = 1;
-		return 0;
+return 0;
 #endif
-	case SDL_GL_DEPTH_SIZE:
+case SDL_GL_DEPTH_SIZE:
-		attrib = GL_DEPTH_BITS;
+attrib = GL_DEPTH_BITS;
-		break;
+break;
-	case SDL_GL_STENCIL_SIZE:
+case SDL_GL_STENCIL_SIZE:
-		attrib = GL_STENCIL_BITS;
+attrib = GL_STENCIL_BITS;
-		break;
+break;
 #ifndef SDL_VIDEO_OPENGL_ES
-	case SDL_GL_ACCUM_RED_SIZE:
+case SDL_GL_ACCUM_RED_SIZE:
-		attrib = GL_ACCUM_RED_BITS;
+attrib = GL_ACCUM_RED_BITS;
-		break;
+break;
-	case SDL_GL_ACCUM_GREEN_SIZE:
+case SDL_GL_ACCUM_GREEN_SIZE:
-		attrib = GL_ACCUM_GREEN_BITS;
+attrib = GL_ACCUM_GREEN_BITS;
-		break;
+break;
-	case SDL_GL_ACCUM_BLUE_SIZE:
+case SDL_GL_ACCUM_BLUE_SIZE:
-		attrib = GL_ACCUM_BLUE_BITS;
+attrib = GL_ACCUM_BLUE_BITS;
-		break;
+break;
-	case SDL_GL_ACCUM_ALPHA_SIZE:
+case SDL_GL_ACCUM_ALPHA_SIZE:
-		attrib = GL_ACCUM_ALPHA_BITS;
+attrib = GL_ACCUM_ALPHA_BITS;
-		break;
+break;
-	case SDL_GL_STEREO:
+case SDL_GL_STEREO:
-		attrib = GL_STEREO;
+attrib = GL_STEREO;
-		break;
+break;
 #else
-	case SDL_GL_ACCUM_RED_SIZE:
+case SDL_GL_ACCUM_RED_SIZE:
-	case SDL_GL_ACCUM_GREEN_SIZE:
+case SDL_GL_ACCUM_GREEN_SIZE:
-	case SDL_GL_ACCUM_BLUE_SIZE:
+case SDL_GL_ACCUM_BLUE_SIZE:
-	case SDL_GL_ACCUM_ALPHA_SIZE:
+case SDL_GL_ACCUM_ALPHA_SIZE:
-	case SDL_GL_STEREO:
+case SDL_GL_STEREO:
-		/* none of these are supported in OpenGL ES */
+/* none of these are supported in OpenGL ES */
-		*value = 0;
+*value = 0;
-		return 0;
+return 0;
 #endif
-	case SDL_GL_MULTISAMPLEBUFFERS:
+case SDL_GL_MULTISAMPLEBUFFERS:
 #ifndef SDL_VIDEO_OPENGL_ES
-		attrib = GL_SAMPLE_BUFFERS_ARB;
+attrib = GL_SAMPLE_BUFFERS_ARB;
 #else
-		attrib = GL_SAMPLE_BUFFERS;
+attrib = GL_SAMPLE_BUFFERS;
 #endif
-		break;
+break;
-	case SDL_GL_MULTISAMPLESAMPLES:
+case SDL_GL_MULTISAMPLESAMPLES:
 #ifndef SDL_VIDEO_OPENGL_ES
-		attrib = GL_SAMPLES_ARB;
+attrib = GL_SAMPLES_ARB;
 #else
-		attrib = GL_SAMPLES;
+attrib = GL_SAMPLES;
 #endif
-		break;
+break;
-	case SDL_GL_BUFFER_SIZE:
+case SDL_GL_BUFFER_SIZE:
-		{
+{
-			GLint           bits = 0;
+GLint bits = 0;
-			GLint           component;
+GLint component;
-			/*
+/*
-			 * there doesn't seem to be a single flag in OpenGL
+* there doesn't seem to be a single flag in OpenGL
-			 * for this!
+* for this!
-			 */
+*/
-			glGetIntegervFunc(GL_RED_BITS, &component);
+glGetIntegervFunc(GL_RED_BITS, &component);
-			bits += component;
+bits += component;
-			glGetIntegervFunc(GL_GREEN_BITS, &component);
+glGetIntegervFunc(GL_GREEN_BITS, &component);
-			bits += component;
+bits += component;
-			glGetIntegervFunc(GL_BLUE_BITS, &component);
+glGetIntegervFunc(GL_BLUE_BITS, &component);
-			bits += component;
+bits += component;
-			glGetIntegervFunc(GL_ALPHA_BITS, &component);
+glGetIntegervFunc(GL_ALPHA_BITS, &component);
-			bits += component;
+bits += component;
-			*value = bits;
+*value = bits;
-			return 0;
+return 0;
-		}
+}
-	case SDL_GL_ACCELERATED_VISUAL:
+case SDL_GL_ACCELERATED_VISUAL:
-		{
+{
-			/* FIXME: How do we get this information? */
+/* FIXME: How do we get this information? */
-			*value = (_this->gl_config.accelerated != 0);
+*value = (_this->gl_config.accelerated != 0);
-			return 0;
+return 0;
-		}
+}
-	default:
+default:
-		SDL_SetError("Unknown OpenGL attribute");
+SDL_SetError("Unknown OpenGL attribute");
-		return -1;
+return -1;
-	}
+}
-	glGetIntegervFunc(attrib, (GLint *) value);
+glGetIntegervFunc(attrib, (GLint *) value);
-	return 0;
+return 0;
 #else
-	SDL_Unsupported();
+SDL_Unsupported();
-	return -1;
+return -1;
-#endif				/* SDL_VIDEO_OPENGL */
+#endif /* SDL_VIDEO_OPENGL */
 }
 SDL_GLContext
 SDL_GL_CreateContext(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return NULL;
+return NULL;
-	}
+}
-	if (!(window->flags & SDL_WINDOW_OPENGL)) {
+if (!(window->flags & SDL_WINDOW_OPENGL)) {
-		SDL_SetError("The specified window isn't an OpenGL window");
+SDL_SetError("The specified window isn't an OpenGL window");
-		return NULL;
+return NULL;
-	}
+}
-	return _this->GL_CreateContext(_this, window);
+return _this->GL_CreateContext(_this, window);
 }
 int
 SDL_GL_MakeCurrent(SDL_WindowID windowID, SDL_GLContext context)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (window && !(window->flags & SDL_WINDOW_OPENGL)) {
+if (window && !(window->flags & SDL_WINDOW_OPENGL)) {
-		SDL_SetError("The specified window isn't an OpenGL window");
+SDL_SetError("The specified window isn't an OpenGL window");
-		return -1;
+return -1;
-	}
+}
-	if (!context) {
+if (!context) {
-		window = NULL;
+window = NULL;
-	}
+}
-	return _this->GL_MakeCurrent(_this, window, context);
+return _this->GL_MakeCurrent(_this, window, context);
 }
 int
 SDL_GL_SetSwapInterval(int interval)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (_this->GL_SetSwapInterval) {
+if (_this->GL_SetSwapInterval) {
-		return _this->GL_SetSwapInterval(_this, interval);
+return _this->GL_SetSwapInterval(_this, interval);
-	} else {
+} else {
-		SDL_SetError("Setting the swap interval is not supported");
+SDL_SetError("Setting the swap interval is not supported");
-		return -1;
+return -1;
-	}
+}
 }
 int
 SDL_GL_GetSwapInterval(void)
 {
-	if (!_this) {
+if (!_this) {
-		SDL_UninitializedVideo();
+SDL_UninitializedVideo();
-		return -1;
+return -1;
-	}
+}
-	if (_this->GL_GetSwapInterval) {
+if (_this->GL_GetSwapInterval) {
-		return _this->GL_GetSwapInterval(_this);
+return _this->GL_GetSwapInterval(_this);
-	} else {
+} else {
-		SDL_SetError("Getting the swap interval is not supported");
+SDL_SetError("Getting the swap interval is not supported");
-		return -1;
+return -1;
-	}
+}
 }
 void
 SDL_GL_SwapWindow(SDL_WindowID windowID)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window) {
+if (!window) {
-		return;
+return;
-	}
+}
-	if (!(window->flags & SDL_WINDOW_OPENGL)) {
+if (!(window->flags & SDL_WINDOW_OPENGL)) {
-		SDL_SetError("The specified window isn't an OpenGL window");
+SDL_SetError("The specified window isn't an OpenGL window");
-		return;
+return;
-	}
+}
-	_this->GL_SwapWindow(_this, window);
+_this->GL_SwapWindow(_this, window);
 }
 void
 SDL_GL_DeleteContext(SDL_GLContext context)
 {
-	if (!_this || !context) {
+if (!_this || !context) {
-		return;
+return;
-	}
+}
-	_this->GL_MakeCurrent(_this, NULL, NULL);
+_this->GL_MakeCurrent(_this, NULL, NULL);
-	_this->GL_DeleteContext(_this, context);
+_this->GL_DeleteContext(_this, context);
 }
 #if 0                           // FIXME
 /*
 * 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)
 {
-	int             x, y;
+int x, y;
-	Uint32          colorkey;
+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:
+case 1:
-		{
+{
-			Uint8          *pixels;
+Uint8 *pixels;
-			for (y = 0; y < icon->h; ++y) {
+for (y = 0; y < icon->h; ++y) {
-				pixels = (Uint8 *) icon->pixels + y * icon->pitch;
+pixels = (Uint8 *) icon->pixels + y * icon->pitch;
-				for (x = 0; x < icon->w; ++x) {
+for (x = 0; x < icon->w; ++x) {
-					if (*pixels++ == colorkey) {
+if (*pixels++ == colorkey) {
-						SET_MASKBIT(icon, x, y, mask);
+SET_MASKBIT(icon, x, y, mask);
-					}
+}
-				}
+}
-			}
+}
-		}
+}
-		break;
+break;
-	case 2:
+case 2:
-		{
+{
-			Uint16         *pixels;
+Uint16 *pixels;
-			for (y = 0; y < icon->h; ++y) {
+for (y = 0; y < icon->h; ++y) {
-				pixels = (Uint16 *) icon->pixels + y * icon->pitch / 2;
+pixels = (Uint16 *) icon->pixels + y * icon->pitch / 2;
-				for (x = 0; x < icon->w; ++x) {
+for (x = 0; x < icon->w; ++x) {
-					if ((flags & 1) && *pixels == colorkey) {
+if ((flags & 1) && *pixels == colorkey) {
-						SET_MASKBIT(icon, x, y, mask);
+SET_MASKBIT(icon, x, y, mask);
-					} else if ((flags & 2)
+} else if ((flags & 2)
-						   && (*pixels & icon->format->Amask) == 0) {
+&& (*pixels & icon->format->Amask) == 0) {
-						SET_MASKBIT(icon, x, y, mask);
+SET_MASKBIT(icon, x, y, mask);
-					}
+}
-					pixels++;
+pixels++;
-				}
+}
-			}
+}
-		}
+}
-		break;
+break;
-	case 4:
+case 4:
-		{
+{
-			Uint32         *pixels;
+Uint32 *pixels;
-			for (y = 0; y < icon->h; ++y) {
+for (y = 0; y < icon->h; ++y) {
-				pixels = (Uint32 *) icon->pixels + y * icon->pitch / 4;
+pixels = (Uint32 *) icon->pixels + y * icon->pitch / 4;
-				for (x = 0; x < icon->w; ++x) {
+for (x = 0; x < icon->w; ++x) {
-					if ((flags & 1) && *pixels == colorkey) {
+if ((flags & 1) && *pixels == colorkey) {
-						SET_MASKBIT(icon, x, y, mask);
+SET_MASKBIT(icon, x, y, mask);
-					} else if ((flags & 2)
+} else if ((flags & 2)
-						   && (*pixels & icon->format->Amask) == 0) {
+&& (*pixels & icon->format->Amask) == 0) {
-						SET_MASKBIT(icon, x, y, mask);
+SET_MASKBIT(icon, x, y, mask);
-					}
+}
-					pixels++;
+pixels++;
-				}
+}
-			}
+}
-		}
+}
-		break;
+break;
-	}
+}
 }
 /*
 * Sets the window manager icon for the display window.
 */
 void
 SDL_WM_SetIcon(SDL_Surface * icon, Uint8 * mask)
 {
-	if (icon && _this->SetIcon) {
+if (icon && _this->SetIcon) {
-		/* Generate a mask if necessary, and create the icon! */
+/* Generate a mask if necessary, and create the icon! */
-		if (mask == NULL) {
+if (mask == NULL) {
-			int             mask_len = icon->h * (icon->w + 7) / 8;
+int mask_len = icon->h * (icon->w + 7) / 8;
-			int             flags = 0;
+int flags = 0;
-			mask = (Uint8 *) SDL_malloc(mask_len);
+mask = (Uint8 *) SDL_malloc(mask_len);
-			if (mask == NULL) {
+if (mask == NULL) {
-				return;
+return;
-			}
+}
-			SDL_memset(mask, ~0, mask_len);
+SDL_memset(mask, ~0, mask_len);
-			if (icon->flags & SDL_SRCCOLORKEY)
+if (icon->flags & SDL_SRCCOLORKEY)
-				flags |= 1;
+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);
-			}
+}
-			_this->SetIcon(_this, icon, mask);
+_this->SetIcon(_this, icon, mask);
-			SDL_free(mask);
+SDL_free(mask);
-		} else {
+} else {
-			_this->SetIcon(_this, icon, mask);
+_this->SetIcon(_this, icon, mask);
-		}
+}
-	}
+}
 }
 #endif
 SDL_bool
-SDL_GetWindowWMInfo(SDL_WindowID windowID, struct SDL_SysWMinfo * info)
+SDL_GetWindowWMInfo(SDL_WindowID windowID, struct SDL_SysWMinfo *info)
 {
-	SDL_Window     *window = SDL_GetWindowFromID(windowID);
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-	if (!window || !_this->GetWindowWMInfo) {
+if (!window || !_this->GetWindowWMInfo) {
-		return SDL_FALSE;
+return SDL_FALSE;
-	}
+}
-	return (_this->GetWindowWMInfo(_this, window, info));
+return (_this->GetWindowWMInfo(_this, window, info));
 }
 /* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison src/video/SDL_video.c @ 2753:0969758c8809