/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2009 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"

/* This file contains functions for backwards compatibility with SDL 1.2 */

#include "SDL.h"

#include "SDL_syswm.h"

#include "video/SDL_sysvideo.h"

#include "video/SDL_pixels_c.h"

#include "video/SDL_yuv_sw_c.h"

static SDL_WindowID SDL_VideoWindow = 0;

static SDL_RendererInfo SDL_VideoRendererInfo;

static SDL_TextureID SDL_VideoTexture = 0;

static SDL_Surface *SDL_VideoSurface = NULL;

static SDL_Surface *SDL_ShadowSurface = NULL;

static SDL_Surface *SDL_PublicSurface = NULL;

static SDL_GLContext *SDL_VideoContext = NULL;

static Uint32 SDL_VideoFlags = 0;

static char *wm_title = NULL;

static SDL_Surface *SDL_VideoIcon;

static int SDL_enabled_UNICODE = 0;

char *

SDL_AudioDriverName(char *namebuf, int maxlen)

{

    const char *name = SDL_GetCurrentAudioDriver();

    if (name) {

        SDL_strlcpy(namebuf, name, maxlen);

        return namebuf;

    }

    return NULL;

}

char *

SDL_VideoDriverName(char *namebuf, int maxlen)

{

    const char *name = SDL_GetCurrentVideoDriver();

    if (name) {

        SDL_strlcpy(namebuf, name, maxlen);

        return namebuf;

    }

    return NULL;

}

static void

SelectVideoDisplay()

{

    const char *variable = SDL_getenv("SDL_VIDEO_FULLSCREEN_DISPLAY");

    if ( !variable ) {

        variable = SDL_getenv("SDL_VIDEO_FULLSCREEN_HEAD");

    }

    if ( variable ) {

        SDL_SelectVideoDisplay(SDL_atoi(variable));

    }

}

const SDL_VideoInfo *

SDL_GetVideoInfo(void)

{

    static SDL_VideoInfo info;

    SDL_DisplayMode mode;

    SelectVideoDisplay();

    /* Memory leak, compatibility code, who cares? */

    if (!info.vfmt && SDL_GetDesktopDisplayMode(&mode) == 0) {

        int bpp;

        Uint32 Rmask, Gmask, Bmask, Amask;

        SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, &Bmask,

                                   &Amask);

        info.vfmt = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask);

        info.current_w = mode.w;

        info.current_h = mode.h;

    }

    return &info;

}

int

SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags)

{

    int i, actual_bpp = 0;

    if (!SDL_GetVideoDevice()) {

        return 0;

    }

    SelectVideoDisplay();

    if (!(flags & SDL_FULLSCREEN)) {

        SDL_DisplayMode mode;

        SDL_GetDesktopDisplayMode(&mode);

        return SDL_BITSPERPIXEL(mode.format);

    }

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

        SDL_DisplayMode mode;

        SDL_GetDisplayMode(i, &mode);

        if (!mode.w || !mode.h || (width == mode.w && height == mode.h)) {

            if (!mode.format) {

                return bpp;

            }

            if (SDL_BITSPERPIXEL(mode.format) >= (Uint32) bpp) {

                actual_bpp = SDL_BITSPERPIXEL(mode.format);

            }

        }

    }

    return actual_bpp;

}

SDL_Rect **

SDL_ListModes(const SDL_PixelFormat * format, Uint32 flags)

{

    int i, nmodes;

    SDL_Rect **modes;

    if (!SDL_GetVideoDevice()) {

        return NULL;

    }

    SelectVideoDisplay();

    if (!(flags & SDL_FULLSCREEN)) {

        return (SDL_Rect **) (-1);

    }

    if (!format) {

        format = SDL_GetVideoInfo()->vfmt;

    }

    /* Memory leak, but this is a compatibility function, who cares? */

    nmodes = 0;

    modes = NULL;

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

        SDL_DisplayMode mode;

        SDL_GetDisplayMode(i, &mode);

        if (!mode.w || !mode.h) {

            return (SDL_Rect **) (-1);

        }

        if (SDL_BITSPERPIXEL(mode.format) != format->BitsPerPixel) {

            continue;

        }

        if (nmodes > 0 && modes[nmodes - 1]->w == mode.w

            && modes[nmodes - 1]->h == mode.h) {

            continue;

        }

        modes = SDL_realloc(modes, (nmodes + 2) * sizeof(*modes));

        if (!modes) {

            return NULL;

        }

        modes[nmodes] = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect));

        if (!modes[nmodes]) {

            return NULL;

        }

        modes[nmodes]->x = 0;

        modes[nmodes]->y = 0;

        modes[nmodes]->w = mode.w;

        modes[nmodes]->h = mode.h;

        ++nmodes;

    }

    if (modes) {

        modes[nmodes] = NULL;

    }

    return modes;

}

static int

SDL_CompatEventFilter(void *userdata, SDL_Event * event)

{

    SDL_Event fake;

    switch (event->type) {

    case SDL_WINDOWEVENT:

        switch (event->window.event) {

        case SDL_WINDOWEVENT_EXPOSED:

            if (!SDL_HasEvent(SDL_VIDEOEXPOSEMASK)) {

                fake.type = SDL_VIDEOEXPOSE;

                SDL_PushEvent(&fake);

            }

            break;

        case SDL_WINDOWEVENT_RESIZED:

            SDL_PeepEvents(&fake, 1, SDL_GETEVENT, SDL_VIDEORESIZEMASK);

            fake.type = SDL_VIDEORESIZE;

            fake.resize.w = event->window.data1;

            fake.resize.h = event->window.data2;

            SDL_PushEvent(&fake);

            break;

        case SDL_WINDOWEVENT_MINIMIZED:

            fake.type = SDL_ACTIVEEVENT;

            fake.active.gain = 0;

            fake.active.state = SDL_APPACTIVE;

            SDL_PushEvent(&fake);

            break;

        case SDL_WINDOWEVENT_RESTORED:

            fake.type = SDL_ACTIVEEVENT;

            fake.active.gain = 1;

            fake.active.state = SDL_APPACTIVE;

            SDL_PushEvent(&fake);

            break;

        case SDL_WINDOWEVENT_ENTER:

            fake.type = SDL_ACTIVEEVENT;

            fake.active.gain = 1;

            fake.active.state = SDL_APPMOUSEFOCUS;

            SDL_PushEvent(&fake);

            break;

        case SDL_WINDOWEVENT_LEAVE:

            fake.type = SDL_ACTIVEEVENT;

            fake.active.gain = 0;

            fake.active.state = SDL_APPMOUSEFOCUS;

            SDL_PushEvent(&fake);

            break;

        case SDL_WINDOWEVENT_FOCUS_GAINED:

            fake.type = SDL_ACTIVEEVENT;

            fake.active.gain = 1;

            fake.active.state = SDL_APPINPUTFOCUS;

            SDL_PushEvent(&fake);

            break;

        case SDL_WINDOWEVENT_FOCUS_LOST:

            fake.type = SDL_ACTIVEEVENT;

            fake.active.gain = 0;

            fake.active.state = SDL_APPINPUTFOCUS;

            SDL_PushEvent(&fake);

            break;

        case SDL_WINDOWEVENT_CLOSE:

            fake.type = SDL_QUIT;

            SDL_PushEvent(&fake);

            break;

        }

    case SDL_KEYDOWN:

    case SDL_KEYUP:

        {

            Uint32 unicode = 0;

            if (event->key.type == SDL_KEYDOWN && event->key.keysym.sym < 256) {

                unicode = event->key.keysym.sym;

                if (unicode >= 'a' && unicode <= 'z') {

                    int shifted = !!(event->key.keysym.mod & KMOD_SHIFT);

                    int capslock = !!(event->key.keysym.mod & KMOD_CAPS);

                    if ((shifted ^ capslock) != 0) {

                        unicode = SDL_toupper(unicode);

                    }

                }

            }

            if (unicode) {

                event->key.keysym.unicode = unicode;

            }

            break;

        }

    case SDL_TEXTINPUT:

        {

            /* FIXME: Generate an old style key repeat event if needed */

            //printf("TEXTINPUT: '%s'\n", event->text.text);

            break;

        }

    case SDL_MOUSEWHEEL:

        {

            Uint8 button;

            int selected;

            int x, y;

            if (event->wheel.y == 0) {

                break;

            }

            selected = SDL_SelectMouse(event->wheel.which);

            SDL_GetMouseState(&x, &y);

            SDL_SelectMouse(selected);

            if (event->wheel.y > 0) {

                button = SDL_BUTTON_WHEELUP;

            } else {

                button = SDL_BUTTON_WHEELDOWN;

            }

            fake.button.which = event->wheel.windowID;

            fake.button.button = button;

            fake.button.x = x;

            fake.button.y = y;

            fake.button.windowID = event->wheel.windowID;

            fake.type = SDL_MOUSEBUTTONDOWN;

            fake.button.state = SDL_PRESSED;

            SDL_PushEvent(&fake);

            fake.type = SDL_MOUSEBUTTONUP;

            fake.button.state = SDL_RELEASED;

            SDL_PushEvent(&fake);

            break;

        }

    }

    return 1;

}

static int

SDL_VideoPaletteChanged(void *userdata, SDL_Palette * palette)

{

    if (userdata == SDL_ShadowSurface) {

        /* If the shadow palette changed, make the changes visible */

        if (!SDL_VideoSurface->format->palette) {

            SDL_UpdateRect(SDL_ShadowSurface, 0, 0, 0, 0);

        }

    }

    if (userdata == SDL_VideoSurface) {

        if (SDL_SetDisplayPalette(palette->colors, 0, palette->ncolors) < 0) {

            return -1;

        }

        if (SDL_SetTexturePalette

            (SDL_VideoTexture, palette->colors, 0, palette->ncolors) < 0) {

            return -1;

        }

    }

    return 0;

}

static void

GetEnvironmentWindowPosition(int w, int h, int *x, int *y)

{

    const char *window = SDL_getenv("SDL_VIDEO_WINDOW_POS");

    const char *center = SDL_getenv("SDL_VIDEO_CENTERED");

    if (window) {

        if (SDL_sscanf(window, "%d,%d", x, y) == 2) {

            return;

        }

        if (SDL_strcmp(window, "center") == 0) {

            center = window;

        }

    }

    if (center) {

        SDL_DisplayMode mode;

        SDL_GetDesktopDisplayMode(&mode);

        *x = (mode.w - w) / 2;

        *y = (mode.h - h) / 2;

    }

}

static SDL_Surface *

CreateVideoSurface(SDL_TextureID textureID)

{

    SDL_Surface *surface;

    Uint32 format;

    int w, h;

    int bpp;

    Uint32 Rmask, Gmask, Bmask, Amask;

    void *pixels;

    int pitch;

    if (SDL_QueryTexture(textureID, &format, NULL, &w, &h) < 0) {

        return NULL;

    }

    if (!SDL_PixelFormatEnumToMasks

        (format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {

        SDL_SetError("Unknown texture format");

        return NULL;

    }

    if (SDL_QueryTexturePixels(textureID, &pixels, &pitch) == 0) {

        surface =

            SDL_CreateRGBSurfaceFrom(pixels, w, h, bpp, pitch, Rmask, Gmask,

                                     Bmask, Amask);

    } else {

        surface =

            SDL_CreateRGBSurface(0, w, h, bpp, Rmask, Gmask, Bmask, Amask);

    }

    return surface;

}

static void

ClearVideoSurface()

{

    Uint32 black;

    /* Clear the surface for display */

    black = SDL_MapRGB(SDL_PublicSurface->format, 0, 0, 0);

    SDL_FillRect(SDL_PublicSurface, NULL, black);

    SDL_UpdateRect(SDL_PublicSurface, 0, 0, 0, 0);

}

static void

SetupScreenSaver(int flags)

{

    const char *env;

    SDL_bool allow_screensaver;

    /* Allow environment override of screensaver disable */

    env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");

    if (env) {

        allow_screensaver = SDL_atoi(env) ? SDL_TRUE : SDL_FALSE;

    } else if (flags & SDL_FULLSCREEN) {

        allow_screensaver = SDL_FALSE;

    } else {

        allow_screensaver = SDL_TRUE;

    }

    if (allow_screensaver) {

        SDL_EnableScreenSaver();

    } else {

        SDL_DisableScreenSaver();

    }

}

int

SDL_ResizeVideoMode(int width, int height, int bpp, Uint32 flags)

{

    int w, h;

    Uint32 format;

    int access;

    void *pixels;

    int pitch;

    /* We can't resize something we don't have... */

    if (!SDL_VideoWindow) {

        return -1;

    }

    /* We probably have to recreate the window in fullscreen mode */

    if (flags & SDL_FULLSCREEN) {

        return -1;

    }

    /* I don't think there's any change we can gracefully make in flags */

    if (flags != SDL_VideoFlags) {

        return -1;

    }

    /* Resize the window */

    SDL_GetWindowSize(SDL_VideoWindow, &w, &h);

    if (w != width || h != height) {

        SDL_SetWindowSize(SDL_VideoWindow, width, height);

    }

    /* If we're in OpenGL mode, just resize the stub surface and we're done! */

    if (flags & SDL_OPENGL) {

        SDL_VideoSurface->w = width;

        SDL_VideoSurface->h = height;

        return 0;

    }

    /* Destroy the screen texture and recreate it */

    SDL_QueryTexture(SDL_VideoTexture, &format, &access, &w, &h);

    SDL_DestroyTexture(SDL_VideoTexture);

    SDL_VideoTexture = SDL_CreateTexture(format, access, width, height);

    if (!SDL_VideoTexture) {

        return -1;

    }

    SDL_VideoSurface->w = width;

    SDL_VideoSurface->h = height;

    if (SDL_QueryTexturePixels(SDL_VideoTexture, &pixels, &pitch) == 0) {

        SDL_VideoSurface->pixels = pixels;

        SDL_VideoSurface->pitch = pitch;

    } else {

        SDL_CalculatePitch(SDL_VideoSurface);

        SDL_VideoSurface->pixels =

            SDL_realloc(SDL_VideoSurface->pixels,

                        SDL_VideoSurface->h * SDL_VideoSurface->pitch);

    }

    SDL_SetClipRect(SDL_VideoSurface, NULL);

    SDL_InvalidateMap(SDL_VideoSurface->map);

    if (SDL_ShadowSurface) {

        SDL_ShadowSurface->w = width;

        SDL_ShadowSurface->h = height;

        SDL_ShadowSurface->pitch = SDL_CalculatePitch(SDL_ShadowSurface);

        SDL_ShadowSurface->pixels =

            SDL_realloc(SDL_ShadowSurface->pixels,

                        SDL_ShadowSurface->h * SDL_ShadowSurface->pitch);

        SDL_SetClipRect(SDL_ShadowSurface, NULL);

        SDL_InvalidateMap(SDL_ShadowSurface->map);

    }

    ClearVideoSurface();

    return 0;

}

SDL_Surface *

SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)

{

    SDL_DisplayMode desktop_mode;

    int window_x = SDL_WINDOWPOS_UNDEFINED;

    int window_y = SDL_WINDOWPOS_UNDEFINED;

    Uint32 window_flags;

    Uint32 desktop_format;

    Uint32 desired_format;

    Uint32 surface_flags;

    if (!SDL_GetVideoDevice()) {

        if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) {

            return NULL;

        }

    }

    SelectVideoDisplay();

    SDL_GetDesktopDisplayMode(&desktop_mode);

    if (width == 0) {

        width = desktop_mode.w;

    }

    if (height == 0) {

        height = desktop_mode.h;

    }

    /* See if we can simply resize the existing window and surface */

    if (SDL_ResizeVideoMode(width, height, bpp, flags) == 0) {

        return SDL_PublicSurface;

    }

    /* Destroy existing window */

    SDL_PublicSurface = NULL;

    if (SDL_ShadowSurface) {

        SDL_FreeSurface(SDL_ShadowSurface);

        SDL_ShadowSurface = NULL;

    }

    if (SDL_VideoSurface) {

        SDL_DelPaletteWatch(SDL_VideoSurface->format->palette,

                            SDL_VideoPaletteChanged, NULL);

        SDL_FreeSurface(SDL_VideoSurface);

        SDL_VideoSurface = NULL;

    }

    if (SDL_VideoContext) {

        /* SDL_GL_MakeCurrent(0, NULL); *//* Doesn't do anything */

        SDL_GL_DeleteContext(SDL_VideoContext);

        SDL_VideoContext = NULL;

    }

    if (SDL_VideoWindow) {

        SDL_GetWindowPosition(SDL_VideoWindow, &window_x, &window_y);

        SDL_DestroyWindow(SDL_VideoWindow);

    }

    /* Set up the event filter */

    if (!SDL_GetEventFilter(NULL, NULL)) {

        SDL_SetEventFilter(SDL_CompatEventFilter, NULL);

    }

    /* Create a new window */

    window_flags = SDL_WINDOW_SHOWN;

    if (flags & SDL_FULLSCREEN) {

        window_flags |= SDL_WINDOW_FULLSCREEN;

    }

    if (flags & SDL_OPENGL) {

        window_flags |= SDL_WINDOW_OPENGL;

    }

    if (flags & SDL_RESIZABLE) {

        window_flags |= SDL_WINDOW_RESIZABLE;

    }

    if (flags & SDL_NOFRAME) {

        window_flags |= SDL_WINDOW_BORDERLESS;

    }

    GetEnvironmentWindowPosition(width, height, &window_x, &window_y);

    SDL_VideoWindow =

        SDL_CreateWindow(wm_title, window_x, window_y, width, height,

                         window_flags);

    if (!SDL_VideoWindow) {

        return NULL;

    }

    SDL_SetWindowIcon(SDL_VideoWindow, SDL_VideoIcon);

    window_flags = SDL_GetWindowFlags(SDL_VideoWindow);

    surface_flags = 0;

    if (window_flags & SDL_WINDOW_FULLSCREEN) {

        surface_flags |= SDL_FULLSCREEN;

    }

    if (window_flags & SDL_WINDOW_OPENGL) {

        surface_flags |= SDL_OPENGL;

    }

    if (window_flags & SDL_WINDOW_RESIZABLE) {

        surface_flags |= SDL_RESIZABLE;

    }

    if (window_flags & SDL_WINDOW_BORDERLESS) {

        surface_flags |= SDL_NOFRAME;

    }

    /* Set up the desired display mode */

    desktop_format = desktop_mode.format;

    if (desktop_format && ((flags & SDL_ANYFORMAT)

                           || (bpp == SDL_BITSPERPIXEL(desktop_format)))) {

        desired_format = desktop_format;

    } else {

        switch (bpp) {

        case 0:

            if (desktop_format) {

                desired_format = desktop_format;

            } else {

                desired_format = SDL_PIXELFORMAT_RGB888;

            }

            bpp = SDL_BITSPERPIXEL(desired_format);

            break;

        case 8:

            desired_format = SDL_PIXELFORMAT_INDEX8;

            break;

        case 15:

            desired_format = SDL_PIXELFORMAT_RGB555;

            break;

        case 16:

            desired_format = SDL_PIXELFORMAT_RGB565;

            break;

        case 24:

            desired_format = SDL_PIXELFORMAT_RGB24;

            break;

        case 32:

            desired_format = SDL_PIXELFORMAT_RGB888;

            break;

        default:

            SDL_SetError("Unsupported bpp in SDL_SetVideoMode()");

            return NULL;

        }

    }

    /* Set up the desired display mode */

    if (flags & SDL_FULLSCREEN) {

        SDL_DisplayMode mode;

        SDL_zero(mode);

        mode.format = desired_format;

        if (SDL_SetWindowDisplayMode(SDL_VideoWindow, &mode) < 0) {

            return NULL;

        }

    }

    /* If we're in OpenGL mode, just create a stub surface and we're done! */

    if (flags & SDL_OPENGL) {

        SDL_VideoContext = SDL_GL_CreateContext(SDL_VideoWindow);

        if (!SDL_VideoContext) {

            return NULL;

        }

        if (SDL_GL_MakeCurrent(SDL_VideoWindow, SDL_VideoContext) < 0) {

            return NULL;

        }

        SDL_VideoSurface =

            SDL_CreateRGBSurfaceFrom(NULL, width, height, bpp, 0, 0, 0, 0, 0);

        if (!SDL_VideoSurface) {

            return NULL;

        }

        SDL_VideoSurface->flags |= surface_flags;

        SDL_PublicSurface = SDL_VideoSurface;

        return SDL_PublicSurface;

    }

    /* Create a renderer for the window */

    if (SDL_CreateRenderer

        (SDL_VideoWindow, -1,

         SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD) < 0) {

        return NULL;

    }

    SDL_GetRendererInfo(&SDL_VideoRendererInfo);

    /* Create a texture for the screen surface */

    SDL_VideoTexture =

        SDL_CreateTexture(desired_format, SDL_TEXTUREACCESS_STREAMING, width,

                          height);

    if (!SDL_VideoTexture) {

        SDL_VideoTexture =

            SDL_CreateTexture(desktop_format,

                              SDL_TEXTUREACCESS_STREAMING, width, height);

    }

    if (!SDL_VideoTexture) {

        return NULL;

    }

    /* Create the screen surface */

    SDL_VideoSurface = CreateVideoSurface(SDL_VideoTexture);

    if (!SDL_VideoSurface) {

        return NULL;

    }

    SDL_VideoSurface->flags |= surface_flags;

    /* Set a default screen palette */

    if (SDL_VideoSurface->format->palette) {

        SDL_VideoSurface->flags |= SDL_HWPALETTE;

        SDL_DitherColors(SDL_VideoSurface->format->palette->colors,

                         SDL_VideoSurface->format->BitsPerPixel);

        SDL_AddPaletteWatch(SDL_VideoSurface->format->palette,

                            SDL_VideoPaletteChanged, SDL_VideoSurface);

        SDL_SetPaletteColors(SDL_VideoSurface->format->palette,

                             SDL_VideoSurface->format->palette->colors, 0,

                             SDL_VideoSurface->format->palette->ncolors);

    }

    /* Create a shadow surface if necessary */

    if ((bpp != SDL_VideoSurface->format->BitsPerPixel)

        && !(flags & SDL_ANYFORMAT)) {

        SDL_ShadowSurface =

            SDL_CreateRGBSurface(0, width, height, bpp, 0, 0, 0, 0);

        if (!SDL_ShadowSurface) {

            return NULL;

        }

        SDL_ShadowSurface->flags |= surface_flags;

        /* 8-bit SDL_ShadowSurface surfaces report that they have exclusive palette */

        if (SDL_ShadowSurface->format->palette) {

            SDL_ShadowSurface->flags |= SDL_HWPALETTE;

            if (SDL_VideoSurface->format->palette) {

                SDL_SetSurfacePalette(SDL_ShadowSurface,

                                      SDL_VideoSurface->format->palette);

            } else {

                SDL_DitherColors(SDL_ShadowSurface->format->palette->colors,

                                 SDL_ShadowSurface->format->BitsPerPixel);

            }

            SDL_AddPaletteWatch(SDL_ShadowSurface->format->palette,

                                SDL_VideoPaletteChanged, SDL_ShadowSurface);

        }

    }

    SDL_PublicSurface =

        (SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface);

    SDL_VideoFlags = flags;

    ClearVideoSurface();

    SetupScreenSaver(flags);

    /* We're finally done! */

    return SDL_PublicSurface;

}

SDL_Surface *

SDL_GetVideoSurface(void)

{

    return SDL_PublicSurface;

}

int

SDL_SetAlpha(SDL_Surface * surface, Uint32 flag, Uint8 value)

{

    if (flag & SDL_SRCALPHA) {

        /* According to the docs, value is ignored for alpha surfaces */

        if (surface->format->Amask) {

            value = 0xFF;

        }

        SDL_SetSurfaceAlphaMod(surface, value);

        SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);

    } else {

        SDL_SetSurfaceAlphaMod(surface, 0xFF);

        SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_NONE);

    }

    SDL_SetSurfaceRLE(surface, (flag & SDL_RLEACCEL));

    return 0;

}

SDL_Surface *

SDL_DisplayFormat(SDL_Surface * surface)

{

    SDL_PixelFormat *format;

    if (!SDL_PublicSurface) {

        SDL_SetError("No video mode has been set");

        return NULL;

    }

    format = SDL_PublicSurface->format;

    /* Set the flags appropriate for copying to display surface */

    return SDL_ConvertSurface(surface, format, SDL_RLEACCEL);

}

SDL_Surface *

SDL_DisplayFormatAlpha(SDL_Surface * surface)

{

    SDL_PixelFormat *vf;

    SDL_PixelFormat *format;

    SDL_Surface *converted;

    /* default to ARGB8888 */

    Uint32 amask = 0xff000000;

    Uint32 rmask = 0x00ff0000;

    Uint32 gmask = 0x0000ff00;

    Uint32 bmask = 0x000000ff;

    if (!SDL_PublicSurface) {

        SDL_SetError("No video mode has been set");

        return NULL;

    }

    vf = SDL_PublicSurface->format;

    switch (vf->BytesPerPixel) {

    case 2:

        /* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}.

           For anything else (like ARGB4444) it doesn't matter

           since we have no special code for it anyway */

        if ((vf->Rmask == 0x1f) &&

            (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) {

            rmask = 0xff;

            bmask = 0xff0000;

        }

        break;

    case 3:

    case 4:

        /* Keep the video format, as long as the high 8 bits are

           unused or alpha */

        if ((vf->Rmask == 0xff) && (vf->Bmask == 0xff0000)) {

            rmask = 0xff;

            bmask = 0xff0000;

        }

        break;

    default:

        /* We have no other optimised formats right now. When/if a new

           optimised alpha format is written, add the converter here */

        break;

    }

    format = SDL_AllocFormat(32, rmask, gmask, bmask, amask);

    converted = SDL_ConvertSurface(surface, format, SDL_RLEACCEL);

    SDL_FreeFormat(format);

    return converted;

}

int

SDL_Flip(SDL_Surface * screen)

{

    SDL_UpdateRect(screen, 0, 0, 0, 0);

    return 0;

}

void

SDL_UpdateRect(SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h)

{

    if (screen) {

        SDL_Rect rect;

        /* Fill the rectangle */

        rect.x = (int) x;

        rect.y = (int) y;

        rect.w = (int) (w ? w : screen->w);

        rect.h = (int) (h ? h : screen->h);

        SDL_UpdateRects(screen, 1, &rect);

    }

}

void

SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects)

{

    int i;

    if (screen == SDL_ShadowSurface) {

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

            SDL_LowerBlit(SDL_ShadowSurface, &rects[i], SDL_VideoSurface,

                          &rects[i]);

        }

        /* Fall through to video surface update */

        screen = SDL_VideoSurface;

    }

    if (screen == SDL_VideoSurface) {

        if (screen->flags & SDL_PREALLOC) {

            /* The surface memory is maintained by the renderer */

            SDL_DirtyTexture(SDL_VideoTexture, numrects, rects);

        } else {

            /* The surface memory needs to be copied to texture */

            int pitch = screen->pitch;

            int psize = screen->format->BytesPerPixel;

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

                const SDL_Rect *rect = &rects[i];

                void *pixels =

                    (Uint8 *) screen->pixels + rect->y * pitch +

                    rect->x * psize;

                SDL_UpdateTexture(SDL_VideoTexture, rect, pixels, pitch);

            }

        }

        if (SDL_VideoRendererInfo.flags & SDL_RENDERER_PRESENTCOPY) {

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

                SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i]);

            }

        } else {

            SDL_Rect rect;

            rect.x = 0;

            rect.y = 0;

            rect.w = screen->w;

            rect.h = screen->h;

            SDL_RenderCopy(SDL_VideoTexture, &rect, &rect);

        }

        SDL_RenderPresent();

    }

}

void

SDL_WM_SetCaption(const char *title, const char *icon)

{

    if (wm_title) {

        SDL_free(wm_title);

    }

    if (title) {

        wm_title = SDL_strdup(title);

    } else {

        wm_title = NULL;

    }

    SDL_SetWindowTitle(SDL_VideoWindow, wm_title);

}

void

SDL_WM_GetCaption(const char **title, const char **icon)

{

    if (title) {

        *title = wm_title;

    }

    if (icon) {

        *icon = "";

    }

}

void

SDL_WM_SetIcon(SDL_Surface * icon, Uint8 * mask)

{

    SDL_VideoIcon = icon;

}

int

SDL_WM_IconifyWindow(void)

{

    SDL_MinimizeWindow(SDL_VideoWindow);

    return 0;

}

int

SDL_WM_ToggleFullScreen(SDL_Surface * surface)

{

    if (SDL_GetWindowFlags(SDL_VideoWindow) & SDL_WINDOW_FULLSCREEN) {

        if (SDL_SetWindowFullscreen(SDL_VideoWindow, 0) < 0) {

            return 0;

        }

        SDL_PublicSurface->flags &= ~SDL_FULLSCREEN;

    } else {

        if (SDL_SetWindowFullscreen(SDL_VideoWindow, 1) < 0) {

            return 0;

        }

        SDL_PublicSurface->flags |= SDL_FULLSCREEN;

    }

    return 1;

}

SDL_GrabMode

SDL_WM_GrabInput(SDL_GrabMode mode)

{

    if (mode != SDL_GRAB_QUERY) {

        SDL_SetWindowGrab(SDL_VideoWindow, mode);

    }

    return (SDL_GrabMode) SDL_GetWindowGrab(SDL_VideoWindow);

}

void

SDL_WarpMouse(Uint16 x, Uint16 y)

{

    SDL_WarpMouseInWindow(SDL_VideoWindow, x, y);

}

Uint8

SDL_GetAppState(void)

{

    Uint8 state = 0;

    Uint32 flags = 0;

    flags = SDL_GetWindowFlags(SDL_VideoWindow);

    if ((flags & SDL_WINDOW_SHOWN) && !(flags & SDL_WINDOW_MINIMIZED)) {

        state |= SDL_APPACTIVE;

    }

    if (flags & SDL_WINDOW_INPUT_FOCUS) {

        state |= SDL_APPINPUTFOCUS;

    }

    if (flags & SDL_WINDOW_MOUSE_FOCUS) {

        state |= SDL_APPMOUSEFOCUS;

    }

    return state;

}

const SDL_version *

SDL_Linked_Version(void)

{

    static SDL_version version;

    SDL_VERSION(&version);