/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2012 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#include "SDL_config.h"

#if SDL_VIDEO_DRIVER_X11

#include "../SDL_sysvideo.h"

#include "../SDL_pixels_c.h"

#include "../../events/SDL_keyboard_c.h"

#include "../../events/SDL_mouse_c.h"

#include "SDL_x11video.h"

#include "SDL_x11mouse.h"

#include "SDL_x11shape.h"

#include "SDL_x11xinput2.h"

#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2

#include "SDL_x11opengles.h"

#endif

#include "SDL_timer.h"

#include "SDL_syswm.h"

#include "SDL_assert.h"

#define _NET_WM_STATE_REMOVE    0l

#define _NET_WM_STATE_ADD       1l

#define _NET_WM_STATE_TOGGLE    2l

static Bool isMapNotify(Display *dpy, XEvent *ev, XPointer win)

{

    return ev->type == MapNotify && ev->xmap.window == *((Window*)win);

}

static Bool isUnmapNotify(Display *dpy, XEvent *ev, XPointer win)

{

    return ev->type == UnmapNotify && ev->xunmap.window == *((Window*)win);

}

static Bool isConfigureNotify(Display *dpy, XEvent *ev, XPointer win)

{

}

static SDL_bool

X11_IsWindowLegacyFullscreen(_THIS, SDL_Window * window)

{

    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;

    return (data->fswindow != 0);

}

static SDL_bool

X11_IsWindowMapped(_THIS, SDL_Window * window)

{

    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;

    SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;

    XWindowAttributes attr;

    XGetWindowAttributes(videodata->display, data->xwindow, &attr);

    if (attr.map_state != IsUnmapped) {

        return SDL_TRUE;

    } else {

        return SDL_FALSE;

    }

}

static int

X11_GetWMStateProperty(_THIS, SDL_Window * window, Atom atoms[3])

{

    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

    int count = 0;

    if (window->flags & SDL_WINDOW_FULLSCREEN) {

        atoms[count++] = data->_NET_WM_STATE_FULLSCREEN;

    }

    if (window->flags & SDL_WINDOW_MAXIMIZED) {

        atoms[count++] = data->_NET_WM_STATE_MAXIMIZED_VERT;

        atoms[count++] = data->_NET_WM_STATE_MAXIMIZED_HORZ;

    }

    return count;

}

static int

SetupWindowData(_THIS, SDL_Window * window, Window w, BOOL created)

{

    SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;

    SDL_WindowData *data;

    int numwindows = videodata->numwindows;

    int windowlistlength = videodata->windowlistlength;

    SDL_WindowData **windowlist = videodata->windowlist;

    /* Allocate the window data */

    data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data));

    if (!data) {

        SDL_OutOfMemory();

        return -1;

    }

    data->window = window;

    data->xwindow = w;

#ifdef X_HAVE_UTF8_STRING

    if (SDL_X11_HAVE_UTF8) {

        data->ic =

            pXCreateIC(videodata->im, XNClientWindow, w, XNFocusWindow, w,

                       XNInputStyle, XIMPreeditNothing | XIMStatusNothing,

                       XNResourceName, videodata->classname, XNResourceClass,

                       videodata->classname, NULL);

    }

#endif

    data->created = created;

    data->videodata = videodata;

    /* Associate the data with the window */

    if (numwindows < windowlistlength) {

        windowlist[numwindows] = data;

        videodata->numwindows++;

    } else {

        windowlist =

            (SDL_WindowData **) SDL_realloc(windowlist,

                                            (numwindows +

                                             1) * sizeof(*windowlist));

        if (!windowlist) {

            SDL_OutOfMemory();

            SDL_free(data);

            return -1;

        }

        windowlist[numwindows] = data;

        videodata->numwindows++;

        videodata->windowlistlength++;

        videodata->windowlist = windowlist;

    }

    /* Fill in the SDL window with the window data */

    {

        XWindowAttributes attrib;

        XGetWindowAttributes(data->videodata->display, w, &attrib);

        window->x = attrib.x;

        window->y = attrib.y;

        window->w = attrib.width;

        window->h = attrib.height;

        if (attrib.map_state != IsUnmapped) {

            window->flags |= SDL_WINDOW_SHOWN;

        } else {

            window->flags &= ~SDL_WINDOW_SHOWN;

        }

        data->visual = attrib.visual;

        data->colormap = attrib.colormap;

    }

    {

        Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;

        Atom _NET_WM_STATE_MAXIMIZED_VERT = data->videodata->_NET_WM_STATE_MAXIMIZED_VERT;

        Atom _NET_WM_STATE_MAXIMIZED_HORZ = data->videodata->_NET_WM_STATE_MAXIMIZED_HORZ;

        Atom _NET_WM_STATE_FULLSCREEN = data->videodata->_NET_WM_STATE_FULLSCREEN;

        Atom actualType;

        int actualFormat;

        unsigned long i, numItems, bytesAfter;

        unsigned char *propertyValue = NULL;

        long maxLength = 1024;

        if (XGetWindowProperty(data->videodata->display, w, _NET_WM_STATE,

                               0l, maxLength, False, XA_ATOM, &actualType,

                               &actualFormat, &numItems, &bytesAfter,

                               &propertyValue) == Success) {

            Atom *atoms = (Atom *) propertyValue;

            int maximized = 0;

            int fullscreen = 0;

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

                if (atoms[i] == _NET_WM_STATE_MAXIMIZED_VERT) {

                    maximized |= 1;

                } else if (atoms[i] == _NET_WM_STATE_MAXIMIZED_HORZ) {

                    maximized |= 2;

                } else if ( atoms[i] == _NET_WM_STATE_FULLSCREEN) {

                    fullscreen = 1;

                }

            }

            if (maximized == 3) {

                window->flags |= SDL_WINDOW_MAXIMIZED;

            }  else if (fullscreen == 1) {

                window->flags |= SDL_WINDOW_FULLSCREEN;

            }

            XFree(propertyValue);

        }

    }

    {

        Window FocalWindow;

        int RevertTo=0;

        XGetInputFocus(data->videodata->display, &FocalWindow, &RevertTo);

        if (FocalWindow==w)

        {

            window->flags |= SDL_WINDOW_INPUT_FOCUS;

            SDL_SetKeyboardFocus(data->window);

        }

        if (window->flags & SDL_WINDOW_INPUT_GRABBED) {

            /* Tell x11 to clip mouse */

        }

    }

    /* FIXME: How can I tell?

       {

       DWORD style = GetWindowLong(hwnd, GWL_STYLE);

       if (style & WS_VISIBLE) {

       if (style & (WS_BORDER | WS_THICKFRAME)) {

       window->flags &= ~SDL_WINDOW_BORDERLESS;

       } else {

       window->flags |= SDL_WINDOW_BORDERLESS;

       }

       if (style & WS_THICKFRAME) {

       window->flags |= SDL_WINDOW_RESIZABLE;

       } else {

       window->flags &= ~SDL_WINDOW_RESIZABLE;

       }

       if (style & WS_MINIMIZE) {

       window->flags |= SDL_WINDOW_MINIMIZED;

       } else {

       window->flags &= ~SDL_WINDOW_MINIMIZED;

       }

       }

       if (GetFocus() == hwnd) {

       int index = data->videodata->keyboard;

       window->flags |= SDL_WINDOW_INPUT_FOCUS;

       SDL_SetKeyboardFocus(index, data->window);

       if (window->flags & SDL_WINDOW_INPUT_GRABBED) {

       RECT rect;

       GetClientRect(hwnd, &rect);

       ClientToScreen(hwnd, (LPPOINT) & rect);

       ClientToScreen(hwnd, (LPPOINT) & rect + 1);

       ClipCursor(&rect);

       }

       }

     */

    /* All done! */

    window->driverdata = data;

    return 0;

}

static void

SetWindowBordered(Display *display, int screen, Window window, SDL_bool border)

{

    /*

     * this code used to check for KWM_WIN_DECORATION, but KDE hasn't

     *  supported it for years and years. It now respects _MOTIF_WM_HINTS.

     *  Gnome is similar: just use the Motif atom.

     */

    Atom WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", True);

    if (WM_HINTS != None) {

        /* Hints used by Motif compliant window managers */

        struct

        {

            unsigned long flags;

            unsigned long functions;

            unsigned long decorations;

            long input_mode;

            unsigned long status;

        } MWMHints = {

            (1L << 1), 0, border ? 1 : 0, 0, 0

        };

        XChangeProperty(display, window, WM_HINTS, WM_HINTS, 32,

                        PropModeReplace, (unsigned char *) &MWMHints,

                        sizeof(MWMHints) / 4);

    } else {  /* set the transient hints instead, if necessary */

        XSetTransientForHint(display, window, RootWindow(display, screen));

    }

}

int

X11_CreateWindow(_THIS, SDL_Window * window)

{

    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

    SDL_DisplayData *displaydata =

        (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;

    Display *display = data->display;

    int screen = displaydata->screen;

    Visual *visual;

    int depth;

    XSetWindowAttributes xattr;

    Window w;

    XSizeHints *sizehints;

    XWMHints *wmhints;

    XClassHint *classhints;

    Atom _NET_WM_WINDOW_TYPE;

    Atom _NET_WM_WINDOW_TYPE_NORMAL;

    Atom _NET_WM_PID;

    int wmstate_count;

    Atom wmstate_atoms[3];

    Uint32 fevent = 0;

#if SDL_VIDEO_OPENGL_GLX || SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2

    if (window->flags & SDL_WINDOW_OPENGL) {

        XVisualInfo *vinfo;

#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2        

        if (_this->gl_config.use_egl == 1) {

            vinfo = X11_GLES_GetVisual(_this, display, screen);

        } else

#endif

        {

#if SDL_VIDEO_OPENGL_GLX

            vinfo = X11_GL_GetVisual(_this, display, screen);

#endif

        }

        if (!vinfo) {

            return -1;

        }

        visual = vinfo->visual;

        depth = vinfo->depth;

        XFree(vinfo);

    } else

#endif

    {

        visual = displaydata->visual;

        depth = displaydata->depth;

    }

    xattr.override_redirect = False;

    xattr.background_pixel = 0;

    xattr.border_pixel = 0;

    if (visual->class == DirectColor) {

        XColor *colorcells;

        int i;

        int ncolors;

        int rmax, gmax, bmax;

        int rmask, gmask, bmask;

        int rshift, gshift, bshift;

        xattr.colormap =

            XCreateColormap(display, RootWindow(display, screen),

                            visual, AllocAll);

        /* If we can't create a colormap, then we must die */

        if (!xattr.colormap) {

            SDL_SetError("Could not create writable colormap");

            return -1;

        }

        /* OK, we got a colormap, now fill it in as best as we can */

        colorcells = SDL_malloc(visual->map_entries * sizeof(XColor));

        if (!colorcells) {

            SDL_OutOfMemory();

            return -1;

        }

        ncolors = visual->map_entries;

        rmax = 0xffff;

        gmax = 0xffff;

        bmax = 0xffff;

        rshift = 0;

        rmask = visual->red_mask;

        while (0 == (rmask & 1)) {

            rshift++;

            rmask >>= 1;

        }

        gshift = 0;

        gmask = visual->green_mask;

        while (0 == (gmask & 1)) {

            gshift++;

            gmask >>= 1;

        }

        bshift = 0;

        bmask = visual->blue_mask;

        while (0 == (bmask & 1)) {

            bshift++;

            bmask >>= 1;

        }

        /* build the color table pixel values */

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

            Uint32 red = (rmax * i) / (ncolors - 1);

            Uint32 green = (gmax * i) / (ncolors - 1);

            Uint32 blue = (bmax * i) / (ncolors - 1);

            Uint32 rbits = (rmask * i) / (ncolors - 1);

            Uint32 gbits = (gmask * i) / (ncolors - 1);

            Uint32 bbits = (bmask * i) / (ncolors - 1);

            Uint32 pix =

                (rbits << rshift) | (gbits << gshift) | (bbits << bshift);

            colorcells[i].pixel = pix;

            colorcells[i].red = red;

            colorcells[i].green = green;

            colorcells[i].blue = blue;

            colorcells[i].flags = DoRed | DoGreen | DoBlue;

        }

        XStoreColors(display, xattr.colormap, colorcells, ncolors);

        SDL_free(colorcells);

    } else {

        xattr.colormap =

            XCreateColormap(display, RootWindow(display, screen),

                            visual, AllocNone);

    }

    w = XCreateWindow(display, RootWindow(display, screen),

                      window->x, window->y, window->w, window->h,

                      0, depth, InputOutput, visual,

                      (CWOverrideRedirect | CWBackPixel | CWBorderPixel |

                       CWColormap), &xattr);

    if (!w) {

        SDL_SetError("Couldn't create window");

        return -1;

    }

#if SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2

    if ((window->flags & SDL_WINDOW_OPENGL) && (_this->gl_config.use_egl == 1)) {

        if (!_this->gles_data) {

            XDestroyWindow(display, w);

            return -1;

        }

        /* Create the GLES window surface */

        _this->gles_data->egl_surface =

            _this->gles_data->eglCreateWindowSurface(_this->gles_data->

                                                 egl_display,

                                                 _this->gles_data->egl_config,

                                                 (NativeWindowType) w, NULL);

        if (_this->gles_data->egl_surface == EGL_NO_SURFACE) {

            SDL_SetError("Could not create GLES window surface");

            XDestroyWindow(display, w);

            return -1;

        }

    }

#endif

    SetWindowBordered(display, screen, w,

                      (window->flags & SDL_WINDOW_BORDERLESS) == 0);

    sizehints = XAllocSizeHints();

    /* Setup the normal size hints */

    sizehints->flags = 0;

    if (!(window->flags & SDL_WINDOW_RESIZABLE)) {

        sizehints->min_width = sizehints->max_width = window->w;

        sizehints->min_height = sizehints->max_height = window->h;

        sizehints->flags |= (PMaxSize | PMinSize);

    }

    sizehints->x = window->x;

    sizehints->y = window->y;

    sizehints->flags |= USPosition;

    /* Setup the input hints so we get keyboard input */

    wmhints = XAllocWMHints();

    wmhints->input = True;

    wmhints->flags = InputHint;

    /* Setup the class hints so we can get an icon (AfterStep) */

    classhints = XAllocClassHint();

    classhints->res_name = data->classname;

    classhints->res_class = data->classname;

    /* Set the size, input and class hints, and define WM_CLIENT_MACHINE and WM_LOCALE_NAME */

    XSetWMProperties(display, w, NULL, NULL, NULL, 0, sizehints, wmhints, classhints);

    XFree(sizehints);

    XFree(wmhints);

    XFree(classhints);

    /* Set the PID related to the window for the given hostname, if possible */

    if (data->pid > 0) {

        _NET_WM_PID = XInternAtom(display, "_NET_WM_PID", False);