glfw/src/x11_window.c

1222 lines
40 KiB
C
Raw Normal View History

2010-09-07 15:34:51 +00:00
//========================================================================
// GLFW - An OpenGL library
2010-09-07 15:34:51 +00:00
// Platform: X11/GLX
2010-09-07 15:41:26 +00:00
// API version: 3.0
2010-09-07 15:34:51 +00:00
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// 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 <string.h>
#include <stdio.h>
#include <stdlib.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
2010-09-07 15:34:51 +00:00
2012-08-26 13:38:18 +00:00
2010-09-07 15:34:51 +00:00
//========================================================================
// Translates an X Window key to internal coding
//========================================================================
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)
if ((keycode >= 0) && (keycode < 256))
return _glfwLibrary.X11.keyCodeLUT[keycode];
else
return -1;
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Translates an X Window event to Unicode
//========================================================================
2010-09-08 13:58:43 +00:00
static int translateChar(XKeyEvent* event)
2010-09-07 15:34:51 +00:00
{
KeySym keysym;
// Get X11 keysym
2010-09-08 13:51:25 +00:00
XLookupString(event, NULL, 0, &keysym, NULL);
2010-09-07 15:34:51 +00:00
// Convert to Unicode (see x11_keysym2unicode.c)
2010-09-08 13:51:25 +00:00
return (int) _glfwKeySym2Unicode(keysym);
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Create the X11 window (and its colormap)
//========================================================================
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 = _glfwGetContextVisual(window);
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
2010-09-09 16:15:32 +00:00
window->X11.colormap = XCreateColormap(_glfwLibrary.X11.display,
_glfwLibrary.X11.root,
visual->visual,
AllocNone);
2010-09-07 15:34:51 +00:00
// Create the actual window
{
wamask = CWBorderPixel | CWColormap | CWEventMask;
2010-09-09 16:15:32 +00:00
wa.colormap = window->X11.colormap;
2010-09-07 15:34:51 +00:00
wa.border_pixel = 0;
wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
ExposureMask | FocusChangeMask | VisibilityChangeMask |
EnterWindowMask | LeaveWindowMask;
2010-09-07 15:34:51 +00:00
2010-09-10 11:24:19 +00:00
if (wndconfig->mode == GLFW_WINDOWED)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// The /only/ reason for setting the background pixel here is that
// otherwise our window won't get any decorations on systems using
// certain versions of Compiz on Intel hardware
2010-10-27 15:53:24 +00:00
wa.background_pixel = BlackPixel(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen);
2010-09-07 15:34:51 +00:00
wamask |= CWBackPixel;
}
2012-08-26 13:38:18 +00:00
window->X11.handle = XCreateWindow(_glfwLibrary.X11.display,
_glfwLibrary.X11.root,
0, 0, // Position
window->width, window->height,
0, // Border width
visual->depth, // Color depth
InputOutput,
visual->visual,
wamask,
&wa);
if (!window->X11.handle)
{
2012-08-26 13:38:18 +00:00
// TODO: Handle all the various error codes here and translate them
// to GLFW errors
2010-11-23 16:45:23 +00:00
2011-05-21 15:34:17 +00:00
_glfwSetError(GLFW_PLATFORM_ERROR,
"X11/GLX: Failed to create window");
2010-09-07 15:34:51 +00:00
return GL_FALSE;
}
2010-09-07 15:34:51 +00:00
}
2012-04-05 15:29:08 +00:00
if (window->mode == GLFW_FULLSCREEN && !_glfwLibrary.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;
2010-09-09 16:15:32 +00:00
XChangeWindowAttributes(_glfwLibrary.X11.display,
window->X11.handle,
2010-09-08 13:51:25 +00:00
CWOverrideRedirect,
&attributes);
2010-09-07 15:34:51 +00:00
2010-09-09 16:15:32 +00:00
window->X11.overrideRedirect = GL_TRUE;
2010-09-07 15:34:51 +00:00
}
// Find or create the protocol atom for window close notifications
2012-04-05 15:29:08 +00:00
_glfwLibrary.X11.wmDeleteWindow = XInternAtom(_glfwLibrary.X11.display,
"WM_DELETE_WINDOW",
False);
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
2012-04-05 15:29:08 +00:00
if (_glfwLibrary.X11.wmDeleteWindow != None)
protocols[count++] = _glfwLibrary.X11.wmDeleteWindow;
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
2012-04-05 15:29:08 +00:00
if (_glfwLibrary.X11.wmPing != None)
protocols[count++] = _glfwLibrary.X11.wmPing;
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(_glfwLibrary.X11.display, window->X11.handle,
2010-09-08 13:51:25 +00:00
protocols, count);
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)
{
2011-05-21 15:34:17 +00:00
_glfwSetError(GLFW_OUT_OF_MEMORY,
"X11/GLX: 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(_glfwLibrary.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-08 13:51:25 +00:00
if (!hints)
{
2011-05-21 15:34:17 +00:00
_glfwSetError(GLFW_OUT_OF_MEMORY,
"X11/GLX: Failed to allocate size hints");
2010-09-07 15:34:51 +00:00
return GL_FALSE;
}
2010-09-07 15:34:51 +00:00
hints->flags = 0;
if (!wndconfig->resizable)
2010-09-07 15:34:51 +00:00
{
hints->flags |= (PMinSize | PMaxSize);
2010-09-09 16:15:32 +00:00
hints->min_width = hints->max_width = window->width;
hints->min_height = hints->max_height = window->height;
2010-09-07 15:34:51 +00:00
}
XSetWMNormalHints(_glfwLibrary.X11.display, window->X11.handle, hints);
2010-09-08 13:51:25 +00:00
XFree(hints);
2010-09-07 15:34:51 +00:00
}
2010-09-14 01:10:45 +00:00
_glfwPlatformSetWindowTitle(window, wndconfig->title);
2010-09-07 15:34:51 +00:00
// Make sure the window is mapped before proceeding
XMapWindow(_glfwLibrary.X11.display, window->X11.handle);
XFlush(_glfwLibrary.X11.display);
2010-09-07 15:34:51 +00:00
return GL_TRUE;
}
//========================================================================
// Hide cursor
//========================================================================
static void hideCursor(_GLFWwindow* window)
{
if (!window->X11.cursorHidden)
{
XDefineCursor(_glfwLibrary.X11.display,
window->X11.handle,
_glfwLibrary.X11.cursor);
window->X11.cursorHidden = GL_TRUE;
}
}
//========================================================================
// Capture cursor
//========================================================================
static void captureCursor(_GLFWwindow* window)
{
hideCursor(window);
if (!window->X11.cursorGrabbed)
{
if (XGrabPointer(_glfwLibrary.X11.display, window->X11.handle, True,
ButtonPressMask | ButtonReleaseMask |
PointerMotionMask, GrabModeAsync, GrabModeAsync,
window->X11.handle, None, CurrentTime) ==
GrabSuccess)
{
window->X11.cursorGrabbed = GL_TRUE;
window->X11.cursorCentered = GL_FALSE;
}
}
}
//========================================================================
// Show cursor
//========================================================================
static void showCursor(_GLFWwindow* window)
{
2012-08-26 13:38:18 +00:00
// Un-grab cursor (in windowed mode only; in fullscreen mode we still
// want the cursor grabbed in order to confine the cursor to the window
// area)
if (window->X11.cursorGrabbed)
{
XUngrabPointer(_glfwLibrary.X11.display, CurrentTime);
window->X11.cursorGrabbed = GL_FALSE;
}
// Show cursor
if (window->X11.cursorHidden)
{
XUndefineCursor(_glfwLibrary.X11.display, window->X11.handle);
window->X11.cursorHidden = GL_FALSE;
}
}
2010-09-07 15:34:51 +00:00
//========================================================================
// Enter fullscreen mode
//========================================================================
2010-09-09 16:15:32 +00:00
static void enterFullscreenMode(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
2010-09-09 18:22:23 +00:00
if (!_glfwLibrary.X11.saver.changed)
2010-09-07 15:34:51 +00:00
{
// Remember old screen saver settings
2010-09-09 16:15:32 +00:00
XGetScreenSaver(_glfwLibrary.X11.display,
2010-09-09 18:22:23 +00:00
&_glfwLibrary.X11.saver.timeout,
&_glfwLibrary.X11.saver.interval,
&_glfwLibrary.X11.saver.blanking,
&_glfwLibrary.X11.saver.exposure);
2010-09-07 15:34:51 +00:00
// Disable screen saver
2010-09-09 16:15:32 +00:00
XSetScreenSaver(_glfwLibrary.X11.display, 0, 0, DontPreferBlanking,
2010-09-08 13:51:25 +00:00
DefaultExposures);
2010-09-07 15:34:51 +00:00
2010-09-09 18:22:23 +00:00
_glfwLibrary.X11.saver.changed = GL_TRUE;
2010-09-07 15:34:51 +00:00
}
2012-04-05 14:14:01 +00:00
_glfwSetVideoMode(&window->width, &window->height,
2010-09-09 16:15:32 +00:00
&window->refreshRate);
2010-09-07 15:34:51 +00:00
2012-04-05 15:29:08 +00:00
if (_glfwLibrary.X11.hasEWMH &&
_glfwLibrary.X11.wmState != None &&
_glfwLibrary.X11.wmStateFullscreen != None)
2010-09-07 15:34:51 +00:00
{
2012-04-05 15:29:08 +00:00
if (_glfwLibrary.X11.wmActiveWindow != None)
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
2012-04-05 15:29:08 +00:00
event.xclient.message_type = _glfwLibrary.X11.wmActiveWindow;
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
2010-09-09 16:15:32 +00:00
XSendEvent(_glfwLibrary.X11.display,
_glfwLibrary.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
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
2012-04-05 15:29:08 +00:00
event.xclient.message_type = _glfwLibrary.X11.wmState;
2010-09-07 15:34:51 +00:00
event.xclient.data.l[0] = _NET_WM_STATE_ADD;
2012-04-05 15:29:08 +00:00
event.xclient.data.l[1] = _glfwLibrary.X11.wmStateFullscreen;
2010-09-07 15:34:51 +00:00
event.xclient.data.l[2] = 0; // No secondary property
event.xclient.data.l[3] = 1; // Sender is a normal application
2010-09-09 16:15:32 +00:00
XSendEvent(_glfwLibrary.X11.display,
_glfwLibrary.X11.root,
2010-09-08 13:51:25 +00:00
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
2010-09-07 15:34:51 +00:00
}
2010-09-09 16:15:32 +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
XRaiseWindow(_glfwLibrary.X11.display, window->X11.handle);
XSetInputFocus(_glfwLibrary.X11.display, window->X11.handle,
2010-09-08 13:51:25 +00:00
RevertToParent, CurrentTime);
XMoveWindow(_glfwLibrary.X11.display, window->X11.handle, 0, 0);
XResizeWindow(_glfwLibrary.X11.display, window->X11.handle,
2010-09-09 16:15:32 +00:00
window->width, window->height);
2010-09-07 15:34:51 +00:00
}
// HACK: Try to get window inside viewport (for virtual displays) by moving
// the cursor to the upper left corner (and then to the center)
2010-09-07 15:34:51 +00:00
// This hack should be harmless on saner systems as well
XWarpPointer(_glfwLibrary.X11.display, None, window->X11.handle, 0,0,0,0, 0,0);
XWarpPointer(_glfwLibrary.X11.display, None, window->X11.handle, 0,0,0,0,
2010-09-09 16:15:32 +00:00
window->width / 2, window->height / 2);
2010-09-07 15:34:51 +00:00
}
2011-10-08 21:57:03 +00:00
2010-09-07 15:34:51 +00:00
//========================================================================
// Leave fullscreen mode
//========================================================================
2010-09-09 16:15:32 +00:00
static void leaveFullscreenMode(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
2012-04-05 14:14:01 +00:00
_glfwRestoreVideoMode();
2010-09-07 15:34:51 +00:00
2010-09-09 18:22:23 +00:00
if (_glfwLibrary.X11.saver.changed)
2010-09-07 15:34:51 +00:00
{
// Restore old screen saver settings
2010-09-09 16:15:32 +00:00
XSetScreenSaver(_glfwLibrary.X11.display,
2010-09-09 18:22:23 +00:00
_glfwLibrary.X11.saver.timeout,
_glfwLibrary.X11.saver.interval,
_glfwLibrary.X11.saver.blanking,
_glfwLibrary.X11.saver.exposure);
2010-09-07 15:34:51 +00:00
2010-09-09 18:22:23 +00:00
_glfwLibrary.X11.saver.changed = GL_FALSE;
2010-09-07 15:34:51 +00:00
}
2012-04-05 15:29:08 +00:00
if (_glfwLibrary.X11.hasEWMH &&
_glfwLibrary.X11.wmState != None &&
_glfwLibrary.X11.wmStateFullscreen != None)
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
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
2012-04-05 15:29:08 +00:00
event.xclient.message_type = _glfwLibrary.X11.wmState;
2010-09-07 15:34:51 +00:00
event.xclient.data.l[0] = _NET_WM_STATE_REMOVE;
2012-04-05 15:29:08 +00:00
event.xclient.data.l[1] = _glfwLibrary.X11.wmStateFullscreen;
2010-09-07 15:34:51 +00:00
event.xclient.data.l[2] = 0; // No secondary property
event.xclient.data.l[3] = 1; // Sender is a normal application
2010-09-09 16:15:32 +00:00
XSendEvent(_glfwLibrary.X11.display,
_glfwLibrary.X11.root,
2010-09-08 13:51:25 +00:00
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
2010-09-07 15:34:51 +00:00
}
}
2010-09-09 22:06:23 +00:00
//========================================================================
// Return the GLFW window corresponding to the specified X11 window
//========================================================================
2011-03-04 14:47:57 +00:00
2010-09-09 22:06:23 +00:00
static _GLFWwindow* findWindow(Window handle)
{
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; window = window->next)
{
if (window->X11.handle == handle)
2010-09-09 22:06:23 +00:00
return window;
}
return NULL;
}
2010-09-07 15:34:51 +00:00
//========================================================================
// Get and process next X event (called by _glfwPlatformPollEvents)
//========================================================================
2010-09-09 22:06:23 +00:00
static void processSingleEvent(void)
2010-09-07 15:34:51 +00:00
{
2010-09-09 22:06:23 +00:00
_GLFWwindow* window;
2010-09-09 16:15:32 +00:00
2010-09-07 15:34:51 +00:00
XEvent event;
2010-09-09 16:15:32 +00:00
XNextEvent(_glfwLibrary.X11.display, &event);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
switch (event.type)
2010-09-07 15:34:51 +00:00
{
case KeyPress:
{
// A keyboard key was pressed
2010-09-09 22:06:23 +00:00
window = findWindow(event.xkey.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for KeyPress event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
// Translate and report key press
2010-09-09 16:15:32 +00:00
_glfwInputKey(window, translateKey(event.xkey.keycode), GLFW_PRESS);
2010-09-07 15:34:51 +00:00
// Translate and report character input
_glfwInputChar(window, translateChar(&event.xkey));
2010-09-08 13:51:25 +00:00
2010-09-07 15:34:51 +00:00
break;
}
case KeyRelease:
{
// A keyboard key was released
2010-09-09 22:06:23 +00:00
window = findWindow(event.xkey.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for KeyRelease event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
// Do not report key releases for key repeats. For key repeats we
// will get KeyRelease/KeyPress pairs with similar or identical
// time stamps. User selected key repeat filtering is handled in
2011-03-04 14:49:05 +00:00
// _glfwInputKey/_glfwInputChar.
2010-09-09 16:15:32 +00:00
if (XEventsQueued(_glfwLibrary.X11.display, QueuedAfterReading))
2010-09-07 15:34:51 +00:00
{
XEvent nextEvent;
2010-09-09 16:15:32 +00:00
XPeekEvent(_glfwLibrary.X11.display, &nextEvent);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
if (nextEvent.type == KeyPress &&
2010-09-07 15:34:51 +00:00
nextEvent.xkey.window == event.xkey.window &&
2010-09-08 13:51:25 +00:00
nextEvent.xkey.keycode == event.xkey.keycode)
2010-09-07 15:34:51 +00:00
{
// This last check is a hack to work around key repeats
// leaking through due to some sort of time drift
// 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)
2010-09-08 13:51:25 +00:00
if ((nextEvent.xkey.time - event.xkey.time) < 20)
2010-09-07 15:34:51 +00:00
{
// Do not report anything for this event
break;
}
}
}
// Translate and report key release
2010-09-09 16:15:32 +00:00
_glfwInputKey(window, translateKey(event.xkey.keycode), GLFW_RELEASE);
2010-09-07 15:34:51 +00:00
break;
}
case ButtonPress:
{
// A mouse button was pressed or a scrolling event occurred
2010-09-09 22:06:23 +00:00
window = findWindow(event.xbutton.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ButtonPress event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
if (event.xbutton.button == Button1)
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS);
2010-09-08 13:51:25 +00:00
else if (event.xbutton.button == Button2)
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS);
2010-09-08 13:51:25 +00:00
else if (event.xbutton.button == Button3)
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS);
2010-09-07 15:34:51 +00:00
// XFree86 3.3.2 and later translates mouse wheel up/down into
// mouse button 4 & 5 presses
2010-09-08 13:51:25 +00:00
else if (event.xbutton.button == Button4)
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 0.0, 1.0);
2010-09-08 13:51:25 +00:00
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)
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 1.0, 0.0);
2010-09-07 15:34:51 +00:00
break;
}
case ButtonRelease:
{
// A mouse button was released
2010-09-09 22:06:23 +00:00
window = findWindow(event.xbutton.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ButtonRelease event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
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,
2010-09-08 13:51:25 +00:00
GLFW_RELEASE);
2010-09-07 15:34:51 +00:00
}
2010-09-08 13:51:25 +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,
2010-09-08 13:51:25 +00:00
GLFW_RELEASE);
2010-09-07 15:34:51 +00:00
}
2010-09-08 13:51:25 +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,
2010-09-08 13:51:25 +00:00
GLFW_RELEASE);
2010-09-07 15:34:51 +00:00
}
break;
}
case EnterNotify:
{
// The cursor entered the window
window = findWindow(event.xcrossing.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for EnterNotify event\n");
return;
}
2012-01-30 21:32:14 +00:00
if (window->cursorMode == GLFW_CURSOR_HIDDEN)
hideCursor(window);
2012-01-30 21:32:14 +00:00
2012-01-30 21:59:38 +00:00
_glfwInputCursorEnter(window, GL_TRUE);
break;
}
case LeaveNotify:
{
// The cursor left the window
window = findWindow(event.xcrossing.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for LeaveNotify event\n");
return;
}
2012-01-30 21:32:14 +00:00
if (window->cursorMode == GLFW_CURSOR_HIDDEN)
showCursor(window);
2012-01-30 21:32:14 +00:00
2012-01-30 21:59:38 +00:00
_glfwInputCursorEnter(window, GL_FALSE);
break;
}
2010-09-07 15:34:51 +00:00
case MotionNotify:
{
// The cursor was moved
2010-09-09 22:06:23 +00:00
window = findWindow(event.xmotion.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for MotionNotify event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
2010-09-09 16:15:32 +00:00
if (event.xmotion.x != window->X11.cursorPosX ||
event.xmotion.y != window->X11.cursorPosY)
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_CAPTURED)
2010-09-07 15:34:51 +00:00
{
if (_glfwLibrary.activeWindow != 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;
2011-10-13 12:07:52 +00:00
y = event.xmotion.y;
2010-09-07 15:34:51 +00:00
}
2010-09-09 16:15:32 +00:00
window->X11.cursorPosX = event.xmotion.x;
window->X11.cursorPosY = event.xmotion.y;
window->X11.cursorCentered = GL_FALSE;
2010-09-07 15:34:51 +00:00
_glfwInputCursorMotion(window, x, y);
2010-09-07 15:34:51 +00:00
}
2010-09-07 15:34:51 +00:00
break;
}
case ConfigureNotify:
{
2010-09-09 22:06:23 +00:00
// The window configuration changed somehow
window = findWindow(event.xconfigure.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ConfigureNotify event\n");
2010-09-09 22:06:23 +00:00
return;
}
_glfwInputWindowSize(window,
event.xconfigure.width,
event.xconfigure.height);
2010-09-14 01:53:22 +00:00
_glfwInputWindowPos(window,
event.xconfigure.x,
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
window = findWindow(event.xclient.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ClientMessage event\n");
2010-09-09 22:06:23 +00:00
return;
}
2012-04-05 15:29:08 +00:00
if ((Atom) event.xclient.data.l[0] == _glfwLibrary.X11.wmDeleteWindow)
2010-09-07 15:34:51 +00:00
{
// The window manager was asked to close the window, for example by
// the user pressing a 'close' window decoration button
_glfwInputWindowCloseRequest(window);
2010-09-07 15:34:51 +00:00
}
2012-04-05 15:29:08 +00:00
else if (_glfwLibrary.X11.wmPing != None &&
(Atom) event.xclient.data.l[0] == _glfwLibrary.X11.wmPing)
2010-09-07 15:34:51 +00:00
{
2012-08-26 13:38:18 +00:00
// The window manager is pinging the application to ensure it's
// still responding to events
2010-09-07 15:34:51 +00:00
event.xclient.window = _glfwLibrary.X11.root;
2010-09-09 16:15:32 +00:00
XSendEvent(_glfwLibrary.X11.display,
2010-09-08 13:51:25 +00:00
event.xclient.window,
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
2010-09-07 15:34:51 +00:00
}
break;
}
case MapNotify:
{
// The window was mapped
2010-09-09 22:06:23 +00:00
window = findWindow(event.xmap.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for MapNotify event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
_glfwInputWindowIconify(window, GL_FALSE);
2010-09-07 15:34:51 +00:00
break;
}
case UnmapNotify:
{
// The window was unmapped
2010-09-09 22:06:23 +00:00
window = findWindow(event.xmap.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for UnmapNotify event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
_glfwInputWindowIconify(window, GL_TRUE);
2010-09-07 15:34:51 +00:00
break;
}
case FocusIn:
{
// The window gained focus
2010-09-09 22:06:23 +00:00
window = findWindow(event.xfocus.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for FocusIn event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
_glfwInputWindowFocus(window, GL_TRUE);
2010-09-07 15:34:51 +00:00
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
captureCursor(window);
2010-09-07 15:34:51 +00:00
break;
}
case FocusOut:
{
// The window lost focus
2010-09-09 22:06:23 +00:00
window = findWindow(event.xfocus.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for FocusOut event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
_glfwInputWindowFocus(window, GL_FALSE);
2010-09-07 15:34:51 +00:00
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
showCursor(window);
2010-09-07 15:34:51 +00:00
break;
}
case Expose:
{
// The window's contents was damaged
2010-09-09 22:06:23 +00:00
window = findWindow(event.xexpose.window);
if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for Expose event\n");
2010-09-09 22:06:23 +00:00
return;
}
2010-09-07 15:34:51 +00:00
_glfwInputWindowDamage(window);
2010-09-07 15:34:51 +00:00
break;
}
case SelectionClear:
{
// The ownership of the selection was lost
free(_glfwLibrary.X11.selection.string);
_glfwLibrary.X11.selection.string = NULL;
break;
}
case SelectionNotify:
{
// The selection conversion status is available
XSelectionEvent* request = &event.xselection;
if (_glfwReadSelection(request))
_glfwLibrary.X11.selection.status = _GLFW_CONVERSION_SUCCEEDED;
else
_glfwLibrary.X11.selection.status = _GLFW_CONVERSION_FAILED;
break;
}
case SelectionRequest:
{
// The contents of the 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(_glfwLibrary.X11.display,
request->requestor,
False, 0, &response);
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
default:
{
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
2010-10-13 21:05:17 +00:00
switch (event.type - _glfwLibrary.X11.RandR.eventBase)
2010-09-07 15:34:51 +00:00
{
case RRScreenChangeNotify:
{
2010-09-08 13:51:25 +00:00
XRRUpdateConfiguration(&event);
2010-09-07 15:34:51 +00:00
break;
}
}
#endif /*_GLFW_HAS_XRANDR*/
2010-09-07 15:34:51 +00:00
break;
}
}
}
2010-09-15 14:44:43 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
2010-09-07 15:34:51 +00:00
//========================================================================
// Here is where the window is created, and
// the OpenGL rendering context is created
//========================================================================
int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
2010-09-07 15:34:51 +00:00
{
window->refreshRate = wndconfig->refreshRate;
2010-09-07 15:34:51 +00:00
if (!_glfwCreateContext(window, wndconfig, 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;
2010-09-08 13:51:25 +00:00
if (wndconfig->mode == GLFW_FULLSCREEN)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
2010-09-07 15:34:51 +00:00
// Request screen change notifications
2010-10-13 21:05:17 +00:00
if (_glfwLibrary.X11.RandR.available)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +00:00
XRRSelectInput(_glfwLibrary.X11.display,
window->X11.handle,
2010-09-08 13:51:25 +00:00
RRScreenChangeNotifyMask);
2010-09-07 15:34:51 +00:00
}
#endif /*_GLFW_HAS_XRANDR*/
2010-09-09 16:15:32 +00:00
enterFullscreenMode(window);
2010-09-07 15:34:51 +00:00
}
// Retrieve and set initial cursor position
{
2010-09-09 16:15:32 +00:00
Window cursorWindow, cursorRoot;
2010-09-07 15:34:51 +00:00
int windowX, windowY, rootX, rootY;
unsigned int mask;
2010-09-09 16:15:32 +00:00
XQueryPointer(_glfwLibrary.X11.display,
window->X11.handle,
2010-09-09 16:15:32 +00:00
&cursorRoot,
&cursorWindow,
2010-09-08 13:51:25 +00:00
&rootX, &rootY,
&windowX, &windowY,
&mask);
2010-09-07 15:34:51 +00:00
// TODO: Probably check for some corner cases here.
window->cursorPosX = windowX;
window->cursorPosY = windowY;
2010-09-07 15:34:51 +00:00
}
return GL_TRUE;
}
//========================================================================
// Properly kill the window/video display
//========================================================================
void _glfwPlatformDestroyWindow(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +00:00
if (window->mode == GLFW_FULLSCREEN)
leaveFullscreenMode(window);
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
{
XUnmapWindow(_glfwLibrary.X11.display, window->X11.handle);
XDestroyWindow(_glfwLibrary.X11.display, window->X11.handle);
window->X11.handle = (Window) 0;
2010-09-07 15:34:51 +00:00
}
2010-09-09 16:15:32 +00:00
if (window->X11.colormap)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +00:00
XFreeColormap(_glfwLibrary.X11.display, window->X11.colormap);
window->X11.colormap = (Colormap) 0;
2010-09-07 15:34:51 +00:00
}
}
//========================================================================
// Set the window title
//========================================================================
2010-09-09 16:15:32 +00:00
void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
2010-09-07 15:34:51 +00:00
{
2012-02-02 16:20:14 +00:00
Atom type = XInternAtom(_glfwLibrary.X11.display, "UTF8_STRING", False);
#if defined(X_HAVE_UTF8_STRING)
Xutf8SetWMProperties(_glfwLibrary.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(_glfwLibrary.X11.display,
window->X11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
#endif
2012-02-01 13:43:42 +00:00
2012-04-05 15:29:08 +00:00
if (_glfwLibrary.X11.wmName != None)
2012-01-31 23:10:17 +00:00
{
XChangeProperty(_glfwLibrary.X11.display, window->X11.handle,
2012-04-05 15:29:08 +00:00
_glfwLibrary.X11.wmName, type, 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
2012-04-05 15:29:08 +00:00
if (_glfwLibrary.X11.wmIconName != None)
2012-02-02 16:20:14 +00:00
{
XChangeProperty(_glfwLibrary.X11.display, window->X11.handle,
2012-04-05 15:29:08 +00:00
_glfwLibrary.X11.wmIconName, type, 8,
2012-02-02 16:20:14 +00:00
PropModeReplace,
(unsigned char*) title, strlen(title));
}
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Set the window size
//========================================================================
2010-09-09 16:15:32 +00:00
void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
2010-09-07 15:34:51 +00:00
{
int mode = 0, rate, sizeChanged = GL_FALSE;
2010-09-08 13:58:43 +00:00
XSizeHints* sizehints;
2010-09-07 15:34:51 +00:00
2010-09-09 16:15:32 +00:00
rate = window->refreshRate;
2010-09-07 15:34:51 +00:00
2010-09-09 16:15:32 +00:00
if (window->mode == GLFW_FULLSCREEN)
2010-09-07 15:34:51 +00:00
{
// Get the closest matching video mode for the specified window size
2012-04-05 14:14:01 +00:00
mode = _glfwGetClosestVideoMode(&width, &height, &rate);
2010-09-07 15:34:51 +00:00
}
if (!window->resizable)
2010-09-07 15:34:51 +00:00
{
// Update window size restrictions to match new window size
sizehints = XAllocSizeHints();
sizehints->flags = 0;
sizehints->min_width = sizehints->max_width = width;
sizehints->min_height = sizehints->max_height = height;
XSetWMNormalHints(_glfwLibrary.X11.display, window->X11.handle, sizehints);
2010-09-08 13:51:25 +00:00
XFree(sizehints);
2010-09-07 15:34:51 +00:00
}
// Change window size before changing fullscreen mode?
2010-09-09 16:15:32 +00:00
if (window->mode == GLFW_FULLSCREEN && (width > window->width))
2010-09-07 15:34:51 +00:00
{
XResizeWindow(_glfwLibrary.X11.display, window->X11.handle, width, height);
2010-09-07 15:34:51 +00:00
sizeChanged = GL_TRUE;
}
2010-09-09 16:15:32 +00:00
if (window->mode == GLFW_FULLSCREEN)
2010-09-07 15:34:51 +00:00
{
// Change video mode, keeping current refresh rate
2012-04-05 14:14:01 +00:00
_glfwSetVideoModeMODE(mode, window->refreshRate);
2010-09-07 15:34:51 +00:00
}
// Set window size (if not already changed)
2010-09-08 13:51:25 +00:00
if (!sizeChanged)
XResizeWindow(_glfwLibrary.X11.display, window->X11.handle, width, height);
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Set the window position.
//========================================================================
2010-09-09 16:15:32 +00:00
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
2010-09-07 15:34:51 +00:00
{
XMoveWindow(_glfwLibrary.X11.display, window->X11.handle, x, y);
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Window iconification
//========================================================================
2010-09-09 16:15:32 +00:00
void _glfwPlatformIconifyWindow(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +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
2010-09-07 15:34:51 +00:00
return;
}
2010-10-27 15:53:24 +00:00
XIconifyWindow(_glfwLibrary.X11.display,
window->X11.handle,
_glfwLibrary.X11.screen);
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Window un-iconification
//========================================================================
2010-09-09 16:15:32 +00:00
void _glfwPlatformRestoreWindow(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
2010-09-09 16:15:32 +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
2010-09-07 15:34:51 +00:00
return;
}
XMapWindow(_glfwLibrary.X11.display, window->X11.handle);
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Read back framebuffer parameters from the context
//========================================================================
2012-08-03 13:21:49 +00:00
void _glfwPlatformRefreshWindowParams(_GLFWwindow* window)
2010-09-07 15:34:51 +00:00
{
// Retrieve refresh rate if possible
2010-10-13 21:05:17 +00:00
if (_glfwLibrary.X11.RandR.available)
2010-09-07 15:34:51 +00:00
{
#if defined(_GLFW_HAS_XRANDR)
XRRScreenConfiguration* sc;
sc = XRRGetScreenInfo(_glfwLibrary.X11.display, _glfwLibrary.X11.root);
2010-09-09 16:15:32 +00:00
window->refreshRate = XRRConfigCurrentRate(sc);
2010-09-08 13:51:25 +00:00
XRRFreeScreenConfigInfo(sc);
#endif /*_GLFW_HAS_XRANDR*/
2010-09-07 15:34:51 +00:00
}
else if (_glfwLibrary.X11.VidMode.available)
2010-09-07 15:34:51 +00:00
{
#if defined(_GLFW_HAS_XF86VIDMODE)
XF86VidModeModeLine modeline;
int dotclock;
float pixels_per_second, pixels_per_frame;
2010-09-07 15:34:51 +00:00
// Use the XF86VidMode extension to get current video mode
2011-05-21 15:34:17 +00:00
XF86VidModeGetModeLine(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
2010-09-08 13:51:25 +00:00
&dotclock, &modeline);
2010-09-07 15:34:51 +00:00
pixels_per_second = 1000.0f * (float) dotclock;
pixels_per_frame = (float) modeline.htotal * modeline.vtotal;
2011-11-02 16:34:27 +00:00
window->refreshRate = (int) (pixels_per_second / pixels_per_frame + 0.5);
#endif /*_GLFW_HAS_XF86VIDMODE*/
2010-09-07 15:34:51 +00:00
}
2011-03-07 13:58:10 +00:00
else
{
// Zero means unknown according to the GLFW spec
window->refreshRate = 0;
}
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Poll for new window and input events
//========================================================================
2010-09-08 13:51:25 +00:00
void _glfwPlatformPollEvents(void)
2010-09-07 15:34:51 +00:00
{
2010-09-09 22:06:23 +00:00
_GLFWwindow* window;
2010-09-09 16:15:32 +00:00
2010-09-07 15:34:51 +00:00
// Process all pending events
2010-09-09 16:15:32 +00:00
while (XPending(_glfwLibrary.X11.display))
2010-09-09 22:06:23 +00:00
processSingleEvent();
2010-09-07 15:34:51 +00:00
// Did the cursor move in an active window that has captured the cursor
window = _glfwLibrary.activeWindow;
if (window)
2010-09-07 15:34:51 +00:00
{
if (window->cursorMode == GLFW_CURSOR_CAPTURED &&
!window->X11.cursorCentered)
2010-09-09 22:06:23 +00:00
{
_glfwPlatformSetCursorPos(window,
window->width / 2,
window->height / 2);
window->X11.cursorCentered = GL_TRUE;
// NOTE: This is a temporary fix. It works as long as you use
// offsets accumulated over the course of a frame, instead of
// performing the necessary actions per callback call.
XFlush( _glfwLibrary.X11.display );
2010-09-09 22:06:23 +00:00
}
2010-09-07 15:34:51 +00:00
}
}
//========================================================================
// Wait for new window and input events
//========================================================================
2010-09-08 13:51:25 +00:00
void _glfwPlatformWaitEvents(void)
2010-09-07 15:34:51 +00:00
{
XEvent event;
// Block waiting for an event to arrive
2010-09-09 16:15:32 +00:00
XNextEvent(_glfwLibrary.X11.display, &event);
XPutBackEvent(_glfwLibrary.X11.display, &event);
2010-09-07 15:34:51 +00:00
_glfwPlatformPollEvents();
}
//========================================================================
// Set physical cursor position
2010-09-07 15:34:51 +00:00
//========================================================================
void _glfwPlatformSetCursorPos(_GLFWwindow* window, int x, int 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
window->X11.cursorPosX = x;
window->X11.cursorPosY = y;
2010-09-07 15:34:51 +00:00
XWarpPointer(_glfwLibrary.X11.display, None, window->X11.handle, 0,0,0,0, x, y);
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Set physical cursor mode
2010-09-07 15:34:51 +00:00
//========================================================================
void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
2010-09-07 15:34:51 +00:00
{
switch (mode)
2010-09-07 15:34:51 +00:00
{
case GLFW_CURSOR_NORMAL:
showCursor(window);
break;
case GLFW_CURSOR_HIDDEN:
hideCursor(window);
break;
case GLFW_CURSOR_CAPTURED:
captureCursor(window);
break;
2010-09-07 15:34:51 +00:00
}
}