/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

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

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

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

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

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

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

/* The high-level video driver subsystem */

#include "SDL.h"

#include "SDL_sysvideo.h"

#include "SDL_blit.h"

#include "SDL_pixels_c.h"

#include "SDL_renderer_sw.h"

#include "../events/SDL_sysevents.h"

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

/* Available video drivers */

static VideoBootStrap *bootstrap[] = {

#if SDL_VIDEO_DRIVER_QUARTZ

    &QZ_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_X11

    &X11_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DGA

    &DGA_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_NANOX

    &NX_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_IPOD

    &iPod_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_QTOPIA

    &Qtopia_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_WSCONS

    &WSCONS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_FBCON

    &FBCON_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DIRECTFB

    &DirectFB_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PS2GS

    &PS2GS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_GGI

    &GGI_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_VGL

    &VGL_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_SVGALIB

    &SVGALIB_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_GAPI

    &GAPI_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_WIN32

    &WIN32_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_BWINDOW

    &BWINDOW_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_TOOLBOX

    &TOOLBOX_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DRAWSPROCKET

    &DSp_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_CYBERGRAPHICS

    &CGX_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PHOTON

    &ph_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_EPOC

    &EPOC_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_XBIOS

    &XBIOS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_GEM

    &GEM_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_PICOGUI

    &PG_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DC

    &DC_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_RISCOS

    &RISCOS_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_OS2FS

    &OS2FSLib_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_AALIB

    &AALIB_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_DUMMY

    &DUMMY_bootstrap,

#endif

#if SDL_VIDEO_DRIVER_GLSDL

    &glSDL_bootstrap,

#endif

    NULL

};

static SDL_VideoDevice *_this = NULL;

/* Various local functions */

int SDL_VideoInit(const char *driver_name, Uint32 flags);

void SDL_VideoQuit(void);

static int

cmpmodes(const void *A, const void *B)

{

    SDL_DisplayMode a = *(const SDL_DisplayMode *) A;

    SDL_DisplayMode b = *(const SDL_DisplayMode *) B;

    if (a.w != b.w) {

        return b.w - a.w;

    }

    if (a.h != b.h) {

        return b.h - a.h;

    }

    if (SDL_BITSPERPIXEL(a.format) != SDL_BITSPERPIXEL(b.format)) {

        return SDL_BITSPERPIXEL(b.format) - SDL_BITSPERPIXEL(a.format);

    }

    if (a.refresh_rate != b.refresh_rate) {

        return b.refresh_rate - a.refresh_rate;

    }

    return 0;

}

int

SDL_GetNumVideoDrivers(void)

{

    return SDL_arraysize(bootstrap) - 1;

}

const char *

SDL_GetVideoDriver(int index)

{

    if (index >= 0 && index < SDL_GetNumVideoDrivers()) {

        return bootstrap[index]->name;

    }

    return NULL;

}

/*

 * Initialize the video and event subsystems -- determine native pixel format

 */

int

SDL_VideoInit(const char *driver_name, Uint32 flags)

{

    SDL_VideoDevice *video;

    int index;

    int i;

    /* Toggle the event thread flags, based on OS requirements */

#if defined(MUST_THREAD_EVENTS)

    flags |= SDL_INIT_EVENTTHREAD;

#elif defined(CANT_THREAD_EVENTS)

    if ((flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD) {

        SDL_SetError("OS doesn't support threaded events");

        return -1;

    }

#endif

    /* Start the event loop */

    if (SDL_StartEventLoop(flags) < 0) {

        return -1;

    }

    /* Check to make sure we don't overwrite '_this' */

    if (_this != NULL) {

        SDL_VideoQuit();

    }

    /* Select the proper video driver */

    index = 0;

    video = NULL;

    if (driver_name != NULL) {

        for (i = 0; bootstrap[i]; ++i) {

            if (SDL_strncmp(bootstrap[i]->name, driver_name,

                            SDL_strlen(bootstrap[i]->name)) == 0) {

                if (bootstrap[i]->available()) {

                    video = bootstrap[i]->create(index);

                }

                break;

            }

        }

    } else {

        for (i = 0; bootstrap[i]; ++i) {

            if (bootstrap[i]->available()) {

                video = bootstrap[i]->create(index);

                if (video != NULL) {

                    break;

                }

            }

        }

    }

    if (video == NULL) {

        if (driver_name) {

            SDL_SetError("%s not available", driver_name);

        } else {

            SDL_SetError("No available video device");

        }

        return -1;

    }

    _this = video;

    _this->name = bootstrap[i]->name;

    _this->next_object_id = 1;

    /* Set some very sane GL defaults */

    _this->gl_config.driver_loaded = 0;

    _this->gl_config.dll_handle = NULL;

    _this->gl_config.red_size = 3;

    _this->gl_config.green_size = 3;

    _this->gl_config.blue_size = 2;

    _this->gl_config.alpha_size = 0;

    _this->gl_config.buffer_size = 0;

    _this->gl_config.depth_size = 16;

    _this->gl_config.stencil_size = 0;

    _this->gl_config.double_buffer = 1;

    _this->gl_config.accum_red_size = 0;

    _this->gl_config.accum_green_size = 0;

    _this->gl_config.accum_blue_size = 0;

    _this->gl_config.accum_alpha_size = 0;

    _this->gl_config.stereo = 0;

    _this->gl_config.multisamplebuffers = 0;

    _this->gl_config.multisamplesamples = 0;

    _this->gl_config.accelerated = -1;  /* not known, don't set */

    /* Initialize the video subsystem */

    if (_this->VideoInit(_this) < 0) {

        SDL_VideoQuit();

        return -1;

    }

    /* Make sure some displays were added */

    if (_this->num_displays == 0) {

        SDL_SetError("The video driver did not add any displays");

        SDL_VideoQuit();

        return (-1);

    }

    /* The software renderer is always available */

    for (i = 0; i < _this->num_displays; ++i) {

        if (_this->displays[i].num_render_drivers > 0) {

            SDL_AddRenderDriver(i, &SDL_SW_RenderDriver);

        }

    }

    /* We're ready to go! */

    return 0;

}

const char *

SDL_GetCurrentVideoDriver()

{

    if (!_this) {

        return NULL;

    }

    return _this->name;

}

SDL_VideoDevice *

SDL_GetVideoDevice()

{

    return _this;

}

int

SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode)

{

    SDL_VideoDisplay display;

    SDL_zero(display);

    if (desktop_mode) {

        display.desktop_mode = *desktop_mode;

    }

    display.current_mode = display.desktop_mode;

    return SDL_AddVideoDisplay(&display);

}

int

SDL_AddVideoDisplay(const SDL_VideoDisplay * display)

{

    SDL_VideoDisplay *displays;

    int index = -1;

    displays =

        SDL_realloc(_this->displays,

                    (_this->num_displays + 1) * sizeof(*displays));

    if (displays) {

        index = _this->num_displays++;

        displays[index] = *display;

        displays[index].device = _this;

        _this->displays = displays;

    } else {

        SDL_OutOfMemory();

    }

    return index;

}

int

SDL_GetNumVideoDisplays(void)

{

    if (!_this) {

        return 0;

    }

    return _this->num_displays;

}

int

SDL_SelectVideoDisplay(int index)

{

    if (!_this) {

        SDL_SetError("Video subsystem has not been initialized");

        return (-1);

    }

    if (index >= 0) {

        if (index >= _this->num_displays) {

            SDL_SetError("index must be in the range 0 - %d",

                         _this->num_displays - 1);

            return -1;

        }

        _this->current_display = index;

    }

    return _this->current_display;

}

SDL_bool

SDL_AddDisplayMode(int displayIndex, const SDL_DisplayMode * mode)

{

    SDL_VideoDisplay *display = &_this->displays[displayIndex];

    SDL_DisplayMode *modes;

    int i, nmodes;

    /* Make sure we don't already have the mode in the list */

    modes = display->display_modes;

    nmodes = display->num_display_modes;

    for (i = nmodes; i--;) {

        if (SDL_memcmp(mode, &modes[i], sizeof(*mode)) == 0) {

            return SDL_FALSE;

        }

    }

    /* Go ahead and add the new mode */

    if (nmodes == display->max_display_modes) {

        modes =

            SDL_realloc(modes,

                        (display->max_display_modes + 32) * sizeof(*modes));

        if (!modes) {

            return SDL_FALSE;

        }

        display->display_modes = modes;

        display->max_display_modes += 32;

    }

    modes[nmodes] = *mode;

    display->num_display_modes++;

    return SDL_TRUE;

}

int

SDL_GetNumDisplayModes()

{

    if (_this) {

        SDL_VideoDisplay *display = &SDL_CurrentDisplay;

        if (!display->num_display_modes && _this->GetDisplayModes) {

            _this->GetDisplayModes(_this);

            SDL_qsort(display->display_modes, display->num_display_modes,

                      sizeof(SDL_DisplayMode), cmpmodes);

        }

        return display->num_display_modes;

    }

    return 0;

}

const SDL_DisplayMode *

SDL_GetDisplayMode(int index)

{

    if (index < 0 || index >= SDL_GetNumDisplayModes()) {

        SDL_SetError("index must be in the range of 0 - %d",

                     SDL_GetNumDisplayModes() - 1);

        return NULL;

    }

    return &SDL_CurrentDisplay.display_modes[index];

}

const SDL_DisplayMode *

SDL_GetDesktopDisplayMode(void)

{

    if (_this) {

        return &SDL_CurrentDisplay.desktop_mode;

    }

    return NULL;

}

const SDL_DisplayMode *

SDL_GetCurrentDisplayMode(void)

{

    if (_this) {

        return &SDL_CurrentDisplay.current_mode;

    }

    return NULL;

}

SDL_DisplayMode *

SDL_GetClosestDisplayMode(const SDL_DisplayMode * mode,

                          SDL_DisplayMode * closest)

{

    Uint32 target_format;

    int target_refresh_rate;

    int i;

    SDL_DisplayMode *current, *match;

    if (!_this || !mode || !closest) {

        return NULL;

    }

    /* Default to the desktop format */

    if (mode->format) {

        target_format = mode->format;

    } else {

        target_format = SDL_CurrentDisplay.desktop_mode.format;

    }

    /* Default to the desktop refresh rate */

    if (mode->refresh_rate) {

        target_refresh_rate = mode->refresh_rate;

    } else {

        target_refresh_rate = SDL_CurrentDisplay.desktop_mode.refresh_rate;

    }

    match = NULL;

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

        current = &SDL_CurrentDisplay.display_modes[i];

        if ((current->w && current->h) &&

            (current->w < mode->w || current->h < mode->h)) {

            /* Out of sorted modes large enough here */

            break;

        }

        if (!match || current->w < match->w || current->h < match->h) {

            match = current;

            continue;

        }

        if (current->format != match->format) {

            /* Sorted highest depth to lowest */

            if (current->format == target_format ||

                (SDL_BITSPERPIXEL(current->format) >=

                 SDL_BITSPERPIXEL(target_format)

                 && SDL_PIXELTYPE(current->format) ==

                 SDL_PIXELTYPE(target_format))) {

                match = current;

            }

            continue;

        }

        if (current->refresh_rate != match->refresh_rate) {

            /* Sorted highest refresh to lowest */

            if (current->refresh_rate >= target_refresh_rate) {

                match = current;

            }

        }

    }

    if (match) {

        if (match->format) {

            closest->format = match->format;

        } else {

            closest->format = mode->format;

        }

        if (match->w && match->h) {

            closest->w = match->w;

            closest->h = match->h;

        } else {

            closest->w = mode->w;

            closest->h = mode->h;

        }

        if (match->refresh_rate) {

            closest->refresh_rate = match->refresh_rate;

        } else {

            closest->refresh_rate = mode->refresh_rate;

        }

        closest->driverdata = match->driverdata;

        /* Pick some reasonable defaults if the app and driver don't care */

        if (!closest->format) {

            closest->format = SDL_PixelFormat_RGB888;

        }

        if (!closest->w) {

            closest->w = 640;

        }

        if (!closest->h) {

            closest->h = 480;

        }

        return closest;

    }

    return NULL;

}

int

SDL_SetDisplayMode(const SDL_DisplayMode * mode)

{

    SDL_VideoDisplay *display;

    SDL_DisplayMode display_mode;

    int i, ncolors;

    if (!_this) {

        SDL_SetError("Video subsystem has not been initialized");

        return -1;

    }

    if (!mode) {

        mode = SDL_GetDesktopDisplayMode();

    }

    display = &SDL_CurrentDisplay;

    display_mode = *mode;

    /* Default to the current mode */

    if (!display_mode.format) {

        display_mode.format = display->current_mode.format;

    }

    if (!display_mode.w) {

        display_mode.w = display->current_mode.w;

    }

    if (!display_mode.h) {

        display_mode.h = display->current_mode.h;

    }

    if (!display_mode.refresh_rate) {

        display_mode.refresh_rate = display->current_mode.refresh_rate;

    }

    /* Get a good video mode, the closest one possible */

    if (!SDL_GetClosestDisplayMode(&display_mode, &display_mode)) {

        SDL_SetError("No video mode large enough for %dx%d",

                     display_mode.w, display_mode.h);

        return -1;

    }

    /* See if there's anything left to do */

    if (SDL_memcmp

        (&display_mode, SDL_GetCurrentDisplayMode(),

         sizeof(display_mode)) == 0) {

        return 0;

    }

    /* Actually change the display mode */

    if (_this->SetDisplayMode(_this, &display_mode) < 0) {

        return -1;

    }

    display->current_mode = display_mode;

    /* Set up a palette, if necessary */

    if (SDL_ISPIXELFORMAT_INDEXED(display_mode.format)) {

        ncolors = (1 << SDL_BITSPERPIXEL(display_mode.format));

    } else {

        ncolors = 0;

    }

    if ((!ncolors && display->palette) || (ncolors && !display->palette)

        || (ncolors && ncolors != display->palette->ncolors)) {

        if (display->palette) {

            SDL_FreePalette(display->palette);

            display->palette = NULL;

        }

        if (ncolors) {

            display->palette = SDL_AllocPalette(ncolors);

            if (!display->palette) {

                return -1;

            }

            SDL_DitherColors(display->palette->colors,

                             SDL_BITSPERPIXEL(display_mode.format));

        }

    }

    /* Move any fullscreen windows into position */

    for (i = 0; i < display->num_windows; ++i) {

        SDL_Window *window = &display->windows[i];

        if (FULLSCREEN_VISIBLE(window)) {

            SDL_SetWindowPosition(window->id,

                                  ((display_mode.w - window->w) / 2),

                                  ((display_mode.h - window->h) / 2));

        }

    }

    return 0;

}

int

SDL_SetFullscreenDisplayMode(const SDL_DisplayMode * mode)

{

    SDL_VideoDisplay *display;

    int i;

    if (!_this) {

        SDL_SetError("Video subsystem has not been initialized");

        return -1;

    }

    display = &SDL_CurrentDisplay;

    if (mode) {

        SDL_GetClosestDisplayMode(mode, &display->desired_mode);

        display->fullscreen_mode = &display->desired_mode;

    } else {

        display->fullscreen_mode = NULL;

    }

    /* Actually set the mode if we have a fullscreen window visible */

    for (i = 0; i < display->num_windows; ++i) {

        SDL_Window *window = &display->windows[i];

        if (FULLSCREEN_VISIBLE(window)) {

            return SDL_SetDisplayMode(display->fullscreen_mode);

        }

    }

    return 0;

}

const SDL_DisplayMode *

SDL_GetFullscreenDisplayMode(void)

{

    if (_this) {

        return SDL_CurrentDisplay.fullscreen_mode;

    }

    return NULL;

}

int

SDL_SetDisplayPalette(const SDL_Color * colors, int firstcolor, int ncolors)

{

    SDL_Palette *palette;

    int status = 0;

    if (!_this) {

        SDL_SetError("Video subsystem has not been initialized");

        return -1;

    }

    palette = SDL_CurrentDisplay.palette;

    if (!palette) {

        SDL_SetError("Display mode does not have a palette");

        return -1;

    }

    status = SDL_SetPaletteColors(palette, colors, firstcolor, ncolors);

    if (_this->SetDisplayPalette) {

        if (_this->SetDisplayPalette(_this, palette) < 0) {

            status = -1;

        }

    }

    return status;

}

int

SDL_GetDisplayPalette(SDL_Color * colors, int firstcolor, int ncolors)

{

    SDL_Palette *palette;

    if (!_this) {

        SDL_SetError("Video subsystem has not been initialized");

        return -1;

    }

    palette = SDL_CurrentDisplay.palette;

    if (!palette->ncolors) {

        SDL_SetError("Display mode does not have a palette");

        return -1;

    }

    if (firstcolor < 0 || (firstcolor + ncolors) > palette->ncolors) {

        SDL_SetError("Palette indices are out of range");

        return -1;

    }

    SDL_memcpy(colors, &palette->colors[firstcolor],

               ncolors * sizeof(*colors));

    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 |

                                  SDL_WINDOW_OPENGL |

                                  SDL_WINDOW_SHOWN |

                                  SDL_WINDOW_BORDERLESS |

                                  SDL_WINDOW_RESIZABLE |

                                  SDL_WINDOW_MAXIMIZED |

                                  SDL_WINDOW_MINIMIZED |

                                  SDL_WINDOW_INPUT_GRABBED);

    SDL_VideoDisplay *display;

    SDL_Window window;

    int num_windows;

    SDL_Window *windows;

    if (!_this) {

        SDL_SetError("Video subsystem has not been initialized");

        return 0;

    }

    SDL_zero(window);

    window.id = _this->next_object_id++;

    window.title = title ? SDL_strdup(title) : NULL;

    window.x = x;

    window.y = y;

    window.w = w;

    window.h = h;

    window.flags = (flags & allowed_flags);

    window.display = _this->current_display;

    if (_this->CreateWindow && _this->CreateWindow(_this, &window) < 0) {

        if (window.title) {

            SDL_free(window.title);

        }

        return 0;

    }

    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 (window.title) {

            SDL_free(window.title);

        }

        return 0;

    }

    windows[num_windows] = window;

    display->windows = windows;

    display->num_windows++;

    if (FULLSCREEN_VISIBLE(&window)) {

        /* Hide any other fullscreen windows */

        int i;

        for (i = 0; i < display->num_windows; ++i) {

            SDL_Window *other = &display->windows[i];

            if (other->id != window.id && FULLSCREEN_VISIBLE(other)) {

                SDL_MinimizeWindow(other->id);

            }

        }

        SDL_SetDisplayMode(display->fullscreen_mode);

    }

    return window.id;

}

SDL_WindowID

SDL_CreateWindowFrom(const void *data)

{

    SDL_VideoDisplay *display;

    SDL_Window window;

    int num_windows;

    SDL_Window *windows;

    if (!_this) {

        SDL_SetError("Video subsystem has not been initialized");

        return (0);

    }

    SDL_zero(window);

    window.id = _this->next_object_id++;

    window.display = _this->current_display;

    if (!_this->CreateWindowFrom ||

        _this->CreateWindowFrom(_this, &window, data) < 0) {

        return 0;

    }

    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 (window.title) {

            SDL_free(window.title);

        }

        return 0;

    }

    windows[num_windows] = window;

    display->windows = windows;

    display->num_windows++;

    return window.id;

}

SDL_Window *

SDL_GetWindowFromID(SDL_WindowID windowID)

{

    int i, j;

    if (!_this) {

        return NULL;

    }

    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;

            }

        }

    }

    return NULL;

}

SDL_VideoDisplay *

SDL_GetDisplayFromWindow(SDL_Window * window)

{

    if (!_this) {

        return NULL;

    }

    return &_this->displays[window->display];

}

Uint32

SDL_GetWindowFlags(SDL_WindowID windowID)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return 0;

    }

    return window->flags;

}

void

SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return;

    }

    if (window->title) {

        SDL_free(window->title);

    }

    window->title = SDL_strdup(title);

    if (_this->SetWindowTitle) {

        _this->SetWindowTitle(_this, window);

    }

}

const char *

SDL_GetWindowTitle(SDL_WindowID windowID)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return NULL;

    }

    return window->title;

}

void

SDL_SetWindowData(SDL_WindowID windowID, void *userdata)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return;

    }

    window->userdata = userdata;

}

void *

SDL_GetWindowData(SDL_WindowID windowID)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return NULL;

    }

    return window->userdata;

}

void

SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return;

    }

    if (x != SDL_WINDOWPOS_UNDEFINED) {

        window->x = x;

    }

    if (y != SDL_WINDOWPOS_UNDEFINED) {

        window->y = y;

    }

    if (_this->SetWindowPosition) {

        _this->SetWindowPosition(_this, window);

    }

}

void

SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return;

    }

    if (x) {

        *x = window->x;

    }

    if (y) {

        *y = window->y;

    }

}

void

SDL_SetWindowSize(SDL_WindowID windowID, int w, int h)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return;

    }

    window->w = w;

    window->h = h;

    if (_this->SetWindowSize) {

        _this->SetWindowSize(_this, window);

    }

}

void

SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *h)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window) {

        return;

    }

    if (w) {

        *w = window->w;

    }

    if (h) {

        *h = window->h;

    }

}

void

SDL_ShowWindow(SDL_WindowID windowID)

{

    SDL_Window *window = SDL_GetWindowFromID(windowID);

    if (!window || (window->flags & SDL_WINDOW_SHOWN)) {

        return;

    }

    SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);

    if (_this->ShowWindow) {

        _this->ShowWindow(_this, window);

    }

}