/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2010 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_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_x11gamma.h"

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

#ifdef SDL_VIDEO_DRIVER_PANDORA

#include "SDL_x11opengles.h"

#endif

#include "SDL_timer.h"

#include "SDL_syswm.h"

#define _NET_WM_STATE_REMOVE    0l

#define _NET_WM_STATE_ADD       1l

#define _NET_WM_STATE_TOGGLE    2l

static SDL_bool

X11_IsWindowOldFullscreen(_THIS, SDL_Window * window)

{

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

    /* ICCCM2.0-compliant window managers can handle fullscreen windows */

    if ((window->flags & SDL_WINDOW_FULLSCREEN) && !videodata->net_wm) {

        return SDL_TRUE;

    } else {

        return SDL_FALSE;

    }

}

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 void

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

{

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

    SDL_DisplayData *displaydata =

        (SDL_DisplayData *) window->display->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;

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

        }

    }

    {

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

        }

    }

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

}

int

X11_CreateWindow(_THIS, SDL_Window * window)

{

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

    SDL_DisplayData *displaydata =

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

    Display *display = data->display;

    int screen = displaydata->screen;

    Visual *visual;

    int depth;

    XSetWindowAttributes xattr;

    int x, y;

    Window w;

    XSizeHints *sizehints;

    XWMHints *wmhints;

    XClassHint *classhints;

    SDL_bool oldstyle_fullscreen;

    Atom _NET_WM_WINDOW_TYPE;

    Atom _NET_WM_WINDOW_TYPE_NORMAL;

    int wmstate_count;

    Atom wmstate_atoms[3];

    /* ICCCM2.0-compliant window managers can handle fullscreen windows */

    oldstyle_fullscreen = X11_IsWindowOldFullscreen(_this, window);

#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, display, screen);

        if (!vinfo) {

            return -1;

        }

        visual = vinfo->visual;

        depth = vinfo->depth;

        XFree(vinfo);

    } else

#endif

#ifdef SDL_VIDEO_DRIVER_PANDORA

    if (window->flags & SDL_WINDOW_OPENGL) {

        XVisualInfo *vinfo;

        vinfo = X11_GLES_GetVisual(_this, display, screen);

        if (!vinfo) {

            return -1;

        }

        visual = vinfo->visual;

        depth = vinfo->depth;

        XFree(vinfo);

    } else

#endif

    {

        visual = displaydata->visual;

        depth = displaydata->depth;

    }

    if (oldstyle_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; */

        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(display, 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(display, RootWindow(display, 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(display, colormap, colorcells, ncolors); */

            xattr.colormap = colormap;

            X11_TrackColormap(display, screen, colormap, visual, NULL);

            SDL_free(colorcells);

        }

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

        Status status;

        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(display, 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(display, RootWindow(display, 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); */