/*

    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"

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

#include "SDL.h"

#include "SDL_syswm.h"

#include "video/SDL_pixels_c.h"

static SDL_WindowID SDL_VideoWindow;

static SDL_TextureID SDL_VideoTexture;

static SDL_Surface *SDL_VideoSurface;

static SDL_Surface *SDL_ShadowSurface;

static SDL_Surface *SDL_PublicSurface;

static char *wm_title;

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;

}

const SDL_VideoInfo *

SDL_GetVideoInfo(void)

{

    static SDL_VideoInfo info;

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

    if (!info.vfmt && SDL_GetDesktopDisplayMode()) {

        int bpp;

        Uint32 Rmask, Gmask, Bmask, Amask;

        SDL_PixelFormatEnumToMasks(SDL_GetDesktopDisplayMode()->format, &bpp,

                                   &Rmask, &Gmask, &Bmask, &Amask);

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

    }

    return &info;

}

int

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

{

    int i, actual_bpp = 0;

    if (!SDL_GetVideoDevice()) {

        return 0;

    }

    if (!(flags & SDL_FULLSCREEN)) {

        return SDL_BITSPERPIXEL(SDL_GetDesktopDisplayMode()->format);

    }

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

        const SDL_DisplayMode *mode = SDL_GetDisplayMode(i);

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

            if (!mode->format) {

                return bpp;

            }

                actual_bpp = SDL_BITSPERPIXEL(mode->format);

            }

        }

    }

    return actual_bpp;

}

SDL_Rect **

SDL_ListModes(SDL_PixelFormat * format, Uint32 flags)

{

    int i, nmodes;

    SDL_Rect **modes;

    if (!SDL_GetVideoDevice()) {

        return NULL;

    }

    if (!(flags & SDL_FULLSCREEN)) {

        return (SDL_Rect **) (-1);

    }

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

    nmodes = 0;

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

        const SDL_DisplayMode *mode = SDL_GetDisplayMode(i);

        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 (*orig_eventfilter) (SDL_Event * event);

static int

SDL_CompatEventFilter(SDL_Event * event)

{

    SDL_Event fake;

    switch (event->type) {

    case SDL_WINDOWEVENT:

        switch (event->window.event) {

        case SDL_WINDOWEVENT_RESIZED:

            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 = 1;

            fake.active.state = SDL_APPINPUTFOCUS;

            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;

        }

    }

    if (orig_eventfilter) {

        return orig_eventfilter(event);

    } else {

        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) {

        return SDL_SetDisplayPalette(palette->colors, 0, palette->ncolors);

    }

}

SDL_Surface *

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

{

    int (*filter) (SDL_Event * event);

    const SDL_DisplayMode *desktop_mode;

    SDL_DisplayMode mode;

    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;

        }

    }

    /* 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;

    }

    SDL_DestroyWindow(SDL_VideoWindow);

    /* Set up the event filter */

    filter = SDL_GetEventFilter();

    if (filter != SDL_CompatEventFilter) {

        orig_eventfilter = filter;

    }

    SDL_SetEventFilter(SDL_CompatEventFilter);

    /* 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;

    }

    SDL_VideoWindow =

        SDL_CreateWindow(wm_title, 0, 0, width, height, window_flags);

    if (!SDL_VideoWindow) {

        return NULL;

    }

    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_mode = SDL_GetDesktopDisplayMode();

    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;

            }

            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;

        }

    }

    mode.format = desired_format;

    mode.w = width;

    mode.h = height;

    mode.refresh_rate = 0;

    /* Set the desired display mode */

    if (flags & SDL_FULLSCREEN) {

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

            return NULL;

        }

    } else {

        if (desktop_format) {

            mode.format = desktop_format;

        }

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

            mode.w = desktop_mode->w;

            mode.h = desktop_mode->h;

        }

        mode.refresh_rate = desktop_mode->refresh_rate;

    }

    if (SDL_SetDisplayMode(&mode) < 0) {

        return NULL;

    }

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

    if (flags & SDL_OPENGL) {

        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, 0) < 0) {

        return NULL;

    }

    /* Create a texture for the screen surface */

    SDL_VideoTexture =

        SDL_CreateTexture(desired_format, SDL_TextureAccess_Local, width,

                          height);

    if (!SDL_VideoTexture) {

        SDL_VideoTexture =

            SDL_CreateTexture(0, SDL_TextureAccess_Local, width, height);

    }

    if (!SDL_VideoTexture) {

        return NULL;

    }

    /* Create the screen surface */

    SDL_VideoSurface = SDL_CreateRGBSurfaceFromTexture(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, NULL);

        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_VideoSurface->flags & SDL_HWSURFACE)

            && !(flags & SDL_HWSURFACE))) {

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

            || (flags & SDL_ANYFORMAT)) {

            SDL_ShadowSurface =

                SDL_CreateRGBSurface(0, width, height,

                                     SDL_VideoSurface->format->BitsPerPixel,

                                     SDL_VideoSurface->format->Rmask,

                                     SDL_VideoSurface->format->Gmask,

                                     SDL_VideoSurface->format->Bmask,

                                     SDL_VideoSurface->format->Amask);

        } else {

            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_PublicSurface =

        (SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface);

    /* Clear the surface for display */

    SDL_FillRect(SDL_PublicSurface, NULL, 0);

    /* We're finally done! */

    return SDL_PublicSurface;

}

SDL_Surface *

SDL_GetVideoSurface(void)

{

    return SDL_PublicSurface;

}

SDL_Surface *

SDL_DisplayFormat(SDL_Surface * surface)

{

    Uint32 flags;

    if (!SDL_PublicSurface) {

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

        return NULL;

    }

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

    flags = SDL_SWSURFACE;

#ifdef AUTORLE_DISPLAYFORMAT

    flags |= (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA));

    flags |= SDL_RLEACCELOK;

#else

    flags |=