/*

SDL - Simple DirectMedia Layer

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_x11video.h"

#ifdef SDL_VIDEO_DRIVER_PANDORA

#include "SDL_x11opengles.h"

#endif

#include "SDL_syswm.h"

#define _NET_WM_STATE_REMOVE 0l

#define _NET_WM_STATE_ADD 1l

#define _NET_WM_STATE_TOGGLE 2l

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

XWindowAttributes attr;

XGetWindowAttributes(data->display, RootWindow(data->display, displaydata->screen), &attr);

if (window->flags & SDL_WINDOW_FULLSCREEN) {

/* The bounds when this window is visible is the fullscreen mode */

SDL_DisplayMode fullscreen_mode;

if (SDL_GetWindowDisplayMode(window, &fullscreen_mode) == 0) {

attr.width = fullscreen_mode.w;

attr.height = fullscreen_mode.h;

}

}

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;

SDL_WindowData **windowlist = videodata->windowlist;

/* Allocate the window 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++;

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;

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;

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 =

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;

int wmstate_count;

Atom wmstate_atoms[3];

#if SDL_VIDEO_DRIVER_X11_XINERAMA

/* FIXME

if ( use_xinerama ) {

x = xinerama_info.x_org;

y = xinerama_info.y_org;

}

*/

#endif

XVisualInfo *vinfo;

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;

if (!vinfo) {

return -1;

}

visual = vinfo->visual;

depth = vinfo->depth;

XFree(vinfo);

} else

#endif

{

visual = displaydata->visual;

depth = displaydata->depth;

}

xattr.background_pixel = 0;

xattr.border_pixel = 0;

if (visual->class == DirectColor) {

Status status;

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_DRIVER_PANDORA

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

return -1;

}

#endif

sizehints = XAllocSizeHints();

if (sizehints) {

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

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

sizehints->x = window->x;

sizehints->y = window->y;

sizehints->flags |= USPosition;

XFree(sizehints);

}

SDL_bool set;

Atom WM_HINTS;

/* We haven't modified the window manager hints yet */

set = SDL_FALSE;

/* First try to set MWM hints */

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, 0, 0, 0};

set = SDL_TRUE;

}

/* Now try to set KWM hints */

if (WM_HINTS != None) {

long KWMHints = 0;

PropModeReplace,

(unsigned char *) &KWMHints,

set = SDL_TRUE;

}

/* Now try to set GNOME hints */

if (WM_HINTS != None) {

long GNOMEHints = 0;

PropModeReplace,

(unsigned char *) &GNOMEHints,

set = SDL_TRUE;

}

/* Finally set the transient hints if necessary */

if (!set) {

}

} else {

SDL_bool set;

Atom WM_HINTS;

/* We haven't modified the window manager hints yet */

set = SDL_FALSE;

/* First try to unset MWM hints */

set = SDL_TRUE;

}

/* Now try to unset KWM hints */

set = SDL_TRUE;

}

/* Now try to unset GNOME hints */

set = SDL_TRUE;

}

/* Finally unset the transient hints if necessary */

if (!set) {

}

}

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

wmhints = XAllocWMHints();

if (wmhints) {

wmhints->input = True;

XFree(wmhints);

}

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

classhints = XAllocClassHint();

if (classhints != NULL) {

classhints->res_name = data->classname;

classhints->res_class = data->classname;

XFree(classhints);

}

/* Set the window manager state */

wmstate_count = X11_GetWMStateProperty(_this, window, wmstate_atoms);

if (wmstate_count > 0) {

XChangeProperty(display, w, data->_NET_WM_STATE, XA_ATOM, 32,

PropModeReplace,

(unsigned char *)wmstate_atoms, wmstate_count);

} else {

XDeleteProperty(display, w, data->_NET_WM_STATE);

}

/* Let the window manager know we're a "normal" window */

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

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

XChangeProperty(display, w, _NET_WM_WINDOW_TYPE, XA_ATOM, 32,

PropModeReplace,

(unsigned char *)&_NET_WM_WINDOW_TYPE_NORMAL, 1);

if (SetupWindowData(_this, window, w, SDL_TRUE) < 0) {

return -1;

}

#ifdef X_HAVE_UTF8_STRING

{

Uint32 fevent = 0;

pXGetICValues(((SDL_WindowData *) window->driverdata)->ic,

XNFilterEvents, &fevent, NULL);

(FocusChangeMask | EnterWindowMask | LeaveWindowMask |

ExposureMask | ButtonPressMask | ButtonReleaseMask |

PointerMotionMask | KeyPressMask | KeyReleaseMask |

PropertyChangeMask | StructureNotifyMask |

KeymapStateMask | fevent));

}

#else

(FocusChangeMask | EnterWindowMask | LeaveWindowMask |

ExposureMask | ButtonPressMask | ButtonReleaseMask |

PointerMotionMask | KeyPressMask | KeyReleaseMask |

PropertyChangeMask | StructureNotifyMask |

KeymapStateMask));

#endif

XFlush(display);

return 0;

}

int

{

Window w = (Window) data;

if (SetupWindowData(_this, window, w, SDL_FALSE) < 0) {

return -1;

}

return 0;

}

char *

X11_GetWindowTitle(_THIS, Window xwindow)

{

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

Display *display = data->display;

int status, real_format;

Atom real_type;

unsigned long items_read, items_left;

unsigned char *propdata;

char *title = NULL;

status = XGetWindowProperty(display, xwindow, data->_NET_WM_NAME,

0L, 8192L, False, data->UTF8_STRING, &real_type, &real_format,

&items_read, &items_left, &propdata);

if (status == Success) {

title = SDL_strdup(SDL_static_cast(char*, propdata));

XFree(propdata);

} else {

status = XGetWindowProperty(display, xwindow, XA_WM_NAME,

0L, 8192L, False, XA_STRING, &real_type, &real_format,

&items_read, &items_left, &propdata);

if (status == Success) {

title = SDL_iconv_string("UTF-8", "", SDL_static_cast(char*, propdata), items_read+1);

} else {

title = SDL_strdup("");

}

}

return title;

}

void

X11_SetWindowTitle(_THIS, SDL_Window * window)

{

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

Display *display = data->videodata->display;

XTextProperty titleprop, iconprop;

Status status;

const char *title = window->title;

const char *icon = NULL;

#ifdef X_HAVE_UTF8_STRING

Atom _NET_WM_NAME = data->videodata->_NET_WM_NAME;

Atom _NET_WM_ICON_NAME = data->videodata->_NET_WM_ICON_NAME;

#endif

if (title != NULL) {

char *title_locale = SDL_iconv_utf8_locale(title);

if (!title_locale) {

SDL_OutOfMemory();

return;

}

status = XStringListToTextProperty(&title_locale, 1, &titleprop);

SDL_free(title_locale);

XFree(titleprop.value);

}

#ifdef X_HAVE_UTF8_STRING

if (SDL_X11_HAVE_UTF8) {

status =

Xutf8TextListToTextProperty(display, (char **) &title, 1,

XUTF8StringStyle, &titleprop);

if (status == Success) {

_NET_WM_NAME);

XFree(titleprop.value);

}

}

#endif

}

if (icon != NULL) {

char *icon_locale = SDL_iconv_utf8_locale(icon);

if (!icon_locale) {

SDL_OutOfMemory();

return;

}

status = XStringListToTextProperty(&icon_locale, 1, &iconprop);

SDL_free(icon_locale);

XA_WM_ICON_NAME);

XFree(iconprop.value);

}

#ifdef X_HAVE_UTF8_STRING

if (SDL_X11_HAVE_UTF8) {

status =

Xutf8TextListToTextProperty(display, (char **) &icon, 1,

XUTF8StringStyle, &iconprop);

if (status == Success) {

_NET_WM_ICON_NAME);

XFree(iconprop.value);

}

}

#endif

}

}

void

X11_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)

{

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

Display *display = data->videodata->display;

if (icon) {

SDL_PixelFormat format;

SDL_Surface *surface;

int propsize;

/* Convert the icon to ARGB for modern window managers */

surface = SDL_ConvertSurface(icon, &format, 0);

if (!surface) {

return;

}

/* Set the _NET_WM_ICON property */

int x, y;

Uint32 *src;

long *dst;

propdata[0] = icon->w;

propdata[1] = icon->h;

dst = &propdata[2];

for (y = 0; y < icon->h; ++y) {

src = (Uint32*)((Uint8*)surface->pixels + y * surface->pitch);

for (x = 0; x < icon->w; ++x) {

*dst++ = *src++;

}

}

32, PropModeReplace, (unsigned char *) propdata,

propsize);

}

SDL_FreeSurface(surface);

} else {

}

void

X11_SetWindowPosition(_THIS, SDL_Window * window)

{

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

Display *display = data->videodata->display;

}

void

X11_SetWindowSize(_THIS, SDL_Window * window)

{

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

Display *display = data->videodata->display;