glfw/src/x11_window.c

1857 lines
58 KiB
C
Raw Normal View History

2010-09-07 15:34:51 +00:00
//========================================================================
// GLFW 3.1 X11 - www.glfw.org
2010-09-07 15:34:51 +00:00
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.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 "internal.h"
#include <sys/select.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
2013-01-21 18:57:03 +00:00
#include <limits.h>
2010-09-07 15:34:51 +00:00
// Action for EWMH client messages
#define _NET_WM_STATE_REMOVE 0
#define _NET_WM_STATE_ADD 1
#define _NET_WM_STATE_TOGGLE 2
// Additional mouse button names for XButtonEvent
#define Button6 6
#define Button7 7
typedef struct
{
2014-02-13 01:30:28 +00:00
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long input_mode;
unsigned long status;
} MotifWmHints;
#define MWM_HINTS_DECORATIONS (1L << 1)
2012-08-26 13:38:18 +00:00
2013-04-08 13:16:32 +00:00
// Returns whether the event is a selection event
//
static Bool isFrameExtentsEvent(Display* display, XEvent* event, XPointer pointer)
{
_GLFWwindow* window = (_GLFWwindow*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == window->x11.handle &&
event->xproperty.atom == _glfw.x11.NET_FRAME_EXTENTS;
}
// Translates an X event modifier state mask
//
2013-05-30 22:09:37 +00:00
static int translateState(int state)
{
int mods = 0;
if (state & ShiftMask)
mods |= GLFW_MOD_SHIFT;
if (state & ControlMask)
mods |= GLFW_MOD_CONTROL;
if (state & Mod1Mask)
mods |= GLFW_MOD_ALT;
if (state & Mod4Mask)
mods |= GLFW_MOD_SUPER;
return mods;
}
2010-09-07 15:34:51 +00:00
// Translates an X Window key to internal coding
2013-02-04 12:22:10 +00:00
//
2010-09-08 13:51:25 +00:00
static int translateKey(int keycode)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// Use the pre-filled LUT (see updateKeyCodeLUT() in x11_init.c)
2014-03-30 10:32:17 +00:00
if (keycode < 0 || keycode > 255)
return GLFW_KEY_UNKNOWN;
2013-05-30 15:19:12 +00:00
2014-03-30 10:32:17 +00:00
return _glfw.x11.keyCodeLUT[keycode];
2010-09-07 15:34:51 +00:00
}
2014-09-09 14:26:57 +00:00
// Return the GLFW window corresponding to the specified X11 window
//
static _GLFWwindow* findWindowByHandle(Window handle)
{
_GLFWwindow* window;
if (XFindContext(_glfw.x11.display,
handle,
_glfw.x11.context,
(XPointer*) &window) != 0)
{
return NULL;
}
return window;
}
2014-05-23 12:01:02 +00:00
// Adds or removes an EWMH state to a window
//
static void changeWindowState(_GLFWwindow* window, Atom state, int action)
{
XEvent event;
memset(&event, 0, sizeof(event));
event.type = ClientMessage;
event.xclient.window = window->x11.handle;
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11.NET_WM_STATE;
event.xclient.data.l[0] = action;
event.xclient.data.l[1] = state;
event.xclient.data.l[2] = 0; // No secondary property
event.xclient.data.l[3] = 1; // Sender is a normal application
XSendEvent(_glfw.x11.display,
_glfw.x11.root,
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
}
2014-04-07 11:38:54 +00:00
// Splits and translates a text/uri-list into separate file paths
2013-12-22 18:28:46 +00:00
//
2014-04-07 11:38:54 +00:00
static char** parseUriList(char* text, int* count)
2013-12-22 18:28:46 +00:00
{
const char* prefix = "file://";
char** names = NULL;
char* line;
*count = 0;
while ((line = strtok(text, "\r\n")))
{
text = NULL;
if (*line == '#')
continue;
if (strncmp(line, prefix, strlen(prefix)) == 0)
line += strlen(prefix);
(*count)++;
char* name = calloc(strlen(line) + 1, 1);
names = realloc(names, *count * sizeof(char*));
names[*count - 1] = name;
while (*line)
{
if (line[0] == '%' && line[1] && line[2])
{
const char digits[3] = { line[1], line[2], '\0' };
*name = strtol(digits, NULL, 16);
line += 2;
}
else
*name = *line;
name++;
line++;
}
}
return names;
}
2010-09-07 15:34:51 +00:00
// Create the X11 window (and its colormap)
2013-02-04 12:22:10 +00:00
//
2010-09-09 16:15:32 +00:00
static GLboolean createWindow(_GLFWwindow* window,
2010-09-08 13:58:43 +00:00
const _GLFWwndconfig* wndconfig)
2010-09-07 15:34:51 +00:00
{
unsigned long wamask;
XSetWindowAttributes wa;
XVisualInfo* visual = _GLFW_X11_CONTEXT_VISUAL;
2010-09-07 15:34:51 +00:00
// Every window needs a colormap
// Create one based on the visual used by the current context
2012-08-26 13:38:18 +00:00
// TODO: Decouple this from context creation
2010-09-07 15:34:51 +00:00
window->x11.colormap = XCreateColormap(_glfw.x11.display,
_glfw.x11.root,
visual->visual,
AllocNone);
2010-09-07 15:34:51 +00:00
// Create the actual window
{
wamask = CWBorderPixel | CWColormap | CWEventMask;
wa.colormap = window->x11.colormap;
2010-09-07 15:34:51 +00:00
wa.border_pixel = 0;
wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
2012-10-21 14:23:36 +00:00
PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
ExposureMask | FocusChangeMask | VisibilityChangeMask |
2013-01-21 18:57:03 +00:00
EnterWindowMask | LeaveWindowMask | PropertyChangeMask;
2010-09-07 15:34:51 +00:00
_glfwGrabXErrorHandler();
window->x11.handle = XCreateWindow(_glfw.x11.display,
_glfw.x11.root,
0, 0,
wndconfig->width, wndconfig->height,
2012-08-26 13:38:18 +00:00
0, // Border width
visual->depth, // Color depth
InputOutput,
visual->visual,
wamask,
&wa);
_glfwReleaseXErrorHandler();
if (!window->x11.handle)
{
_glfwInputXError(GLFW_PLATFORM_ERROR,
"X11: Failed to create window");
2010-09-07 15:34:51 +00:00
return GL_FALSE;
}
2013-04-08 13:16:32 +00:00
if (!wndconfig->decorated)
{
MotifWmHints hints;
hints.flags = MWM_HINTS_DECORATIONS;
hints.decorations = 0;
XChangeProperty(_glfw.x11.display, window->x11.handle,
2013-04-08 13:16:32 +00:00
_glfw.x11.MOTIF_WM_HINTS,
_glfw.x11.MOTIF_WM_HINTS, 32,
PropModeReplace,
(unsigned char*) &hints,
sizeof(MotifWmHints) / sizeof(long));
}
2013-04-15 00:16:51 +00:00
XSaveContext(_glfw.x11.display,
window->x11.handle,
_glfw.x11.context,
(XPointer) window);
2010-09-07 15:34:51 +00:00
}
if (window->monitor && !_glfw.x11.hasEWMH)
2010-09-07 15:34:51 +00:00
{
// This is the butcher's way of removing window decorations
// Setting the override-redirect attribute on a window makes the window
// manager ignore the window completely (ICCCM, section 4)
// The good thing is that this makes undecorated fullscreen windows
// easy to do; the bad thing is that we have to do everything manually
2012-08-26 13:38:18 +00:00
// and some things (like iconify/restore) won't work at all, as those
// are tasks usually performed by the window manager
2010-09-07 15:34:51 +00:00
XSetWindowAttributes attributes;
attributes.override_redirect = True;
XChangeWindowAttributes(_glfw.x11.display,
window->x11.handle,
2010-09-08 13:51:25 +00:00
CWOverrideRedirect,
&attributes);
2010-09-07 15:34:51 +00:00
window->x11.overrideRedirect = GL_TRUE;
2010-09-07 15:34:51 +00:00
}
2012-08-26 13:38:18 +00:00
// Declare the WM protocols supported by GLFW
2010-09-07 15:34:51 +00:00
{
int count = 0;
Atom protocols[2];
// The WM_DELETE_WINDOW ICCCM protocol
// Basic window close notification protocol
2013-11-20 19:04:00 +00:00
if (_glfw.x11.WM_DELETE_WINDOW)
protocols[count++] = _glfw.x11.WM_DELETE_WINDOW;
2010-09-07 15:34:51 +00:00
// The _NET_WM_PING EWMH protocol
2012-08-26 13:38:18 +00:00
// Tells the WM to ping the GLFW window and flag the application as
// unresponsive if the WM doesn't get a reply within a few seconds
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_PING)
protocols[count++] = _glfw.x11.NET_WM_PING;
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
if (count > 0)
2010-09-07 15:34:51 +00:00
{
XSetWMProtocols(_glfw.x11.display, window->x11.handle,
2010-09-08 13:51:25 +00:00
protocols, count);
2010-09-07 15:34:51 +00:00
}
}
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_PID)
2013-05-02 14:31:27 +00:00
{
const pid_t pid = getpid();
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_PID, XA_CARDINAL, 32,
PropModeReplace,
(unsigned char*) &pid, 1);
}
2010-09-07 15:34:51 +00:00
// Set ICCCM WM_HINTS property
{
2010-09-08 13:58:43 +00:00
XWMHints* hints = XAllocWMHints();
2010-09-08 13:51:25 +00:00
if (!hints)
{
_glfwInputError(GLFW_OUT_OF_MEMORY,
"X11: Failed to allocate WM hints");
2010-09-07 15:34:51 +00:00
return GL_FALSE;
}
2010-09-07 15:34:51 +00:00
hints->flags = StateHint;
hints->initial_state = NormalState;
XSetWMHints(_glfw.x11.display, window->x11.handle, hints);
2010-09-08 13:51:25 +00:00
XFree(hints);
2010-09-07 15:34:51 +00:00
}
// Set ICCCM WM_NORMAL_HINTS property (even if no parts are set)
{
2010-09-08 13:58:43 +00:00
XSizeHints* hints = XAllocSizeHints();
2010-09-07 15:34:51 +00:00
hints->flags = 0;
if (wndconfig->monitor)
{
hints->flags |= PPosition;
2013-02-20 15:00:53 +00:00
_glfwPlatformGetMonitorPos(wndconfig->monitor, &hints->x, &hints->y);
}
else
{
2013-11-10 12:56:27 +00:00
// HACK: Explicitly setting PPosition to any value causes some WMs,
// notably Compiz and Metacity, to honor the position of
// unmapped windows set by XMoveWindow
hints->flags |= PPosition;
hints->x = hints->y = 0;
}
if (!wndconfig->resizable)
2010-09-07 15:34:51 +00:00
{
hints->flags |= (PMinSize | PMaxSize);
hints->min_width = hints->max_width = wndconfig->width;
hints->min_height = hints->max_height = wndconfig->height;
2010-09-07 15:34:51 +00:00
}
XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
2010-09-08 13:51:25 +00:00
XFree(hints);
2010-09-07 15:34:51 +00:00
}
2013-10-04 11:41:19 +00:00
// Set ICCCM WM_CLASS property
// HACK: Until a mechanism for specifying the application name is added, the
2013-11-10 12:56:27 +00:00
// initial window title is used as the window class name
2013-10-04 11:41:19 +00:00
if (strlen(wndconfig->title))
{
XClassHint* hint = XAllocClassHint();
hint->res_name = (char*) wndconfig->title;
hint->res_class = (char*) wndconfig->title;
XSetClassHint(_glfw.x11.display, window->x11.handle, hint);
XFree(hint);
}
2013-04-14 14:33:20 +00:00
if (_glfw.x11.xi.available)
2013-04-04 14:48:58 +00:00
{
// Select for XInput2 events
XIEventMask eventmask;
unsigned char mask[] = { 0 };
eventmask.deviceid = 2;
eventmask.mask_len = sizeof(mask);
eventmask.mask = mask;
XISetMask(mask, XI_Motion);
XISelectEvents(_glfw.x11.display, window->x11.handle, &eventmask, 1);
}
2013-12-22 15:38:56 +00:00
if (_glfw.x11.XdndAware)
2013-07-10 09:42:14 +00:00
{
2014-01-22 00:34:44 +00:00
// Announce support for Xdnd (drag and drop)
2013-12-22 15:38:56 +00:00
const Atom version = 5;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.XdndAware, XA_ATOM, 32,
PropModeReplace, (unsigned char*) &version, 1);
2013-07-10 09:42:14 +00:00
}
if (_glfw.x11.NET_REQUEST_FRAME_EXTENTS)
{
// Ensure _NET_FRAME_EXTENTS is set, allowing glfwGetWindowFrameSize to
// function before the window is mapped
XEvent event;
memset(&event, 0, sizeof(event));
event.type = ClientMessage;
event.xclient.window = window->x11.handle;
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11.NET_REQUEST_FRAME_EXTENTS;
XSendEvent(_glfw.x11.display,
_glfw.x11.root,
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
XIfEvent(_glfw.x11.display, &event, isFrameExtentsEvent, (XPointer) window);
}
2014-05-23 12:01:02 +00:00
if (wndconfig->floating && !wndconfig->monitor)
{
if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_ABOVE)
{
changeWindowState(window,
_glfw.x11.NET_WM_STATE_ABOVE,
_NET_WM_STATE_ADD);
}
}
2010-09-14 01:10:45 +00:00
_glfwPlatformSetWindowTitle(window, wndconfig->title);
2010-09-07 15:34:51 +00:00
XRRSelectInput(_glfw.x11.display, window->x11.handle,
RRScreenChangeNotifyMask);
if (_glfw.x11.im)
{
window->x11.ic = XCreateIC(_glfw.x11.im,
XNInputStyle,
XIMPreeditNothing | XIMStatusNothing,
XNClientWindow,
window->x11.handle,
XNFocusWindow,
window->x11.handle,
NULL);
}
2013-06-16 16:29:46 +00:00
_glfwPlatformGetWindowPos(window, &window->x11.xpos, &window->x11.ypos);
_glfwPlatformGetWindowSize(window, &window->x11.width, &window->x11.height);
2010-09-07 15:34:51 +00:00
return GL_TRUE;
}
2014-01-15 12:21:13 +00:00
// Hide the mouse cursor
2013-02-04 12:22:10 +00:00
//
static void hideCursor(_GLFWwindow* window)
{
2014-01-15 12:21:13 +00:00
XUngrabPointer(_glfw.x11.display, CurrentTime);
XDefineCursor(_glfw.x11.display, window->x11.handle, _glfw.x11.cursor);
}
2014-01-15 12:21:13 +00:00
// Disable the mouse cursor
2013-02-04 12:22:10 +00:00
//
2014-01-15 12:21:13 +00:00
static void disableCursor(_GLFWwindow* window)
{
2014-01-15 12:21:13 +00:00
XGrabPointer(_glfw.x11.display, window->x11.handle, True,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync,
window->x11.handle, _glfw.x11.cursor, CurrentTime);
}
2014-01-15 12:21:13 +00:00
// Restores the mouse cursor
2013-02-04 12:22:10 +00:00
//
2014-01-15 12:21:13 +00:00
static void restoreCursor(_GLFWwindow* window)
{
2014-01-15 12:21:13 +00:00
XUngrabPointer(_glfw.x11.display, CurrentTime);
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_glfw.x11.display, window->x11.handle);
}
2014-09-09 14:26:57 +00:00
// Returns whether the event is a selection event
//
static Bool isSelectionEvent(Display* display, XEvent* event, XPointer pointer)
{
return event->type == SelectionRequest ||
event->type == SelectionNotify ||
event->type == SelectionClear;
}
// Set the specified property to the selection converted to the requested target
//
static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
{
int i;
const Atom formats[] = { _glfw.x11.UTF8_STRING,
_glfw.x11.COMPOUND_STRING,
XA_STRING };
const int formatCount = sizeof(formats) / sizeof(formats[0]);
if (request->property == None)
{
// The requestor is a legacy client (ICCCM section 2.2)
// We don't support legacy clients, so fail here
return None;
}
if (request->target == _glfw.x11.TARGETS)
{
// The list of supported targets was requested
const Atom targets[] = { _glfw.x11.TARGETS,
_glfw.x11.MULTIPLE,
_glfw.x11.UTF8_STRING,
_glfw.x11.COMPOUND_STRING,
XA_STRING };
XChangeProperty(_glfw.x11.display,
request->requestor,
request->property,
XA_ATOM,
32,
PropModeReplace,
(unsigned char*) targets,
sizeof(targets) / sizeof(targets[0]));
return request->property;
}
if (request->target == _glfw.x11.MULTIPLE)
{
// Multiple conversions were requested
Atom* targets;
unsigned long i, count;
count = _glfwGetWindowProperty(request->requestor,
request->property,
_glfw.x11.ATOM_PAIR,
(unsigned char**) &targets);
for (i = 0; i < count; i += 2)
{
int j;
for (j = 0; j < formatCount; j++)
{
if (targets[i] == formats[j])
break;
}
if (j < formatCount)
{
XChangeProperty(_glfw.x11.display,
request->requestor,
targets[i + 1],
targets[i],
8,
PropModeReplace,
(unsigned char*) _glfw.x11.clipboardString,
strlen(_glfw.x11.clipboardString));
}
else
targets[i + 1] = None;
}
XChangeProperty(_glfw.x11.display,
request->requestor,
request->property,
_glfw.x11.ATOM_PAIR,
32,
PropModeReplace,
(unsigned char*) targets,
count);
XFree(targets);
return request->property;
}
if (request->target == _glfw.x11.SAVE_TARGETS)
{
// The request is a check whether we support SAVE_TARGETS
// It should be handled as a no-op side effect target
XChangeProperty(_glfw.x11.display,
request->requestor,
request->property,
_glfw.x11._NULL,
32,
PropModeReplace,
NULL,
0);
return request->property;
}
// Conversion to a data target was requested
for (i = 0; i < formatCount; i++)
{
if (request->target == formats[i])
{
// The requested target is one we support
XChangeProperty(_glfw.x11.display,
request->requestor,
request->property,
request->target,
8,
PropModeReplace,
(unsigned char*) _glfw.x11.clipboardString,
strlen(_glfw.x11.clipboardString));
return request->property;
}
}
// The requested target is not supported
return None;
}
static void handleSelectionClear(XEvent* event)
{
free(_glfw.x11.clipboardString);
_glfw.x11.clipboardString = NULL;
}
static void handleSelectionRequest(XEvent* event)
{
const XSelectionRequestEvent* request = &event->xselectionrequest;
XEvent response;
memset(&response, 0, sizeof(response));
response.xselection.property = writeTargetToProperty(request);
response.xselection.type = SelectionNotify;
response.xselection.display = request->display;
response.xselection.requestor = request->requestor;
response.xselection.selection = request->selection;
response.xselection.target = request->target;
response.xselection.time = request->time;
XSendEvent(_glfw.x11.display, request->requestor, False, 0, &response);
}
static void pushSelectionToManager(_GLFWwindow* window)
{
XConvertSelection(_glfw.x11.display,
_glfw.x11.CLIPBOARD_MANAGER,
_glfw.x11.SAVE_TARGETS,
None,
window->x11.handle,
CurrentTime);
for (;;)
{
XEvent event;
if (!XCheckIfEvent(_glfw.x11.display, &event, isSelectionEvent, NULL))
continue;
switch (event.type)
{
case SelectionRequest:
handleSelectionRequest(&event);
break;
case SelectionClear:
handleSelectionClear(&event);
break;
case SelectionNotify:
{
if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
{
// This means one of two things; either the selection was
// not owned, which means there is no clipboard manager, or
// the transfer to the clipboard manager has completed
// In either case, it means we are done here
return;
}
break;
}
}
}
}
2010-09-07 15:34:51 +00:00
// Enter fullscreen mode
2013-02-04 12:22:10 +00:00
//
2010-09-09 16:15:32 +00:00
static void enterFullscreenMode(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
if (_glfw.x11.saver.count == 0)
2010-09-07 15:34:51 +00:00
{
// Remember old screen saver settings
XGetScreenSaver(_glfw.x11.display,
&_glfw.x11.saver.timeout,
&_glfw.x11.saver.interval,
&_glfw.x11.saver.blanking,
&_glfw.x11.saver.exposure);
2010-09-07 15:34:51 +00:00
// Disable screen saver
XSetScreenSaver(_glfw.x11.display, 0, 0, DontPreferBlanking,
2010-09-08 13:51:25 +00:00
DefaultExposures);
2010-09-07 15:34:51 +00:00
}
_glfw.x11.saver.count++;
_glfwSetVideoMode(window->monitor, &window->videoMode);
2010-09-07 15:34:51 +00:00
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_BYPASS_COMPOSITOR)
{
const unsigned long value = 1;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
PropModeReplace, (unsigned char*) &value, 1);
}
if (_glfw.x11.xinerama.available && _glfw.x11.NET_WM_FULLSCREEN_MONITORS)
{
XEvent event;
memset(&event, 0, sizeof(event));
event.type = ClientMessage;
event.xclient.window = window->x11.handle;
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11.NET_WM_FULLSCREEN_MONITORS;
event.xclient.data.l[0] = window->monitor->x11.index;
event.xclient.data.l[1] = window->monitor->x11.index;
event.xclient.data.l[2] = window->monitor->x11.index;
event.xclient.data.l[3] = window->monitor->x11.index;
XSendEvent(_glfw.x11.display,
_glfw.x11.root,
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
}
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
2010-09-07 15:34:51 +00:00
{
int x, y;
_glfwPlatformGetMonitorPos(window->monitor, &x, &y);
_glfwPlatformSetWindowPos(window, x, y);
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_ACTIVE_WINDOW)
2010-09-07 15:34:51 +00:00
{
// Ask the window manager to raise and focus the GLFW window
// Only focused windows with the _NET_WM_STATE_FULLSCREEN state end
// up on top of all other windows ("Stacking order" in EWMH spec)
XEvent event;
2010-09-08 13:51:25 +00:00
memset(&event, 0, sizeof(event));
2010-09-07 15:34:51 +00:00
event.type = ClientMessage;
event.xclient.window = window->x11.handle;
2010-09-07 15:34:51 +00:00
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11.NET_ACTIVE_WINDOW;
2010-09-07 15:34:51 +00:00
event.xclient.data.l[0] = 1; // Sender is a normal application
event.xclient.data.l[1] = 0; // We don't really know the timestamp
XSendEvent(_glfw.x11.display,
_glfw.x11.root,
2010-09-08 13:51:25 +00:00
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
2010-09-07 15:34:51 +00:00
}
// Ask the window manager to make the GLFW window a fullscreen window
// Fullscreen windows are undecorated and, when focused, are kept
// on top of all other windows
2014-05-23 12:01:02 +00:00
changeWindowState(window,
_glfw.x11.NET_WM_STATE_FULLSCREEN,
_NET_WM_STATE_ADD);
2010-09-07 15:34:51 +00:00
}
else if (window->x11.overrideRedirect)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// In override-redirect mode we have divorced ourselves from the
2010-09-07 15:34:51 +00:00
// window manager, so we need to do everything manually
GLFWvidmode mode;
_glfwPlatformGetVideoMode(window->monitor, &mode);
XRaiseWindow(_glfw.x11.display, window->x11.handle);
XSetInputFocus(_glfw.x11.display, window->x11.handle,
RevertToParent, CurrentTime);
XMoveWindow(_glfw.x11.display, window->x11.handle, 0, 0);
XResizeWindow(_glfw.x11.display, window->x11.handle,
mode.width, mode.height);
2010-09-07 15:34:51 +00:00
}
}
// Leave fullscreen mode
2013-02-04 12:22:10 +00:00
//
2010-09-09 16:15:32 +00:00
static void leaveFullscreenMode(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
_glfwRestoreVideoMode(window->monitor);
2010-09-07 15:34:51 +00:00
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
2010-09-07 15:34:51 +00:00
{
// Restore old screen saver settings
XSetScreenSaver(_glfw.x11.display,
_glfw.x11.saver.timeout,
_glfw.x11.saver.interval,
_glfw.x11.saver.blanking,
_glfw.x11.saver.exposure);
2010-09-07 15:34:51 +00:00
}
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_BYPASS_COMPOSITOR)
{
const unsigned long value = 0;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
PropModeReplace, (unsigned char*) &value, 1);
}
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
2010-09-07 15:34:51 +00:00
{
// Ask the window manager to make the GLFW window a normal window
// Normal windows usually have frames and other decorations
2014-05-23 12:01:02 +00:00
changeWindowState(window,
_glfw.x11.NET_WM_STATE_FULLSCREEN,
_NET_WM_STATE_REMOVE);
2010-09-07 15:34:51 +00:00
}
}
2012-08-12 14:21:06 +00:00
// Process the specified X event
2013-02-04 12:22:10 +00:00
//
2012-08-12 14:04:03 +00:00
static void processEvent(XEvent *event)
2010-09-07 15:34:51 +00:00
{
_GLFWwindow* window = NULL;
if (event->type != GenericEvent)
{
2014-09-09 14:26:57 +00:00
window = findWindowByHandle(event->xany.window);
if (window == NULL)
{
2013-06-19 11:49:51 +00:00
// This is an event for a window that has already been destroyed
return;
}
}
2010-09-09 16:15:32 +00:00
switch (event->type)
2010-09-07 15:34:51 +00:00
{
case KeyPress:
{
const int key = translateKey(event->xkey.keycode);
const int mods = translateState(event->xkey.state);
const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
if (event->xkey.keycode)
_glfwInputKey(window, key, event->xkey.keycode, GLFW_PRESS, mods);
if (window->x11.ic)
{
// Translate keys to characters with XIM input context
int i;
Status status;
wchar_t buffer[16];
if (XFilterEvent(event, None))
{
// Discard intermediary (dead key) events for character input
break;
}
const int count = XwcLookupString(window->x11.ic,
&event->xkey,
buffer, sizeof(buffer),
NULL, &status);
for (i = 0; i < count; i++)
_glfwInputChar(window, buffer[i], mods, plain);
}
else
{
// Translate keys to characters with fallback lookup table
KeySym keysym;
XLookupString(&event->xkey, NULL, 0, &keysym, NULL);
const long character = _glfwKeySym2Unicode(keysym);
if (character != -1)
_glfwInputChar(window, character, mods, plain);
}
2010-09-07 15:34:51 +00:00
break;
}
case KeyRelease:
{
const int key = translateKey(event->xkey.keycode);
const int mods = translateState(event->xkey.state);
2014-05-18 10:24:29 +00:00
if (!_glfw.x11.xkb.detectable)
{
// HACK: Key repeat events will arrive as KeyRelease/KeyPress
// pairs with similar or identical time stamps
// The key repeat logic in _glfwInputKey expectes only key
// presses to repeat, so detect and discard release events
2014-05-18 10:24:29 +00:00
if (XEventsQueued(_glfw.x11.display, QueuedAfterReading))
{
XEvent nextEvent;
XPeekEvent(_glfw.x11.display, &nextEvent);
if (nextEvent.type == KeyPress &&
nextEvent.xkey.window == event->xkey.window &&
nextEvent.xkey.keycode == event->xkey.keycode)
{
// HACK: Repeat events sometimes leak through due to
// some sort of time drift, so add an epsilon
// Toshiyuki Takahashi can press a button 16 times
// per second so it's fairly safe to assume that
// no human is pressing the key 50 times per
// second (value is ms)
2014-05-18 10:24:29 +00:00
if ((nextEvent.xkey.time - event->xkey.time) < 20)
{
// This is very likely a server-generated key repeat
// event, so ignore it
2014-05-18 10:24:29 +00:00
break;
}
}
}
}
2013-05-30 15:19:12 +00:00
_glfwInputKey(window, key, event->xkey.keycode, GLFW_RELEASE, mods);
2010-09-07 15:34:51 +00:00
break;
}
case ButtonPress:
{
const int mods = translateState(event->xbutton.state);
if (event->xbutton.button == Button1)
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, mods);
else if (event->xbutton.button == Button2)
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS, mods);
else if (event->xbutton.button == Button3)
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS, mods);
2010-09-07 15:34:51 +00:00
2013-01-12 20:11:41 +00:00
// Modern X provides scroll events as mouse button presses
else if (event->xbutton.button == Button4)
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 0.0, 1.0);
else if (event->xbutton.button == Button5)
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 0.0, -1.0);
else if (event->xbutton.button == Button6)
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 1.0, 0.0);
else if (event->xbutton.button == Button7)
_glfwInputScroll(window, -1.0, 0.0);
2013-09-08 14:08:15 +00:00
else
{
// Additional buttons after 7 are treated as regular buttons
// We subtract 4 to fill the gap left by scroll input above
_glfwInputMouseClick(window,
event->xbutton.button - 4,
GLFW_PRESS,
mods);
}
2010-09-07 15:34:51 +00:00
break;
}
case ButtonRelease:
{
const int mods = translateState(event->xbutton.state);
if (event->xbutton.button == Button1)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_LEFT,
GLFW_RELEASE,
mods);
2010-09-07 15:34:51 +00:00
}
else if (event->xbutton.button == Button2)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_MIDDLE,
GLFW_RELEASE,
mods);
2010-09-07 15:34:51 +00:00
}
else if (event->xbutton.button == Button3)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_RIGHT,
GLFW_RELEASE,
mods);
2010-09-07 15:34:51 +00:00
}
2013-09-08 14:08:15 +00:00
else if (event->xbutton.button > Button7)
{
// Additional buttons after 7 are treated as regular buttons
// We subtract 4 to fill the gap left by scroll input above
_glfwInputMouseClick(window,
event->xbutton.button - 4,
GLFW_RELEASE,
mods);
}
2010-09-07 15:34:51 +00:00
break;
}
case EnterNotify:
{
2012-01-30 21:59:38 +00:00
_glfwInputCursorEnter(window, GL_TRUE);
break;
}
case LeaveNotify:
{
2012-01-30 21:59:38 +00:00
_glfwInputCursorEnter(window, GL_FALSE);
break;
}
2010-09-07 15:34:51 +00:00
case MotionNotify:
{
2013-04-30 13:50:01 +00:00
if (event->xmotion.x != window->x11.warpPosX ||
event->xmotion.y != window->x11.warpPosY)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// The cursor was moved by something other than GLFW
int x, y;
2010-09-07 15:34:51 +00:00
if (window->cursorMode == GLFW_CURSOR_DISABLED)
2010-09-07 15:34:51 +00:00
{
if (_glfw.focusedWindow != window)
break;
x = event->xmotion.x - window->x11.cursorPosX;
y = event->xmotion.y - window->x11.cursorPosY;
2010-09-07 15:34:51 +00:00
}
else
{
x = event->xmotion.x;
y = event->xmotion.y;
2010-09-07 15:34:51 +00:00
}
_glfwInputCursorMotion(window, x, y);
2010-09-07 15:34:51 +00:00
}
2013-04-30 13:50:01 +00:00
window->x11.cursorPosX = event->xmotion.x;
window->x11.cursorPosY = event->xmotion.y;
2010-09-07 15:34:51 +00:00
break;
}
case ConfigureNotify:
{
2013-06-16 16:29:46 +00:00
if (event->xconfigure.width != window->x11.width ||
event->xconfigure.height != window->x11.height)
{
_glfwInputFramebufferSize(window,
event->xconfigure.width,
event->xconfigure.height);
2013-06-16 16:29:46 +00:00
_glfwInputWindowSize(window,
event->xconfigure.width,
event->xconfigure.height);
window->x11.width = event->xconfigure.width;
window->x11.height = event->xconfigure.height;
}
2010-09-07 15:34:51 +00:00
2013-06-16 16:29:46 +00:00
if (event->xconfigure.x != window->x11.xpos ||
event->xconfigure.y != window->x11.ypos)
{
_glfwInputWindowPos(window,
event->xconfigure.x,
event->xconfigure.y);
window->x11.xpos = event->xconfigure.x;
window->x11.ypos = event->xconfigure.y;
}
2010-09-14 01:53:22 +00:00
2010-09-07 15:34:51 +00:00
break;
}
case ClientMessage:
{
2010-09-09 22:06:23 +00:00
// Custom client message, probably from the window manager
if (event->xclient.message_type == None)
break;
2010-09-07 15:34:51 +00:00
if (event->xclient.message_type == _glfw.x11.WM_PROTOCOLS)
2010-09-07 15:34:51 +00:00
{
if (_glfw.x11.WM_DELETE_WINDOW &&
(Atom) event->xclient.data.l[0] == _glfw.x11.WM_DELETE_WINDOW)
{
// The window manager was asked to close the window, for example by
// the user pressing a 'close' window decoration button
_glfwInputWindowCloseRequest(window);
}
else if (_glfw.x11.NET_WM_PING &&
(Atom) event->xclient.data.l[0] == _glfw.x11.NET_WM_PING)
{
// The window manager is pinging the application to ensure it's
// still responding to events
event->xclient.window = _glfw.x11.root;
XSendEvent(_glfw.x11.display,
event->xclient.window,
False,
SubstructureNotifyMask | SubstructureRedirectMask,
event);
}
2013-07-10 09:42:14 +00:00
}
2013-12-22 15:38:56 +00:00
else if (event->xclient.message_type == _glfw.x11.XdndEnter)
2013-07-10 09:42:14 +00:00
{
2014-01-22 00:34:44 +00:00
// A drag operation has entered the window
// TODO: Check if UTF-8 string is supported by the source
2013-07-10 09:42:14 +00:00
}
2013-12-22 15:38:56 +00:00
else if (event->xclient.message_type == _glfw.x11.XdndDrop)
2013-07-10 09:42:14 +00:00
{
2014-01-22 00:34:44 +00:00
// The drag operation has finished dropping on
// the window, ask to convert it to a UTF-8 string
_glfw.x11.xdnd.source = event->xclient.data.l[0];
2013-12-22 15:38:56 +00:00
XConvertSelection(_glfw.x11.display,
_glfw.x11.XdndSelection,
_glfw.x11.UTF8_STRING,
_glfw.x11.XdndSelection,
window->x11.handle, CurrentTime);
2013-07-10 09:42:14 +00:00
}
2013-12-22 15:38:56 +00:00
else if (event->xclient.message_type == _glfw.x11.XdndPosition)
2013-07-10 09:42:14 +00:00
{
2014-01-22 00:34:44 +00:00
// The drag operation has moved over the window
2013-12-22 15:38:56 +00:00
const int absX = (event->xclient.data.l[2] >> 16) & 0xFFFF;
const int absY = (event->xclient.data.l[2]) & 0xFFFF;
int x, y;
_glfwPlatformGetWindowPos(window, &x, &y);
_glfwInputCursorMotion(window, absX - x, absY - y);
2014-01-22 00:34:44 +00:00
// Reply that we are ready to copy the dragged data
2013-12-22 15:38:56 +00:00
XEvent reply;
2013-12-22 15:40:06 +00:00
memset(&reply, 0, sizeof(reply));
2013-12-22 15:38:56 +00:00
reply.type = ClientMessage;
reply.xclient.window = event->xclient.data.l[0];
reply.xclient.message_type = _glfw.x11.XdndStatus;
reply.xclient.format = 32;
reply.xclient.data.l[0] = window->x11.handle;
reply.xclient.data.l[1] = 1; // Always accept the dnd with no rectangle
reply.xclient.data.l[2] = 0; // Specify an empty rectangle
reply.xclient.data.l[3] = 0;
2014-01-22 00:34:44 +00:00
reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy;
2013-12-22 15:38:56 +00:00
XSendEvent(_glfw.x11.display, event->xclient.data.l[0],
2013-12-22 15:38:56 +00:00
False, NoEventMask, &reply);
XFlush(_glfw.x11.display);
2010-09-07 15:34:51 +00:00
}
break;
}
2013-12-22 15:38:56 +00:00
2013-07-10 09:42:14 +00:00
case SelectionNotify:
2013-12-22 15:38:56 +00:00
{
2013-12-22 18:28:46 +00:00
if (event->xselection.property)
2013-12-22 15:38:56 +00:00
{
2014-01-22 00:34:44 +00:00
// The converted data from the drag operation has arrived
2013-12-22 15:38:56 +00:00
char* data;
2014-03-10 12:55:23 +00:00
const int result =
_glfwGetWindowProperty(event->xselection.requestor,
event->xselection.property,
event->xselection.target,
(unsigned char**) &data);
2013-12-22 15:38:56 +00:00
if (result)
{
2013-12-22 18:28:46 +00:00
int i, count;
2014-04-07 11:38:54 +00:00
char** names = parseUriList(data, &count);
2013-12-22 18:28:46 +00:00
_glfwInputDrop(window, count, (const char**) names);
for (i = 0; i < count; i++)
free(names[i]);
free(names);
2013-12-22 15:38:56 +00:00
}
2013-12-22 18:28:46 +00:00
XFree(data);
2013-12-22 15:38:56 +00:00
XEvent reply;
2013-12-22 15:40:06 +00:00
memset(&reply, 0, sizeof(reply));
2013-12-22 15:38:56 +00:00
reply.type = ClientMessage;
2014-01-22 00:34:44 +00:00
reply.xclient.window = _glfw.x11.xdnd.source;
2013-12-22 15:38:56 +00:00
reply.xclient.message_type = _glfw.x11.XdndFinished;
reply.xclient.format = 32;
reply.xclient.data.l[0] = window->x11.handle;
reply.xclient.data.l[1] = result;
2014-01-22 00:34:44 +00:00
reply.xclient.data.l[2] = _glfw.x11.XdndActionCopy;
2013-12-22 15:38:56 +00:00
// Reply that all is well
2014-01-22 00:34:44 +00:00
XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
2013-12-22 15:38:56 +00:00
False, NoEventMask, &reply);
2013-12-22 18:28:46 +00:00
XFlush(_glfw.x11.display);
2013-12-22 15:38:56 +00:00
}
break;
}
2010-09-07 15:34:51 +00:00
case MapNotify:
{
_glfwInputWindowVisibility(window, GL_TRUE);
2010-09-07 15:34:51 +00:00
break;
}
case UnmapNotify:
{
_glfwInputWindowVisibility(window, GL_FALSE);
2010-09-07 15:34:51 +00:00
break;
}
case FocusIn:
{
if (event->xfocus.mode == NotifyNormal)
{
_glfwInputWindowFocus(window, GL_TRUE);
2010-09-07 15:34:51 +00:00
if (window->cursorMode == GLFW_CURSOR_DISABLED)
disableCursor(window);
}
2010-09-07 15:34:51 +00:00
break;
}
case FocusOut:
{
if (event->xfocus.mode == NotifyNormal)
{
_glfwInputWindowFocus(window, GL_FALSE);
2010-09-07 15:34:51 +00:00
if (window->cursorMode == GLFW_CURSOR_DISABLED)
restoreCursor(window);
}
2010-09-07 15:34:51 +00:00
break;
}
case Expose:
{
_glfwInputWindowDamage(window);
2010-09-07 15:34:51 +00:00
break;
}
2013-01-21 18:57:03 +00:00
case PropertyNotify:
{
if (event->xproperty.atom == _glfw.x11.WM_STATE &&
event->xproperty.state == PropertyNewValue)
{
struct {
CARD32 state;
Window icon;
} *state = NULL;
if (_glfwGetWindowProperty(window->x11.handle,
_glfw.x11.WM_STATE,
_glfw.x11.WM_STATE,
(unsigned char**) &state) >= 2)
{
if (state->state == IconicState)
_glfwInputWindowIconify(window, GL_TRUE);
else if (state->state == NormalState)
_glfwInputWindowIconify(window, GL_FALSE);
}
XFree(state);
}
break;
}
case SelectionClear:
{
2014-09-09 14:26:57 +00:00
handleSelectionClear(event);
break;
}
case SelectionRequest:
{
2014-09-09 14:26:57 +00:00
handleSelectionRequest(event);
break;
}
2010-09-07 15:34:51 +00:00
case DestroyNotify:
2010-09-09 22:06:23 +00:00
return;
2010-09-07 15:34:51 +00:00
2013-04-04 14:48:58 +00:00
case GenericEvent:
{
2013-04-14 14:33:20 +00:00
if (event->xcookie.extension == _glfw.x11.xi.majorOpcode &&
2013-04-04 14:48:58 +00:00
XGetEventData(_glfw.x11.display, &event->xcookie))
{
if (event->xcookie.evtype == XI_Motion)
{
XIDeviceEvent* data = (XIDeviceEvent*) event->xcookie.data;
2014-09-09 14:26:57 +00:00
window = findWindowByHandle(data->event);
2013-04-04 14:48:58 +00:00
if (window)
{
2013-04-30 13:50:01 +00:00
if (data->event_x != window->x11.warpPosX ||
data->event_y != window->x11.warpPosY)
2013-04-04 14:48:58 +00:00
{
// The cursor was moved by something other than GLFW
double x, y;
if (window->cursorMode == GLFW_CURSOR_DISABLED)
2013-04-04 14:48:58 +00:00
{
if (_glfw.focusedWindow != window)
break;
x = data->event_x - window->x11.cursorPosX;
y = data->event_y - window->x11.cursorPosY;
}
else
{
x = data->event_x;
y = data->event_y;
}
_glfwInputCursorMotion(window, x, y);
}
2013-04-30 13:50:01 +00:00
window->x11.cursorPosX = data->event_x;
window->x11.cursorPosY = data->event_y;
2013-04-04 14:48:58 +00:00
}
}
}
XFreeEventData(_glfw.x11.display, &event->xcookie);
break;
}
2010-09-07 15:34:51 +00:00
default:
{
switch (event->type - _glfw.x11.randr.eventBase)
2010-09-07 15:34:51 +00:00
{
case RRScreenChangeNotify:
{
XRRUpdateConfiguration(event);
2010-09-07 15:34:51 +00:00
break;
}
}
2010-09-07 15:34:51 +00:00
break;
}
}
}
2013-01-21 18:57:03 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
// Retrieve a single window property of the specified type
// Inspired by fghGetWindowProperty from freeglut
2013-02-04 12:22:10 +00:00
//
2013-01-21 18:57:03 +00:00
unsigned long _glfwGetWindowProperty(Window window,
Atom property,
Atom type,
unsigned char** value)
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetWindowProperty(_glfw.x11.display,
window,
property,
0,
LONG_MAX,
False,
type,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
value);
2013-07-10 09:42:14 +00:00
if (type != AnyPropertyType && actualType != type)
2013-01-21 18:57:03 +00:00
return 0;
return itemCount;
}
2010-09-15 14:44:43 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
2010-09-07 15:34:51 +00:00
int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
2010-09-07 15:34:51 +00:00
{
if (!_glfwCreateContext(window, ctxconfig, fbconfig))
2010-09-07 15:34:51 +00:00
return GL_FALSE;
if (!createWindow(window, wndconfig))
2010-09-07 15:34:51 +00:00
return GL_FALSE;
2012-09-27 19:37:36 +00:00
if (wndconfig->monitor)
{
2012-09-23 13:08:43 +00:00
_glfwPlatformShowWindow(window);
2010-09-09 16:15:32 +00:00
enterFullscreenMode(window);
2010-09-07 15:34:51 +00:00
}
return GL_TRUE;
}
void _glfwPlatformDestroyWindow(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
2012-09-27 19:37:36 +00:00
if (window->monitor)
2010-09-09 16:15:32 +00:00
leaveFullscreenMode(window);
if (window->x11.ic)
{
XDestroyIC(window->x11.ic);
window->x11.ic = NULL;
}
2010-09-07 15:34:51 +00:00
_glfwDestroyContext(window);
2010-09-07 15:34:51 +00:00
if (window->x11.handle)
2010-09-07 15:34:51 +00:00
{
2013-04-29 18:54:42 +00:00
if (window->x11.handle ==
XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD))
{
2014-09-09 14:26:57 +00:00
pushSelectionToManager(window);
2013-04-29 18:54:42 +00:00
}
2013-04-29 11:16:56 +00:00
2013-04-15 00:16:51 +00:00
XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context);
XUnmapWindow(_glfw.x11.display, window->x11.handle);
XDestroyWindow(_glfw.x11.display, window->x11.handle);
window->x11.handle = (Window) 0;
2010-09-07 15:34:51 +00:00
}
if (window->x11.colormap)
2010-09-07 15:34:51 +00:00
{
XFreeColormap(_glfw.x11.display, window->x11.colormap);
window->x11.colormap = (Colormap) 0;
2010-09-07 15:34:51 +00:00
}
XFlush(_glfw.x11.display);
2010-09-07 15:34:51 +00:00
}
2010-09-09 16:15:32 +00:00
void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
2010-09-07 15:34:51 +00:00
{
#if defined(X_HAVE_UTF8_STRING)
Xutf8SetWMProperties(_glfw.x11.display,
window->x11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
#else
// This may be a slightly better fallback than using XStoreName and
// XSetIconName, which always store their arguments using STRING
XmbSetWMProperties(_glfw.x11.display,
window->x11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
#endif
2012-02-01 13:43:42 +00:00
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_NAME)
2012-01-31 23:10:17 +00:00
{
XChangeProperty(_glfw.x11.display, window->x11.handle,
2013-01-29 01:45:08 +00:00
_glfw.x11.NET_WM_NAME, _glfw.x11.UTF8_STRING, 8,
2012-02-01 13:43:42 +00:00
PropModeReplace,
(unsigned char*) title, strlen(title));
2012-01-31 23:10:17 +00:00
}
2012-02-02 16:20:14 +00:00
2013-11-20 19:04:00 +00:00
if (_glfw.x11.NET_WM_ICON_NAME)
2012-02-02 16:20:14 +00:00
{
XChangeProperty(_glfw.x11.display, window->x11.handle,
2013-01-29 01:45:08 +00:00
_glfw.x11.NET_WM_ICON_NAME, _glfw.x11.UTF8_STRING, 8,
2012-02-02 16:20:14 +00:00
PropModeReplace,
(unsigned char*) title, strlen(title));
}
2014-04-07 11:36:25 +00:00
XFlush(_glfw.x11.display);
2010-09-07 15:34:51 +00:00
}
void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
{
Window child;
int x, y;
XTranslateCoordinates(_glfw.x11.display, window->x11.handle, _glfw.x11.root,
0, 0, &x, &y, &child);
2013-11-20 19:04:00 +00:00
if (child)
{
int left, top;
XTranslateCoordinates(_glfw.x11.display, window->x11.handle, child,
0, 0, &left, &top, &child);
x -= left;
y -= top;
}
if (xpos)
*xpos = x;
if (ypos)
*ypos = y;
}
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
{
XMoveWindow(_glfw.x11.display, window->x11.handle, xpos, ypos);
XFlush(_glfw.x11.display);
}
void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
2010-09-07 15:34:51 +00:00
{
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
if (width)
*width = attribs.width;
if (height)
*height = attribs.height;
}
2010-09-07 15:34:51 +00:00
void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
{
2012-09-27 19:37:36 +00:00
if (window->monitor)
2010-09-07 15:34:51 +00:00
{
_glfwSetVideoMode(window->monitor, &window->videoMode);
if (window->x11.overrideRedirect)
2012-09-27 19:37:36 +00:00
{
GLFWvidmode mode;
_glfwPlatformGetVideoMode(window->monitor, &mode);
XResizeWindow(_glfw.x11.display, window->x11.handle,
mode.width, mode.height);
2012-09-27 19:37:36 +00:00
}
2010-09-07 15:34:51 +00:00
}
else
2013-06-19 11:46:18 +00:00
{
if (!window->resizable)
{
// Update window size restrictions to match new window size
XSizeHints* hints = XAllocSizeHints();
hints->flags |= (PMinSize | PMaxSize);
hints->min_width = hints->max_width = width;
hints->min_height = hints->max_height = height;
XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
XFree(hints);
}
XResizeWindow(_glfw.x11.display, window->x11.handle, width, height);
2013-06-19 11:46:18 +00:00
}
XFlush(_glfw.x11.display);
2010-09-07 15:34:51 +00:00
}
void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height)
{
_glfwPlatformGetWindowSize(window, width, height);
}
2014-03-25 20:30:13 +00:00
void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
int* left, int* top,
int* right, int* bottom)
{
long* extents = NULL;
if (_glfw.x11.NET_FRAME_EXTENTS == None)
return;
if (_glfwGetWindowProperty(window->x11.handle,
_glfw.x11.NET_FRAME_EXTENTS,
XA_CARDINAL,
(unsigned char**) &extents) == 4)
{
if (left)
*left = extents[0];
if (top)
*top = extents[2];
if (right)
*right = extents[1];
if (bottom)
*bottom = extents[3];
}
if (extents)
XFree(extents);
}
2010-09-09 16:15:32 +00:00
void _glfwPlatformIconifyWindow(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
if (window->x11.overrideRedirect)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Iconification of full screen windows requires "
"a WM that supports EWMH");
2010-09-07 15:34:51 +00:00
return;
}
XIconifyWindow(_glfw.x11.display, window->x11.handle, _glfw.x11.screen);
2014-04-07 11:36:25 +00:00
XFlush(_glfw.x11.display);
2010-09-07 15:34:51 +00:00
}
2010-09-09 16:15:32 +00:00
void _glfwPlatformRestoreWindow(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
if (window->x11.overrideRedirect)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Iconification of full screen windows requires "
"a WM that supports EWMH");
2010-09-07 15:34:51 +00:00
return;
}
XMapWindow(_glfw.x11.display, window->x11.handle);
2014-04-07 11:36:25 +00:00
XFlush(_glfw.x11.display);
2010-09-07 15:34:51 +00:00
}
void _glfwPlatformShowWindow(_GLFWwindow* window)
{
XMapRaised(_glfw.x11.display, window->x11.handle);
XFlush(_glfw.x11.display);
}
void _glfwPlatformUnhideWindow(_GLFWwindow* window)
{
XMapWindow(_glfw.x11.display, window->x11.handle);
XFlush(_glfw.x11.display);
}
void _glfwPlatformHideWindow(_GLFWwindow* window)
{
XUnmapWindow(_glfw.x11.display, window->x11.handle);
XFlush(_glfw.x11.display);
}
2010-09-08 13:51:25 +00:00
void _glfwPlatformPollEvents(void)
2010-09-07 15:34:51 +00:00
{
int count = XPending(_glfw.x11.display);
while (count--)
2012-08-12 14:04:03 +00:00
{
XEvent event;
XNextEvent(_glfw.x11.display, &event);
2012-08-12 14:04:03 +00:00
processEvent(&event);
}
2010-09-07 15:34:51 +00:00
2013-08-06 18:46:26 +00:00
_GLFWwindow* window = _glfw.focusedWindow;
if (window && window->cursorMode == GLFW_CURSOR_DISABLED)
2010-09-07 15:34:51 +00:00
{
2013-08-06 18:46:26 +00:00
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
_glfwPlatformSetCursorPos(window, width / 2, height / 2);
2010-09-07 15:34:51 +00:00
}
}
2010-09-08 13:51:25 +00:00
void _glfwPlatformWaitEvents(void)
2010-09-07 15:34:51 +00:00
{
if (!XPending(_glfw.x11.display))
{
fd_set fds;
2013-12-08 23:27:36 +00:00
const int fd = ConnectionNumber(_glfw.x11.display);
2010-09-07 15:34:51 +00:00
FD_ZERO(&fds);
FD_SET(fd, &fds);
// select(1) is used instead of an X function like XNextEvent, as the
// wait inside those are guarded by the mutex protecting the display
// struct, locking out other threads from using X (including GLX)
if (select(fd + 1, &fds, NULL, NULL, NULL) < 0)
return;
}
2010-09-07 15:34:51 +00:00
_glfwPlatformPollEvents();
2010-09-07 15:34:51 +00:00
}
2014-02-10 17:16:58 +00:00
void _glfwPlatformPostEmptyEvent(void)
{
XEvent event;
_GLFWwindow* window = _glfw.windowListHead;
memset(&event, 0, sizeof(event));
event.type = ClientMessage;
event.xclient.window = window->x11.handle;
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11._NULL;
XSendEvent(_glfw.x11.display, window->x11.handle, False, 0, &event);
XFlush(_glfw.x11.display);
}
2013-04-04 14:16:21 +00:00
void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// Store the new position so it can be recognized later
2013-04-30 13:50:01 +00:00
window->x11.warpPosX = (int) x;
window->x11.warpPosY = (int) y;
2010-09-07 15:34:51 +00:00
2013-04-04 14:16:21 +00:00
XWarpPointer(_glfw.x11.display, None, window->x11.handle,
0,0,0,0, (int) x, (int) y);
2010-09-07 15:34:51 +00:00
}
2014-01-15 12:21:13 +00:00
void _glfwPlatformApplyCursorMode(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
2014-01-15 12:21:13 +00:00
switch (window->cursorMode)
2010-09-07 15:34:51 +00:00
{
case GLFW_CURSOR_NORMAL:
2014-01-15 12:21:13 +00:00
restoreCursor(window);
break;
case GLFW_CURSOR_HIDDEN:
hideCursor(window);
break;
case GLFW_CURSOR_DISABLED:
2014-01-15 12:21:13 +00:00
disableCursor(window);
break;
2010-09-07 15:34:51 +00:00
}
}
2014-02-23 15:43:17 +00:00
int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
const GLFWimage* image,
int xhot, int yhot)
{
2014-06-22 11:13:53 +00:00
cursor->x11.handle = _glfwCreateCursor(image, xhot, yhot);
if (cursor->x11.handle == None)
return GL_FALSE;
return GL_TRUE;
}
void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
{
2014-01-23 14:24:57 +00:00
if (cursor->x11.handle)
XFreeCursor(_glfw.x11.display, cursor->x11.handle);
}
void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
{
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
if (cursor)
XDefineCursor(_glfw.x11.display, window->x11.handle, cursor->x11.handle);
else
XUndefineCursor(_glfw.x11.display, window->x11.handle);
XFlush(_glfw.x11.display);
}
}
2014-09-09 14:26:57 +00:00
void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
{
free(_glfw.x11.clipboardString);
_glfw.x11.clipboardString = strdup(string);
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.CLIPBOARD,
window->x11.handle, CurrentTime);
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) !=
window->x11.handle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to become owner of the clipboard selection");
}
}
const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
{
size_t i;
const Atom formats[] = { _glfw.x11.UTF8_STRING,
_glfw.x11.COMPOUND_STRING,
XA_STRING };
const size_t formatCount = sizeof(formats) / sizeof(formats[0]);
if (findWindowByHandle(XGetSelectionOwner(_glfw.x11.display,
_glfw.x11.CLIPBOARD)))
{
// Instead of doing a large number of X round-trips just to put this
// string into a window property and then read it back, just return it
return _glfw.x11.clipboardString;
}
free(_glfw.x11.clipboardString);
_glfw.x11.clipboardString = NULL;
for (i = 0; i < formatCount; i++)
{
char* data;
XEvent event;
XConvertSelection(_glfw.x11.display,
_glfw.x11.CLIPBOARD,
formats[i],
_glfw.x11.GLFW_SELECTION,
window->x11.handle, CurrentTime);
// XCheckTypedEvent is used instead of XIfEvent in order not to lock
// other threads out from the display during the entire wait period
while (!XCheckTypedEvent(_glfw.x11.display, SelectionNotify, &event))
;
if (event.xselection.property == None)
continue;
if (_glfwGetWindowProperty(event.xselection.requestor,
event.xselection.property,
event.xselection.target,
(unsigned char**) &data))
{
_glfw.x11.clipboardString = strdup(data);
}
XFree(data);
XDeleteProperty(_glfw.x11.display,
event.xselection.requestor,
event.xselection.property);
if (_glfw.x11.clipboardString)
break;
}
if (_glfw.x11.clipboardString == NULL)
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"X11: Failed to convert selection to string");
}
return _glfw.x11.clipboardString;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
GLFWAPI Display* glfwGetX11Display(void)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
return _glfw.x11.display;
}
GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
return window->x11.handle;
}