/*

    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"

#include "SDL_syswm.h"

#include "../SDL_sysvideo.h"

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

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

#include "SDL_x11video.h"

#include "SDL_x11mouse.h"

#include "SDL_x11gamma.h"

#include "../Xext/extensions/StdCmap.h"

#define _NET_WM_STATE_REMOVE    0l

#define _NET_WM_STATE_ADD       1l

#define _NET_WM_STATE_TOGGLE    2l

static void

X11_GetDisplaySize(_THIS, SDL_Window * window, int *w, int *h)

{

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

    SDL_DisplayData *displaydata =

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

    XWindowAttributes attr;

    XGetWindowAttributes(data->display, RootWindow(data->display,

                                                   displaydata->screen),

                         &attr);

    if (w) {

        *w = attr.width;

    }

    if (h) {

        *h = attr.height;

    }

}

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;

    int index;

    /* Allocate the window data */

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

    if (!data) {

        SDL_OutOfMemory();

        return -1;

    }

    data->windowID = window->id;

    data->window = 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;

        }

    }

    {

        Atom _NET_WM_STATE =

            XInternAtom(data->videodata->display, "_NET_WM_STATE", False);

        Atom _NET_WM_STATE_MAXIMIZED_VERT =

            XInternAtom(data->videodata->display,

                        "_NET_WM_STATE_MAXIMIZED_VERT", False);

        Atom _NET_WM_STATE_MAXIMIZED_HORZ =

            XInternAtom(data->videodata->display,

                        "_NET_WM_STATE_MAXIMIZED_HORZ", False);

        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;

            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;

                }

                /* Might also want to check the following properties:

                   _NET_WM_STATE_ABOVE, _NET_WM_STATE_FULLSCREEN

                 */

            }

            if (maximized == 3) {

                window->flags |= SDL_WINDOW_MAXIMIZED;

            }

            XFree(propertyValue);

        }

    }

    /* 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_MAXIMIZE) {

       window->flags |= SDL_WINDOW_MAXIMIZED;

       } else {

       window->flags &= ~SDL_WINDOW_MAXIMIZED;

       }

       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->windowID);

       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;

}

int

X11_CreateWindow(_THIS, SDL_Window * window)

{

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

    SDL_DisplayData *displaydata =

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

    Visual *visual;

    int depth;

    XSetWindowAttributes xattr;

    int x, y;

    Window w;

    XSizeHints *sizehints;

    XWMHints *wmhints;

    XClassHint *classhints;

#if SDL_VIDEO_DRIVER_X11_XINERAMA

/* FIXME

    if ( use_xinerama ) {

        x = xinerama_info.x_org;

        y = xinerama_info.y_org;

    }

*/

#endif

#ifdef SDL_VIDEO_OPENGL_GLX

    if (window->flags & SDL_WINDOW_OPENGL) {

        XVisualInfo *vinfo;

        vinfo = X11_GL_GetVisual(_this, data->display, displaydata->screen);

        if (!vinfo) {

            return -1;

        }

        visual = vinfo->visual;

        depth = vinfo->depth;

        XFree(vinfo);

    } else

#endif

    {

        visual = displaydata->visual;

        depth = displaydata->depth;

    }

    if (window->flags & SDL_WINDOW_FULLSCREEN) {

        xattr.override_redirect = True;

    } else {

        xattr.override_redirect = False;

    }

    xattr.background_pixel = 0;

    xattr.border_pixel = 0;

    if (visual->class == PseudoColor) {

        printf("asking for PseudoColor\n");

        Status status;

        XStandardColormap cmap;

        XColor *colorcells;

        Colormap colormap;

        Sint32 pix;

        Sint32 ncolors;

        Sint32 nbits;

        Sint32 rmax, gmax, bmax;

        Sint32 rwidth, gwidth, bwidth;

        Sint32 rmask, gmask, bmask;

        Sint32 rshift, gshift, bshift;

        Sint32 r, g, b;

        /* Is the colormap we need already registered in SDL? */

        if (colormap =

            X11_LookupColormap(data->display,

                               displaydata->screen, visual->visualid)) {

            xattr.colormap = colormap;

/*             printf("found existing colormap\n"); */

        } else {

            /* The colormap is not known to SDL so we will create it */

            colormap = XCreateColormap(data->display,

                                       RootWindow(data->display,

                                                  displaydata->screen),

                                       visual, AllocAll);

/*             printf("colormap = %x\n", colormap); */

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

            if (!colormap) {

                SDL_SetError

                    ("Couldn't create window: 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 (NULL == colorcells) {

                SDL_SetError("out of memory in X11_CreateWindow");

                return -1;

            }

            ncolors = visual->map_entries;

            nbits = visual->bits_per_rgb;

/* 	    printf("ncolors = %d nbits = %d\n", ncolors, nbits); */

            /* what if ncolors != (1 << nbits)? That can happen on a

               true PseudoColor display.  I'm assuming that we will

               always have ncolors == (1 << nbits) */

            /* I'm making a lot of assumptions here. */

            /* Compute the width of each field. If there is one extra

               bit, give it to green. If there are two extra bits give

               them to red and greed.  We can get extra bits when the

               number of bits per pixel is not a multiple of 3. For

               example when we have 16 bits per pixel and need a 5/6/5

               layout for the RGB fields */

            rwidth = (nbits / 3) + (((nbits % 3) == 2) ? 1 : 0);

            gwidth = (nbits / 3) + (((nbits % 3) >= 1) ? 1 : 0);

            bwidth = (nbits / 3);

            rshift = gwidth + bwidth;

            gshift = bwidth;

            bshift = 0;

            rmax = 1 << rwidth;

            gmax = 1 << gwidth;

            bmax = 1 << bwidth;

            rmask = rmax - 1;

            gmask = gmax - 1;

            bmask = bmax - 1;

/*             printf("red   mask = %4x shift = %4d width = %d\n", rmask, rshift, rwidth); */

/*             printf("green mask = %4x shift = %4d width = %d\n", gmask, gshift, gwidth); */

/*             printf("blue  mask = %4x shift = %4d width = %d\n", bmask, bshift, bwidth); */

            /* build the color table pixel values */

            pix = 0;

            for (r = 0; r < rmax; r++) {

                for (g = 0; g < gmax; g++) {

                    for (b = 0; b < bmax; b++) {

                        colorcells[pix].pixel =

                            (r << rshift) | (g << gshift) | (b << bshift);

                        colorcells[pix].red = (0xffff * r) / rmask;

                        colorcells[pix].green = (0xffff * g) / gmask;

                        colorcells[pix].blue = (0xffff * b) / bmask;

/* 		  printf("%4x:%4x [%4x %4x %4x]\n",  */

/* 			 pix,  */

/* 			 colorcells[pix].pixel, */

/* 			 colorcells[pix].red, */

/* 			 colorcells[pix].green, */

/* 			 colorcells[pix].blue); */

                        pix++;

                    }

                }

            }

/*             status = */

/*                 XStoreColors(data->display, colormap, colorcells, ncolors); */

            xattr.colormap = colormap;

            X11_TrackColormap(data->display, displaydata->screen,

                              colormap, visual, NULL);

            SDL_free(colorcells);

        }

    } else if (visual->class == DirectColor) {

        Status status;

        XStandardColormap cmap;

        XColor *colorcells;

        Colormap colormap;

        int i;

        int ncolors;

        int rmax, gmax, bmax;

        int rmask, gmask, bmask;

        int rshift, gshift, bshift;

        /* Is the colormap we need already registered in SDL? */

        if (colormap =

            X11_LookupColormap(data->display,

                               displaydata->screen, visual->visualid)) {

            xattr.colormap = colormap;

/*             printf("found existing colormap\n"); */

        } else {

            /* The colormap is not known to SDL so we will create it */

            colormap = XCreateColormap(data->display,

                                       RootWindow(data->display,

                                                  displaydata->screen),

                                       visual, AllocAll);

/*             printf("colormap = %x\n", colormap); */

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

            if (!colormap) {

                SDL_SetError

                    ("Couldn't create window: 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 (NULL == colorcells) {

                SDL_SetError("out of memory in X11_CreateWindow");

                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;

            }

/*             printf("rmask = %4x rshift = %4d\n", rmask, rshift); */

            gshift = 0;

            gmask = visual->green_mask;

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

                gshift++;

                gmask >>= 1;

            }

/*             printf("gmask = %4x gshift = %4d\n", gmask, gshift); */

            bshift = 0;

            bmask = visual->blue_mask;

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

                bshift++;

                bmask >>= 1;

            }

/*             printf("bmask = %4x bshift = %4d\n", bmask, bshift); */

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

/* 		printf("%2d:%4x [%4x %4x %4x]\n", i, pix, red, green, blue); */

            }

            status =

                XStoreColors(data->display, colormap, colorcells, ncolors);

            xattr.colormap = colormap;

            X11_TrackColormap(data->display, displaydata->screen,

                              colormap, visual, colorcells);

            SDL_free(colorcells);

        }

    } else {

        xattr.colormap =

            XCreateColormap(data->display,

                            RootWindow(data->display, displaydata->screen),

                            visual, AllocNone);

    }

    if ((window->flags & SDL_WINDOW_FULLSCREEN)

        || window->x == SDL_WINDOWPOS_CENTERED) {

        X11_GetDisplaySize(_this, window, &x, NULL);

        x = (x - window->w) / 2;