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

comparison src/video/SDL_video.c @ 3685:64ce267332c6

Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.

author	Sam Lantinga <slouken@libsdl.org>
date	Thu, 21 Jan 2010 06:21:52 +0000
parents	4c5ab6841fdc
children	d87db9cf6a31

comparison

equal deleted inserted replaced

-:cc564f08884f
+:64ce267332c6
 int
 SDL_GetNumDisplayModes()
 {
 if (_this) {
-return SDL_GetNumDisplayModesForDisplay(&SDL_CurrentDisplay);
+return SDL_GetNumDisplayModesForDisplay(SDL_CurrentDisplay);
 }
 return 0;
 }
 int
 }
 int
 SDL_GetDisplayMode(int index, SDL_DisplayMode * mode)
 {
-return SDL_GetDisplayModeForDisplay(&SDL_CurrentDisplay, index, mode);
+return SDL_GetDisplayModeForDisplay(SDL_CurrentDisplay, index, mode);
 }
 int
 SDL_GetDesktopDisplayModeForDisplay(SDL_VideoDisplay * display, SDL_DisplayMode * mode)
 {
 {
 if (!_this) {
 SDL_UninitializedVideo();
 return -1;
 }
-return SDL_GetDesktopDisplayModeForDisplay(&SDL_CurrentDisplay, mode);
+return SDL_GetDesktopDisplayModeForDisplay(SDL_CurrentDisplay, mode);
 }
 int
 SDL_GetCurrentDisplayModeForDisplay(SDL_VideoDisplay * display, SDL_DisplayMode * mode)
 {
 {
 if (!_this) {
 SDL_UninitializedVideo();
 return -1;
 }
-return SDL_GetCurrentDisplayModeForDisplay(&SDL_CurrentDisplay, mode);
+return SDL_GetCurrentDisplayModeForDisplay(SDL_CurrentDisplay, mode);
 }
 SDL_DisplayMode *
 SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay * display,
 const SDL_DisplayMode * mode,
 {
 if (!_this) {
 SDL_UninitializedVideo();
 return NULL;
 }
-return SDL_GetClosestDisplayModeForDisplay(&SDL_CurrentDisplay, mode, closest);
+return SDL_GetClosestDisplayModeForDisplay(SDL_CurrentDisplay, mode, closest);
 }
 int
 SDL_SetDisplayModeForDisplay(SDL_VideoDisplay * display, const SDL_DisplayMode * mode)
 {
 {
 if (!_this) {
 SDL_UninitializedVideo();
 return -1;
 }
-return SDL_SetDisplayModeForDisplay(&SDL_CurrentDisplay, mode);
+return SDL_SetDisplayModeForDisplay(SDL_CurrentDisplay, mode);
 }
 int
-SDL_SetWindowDisplayMode(SDL_WindowID windowID, const SDL_DisplayMode * mode)
+SDL_SetWindowDisplayMode(SDL_Window * window, const SDL_DisplayMode * mode)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return -1;
 }
 if (mode) {
 }
 return 0;
 }
 int
-SDL_GetWindowDisplayMode(SDL_WindowID windowID, SDL_DisplayMode * mode)
+SDL_GetWindowDisplayMode(SDL_Window * window, SDL_DisplayMode * mode)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 SDL_DisplayMode fullscreen_mode;
 if (!window) {
 return -1;
 }
 }
 if (!fullscreen_mode.h) {
 fullscreen_mode.h = window->h;
 }
-if (!SDL_GetClosestDisplayModeForDisplay(SDL_GetDisplayFromWindow(window),
+if (!SDL_GetClosestDisplayModeForDisplay(window->display,
 &fullscreen_mode,
 &fullscreen_mode)) {
 SDL_SetError("Couldn't find display mode match");
 return -1;
 }
 }
 static void
 SDL_UpdateFullscreenMode(SDL_Window * window, SDL_bool attempt)
 {
-SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+SDL_VideoDisplay *display = window->display;
 int i;
 /* See if we're already processing a window */
 if (display->updating_fullscreen) {
 return;
 if ((window->flags & SDL_WINDOW_FULLSCREEN) &&
 (window->flags & SDL_WINDOW_SHOWN)) {
 if (attempt) {
 /* We just gained some state, try to gain all states */
 if (window->flags & SDL_WINDOW_MINIMIZED) {
-SDL_RestoreWindow(window->id);
+SDL_RestoreWindow(window);
 } else {
-SDL_RaiseWindow(window->id);
+SDL_RaiseWindow(window);
 }
 } else {
 /* We just lost some state, try to release all states */
-SDL_MinimizeWindow(window->id);
+SDL_MinimizeWindow(window);
 }
 }
 if (FULLSCREEN_VISIBLE(window)) {
 /* Hide any other fullscreen windows */
 for (i = 0; i < display->num_windows; ++i) {
 SDL_Window *other = &display->windows[i];
 if (other != window && FULLSCREEN_VISIBLE(other)) {
-SDL_MinimizeWindow(other->id);
+SDL_MinimizeWindow(other);
 }
 }
 }
 display->updating_fullscreen = SDL_FALSE;
 /* See if there are any fullscreen windows */
 for (i = 0; i < display->num_windows; ++i) {
 window = &display->windows[i];
 if (FULLSCREEN_VISIBLE(window)) {
 SDL_DisplayMode fullscreen_mode;
-if (SDL_GetWindowDisplayMode(window->id, &fullscreen_mode) == 0) {
+if (SDL_GetWindowDisplayMode(window, &fullscreen_mode) == 0) {
 SDL_SetDisplayModeForDisplay(display, &fullscreen_mode);
 display->fullscreen_window = window;
 return;
 }
 }
 {
 if (!_this) {
 SDL_UninitializedVideo();
 return -1;
 }
-return SDL_SetPaletteForDisplay(&SDL_CurrentDisplay, colors, firstcolor, ncolors);
+return SDL_SetPaletteForDisplay(SDL_CurrentDisplay, colors, firstcolor, ncolors);
 }
 int
 SDL_GetPaletteForDisplay(SDL_VideoDisplay * display, SDL_Color * colors, int firstcolor, int ncolors)
 {
 {
 if (!_this) {
 SDL_UninitializedVideo();
 return -1;
 }
-return SDL_GetPaletteForDisplay(&SDL_CurrentDisplay, colors, firstcolor, ncolors);
+return SDL_GetPaletteForDisplay(SDL_CurrentDisplay, colors, firstcolor, ncolors);
 }
-SDL_WindowID
+SDL_Window *
 SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
 {
 const Uint32 allowed_flags = (SDL_WINDOW_FULLSCREEN |
 SDL_WINDOW_OPENGL |
 SDL_WINDOW_BORDERLESS |
 SDL_WINDOW_RESIZABLE |
 SDL_WINDOW_INPUT_GRABBED);
 SDL_VideoDisplay *display;
-SDL_Window window;
+SDL_Window *window;
-int num_windows;
-SDL_Window *windows;
 if (!_this) {
 /* Initialize the video system if needed */
 if (SDL_VideoInit(NULL, 0) < 0) {
-return 0;
+return NULL;
 }
 }
 if (flags & SDL_WINDOW_OPENGL) {
 if (!_this->GL_CreateContext) {
 SDL_SetError("No OpenGL support in video driver");
-return 0;
+return NULL;
 }
 SDL_GL_LoadLibrary(NULL);
 }
-SDL_zero(window);
+display = SDL_CurrentDisplay;
-window.id = _this->next_object_id++;
+window = (SDL_Window *)SDL_calloc(1, sizeof(*window));
-window.x = x;
+window->id = _this->next_object_id++;
-window.y = y;
+window->x = x;
-window.w = w;
+window->y = y;
-window.h = h;
+window->w = w;
-window.flags = (flags & allowed_flags);
+window->h = h;
-window.display = _this->current_display;
+window->flags = (flags & allowed_flags);
+window->display = display;
-if (_this->CreateWindow && _this->CreateWindow(_this, &window) < 0) {
+window->next = display->windows;
-if (flags & SDL_WINDOW_OPENGL) {
+display->windows = window;
-SDL_GL_UnloadLibrary();
-}
+if (_this->CreateWindow && _this->CreateWindow(_this, window) < 0) {
-return 0;
+SDL_DestroyWindow(window);
-}
+return NULL;
-display = &SDL_CurrentDisplay;
+}
-num_windows = display->num_windows;
-windows =
-SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
-if (!windows) {
-if (_this->DestroyWindow) {
-_this->DestroyWindow(_this, &window);
-}
-if (flags & SDL_WINDOW_OPENGL) {
-SDL_GL_UnloadLibrary();
-}
-return 0;
-}
-windows[num_windows] = window;
-display->windows = windows;
-display->num_windows++;
 if (title) {
-SDL_SetWindowTitle(window.id, title);
+SDL_SetWindowTitle(window, title);
 }
 if (flags & SDL_WINDOW_MAXIMIZED) {
-SDL_MaximizeWindow(window.id);
+SDL_MaximizeWindow(window);
 }
 if (flags & SDL_WINDOW_MINIMIZED) {
-SDL_MinimizeWindow(window.id);
+SDL_MinimizeWindow(window);
 }
 if (flags & SDL_WINDOW_SHOWN) {
-SDL_ShowWindow(window.id);
+SDL_ShowWindow(window);
 }
-SDL_UpdateWindowGrab(&window);
+SDL_UpdateWindowGrab(window);
-return window.id;
+return window;
 }
-SDL_WindowID
+SDL_Window *
 SDL_CreateWindowFrom(const void *data)
 {
 SDL_VideoDisplay *display;
-SDL_Window window;
+SDL_Window *window;
-int num_windows;
-SDL_Window *windows;
 if (!_this) {
 SDL_UninitializedVideo();
-return (0);
+return NULL;
 }
-SDL_zero(window);
+display = SDL_CurrentDisplay;
-window.id = _this->next_object_id++;
+window = (SDL_Window *)SDL_calloc(1, sizeof(*window));
-window.display = _this->current_display;
+window->id = _this->next_object_id++;
-window.flags = SDL_WINDOW_FOREIGN;
+window->flags = SDL_WINDOW_FOREIGN;
+window->display = display;
+window->next = display->windows;
+display->windows = window;
 if (!_this->CreateWindowFrom ||
-_this->CreateWindowFrom(_this, &window, data) < 0) {
+_this->CreateWindowFrom(_this, window, data) < 0) {
-return 0;
+SDL_DestroyWindow(window);
-}
+return NULL;
-/* FIXME: Find out what display this window is actually on... */
+}
-display = &SDL_CurrentDisplay;
+return window;
-num_windows = display->num_windows;
-windows =
-SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));
-if (!windows) {
-if (_this->DestroyWindow) {
-_this->DestroyWindow(_this, &window);
-}
-if (window.title) {
-SDL_free(window.title);
-}
-return 0;
-}
-windows[num_windows] = window;
-display->windows = windows;
-display->num_windows++;
-return window.id;
 }
 int
 SDL_RecreateWindow(SDL_Window * window, Uint32 flags)
 {
 return -1;
 }
 }
 if (title) {
-SDL_SetWindowTitle(window->id, title);
+SDL_SetWindowTitle(window, title);
 SDL_free(title);
 }
 if (flags & SDL_WINDOW_MAXIMIZED) {
-SDL_MaximizeWindow(window->id);
+SDL_MaximizeWindow(window);
 }
 if (flags & SDL_WINDOW_MINIMIZED) {
-SDL_MinimizeWindow(window->id);
+SDL_MinimizeWindow(window);
 }
 if (flags & SDL_WINDOW_SHOWN) {
-SDL_ShowWindow(window->id);
+SDL_ShowWindow(window);
 }
 SDL_UpdateWindowGrab(window);
 return 0;
-}
-SDL_Window *
-SDL_GetWindowFromID(SDL_WindowID windowID)
-{
-int i, j;
-if (!_this) {
-SDL_UninitializedVideo();
-return NULL;
-}
-if (windowID) {
-for (i = 0; i < _this->num_displays; ++i) {
-SDL_VideoDisplay *display = &_this->displays[i];
-for (j = 0; j < display->num_windows; ++j) {
-SDL_Window *window = &display->windows[j];
-if (window->id == windowID) {
-return window;
-}
-}
-}
-} else {
-/* Just return the first active window */
-for (i = 0; i < _this->num_displays; ++i) {
-SDL_VideoDisplay *display = &_this->displays[i];
-for (j = 0; j < display->num_windows; ++j) {
-SDL_Window *window = &display->windows[j];
-return window;
-}
-}
-}
-/* Couldn't find the window with the requested ID */
-SDL_SetError("Invalid window ID");
-return NULL;
-}
-SDL_VideoDisplay *
-SDL_GetDisplayFromWindow(SDL_Window * window)
-{
-if (!_this) {
-SDL_UninitializedVideo();
-return NULL;
-}
-if (!window) {
-return NULL;
-}
-return &_this->displays[window->display];
 }
 static __inline__ SDL_Renderer *
 SDL_GetCurrentRenderer(SDL_bool create)
 {
 }
 return SDL_CurrentRenderer;
 }
 Uint32
-SDL_GetWindowFlags(SDL_WindowID windowID)
+SDL_GetWindowID(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return 0;
 }
+return window->id;
+}
+SDL_Window *
+SDL_GetWindowFromID(Uint32 id)
+{
+SDL_Window *window;
+int i;
+if (!_this) {
+return NULL;
+}
+/* FIXME: Should we keep a separate hash table for these? */
+for (i = _this->num_displays; i--;) {
+SDL_VideoDisplay *display = &_this->displays[i];
+for (window = display->windows; window; window = window->next) {
+if (window->id == id) {
+return window;
+}
+}
+}
+return NULL;
+}
+Uint32
+SDL_GetWindowFlags(SDL_Window * window)
+{
+if (!window) {
+return 0;
+}
 return window->flags;
 }
 void
-SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)
+SDL_SetWindowTitle(SDL_Window * window, const char *title)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || title == window->title) {
 return;
 }
 if (window->title) {
 SDL_free(window->title);
 _this->SetWindowTitle(_this, window);
 }
 }
 const char *
-SDL_GetWindowTitle(SDL_WindowID windowID)
+SDL_GetWindowTitle(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return NULL;
 }
 return window->title;
 }
 void
-SDL_SetWindowIcon(SDL_WindowID windowID, SDL_Surface * icon)
+SDL_SetWindowIcon(SDL_Window * window, SDL_Surface * icon)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return;
 }
 if (_this->SetWindowIcon) {
 _this->SetWindowIcon(_this, window, icon);
 }
 }
 void
-SDL_SetWindowData(SDL_WindowID windowID, void *userdata)
+SDL_SetWindowData(SDL_Window * window, void *userdata)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return;
 }
 window->userdata = userdata;
 }
 void *
-SDL_GetWindowData(SDL_WindowID windowID)
+SDL_GetWindowData(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return NULL;
 }
 return window->userdata;
 }
 void
-SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)
+SDL_SetWindowPosition(SDL_Window * window, int x, int y)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
-SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
 if (!window) {
 return;
 }
 if (x != SDL_WINDOWPOS_UNDEFINED) {
 window->x = x;
 window->y = y;
 }
 if (_this->SetWindowPosition) {
 _this->SetWindowPosition(_this, window);
 }
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MOVED, x, y);
+SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED, x, y);
 }
 void
-SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)
+SDL_GetWindowPosition(SDL_Window * window, int *x, int *y)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return;
 }
 if (x) {
 *x = window->x;
 *y = window->y;
 }
 }
 void
-SDL_SetWindowSize(SDL_WindowID windowID, int w, int h)
+SDL_SetWindowSize(SDL_Window * window, int w, int h)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return;
 }
 window->w = w;
 window->h = h;
 }
 SDL_OnWindowResized(window);
 }
 void
-SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *h)
+SDL_GetWindowSize(SDL_Window * window, int *w, int *h)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (window) {
 if (w) {
 *w = window->w;
 }
 if (h) {
 }
 }
 }
 void
-SDL_ShowWindow(SDL_WindowID windowID)
+SDL_ShowWindow(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || (window->flags & SDL_WINDOW_SHOWN)) {
 return;
 }
 if (_this->ShowWindow) {
 _this->ShowWindow(_this, window);
 }
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);
+SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SHOWN, 0, 0);
 }
 void
-SDL_HideWindow(SDL_WindowID windowID)
+SDL_HideWindow(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
 return;
 }
 if (_this->HideWindow) {
 _this->HideWindow(_this, window);
 }
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_HIDDEN, 0, 0);
+SDL_SendWindowEvent(window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
 }
 void
-SDL_RaiseWindow(SDL_WindowID windowID)
+SDL_RaiseWindow(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
 return;
 }
 if (_this->RaiseWindow) {
 _this->RaiseWindow(_this, window);
 } else {
 /* FIXME: What we really want is a way to request focus */
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);
+SDL_SendWindowEvent(window, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);
 }
 }
 void
-SDL_MaximizeWindow(SDL_WindowID windowID)
+SDL_MaximizeWindow(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || (window->flags & SDL_WINDOW_MAXIMIZED)) {
 return;
 }
 if (_this->MaximizeWindow) {
 _this->MaximizeWindow(_this, window);
 }
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
+SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
 }
 void
-SDL_MinimizeWindow(SDL_WindowID windowID)
+SDL_MinimizeWindow(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || (window->flags & SDL_WINDOW_MINIMIZED)) {
 return;
 }
 if (_this->MinimizeWindow) {
 _this->MinimizeWindow(_this, window);
 }
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
+SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
 }
 void
-SDL_RestoreWindow(SDL_WindowID windowID)
+SDL_RestoreWindow(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window
 || !(window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {
 return;
 }
 if (_this->RestoreWindow) {
 _this->RestoreWindow(_this, window);
 }
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESTORED, 0, 0);
+SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESTORED, 0, 0);
 }
 int
-SDL_SetWindowFullscreen(SDL_WindowID windowID, int fullscreen)
+SDL_SetWindowFullscreen(SDL_Window * window, int fullscreen)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return -1;
 }
 if (fullscreen) {
 fullscreen = SDL_WINDOW_FULLSCREEN;
 }
 return 0;
 }
 void
-SDL_SetWindowGrab(SDL_WindowID windowID, int mode)
+SDL_SetWindowGrab(SDL_Window * window, int mode)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || (!!mode == !!(window->flags & SDL_WINDOW_INPUT_GRABBED))) {
 return;
 }
 if (mode) {
 window->flags |= SDL_WINDOW_INPUT_GRABBED;
 _this->SetWindowGrab(_this, window);
 }
 }
 int
-SDL_GetWindowGrab(SDL_WindowID windowID)
+SDL_GetWindowGrab(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return 0;
 }
 return ((window->flags & SDL_WINDOW_INPUT_GRABBED) != 0);
 }
 void
 SDL_OnWindowShown(SDL_Window * window)
 {
-SDL_RaiseWindow(window->id);
+SDL_RaiseWindow(window);
 SDL_UpdateFullscreenMode(window, SDL_TRUE);
 }
 void
 SDL_OnWindowHidden(SDL_Window * window)
 }
 void
 SDL_OnWindowRestored(SDL_Window * window)
 {
-SDL_RaiseWindow(window->id);
+SDL_RaiseWindow(window);
 SDL_UpdateFullscreenMode(window, SDL_TRUE);
 }
 void
 SDL_OnWindowFocusGained(SDL_Window * window)
 {
-SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+SDL_VideoDisplay *display = window->display;
 if (display->gamma && _this->SetDisplayGammaRamp) {
 _this->SetDisplayGammaRamp(_this, display, display->gamma);
 }
 if ((window->flags & (SDL_WINDOW_INPUT_GRABBED | SDL_WINDOW_FULLSCREEN))
 }
 void
 SDL_OnWindowFocusLost(SDL_Window * window)
 {
-SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+SDL_VideoDisplay *display = window->display;
 /* If we're fullscreen on a single-head system and lose focus, minimize */
 if ((window->flags & SDL_WINDOW_FULLSCREEN) &&
 _this->num_displays == 1) {
-SDL_MinimizeWindow(window->id);
+SDL_MinimizeWindow(window);
 }
 if (display->gamma && _this->SetDisplayGammaRamp) {
 _this->SetDisplayGammaRamp(_this, display, display->saved_gamma);
 }
 && _this->SetWindowGrab) {
 _this->SetWindowGrab(_this, window);
 }
 }
-SDL_WindowID
+SDL_Window *
 SDL_GetFocusWindow(void)
 {
 SDL_VideoDisplay *display;
-int i;
+SDL_Window *window;
 if (!_this) {
-return 0;
+return NULL;
 }
-display = &SDL_CurrentDisplay;
+display = SDL_CurrentDisplay;
-for (i = 0; i < display->num_windows; ++i) {
+for (window = display->windows; window; window = window->next) {
-SDL_Window *window = &display->windows[i];
 if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
-return window->id;
+return window;
 }
 }
-return 0;
+return NULL;
 }
 void
-SDL_DestroyWindow(SDL_WindowID windowID)
+SDL_DestroyWindow(SDL_Window * window)
 {
-int i, j;
+SDL_VideoDisplay *display;
-if (!_this) {
+if (!_this || !window || !window->id) {
+SDL_SetError("Invalid window");
 return;
 }
-for (i = 0; i < _this->num_displays; ++i) {
+if (window->title) {
-SDL_VideoDisplay *display = &_this->displays[i];
+SDL_free(window->title);
-for (j = 0; j < display->num_windows; ++j) {
+}
-SDL_Window *window = &display->windows[j];
+if (window->renderer) {
-if (window->id != windowID) {
+SDL_DestroyRenderer(window);
-continue;
+}
-}
-if (window->title) {
+/* Restore video mode, etc. */
-SDL_free(window->title);
+SDL_UpdateFullscreenMode(window, SDL_FALSE);
-window->title = NULL;
-}
+if (_this->DestroyWindow) {
-if (window->renderer) {
+_this->DestroyWindow(_this, window);
-SDL_DestroyRenderer(window->id);
+}
-window->renderer = NULL;
+if (window->flags & SDL_WINDOW_OPENGL) {
-}
+SDL_GL_UnloadLibrary();
+}
-/* Restore video mode, etc. */
-SDL_UpdateFullscreenMode(window, SDL_FALSE);
+/* Unlink the window from the list */
+display = window->display;
-if (_this->DestroyWindow) {
+if (window->prev) {
-_this->DestroyWindow(_this, window);
+window->prev->next = window->next;
-}
+} else {
-if (window->flags & SDL_WINDOW_OPENGL) {
+display->windows = window->next;
-SDL_GL_UnloadLibrary();
+}
-}
-if (j != display->num_windows - 1) {
+/* Clear the ID so we know it was destroyed */
-SDL_memcpy(&display->windows[i],
+window->id = 0;
-&display->windows[i + 1],
-(display->num_windows - i - 1) * sizeof(*window));
+SDL_free(window);
-}
---display->num_windows;
-return;
-}
-}
 }
 void
 SDL_AddRenderDriver(SDL_VideoDisplay * display, const SDL_RenderDriver * driver)
 {
 int
 SDL_GetNumRenderDrivers(void)
 {
 if (_this) {
-return SDL_CurrentDisplay.num_render_drivers;
+return SDL_CurrentDisplay->num_render_drivers;
 }
 return 0;
 }
 int
 if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
 SDL_SetError("index must be in the range of 0 - %d",
 SDL_GetNumRenderDrivers() - 1);
 return -1;
 }
-*info = SDL_CurrentDisplay.render_drivers[index].info;
+*info = SDL_CurrentDisplay->render_drivers[index].info;
 return 0;
 }
 int
-SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags)
+SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
-SDL_SetError("Invalid window ID");
+SDL_SetError("Invalid window");
 return -1;
 }
 /* Free any existing renderer */
-SDL_DestroyRenderer(windowID);
+SDL_DestroyRenderer(window);
 if (index < 0) {
 char *override = SDL_getenv("SDL_VIDEO_RENDERER");
 int n = SDL_GetNumRenderDrivers();
 }
 #endif /* SDL_VIDEO_RENDER_OGL_ES */
 if (override) {
 for (index = 0; index < n; ++index) {
 SDL_RenderDriver *driver =
-&SDL_CurrentDisplay.render_drivers[index];
+&SDL_CurrentDisplay->render_drivers[index];
 if (SDL_strcasecmp(override, driver->info.name) == 0) {
 /* Create a new renderer instance */
 window->renderer = driver->CreateRenderer(window, flags);
 break;
 }
 }
 } else {
 for (index = 0; index < n; ++index) {
 SDL_RenderDriver *driver =
-&SDL_CurrentDisplay.render_drivers[index];
+&SDL_CurrentDisplay->render_drivers[index];
 if ((driver->info.flags & flags) == flags) {
 /* Create a new renderer instance */
 window->renderer = driver->CreateRenderer(window, flags);
 if (window->renderer) {
 SDL_SetError("index must be -1 or in the range of 0 - %d",
 SDL_GetNumRenderDrivers() - 1);
 return -1;
 }
 /* Create a new renderer instance */
-window->renderer = SDL_CurrentDisplay.render_drivers[index].CreateRenderer(window, flags);
+window->renderer = SDL_CurrentDisplay->render_drivers[index].CreateRenderer(window, flags);
 }
 if (window->renderer == NULL) {
 /* Assuming renderer set its error */
 return -1;
 }
-SDL_SelectRenderer(window->id);
+SDL_SelectRenderer(window);
 return 0;
 }
 int
-SDL_SelectRenderer(SDL_WindowID windowID)
+SDL_SelectRenderer(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 SDL_Renderer *renderer;
 if (!window) {
-SDL_SetError("Invalid window ID");
+SDL_SetError("Invalid window");
 return -1;
 }
 renderer = window->renderer;
 if (!renderer) {
 SDL_SetError("Use SDL_CreateRenderer() to create a renderer");
 if (renderer->ActivateRenderer) {
 if (renderer->ActivateRenderer(renderer) < 0) {
 return -1;
 }
 }
-SDL_CurrentDisplay.current_renderer = renderer;
+SDL_CurrentDisplay->current_renderer = renderer;
 return 0;
 }
 int
 SDL_GetRendererInfo(SDL_RendererInfo * info)
 }
 *info = renderer->info;
 return 0;
 }
-SDL_TextureID
+SDL_Texture *
 SDL_CreateTexture(Uint32 format, int access, int w, int h)
 {
-int hash;
 SDL_Renderer *renderer;
 SDL_Texture *texture;
 renderer = SDL_GetCurrentRenderer(SDL_TRUE);
 if (!renderer) {
 texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
 if (!texture) {
 SDL_OutOfMemory();
 return 0;
 }
-texture->id = _this->next_object_id++;
 texture->format = format;
 texture->access = access;
 texture->w = w;
 texture->h = h;
 texture->r = 255;
 texture->g = 255;
 texture->b = 255;
 texture->a = 255;
 texture->renderer = renderer;
+texture->next = renderer->textures;
+renderer->textures = texture;
 if (renderer->CreateTexture(renderer, texture) < 0) {
-if (renderer->DestroyTexture) {
+SDL_DestroyTexture(texture);
-renderer->DestroyTexture(renderer, texture);
-}
-SDL_free(texture);
 return 0;
 }
-hash = (texture->id % SDL_arraysize(SDL_CurrentDisplay.textures));
+return texture;
-texture->next = SDL_CurrentDisplay.textures[hash];
+}
-SDL_CurrentDisplay.textures[hash] = texture;
+SDL_Texture *
-return texture->id;
-}
-SDL_TextureID
 SDL_CreateTextureFromSurface(Uint32 format, SDL_Surface * surface)
 {
-SDL_TextureID textureID;
+SDL_Texture *texture;
 Uint32 requested_format = format;
 SDL_PixelFormat *fmt;
 SDL_Renderer *renderer;
 int bpp;
 Uint32 Rmask, Gmask, Bmask, Amask;
 SDL_SetError("Unknown pixel format");
 return 0;
 }
 }
-textureID =
+texture =
 SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w,
 surface->h);
-if (!textureID && !requested_format) {
+if (!texture && !requested_format) {
 SDL_DisplayMode desktop_mode;
 SDL_GetDesktopDisplayMode(&desktop_mode);
 format = desktop_mode.format;
-textureID =
+texture =
 SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w,
 surface->h);
 }
-if (!textureID) {
+if (!texture) {
 return 0;
 }
 if (bpp == fmt->BitsPerPixel && Rmask == fmt->Rmask && Gmask == fmt->Gmask
 && Bmask == fmt->Bmask && Amask == fmt->Amask) {
 if (SDL_MUSTLOCK(surface)) {
 SDL_LockSurface(surface);
-SDL_UpdateTexture(textureID, NULL, surface->pixels,
+SDL_UpdateTexture(texture, NULL, surface->pixels,
 surface->pitch);
 SDL_UnlockSurface(surface);
 } else {
-SDL_UpdateTexture(textureID, NULL, surface->pixels,
+SDL_UpdateTexture(texture, NULL, surface->pixels,
 surface->pitch);
 }
 } else {
 SDL_PixelFormat dst_fmt;
 SDL_Surface *dst = NULL;
 SDL_BITSPERPIXEL(format));
 }
 }
 dst = SDL_ConvertSurface(surface, &dst_fmt, 0);
 if (dst) {
-SDL_UpdateTexture(textureID, NULL, dst->pixels, dst->pitch);
+SDL_UpdateTexture(texture, NULL, dst->pixels, dst->pitch);
 SDL_FreeSurface(dst);
 }
 if (dst_fmt.palette) {
 SDL_FreePalette(dst_fmt.palette);
 }
 if (!dst) {
-SDL_DestroyTexture(textureID);
+SDL_DestroyTexture(texture);
 return 0;
 }
 }
 {
 Uint8 r, g, b, a;
 int blendMode;
 int scaleMode;
 SDL_GetSurfaceColorMod(surface, &r, &g, &b);
-SDL_SetTextureColorMod(textureID, r, g, b);
+SDL_SetTextureColorMod(texture, r, g, b);
 SDL_GetSurfaceAlphaMod(surface, &a);
-SDL_SetTextureAlphaMod(textureID, a);
+SDL_SetTextureAlphaMod(texture, a);
 SDL_GetSurfaceBlendMode(surface, &blendMode);
-SDL_SetTextureBlendMode(textureID, blendMode);
+SDL_SetTextureBlendMode(texture, blendMode);
 SDL_GetSurfaceScaleMode(surface, &scaleMode);
-SDL_SetTextureScaleMode(textureID, scaleMode);
+SDL_SetTextureScaleMode(texture, scaleMode);
 }
 if (SDL_ISPIXELFORMAT_INDEXED(format) && fmt->palette) {
-SDL_SetTexturePalette(textureID, fmt->palette->colors, 0,
+SDL_SetTexturePalette(texture, fmt->palette->colors, 0,
 fmt->palette->ncolors);
 }
-return textureID;
+return texture;
 }
-static __inline__ SDL_Texture *
+int
-SDL_GetTextureFromID(SDL_TextureID textureID)
+SDL_QueryTexture(SDL_Texture * texture, Uint32 * format, int *access,
-{
-int hash;
-SDL_Texture *texture;
-if (!_this) {
-return NULL;
-}
-hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
-for (texture = SDL_CurrentDisplay.textures[hash]; texture;
-texture = texture->next) {
-if (texture->id == textureID) {
-return texture;
-}
-}
-return NULL;
-}
-int
-SDL_QueryTexture(SDL_TextureID textureID, Uint32 * format, int *access,
 int *w, int *h)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 if (!texture) {
 return -1;
 }
 if (format) {
 *format = texture->format;
 }
 return 0;
 }
 int
-SDL_QueryTexturePixels(SDL_TextureID textureID, void **pixels, int *pitch)
+SDL_QueryTexturePixels(SDL_Texture * texture, void **pixels, int *pitch)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 }
 return renderer->QueryTexturePixels(renderer, texture, pixels, pitch);
 }
 int
-SDL_SetTexturePalette(SDL_TextureID textureID, const SDL_Color * colors,
+SDL_SetTexturePalette(SDL_Texture * texture, const SDL_Color * colors,
 int firstcolor, int ncolors)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 return renderer->SetTexturePalette(renderer, texture, colors, firstcolor,
 ncolors);
 }
 int
-SDL_GetTexturePalette(SDL_TextureID textureID, SDL_Color * colors,
+SDL_GetTexturePalette(SDL_Texture * texture, SDL_Color * colors,
 int firstcolor, int ncolors)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 return renderer->GetTexturePalette(renderer, texture, colors, firstcolor,
 ncolors);
 }
 int
-SDL_SetTextureColorMod(SDL_TextureID textureID, Uint8 r, Uint8 g, Uint8 b)
+SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 texture->b = b;
 return renderer->SetTextureColorMod(renderer, texture);
 }
 int
-SDL_GetTextureColorMod(SDL_TextureID textureID, Uint8 * r, Uint8 * g,
+SDL_GetTextureColorMod(SDL_Texture * texture, Uint8 * r, Uint8 * g,
 Uint8 * b)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 }
 return 0;
 }
 int
-SDL_SetTextureAlphaMod(SDL_TextureID textureID, Uint8 alpha)
+SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 texture->a = alpha;
 return renderer->SetTextureAlphaMod(renderer, texture);
 }
 int
-SDL_GetTextureAlphaMod(SDL_TextureID textureID, Uint8 * alpha)
+SDL_GetTextureAlphaMod(SDL_Texture * texture, Uint8 * alpha)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 if (!texture) {
 return -1;
 }
 if (alpha) {
 *alpha = texture->a;
 }
 return 0;
 }
 int
-SDL_SetTextureBlendMode(SDL_TextureID textureID, int blendMode)
+SDL_SetTextureBlendMode(SDL_Texture * texture, int blendMode)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 texture->blendMode = blendMode;
 return renderer->SetTextureBlendMode(renderer, texture);
 }
 int
-SDL_GetTextureBlendMode(SDL_TextureID textureID, int *blendMode)
+SDL_GetTextureBlendMode(SDL_Texture * texture, int *blendMode)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 if (!texture) {
 return -1;
 }
 if (blendMode) {
 *blendMode = texture->blendMode;
 }
 return 0;
 }
 int
-SDL_SetTextureScaleMode(SDL_TextureID textureID, int scaleMode)
+SDL_SetTextureScaleMode(SDL_Texture * texture, int scaleMode)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return -1;
 }
 texture->scaleMode = scaleMode;
 return renderer->SetTextureScaleMode(renderer, texture);
 }
 int
-SDL_GetTextureScaleMode(SDL_TextureID textureID, int *scaleMode)
+SDL_GetTextureScaleMode(SDL_Texture * texture, int *scaleMode)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 if (!texture) {
 return -1;
 }
 if (scaleMode) {
 *scaleMode = texture->scaleMode;
 }
 return 0;
 }
 int
-SDL_UpdateTexture(SDL_TextureID textureID, const SDL_Rect * rect,
+SDL_UpdateTexture(SDL_Texture * texture, const SDL_Rect * rect,
 const void *pixels, int pitch)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 SDL_Rect full_rect;
 if (!texture) {
 return -1;
 }
 return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
 }
 int
-SDL_LockTexture(SDL_TextureID textureID, const SDL_Rect * rect, int markDirty,
+SDL_LockTexture(SDL_Texture * texture, const SDL_Rect * rect, int markDirty,
 void **pixels, int *pitch)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 SDL_Rect full_rect;
 if (!texture) {
 return -1;
 return renderer->LockTexture(renderer, texture, rect, markDirty, pixels,
 pitch);
 }
 void
-SDL_UnlockTexture(SDL_TextureID textureID)
+SDL_UnlockTexture(SDL_Texture * texture)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return;
 }
 }
 renderer->UnlockTexture(renderer, texture);
 }
 void
-SDL_DirtyTexture(SDL_TextureID textureID, int numrects,
+SDL_DirtyTexture(SDL_Texture * texture, int numrects,
 const SDL_Rect * rects)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 if (!texture) {
 return;
 }
 return 0;
 }
 /* Check for NULL rect, which means fill entire window */
 for (i = 0; i < count; ++i) {
 if (rects[i] == NULL) {
-SDL_Window *window;
+SDL_Window *window = renderer->window;
 SDL_Rect full_rect;
 const SDL_Rect *rect;
-window = SDL_GetWindowFromID(renderer->window);
 full_rect.x = 0;
 full_rect.y = 0;
 full_rect.w = window->w;
 full_rect.h = window->h;
 rect = &full_rect;
 return 0;
 }
 /* Check for NULL rect, which means fill entire window */
 for (i = 0; i < count; ++i) {
 if (rects[i] == NULL) {
-SDL_Window *window;
+SDL_Window *window = renderer->window;
 SDL_Rect full_rect;
 const SDL_Rect *rect;
-window = SDL_GetWindowFromID(renderer->window);
 full_rect.x = 0;
 full_rect.y = 0;
 full_rect.w = window->w;
 full_rect.h = window->h;
 rect = &full_rect;
 }
 return renderer->RenderFillRects(renderer, rects, count);
 }
 int
-SDL_RenderCopy(SDL_TextureID textureID, const SDL_Rect * srcrect,
+SDL_RenderCopy(SDL_Texture * texture, const SDL_Rect * srcrect,
 const SDL_Rect * dstrect)
 {
-SDL_Texture *texture = SDL_GetTextureFromID(textureID);
 SDL_Renderer *renderer;
 SDL_Window *window;
 SDL_Rect real_srcrect;
 SDL_Rect real_dstrect;
 }
 if (!renderer->RenderCopy) {
 SDL_Unsupported();
 return -1;
 }
-window = SDL_GetWindowFromID(renderer->window);
+window = renderer->window;
 real_srcrect.x = 0;
 real_srcrect.y = 0;
 real_srcrect.w = texture->w;
 real_srcrect.h = texture->h;
 }
 if (!renderer->RenderReadPixels) {
 SDL_Unsupported();
 return -1;
 }
-window = SDL_GetWindowFromID(renderer->window);
+window = renderer->window;
 if (!format) {
-format = SDL_GetDisplayFromWindow(window)->current_mode.format;
+format = window->display->current_mode.format;
 }
 real_rect.x = 0;
 real_rect.y = 0;
 real_rect.w = window->w;
 }
 if (real_rect.y > rect->y) {
 pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);
 }
 if (real_rect.x > rect->x) {
-Uint32 format = SDL_CurrentDisplay.current_mode.format;
+Uint32 format = SDL_CurrentDisplay->current_mode.format;
 int bpp = SDL_BYTESPERPIXEL(format);
 pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);
 }
 }
 }
 if (!renderer->RenderWritePixels) {
 SDL_Unsupported();
 return -1;
 }
-window = SDL_GetWindowFromID(renderer->window);
+window = renderer->window;
 if (!format) {
-format = SDL_GetDisplayFromWindow(window)->current_mode.format;
+format = window->display->current_mode.format;
 }
 real_rect.x = 0;
 real_rect.y = 0;
 real_rect.w = window->w;
 }
 if (real_rect.y > rect->y) {
 pixels = (const Uint8 *)pixels + pitch * (real_rect.y - rect->y);
 }
 if (real_rect.x > rect->x) {
-Uint32 format = SDL_CurrentDisplay.current_mode.format;
+Uint32 format = SDL_CurrentDisplay->current_mode.format;
 int bpp = SDL_BYTESPERPIXEL(format);
 pixels = (const Uint8 *)pixels + bpp * (real_rect.x - rect->x);
 }
 }
 }
 renderer->RenderPresent(renderer);
 }
 void
-SDL_DestroyTexture(SDL_TextureID textureID)
+SDL_DestroyTexture(SDL_Texture * texture)
 {
-int hash;
-SDL_Texture *prev, *texture;
 SDL_Renderer *renderer;
-if (!_this) {
+if (!texture || !texture->renderer) {
-SDL_UninitializedVideo();
+SDL_SetError("Invalid texture");
 return;
 }
-/* Look up the texture in the hash table */
-hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
+renderer = texture->renderer;
-prev = NULL;
+if (texture->prev) {
-for (texture = SDL_CurrentDisplay.textures[hash]; texture;
+texture->prev->next = texture->next;
-prev = texture, texture = texture->next) {
-if (texture->id == textureID) {
-break;
-}
-}
-if (!texture) {
-return;
-}
-/* Unlink the texture from the list */
-if (prev) {
-prev->next = texture->next;
 } else {
-SDL_CurrentDisplay.textures[hash] = texture->next;
+renderer->textures = texture->next;
 }
+texture->renderer = NULL;
-/* Free the texture */
-renderer = texture->renderer;
 renderer->DestroyTexture(renderer, texture);
 SDL_free(texture);
 }
 void
-SDL_DestroyRenderer(SDL_WindowID windowID)
+SDL_DestroyRenderer(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 SDL_Renderer *renderer;
 int i;
 if (!window) {
 return;
 }
 renderer = window->renderer;
 if (!renderer) {
 return;
 }
 /* Free existing textures for this renderer */
-for (i = 0; i < SDL_arraysize(SDL_CurrentDisplay.textures); ++i) {
+while (renderer->textures) {
-SDL_Texture *texture;
+SDL_DestroyTexture(renderer->textures);
-SDL_Texture *prev = NULL;
-SDL_Texture *next;
-for (texture = SDL_CurrentDisplay.textures[i]; texture;
-texture = next) {
-next = texture->next;
-if (texture->renderer == renderer) {
-if (prev) {
-prev->next = next;
-} else {
-SDL_CurrentDisplay.textures[i] = next;
-}
-renderer->DestroyTexture(renderer, texture);
-SDL_free(texture);
-} else {
-prev = texture;
-}
-}
 }
 /* Free the renderer instance */
 renderer->DestroyRenderer(renderer);
 /* Clear references */
 window->renderer = NULL;
-if (SDL_CurrentDisplay.current_renderer == renderer) {
+if (SDL_CurrentDisplay->current_renderer == renderer) {
-SDL_CurrentDisplay.current_renderer = NULL;
+SDL_CurrentDisplay->current_renderer = NULL;
 }
 }
 SDL_bool
 SDL_IsScreenSaverEnabled()
 SDL_EnableScreenSaver();
 /* Clean up the system video */
 for (i = _this->num_displays; i--;) {
 SDL_VideoDisplay *display = &_this->displays[i];
-for (j = display->num_windows; j--;) {
+while (display->windows) {
-SDL_DestroyWindow(display->windows[i].id);
+SDL_DestroyWindow(display->windows);
 }
-if (display->windows) {
-SDL_free(display->windows);
-display->windows = NULL;
-}
-display->num_windows = 0;
 if (display->render_drivers) {
 SDL_free(display->render_drivers);
 display->render_drivers = NULL;
 }
 display->num_render_drivers = 0;
 return -1;
 #endif /* SDL_VIDEO_OPENGL */
 }
 SDL_GLContext
-SDL_GL_CreateContext(SDL_WindowID windowID)
+SDL_GL_CreateContext(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return NULL;
 }
 if (!(window->flags & SDL_WINDOW_OPENGL)) {
 SDL_SetError("The specified window isn't an OpenGL window");
 }
 return _this->GL_CreateContext(_this, window);
 }
 int
-SDL_GL_MakeCurrent(SDL_WindowID windowID, SDL_GLContext context)
+SDL_GL_MakeCurrent(SDL_Window * window, SDL_GLContext context)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (window && !(window->flags & SDL_WINDOW_OPENGL)) {
 SDL_SetError("The specified window isn't an OpenGL window");
 return -1;
 }
 if (!context) {
 return -1;
 }
 }
 void
-SDL_GL_SwapWindow(SDL_WindowID windowID)
+SDL_GL_SwapWindow(SDL_Window * window)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window) {
 return;
 }
 if (!(window->flags & SDL_WINDOW_OPENGL)) {
 SDL_SetError("The specified window isn't an OpenGL window");
 }
 }
 #endif
 SDL_bool
-SDL_GetWindowWMInfo(SDL_WindowID windowID, struct SDL_SysWMinfo *info)
+SDL_GetWindowWMInfo(SDL_Window * window, struct SDL_SysWMinfo *info)
 {
-SDL_Window *window = SDL_GetWindowFromID(windowID);
 if (!window || !_this->GetWindowWMInfo) {
 return SDL_FALSE;
 }
 return (_this->GetWindowWMInfo(_this, window, info));
 }

Mercurial > sdl-ios-xcode

comparison src/video/SDL_video.c @ 3685:64ce267332c6