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);
}
// Check whether the running window manager is EWMH-compliant
//
static void detectEWMH(void)
{
Window* windowFromRoot = NULL;
Window* windowFromChild = NULL;
// First we need a couple of atoms, which should already be there
Atom supportingWmCheck =
XInternAtom(_glfw.x11.display, "_NET_SUPPORTING_WM_CHECK", True);
Atom wmSupported =
XInternAtom(_glfw.x11.display, "_NET_SUPPORTED", True);
if (supportingWmCheck == None || wmSupported == None)
return;
// Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window
if (_glfwGetWindowProperty(_glfw.x11.root,
supportingWmCheck,
XA_WINDOW,
(unsigned char**) &windowFromRoot) != 1)
{
if (windowFromRoot)
XFree(windowFromRoot);
return;
}
_glfwGrabXErrorHandler();
// It should be the ID of a child window (of the root)
// Then we look for the same property on the child window
if (_glfwGetWindowProperty(*windowFromRoot,
supportingWmCheck,
XA_WINDOW,
(unsigned char**) &windowFromChild) != 1)
{
XFree(windowFromRoot);
if (windowFromChild)
XFree(windowFromChild);
return;
}
_glfwReleaseXErrorHandler();
// It should be the ID of that same child window
if (*windowFromRoot != *windowFromChild)
{
XFree(windowFromRoot);
XFree(windowFromChild);
return;
}
XFree(windowFromRoot);
XFree(windowFromChild);
// We are now fairly sure that an EWMH-compliant window manager is running
Atom* supportedAtoms;
unsigned long atomCount;
// Now we need to check the _NET_SUPPORTED property of the root window
// It should be a list of supported WM protocol and state atoms
atomCount = _glfwGetWindowProperty(_glfw.x11.root,
wmSupported,
XA_ATOM,
(unsigned char**) &supportedAtoms);
// See which of the atoms we support that are supported by the WM
_glfw.x11.NET_WM_STATE =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE");
_glfw.x11.NET_WM_STATE_ABOVE =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_ABOVE");
_glfw.x11.NET_WM_STATE_FULLSCREEN =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_FULLSCREEN");
_glfw.x11.NET_WM_FULLSCREEN_MONITORS =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_FULLSCREEN_MONITORS");
_glfw.x11.NET_WM_NAME =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_NAME");
_glfw.x11.NET_WM_ICON_NAME =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_ICON_NAME");
_glfw.x11.NET_WM_PID =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PID");
_glfw.x11.NET_WM_PING =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PING");
_glfw.x11.NET_ACTIVE_WINDOW =
getSupportedAtom(supportedAtoms, atomCount, "_NET_ACTIVE_WINDOW");
_glfw.x11.NET_FRAME_EXTENTS =
getSupportedAtom(supportedAtoms, atomCount, "_NET_FRAME_EXTENTS");
_glfw.x11.NET_REQUEST_FRAME_EXTENTS =
getSupportedAtom(supportedAtoms, atomCount, "_NET_REQUEST_FRAME_EXTENTS");
_glfw.x11.NET_WM_BYPASS_COMPOSITOR =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_BYPASS_COMPOSITOR");
XFree(supportedAtoms);
}
// Process the specified X event
//
static void processEvent(XEvent *event)
{
_GLFWwindow* window = NULL;
if (event->type != GenericEvent)
{
window = _glfwFindWindowByHandle(event->xany.window);
if (window == NULL)
{
// This is either an event for a destroyed GLFW window or an event
// of a type not currently supported by GLFW
return;
}
}
switch (event->type)
{
case KeyPress:
{
_glfwInputKey(window, translateKey(event->xkey.keycode), GLFW_PRESS);
if (!(event->xkey.state & ControlMask) &&
!(event->xkey.state & Mod1Mask /*Alt*/))
{
_glfwInputChar(window, translateChar(&event->xkey));
}
break;
}
case KeyRelease:
{
_glfwInputKey(window, translateKey(event->xkey.keycode), GLFW_RELEASE);
break;
}
case ButtonPress:
{
if (event->xbutton.button == Button1)
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS);
else if (event->xbutton.button == Button2)
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS);
else if (event->xbutton.button == Button3)
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS);
// Modern X provides scroll events as mouse button presses
else if (event->xbutton.button == Button4)
_glfwInputScroll(window, 0.0, 1.0);
else if (event->xbutton.button == Button5)
_glfwInputScroll(window, 0.0, -1.0);
else if (event->xbutton.button == Button6)
_glfwInputScroll(window, -1.0, 0.0);
else if (event->xbutton.button == Button7)
_glfwInputScroll(window, 1.0, 0.0);
break;
}
case ButtonRelease:
{
if (event->xbutton.button == Button1)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_LEFT,
GLFW_RELEASE);
}
else if (event->xbutton.button == Button2)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_MIDDLE,
GLFW_RELEASE);
}
else if (event->xbutton.button == Button3)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_RIGHT,
GLFW_RELEASE);
}
break;
}
case EnterNotify:
{
if (window->cursorMode == GLFW_CURSOR_HIDDEN)
hideCursor(window);
_glfwInputCursorEnter(window, GL_TRUE);
break;
}
case LeaveNotify:
{
if (window->cursorMode == GLFW_CURSOR_HIDDEN)
showCursor(window);
_glfwInputCursorEnter(window, GL_FALSE);
break;
}
case MotionNotify:
{
if (event->xmotion.x != window->x11.cursorPosX ||
event->xmotion.y != window->x11.cursorPosY)
{
// The cursor was moved by something other than GLFW
int x, y;
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
{
if (_glfw.focusedWindow != window)
break;
x = event->xmotion.x - window->x11.cursorPosX;
y = event->xmotion.y - window->x11.cursorPosY;
}
else
{
x = event->xmotion.x;
y = event->xmotion.y;
}
window->x11.cursorPosX = event->xmotion.x;
window->x11.cursorPosY = event->xmotion.y;
window->x11.cursorCentered = GL_FALSE;
_glfwInputCursorMotion(window, x, y);
}
break;
}
case ConfigureNotify:
{
_glfwInputWindowSize(window,
event->xconfigure.width,
event->xconfigure.height);
_glfwInputWindowPos(window,
event->xconfigure.x,
event->xconfigure.y);
break;
}
case ClientMessage:
{
// Custom client message, probably from the window manager
if ((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 != None &&
(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);
}
break;
}
case MapNotify:
{
_glfwInputWindowVisibility(window, GL_TRUE);
break;
}
case UnmapNotify:
{
_glfwInputWindowVisibility(window, GL_FALSE);
break;
}
case FocusIn:
{
_glfwInputWindowFocus(window, GL_TRUE);
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
captureCursor(window);
break;
}
case FocusOut:
{
_glfwInputWindowFocus(window, GL_FALSE);
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
showCursor(window);
break;
}
case Expose:
{
_glfwInputWindowDamage(window);
break;
}
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:
{
// The ownership of the clipboard selection was lost
free(_glfw.x11.selection.string);
_glfw.x11.selection.string = NULL;
break;
}
case SelectionRequest:
{
// The contents of the clipboard selection was requested
XSelectionRequestEvent* request = &event->xselectionrequest;
XEvent response;
memset(&response, 0, sizeof(response));
response.xselection.property = _glfwWriteSelection(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);
break;
}
case DestroyNotify:
return;
case GenericEvent:
{
if (event->xcookie.extension == _glfw.x11.xi2.majorOpcode &&
XGetEventData(_glfw.x11.display, &event->xcookie))
{
if (event->xcookie.evtype == XI_Motion)
{
XIDeviceEvent* data = (XIDeviceEvent*) event->xcookie.data;
window = _glfwFindWindowByHandle(data->event);
if (window)
{
if (data->event_x != window->x11.cursorPosX ||
data->event_y != window->x11.cursorPosY)
{
// The cursor was moved by something other than GLFW
double x, y;
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
{
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;
}
window->x11.cursorPosX = data->event_x;
window->x11.cursorPosY = data->event_y;
window->x11.cursorCentered = GL_FALSE;
_glfwInputCursorMotion(window, x, y);
}
}
}
}
XFreeEventData(_glfw.x11.display, &event->xcookie);
break;
}
default:
{
switch (event->type - _glfw.x11.randr.eventBase)
{
case RRScreenChangeNotify:
{
XRRUpdateConfiguration(event);
break;
}
}
break;
}
}
}
// Process the specified X event
//
static void processEvent(XEvent *event)
{
_GLFWwindow* window = NULL;
if (event->type != GenericEvent)
{
window = _glfwFindWindowByHandle(event->xany.window);
if (window == NULL)
{
// This is an event for a window that has already been destroyed
return;
}
}
switch (event->type)
{
case KeyPress:
{
const int key = translateKey(event->xkey.keycode);
const int mods = translateState(event->xkey.state);
const int character = translateChar(&event->xkey);
_glfwInputKey(window, key, event->xkey.keycode, GLFW_PRESS, mods);
if (character != -1)
_glfwInputChar(window, character);
break;
}
case KeyRelease:
{
const int key = translateKey(event->xkey.keycode);
const int mods = translateState(event->xkey.state);
_glfwInputKey(window, key, event->xkey.keycode, GLFW_RELEASE, mods);
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);
// Modern X provides scroll events as mouse button presses
else if (event->xbutton.button == Button4)
_glfwInputScroll(window, 0.0, 1.0);
else if (event->xbutton.button == Button5)
_glfwInputScroll(window, 0.0, -1.0);
else if (event->xbutton.button == Button6)
_glfwInputScroll(window, -1.0, 0.0);
else if (event->xbutton.button == Button7)
_glfwInputScroll(window, 1.0, 0.0);
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);
}
break;
}
case ButtonRelease:
{
const int mods = translateState(event->xbutton.state);
if (event->xbutton.button == Button1)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_LEFT,
GLFW_RELEASE,
mods);
}
else if (event->xbutton.button == Button2)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_MIDDLE,
GLFW_RELEASE,
mods);
}
else if (event->xbutton.button == Button3)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_RIGHT,
GLFW_RELEASE,
mods);
}
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);
}
break;
}
case EnterNotify:
{
_glfwInputCursorEnter(window, GL_TRUE);
break;
}
case LeaveNotify:
{
_glfwInputCursorEnter(window, GL_FALSE);
break;
}
case MotionNotify:
{
if (event->xmotion.x != window->x11.warpPosX ||
event->xmotion.y != window->x11.warpPosY)
{
// The cursor was moved by something other than GLFW
int x, y;
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
if (_glfw.focusedWindow != window)
break;
x = event->xmotion.x - window->x11.cursorPosX;
y = event->xmotion.y - window->x11.cursorPosY;
}
else
{
x = event->xmotion.x;
y = event->xmotion.y;
}
_glfwInputCursorMotion(window, x, y);
}
window->x11.cursorPosX = event->xmotion.x;
window->x11.cursorPosY = event->xmotion.y;
break;
}
case ConfigureNotify:
{
if (event->xconfigure.width != window->x11.width ||
event->xconfigure.height != window->x11.height)
{
_glfwInputFramebufferSize(window,
event->xconfigure.width,
event->xconfigure.height);
_glfwInputWindowSize(window,
event->xconfigure.width,
event->xconfigure.height);
window->x11.width = event->xconfigure.width;
window->x11.height = event->xconfigure.height;
}
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;
}
break;
}
case ClientMessage:
{
// Custom client message, probably from the window manager
if ((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);
}
else if (event->xclient.message_type == _glfw.x11.XdndEnter)
{
// A drag operation has entered the window
// TODO: Check if UTF-8 string is supported by the source
}
else if (event->xclient.message_type == _glfw.x11.XdndDrop)
{
// 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];
XConvertSelection(_glfw.x11.display,
_glfw.x11.XdndSelection,
_glfw.x11.UTF8_STRING,
_glfw.x11.XdndSelection,
window->x11.handle, CurrentTime);
}
else if (event->xclient.message_type == _glfw.x11.XdndPosition)
{
// The drag operation has moved over the window
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);
// Reply that we are ready to copy the dragged data
XEvent reply;
memset(&reply, 0, sizeof(reply));
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;
reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy;
XSendEvent(_glfw.x11.display, event->xclient.data.l[0],
False, NoEventMask, &reply);
XFlush(_glfw.x11.display);
}
break;
}
case SelectionNotify:
{
if (event->xselection.property)
{
// The converted data from the drag operation has arrived
char* data;
const int result = _glfwGetWindowProperty(event->xselection.requestor,
event->xselection.property,
event->xselection.target,
(unsigned char**) &data);
if (result)
{
int i, count;
char** names = splitUriList(data, &count);
_glfwInputDrop(window, count, (const char**) names);
for (i = 0; i < count; i++)
free(names[i]);
free(names);
}
XFree(data);
XEvent reply;
memset(&reply, 0, sizeof(reply));
reply.type = ClientMessage;
reply.xclient.window = _glfw.x11.xdnd.source;
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;
reply.xclient.data.l[2] = _glfw.x11.XdndActionCopy;
// Reply that all is well
XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
False, NoEventMask, &reply);
XFlush(_glfw.x11.display);
}
break;
}
case MapNotify:
{
_glfwInputWindowVisibility(window, GL_TRUE);
break;
}
case UnmapNotify:
{
_glfwInputWindowVisibility(window, GL_FALSE);
break;
}
case FocusIn:
{
_glfwInputWindowFocus(window, GL_TRUE);
if (window->cursorMode == GLFW_CURSOR_DISABLED)
disableCursor(window);
break;
}
case FocusOut:
{
_glfwInputWindowFocus(window, GL_FALSE);
if (window->cursorMode == GLFW_CURSOR_DISABLED)
restoreCursor(window);
break;
}
case Expose:
{
_glfwInputWindowDamage(window);
break;
}
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:
{
_glfwHandleSelectionClear(event);
break;
}
case SelectionRequest:
{
_glfwHandleSelectionRequest(event);
break;
}
case DestroyNotify:
return;
case GenericEvent:
{
if (event->xcookie.extension == _glfw.x11.xi.majorOpcode &&
XGetEventData(_glfw.x11.display, &event->xcookie))
{
if (event->xcookie.evtype == XI_Motion)
{
XIDeviceEvent* data = (XIDeviceEvent*) event->xcookie.data;
window = _glfwFindWindowByHandle(data->event);
if (window)
{
if (data->event_x != window->x11.warpPosX ||
data->event_y != window->x11.warpPosY)
{
// The cursor was moved by something other than GLFW
double x, y;
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
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);
}
window->x11.cursorPosX = data->event_x;
window->x11.cursorPosY = data->event_y;
}
}
}
XFreeEventData(_glfw.x11.display, &event->xcookie);
break;
}
default:
{
switch (event->type - _glfw.x11.randr.eventBase)
{
case RRScreenChangeNotify:
{
XRRUpdateConfiguration(event);
break;
}
}
break;
}
}
}
// Process the specified X event
//
static void processEvent(XEvent *event)
{
_GLFWwindow* window = NULL;
if (event->type != GenericEvent)
{
window = _glfwFindWindowByHandle(event->xany.window);
if (window == NULL)
{
// This is an event for a window that has already been destroyed
return;
}
}
switch (event->type)
{
case KeyPress:
{
const int key = translateKey(event->xkey.keycode);
const int mods = translateState(event->xkey.state);
const int character = translateChar(&event->xkey);
_glfwInputKey(window, key, event->xkey.keycode, GLFW_PRESS, mods);
if (character != -1)
_glfwInputChar(window, character);
break;
}
case KeyRelease:
{
const int key = translateKey(event->xkey.keycode);
const int mods = translateState(event->xkey.state);
_glfwInputKey(window, key, event->xkey.keycode, GLFW_RELEASE, mods);
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);
// Modern X provides scroll events as mouse button presses
else if (event->xbutton.button == Button4)
_glfwInputScroll(window, 0.0, 1.0);
else if (event->xbutton.button == Button5)
_glfwInputScroll(window, 0.0, -1.0);
else if (event->xbutton.button == Button6)
_glfwInputScroll(window, -1.0, 0.0);
else if (event->xbutton.button == Button7)
_glfwInputScroll(window, 1.0, 0.0);
break;
}
case ButtonRelease:
{
const int mods = translateState(event->xbutton.state);
if (event->xbutton.button == Button1)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_LEFT,
GLFW_RELEASE,
mods);
}
else if (event->xbutton.button == Button2)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_MIDDLE,
GLFW_RELEASE,
mods);
}
else if (event->xbutton.button == Button3)
{
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_RIGHT,
GLFW_RELEASE,
mods);
}
break;
}
case EnterNotify:
{
if (window->cursorMode == GLFW_CURSOR_HIDDEN)
hideCursor(window);
_glfwInputCursorEnter(window, GL_TRUE);
break;
}
case LeaveNotify:
{
if (window->cursorMode == GLFW_CURSOR_HIDDEN)
showCursor(window);
_glfwInputCursorEnter(window, GL_FALSE);
break;
}
case MotionNotify:
{
if (event->xmotion.x != window->x11.warpPosX ||
event->xmotion.y != window->x11.warpPosY)
{
// The cursor was moved by something other than GLFW
int x, y;
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
if (_glfw.focusedWindow != window)
break;
x = event->xmotion.x - window->x11.cursorPosX;
y = event->xmotion.y - window->x11.cursorPosY;
}
else
{
x = event->xmotion.x;
y = event->xmotion.y;
}
_glfwInputCursorMotion(window, x, y);
}
window->x11.cursorPosX = event->xmotion.x;
window->x11.cursorPosY = event->xmotion.y;
break;
}
case ConfigureNotify:
{
if (event->xconfigure.width != window->x11.width ||
event->xconfigure.height != window->x11.height)
{
_glfwInputFramebufferSize(window,
event->xconfigure.width,
event->xconfigure.height);
_glfwInputWindowSize(window,
event->xconfigure.width,
event->xconfigure.height);
window->x11.width = event->xconfigure.width;
window->x11.height = event->xconfigure.height;
}
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;
}
break;
}
case ClientMessage:
{
// Custom client message, probably from the window manager
if ((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 != None &&
(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);
}
break;
}
case MapNotify:
{
_glfwInputWindowVisibility(window, GL_TRUE);
break;
}
case UnmapNotify:
{
_glfwInputWindowVisibility(window, GL_FALSE);
break;
}
case FocusIn:
{
_glfwInputWindowFocus(window, GL_TRUE);
if (window->cursorMode == GLFW_CURSOR_DISABLED)
captureCursor(window);
break;
}
case FocusOut:
{
_glfwInputWindowFocus(window, GL_FALSE);
if (window->cursorMode == GLFW_CURSOR_DISABLED)
showCursor(window);
break;
}
case Expose:
{
_glfwInputWindowDamage(window);
break;
}
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:
{
_glfwHandleSelectionClear(event);
break;
}
case SelectionRequest:
{
_glfwHandleSelectionRequest(event);
break;
}
case DestroyNotify:
return;
case GenericEvent:
{
if (event->xcookie.extension == _glfw.x11.xi.majorOpcode &&
XGetEventData(_glfw.x11.display, &event->xcookie))
{
/* if (event->xcookie.evtype == XI_Motion)
{
XIDeviceEvent* data = (XIDeviceEvent*) event->xcookie.data;
window = _glfwFindWindowByHandle(data->event);
if (window)
{
if (data->event_x != window->x11.warpPosX ||
data->event_y != window->x11.warpPosY)
{
// The cursor was moved by something other than GLFW
double x, y;
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
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);
}
window->x11.cursorPosX = data->event_x;
window->x11.cursorPosY = data->event_y;
}
}*/
}
XFreeEventData(_glfw.x11.display, &event->xcookie);
break;
}
default:
{
/* switch (event->type - _glfw.x11.randr.eventBase)
{
case RRScreenChangeNotify:
{
XRRUpdateConfiguration(event);
break;
}
}
*/
break;
}
}
}
// 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.selection.string,
strlen(_glfw.x11.selection.string));
}
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.selection.string,
strlen(_glfw.x11.selection.string));
return request->property;
}
}
// The requested target is not supported
return None;
}
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 (_glfwFindWindowByHandle(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.selection.string;
}
free(_glfw.x11.selection.string);
_glfw.x11.selection.string = 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.selection.string = strdup(data);
}
XFree(data);
XDeleteProperty(_glfw.x11.display,
event.xselection.requestor,
event.xselection.property);
if (_glfw.x11.selection.string)
break;
}
if (_glfw.x11.selection.string == NULL)
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"X11: Failed to convert selection to string");
}
return _glfw.x11.selection.string;
}
