mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-12-02 00:54:36 +00:00
Code Issues Packages Projects Releases Wiki Activity
6381d7ed20
glfw/src/x11_window.c

3356 lines
104 KiB
C
Raw Normal View History

Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
//========================================================================
Start 3.4
2019-04-16 12:43:29 +00:00
// GLFW 3.4 X11 - www.glfw.org
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
Fix copyright years (somewhat)
2019-04-15 18:50:00 +00:00
// Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
//
// 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.
//
//========================================================================
Add C dialect reminders to each source file Files built for Win32 must use C89 style declarations for compatibility with VS 2010 and 2012, which are still supported by GLFW.
2019-05-20 13:24:14 +00:00
// It is fine to use C99 in this file because it will not be built with VS
//========================================================================
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
#include "internal.h"
Add conditional compilation for platform units This is a step towards being able to compile GLFW manually without needing to duplicate a lot of platform- or OS-specific logic.
2021-11-09 18:44:00 +00:00
#if defined(_GLFW_X11)
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
#include <X11/cursorfont.h>
Added support for Cygwin-X. Fixes #406.
2015-01-27 23:04:59 +00:00
#include <X11/Xmd.h>
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
X11: Fix event polling when event fd > 1023 This replaces select with poll for checking for data on event file descriptors, as select cannot handle file descriptors larger than 1023. Closes #2024
2022-02-01 21:05:55 +00:00
#include <poll.h>
Moved inclusion directive to proper location.
2012-08-12 14:06:22 +00:00
Made system header inclusion more conservative.
2010-09-08 15:01:39 +00:00
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
Moved to WM_STATE for iconify events.
2013-01-21 18:57:03 +00:00
#include <limits.h>
Fix EINTR not being handled for select on X11 Closes #580.
2015-08-14 11:49:52 +00:00
#include <errno.h>
Fix XIM input on non-UTF-8 locales
2015-10-09 11:23:34 +00:00
#include <assert.h>
Initial import of 2.7 Lite.
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
Added two-dimensional scrolling API and X11 implementation.
2010-09-27 00:09:54 +00:00
// Additional mouse button names for XButtonEvent
X11 copying code and support PRIMARY & CLIPBOARD clipboards.
2011-09-22 11:03:45 +00:00
#define Button6 6
#define Button7 7
Merged context creation BacMatch workaround from 2.7.1.
2010-10-04 20:18:58 +00:00
X11: Fix decoration enabling after window creation This fixes the enabling of window decorations after creation. Instead of removing the _MOTIF_WM_HINTS property, we now set or unset the MWM_DECOR_ALL bit of the decorations field. Fixes #1566.
2019-09-26 16:29:37 +00:00
// Motif WM hints flags
#define MWM_HINTS_DECORATIONS 2
#define MWM_DECOR_ALL 1
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
#define _GLFW_XDND_VERSION 5
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
// Wait for event data to arrive on the X11 display socket
// This avoids blocking other threads via the per-display Xlib lock that also
// covers GLX functions
//
static GLFWbool waitForX11Event(double* timeout)
{
struct pollfd fd = { ConnectionNumber(_glfw.x11.display), POLLIN };
X11: Fix glfwWaitEvents* ignoring joystick events The data available on the X11 connection may be a reply or an internal event for an X11 extension. Previously the check for whether an event was available for us was done outside waitForEvent. This prevented data available on other file descriptors from breaking the outer wait loop. This commit moves the check for whether an event is available into the wait functions, where there is enough knowledge to limit the check to the X11 connection. Related to #932
2022-02-18 14:20:10 +00:00
while (!XPending(_glfw.x11.display))
{
Share X11 fd polling logic with Wayland This moves the X11 polling implementation to a separate file where it can be used by either the X11 or Wayland backend or both. This code should be POSIX compatible where necessary but will use the lower latency but non-standard polling functions ppoll or pollts where those are available. This commit is based on work by OlivierSohn and kovidgoyal. Fixes #1281 Closes #1285
2022-03-03 20:26:11 +00:00
if (!_glfwPollPOSIX(&fd, 1, timeout))
X11: Fix glfwWaitEvents* ignoring joystick events The data available on the X11 connection may be a reply or an internal event for an X11 extension. Previously the check for whether an event was available for us was done outside waitForEvent. This prevented data available on other file descriptors from breaking the outer wait loop. This commit moves the check for whether an event is available into the wait functions, where there is enough knowledge to limit the check to the X11 connection. Related to #932
2022-02-18 14:20:10 +00:00
return GLFW_FALSE;
}
return GLFW_TRUE;
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
}
// Wait for event data to arrive on any event file descriptor
// This avoids blocking other threads via the per-display Xlib lock that also
// covers GLX functions
//
static GLFWbool waitForAnyEvent(double* timeout)
{
X11: Fix empty event race condition with a pipe There is a seemingly unavoidable race condition when waiting for data on the X11 display connection, as long as any other thread is also making Xlib calls. The event data we are waiting for could be read by the other thread as part of looking for the reply to its request, before our poll has begun. This commit replaces the X11 event sent by glfwPostEmptyEvent with writing to an unnamed pipe. The race condition remains if other Xlib calls are made on other threads, but glfwPostEmptyEvent should now be race-free. This commit is based on work by pcwalton, OlivierSohn, kovidgoyal and joaodasilva. Closes #2033 Related to #379 Related to #1281 Related to #1285
2022-02-18 13:29:43 +00:00
nfds_t count = 2;
struct pollfd fds[3] =
{
{ ConnectionNumber(_glfw.x11.display), POLLIN },
{ _glfw.x11.emptyEventPipe[0], POLLIN }
};
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
Linux: Fix joystick input being disabled Closes #2192
2022-12-15 19:18:59 +00:00
#if defined(GLFW_BUILD_LINUX_JOYSTICK)
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
if (_glfw.joysticksInitialized)
fds[count++] = (struct pollfd) { _glfw.linjs.inotify, POLLIN };
#endif
X11: Fix glfwWaitEvents* ignoring joystick events The data available on the X11 connection may be a reply or an internal event for an X11 extension. Previously the check for whether an event was available for us was done outside waitForEvent. This prevented data available on other file descriptors from breaking the outer wait loop. This commit moves the check for whether an event is available into the wait functions, where there is enough knowledge to limit the check to the X11 connection. Related to #932
2022-02-18 14:20:10 +00:00
while (!XPending(_glfw.x11.display))
{
Share X11 fd polling logic with Wayland This moves the X11 polling implementation to a separate file where it can be used by either the X11 or Wayland backend or both. This code should be POSIX compatible where necessary but will use the lower latency but non-standard polling functions ppoll or pollts where those are available. This commit is based on work by OlivierSohn and kovidgoyal. Fixes #1281 Closes #1285
2022-03-03 20:26:11 +00:00
if (!_glfwPollPOSIX(fds, count, timeout))
X11: Fix glfwWaitEvents* ignoring joystick events The data available on the X11 connection may be a reply or an internal event for an X11 extension. Previously the check for whether an event was available for us was done outside waitForEvent. This prevented data available on other file descriptors from breaking the outer wait loop. This commit moves the check for whether an event is available into the wait functions, where there is enough knowledge to limit the check to the X11 connection. Related to #932
2022-02-18 14:20:10 +00:00
return GLFW_FALSE;
for (int i = 1; i < count; i++)
{
if (fds[i].revents & POLLIN)
return GLFW_TRUE;
}
}
return GLFW_TRUE;
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
}
X11: Fix empty event race condition with a pipe There is a seemingly unavoidable race condition when waiting for data on the X11 display connection, as long as any other thread is also making Xlib calls. The event data we are waiting for could be read by the other thread as part of looking for the reply to its request, before our poll has begun. This commit replaces the X11 event sent by glfwPostEmptyEvent with writing to an unnamed pipe. The race condition remains if other Xlib calls are made on other threads, but glfwPostEmptyEvent should now be race-free. This commit is based on work by pcwalton, OlivierSohn, kovidgoyal and joaodasilva. Closes #2033 Related to #379 Related to #1281 Related to #1285
2022-02-18 13:29:43 +00:00
// Writes a byte to the empty event pipe
//
static void writeEmptyEvent(void)
{
for (;;)
{
const char byte = 0;
POSIX: Fix data type of return values
2022-03-22 19:11:42 +00:00
const ssize_t result = write(_glfw.x11.emptyEventPipe[1], &byte, 1);
X11: Fix empty event race condition with a pipe There is a seemingly unavoidable race condition when waiting for data on the X11 display connection, as long as any other thread is also making Xlib calls. The event data we are waiting for could be read by the other thread as part of looking for the reply to its request, before our poll has begun. This commit replaces the X11 event sent by glfwPostEmptyEvent with writing to an unnamed pipe. The race condition remains if other Xlib calls are made on other threads, but glfwPostEmptyEvent should now be race-free. This commit is based on work by pcwalton, OlivierSohn, kovidgoyal and joaodasilva. Closes #2033 Related to #379 Related to #1281 Related to #1285
2022-02-18 13:29:43 +00:00
if (result == 1 || (result == -1 && errno != EINTR))
break;
}
}
// Drains available data from the empty event pipe
//
static void drainEmptyEvents(void)
{
for (;;)
{
char dummy[64];
POSIX: Fix data type of return values
2022-03-22 19:11:42 +00:00
const ssize_t result = read(_glfw.x11.emptyEventPipe[0], dummy, sizeof(dummy));
X11: Fix empty event race condition with a pipe There is a seemingly unavoidable race condition when waiting for data on the X11 display connection, as long as any other thread is also making Xlib calls. The event data we are waiting for could be read by the other thread as part of looking for the reply to its request, before our poll has begun. This commit replaces the X11 event sent by glfwPostEmptyEvent with writing to an unnamed pipe. The race condition remains if other Xlib calls are made on other threads, but glfwPostEmptyEvent should now be race-free. This commit is based on work by pcwalton, OlivierSohn, kovidgoyal and joaodasilva. Closes #2033 Related to #379 Related to #1281 Related to #1285
2022-02-18 13:29:43 +00:00
if (result == -1 && errno != EINTR)
break;
}
}
X11: Fix BadMatch on XSetInputFocus Input focus was in some cases set before the window was visible (ICCCM section 4.2.2). Related to #798. Fixes #789.
2016-08-10 14:22:03 +00:00
// Waits until a VisibilityNotify event arrives for the specified window or the
// timeout period elapses (ICCCM section 4.2.2)
//
static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
{
XEvent dummy;
double timeout = 0.1;
while (!XCheckTypedWindowEvent(_glfw.x11.display,
window->x11.handle,
VisibilityNotify,
&dummy))
{
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
if (!waitForX11Event(&timeout))
X11: Fix BadMatch on XSetInputFocus Input focus was in some cases set before the window was visible (ICCCM section 4.2.2). Related to #798. Fixes #789.
2016-08-10 14:22:03 +00:00
return GLFW_FALSE;
}
return GLFW_TRUE;
}
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
// Returns whether the window is iconified
//
static int getWindowState(_GLFWwindow* window)
{
int result = WithdrawnState;
struct {
CARD32 state;
Window icon;
} *state = NULL;
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 17:16:46 +00:00
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.WM_STATE,
_glfw.x11.WM_STATE,
(unsigned char**) &state) >= 2)
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
{
result = state->state;
}
X11: Fix potential window property data leaks
2017-01-16 00:36:14 +00:00
if (state)
XFree(state);
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
return result;
}
Cleanup
2016-07-25 11:57:06 +00:00
// Returns whether the event is a selection event
//
static Bool isSelectionEvent(Display* display, XEvent* event, XPointer pointer)
{
X11: Make selection event checks include window
2016-09-06 13:15:23 +00:00
if (event->xany.window != _glfw.x11.helperWindowHandle)
return False;
Cleanup
2016-07-25 11:57:06 +00:00
return event->type == SelectionRequest ||
event->type == SelectionNotify ||
event->type == SelectionClear;
}
Fix comment
2016-08-10 13:21:12 +00:00
// Returns whether it is a _NET_FRAME_EXTENTS event for the specified window
Added support for _NET_REQUEST_FRAME_EXTENTS.
2014-03-30 10:24:18 +00:00
//
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;
}
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
// Returns whether it is a property event for the specified selection transfer
//
static Bool isSelPropNewValueNotify(Display* display, XEvent* event, XPointer pointer)
{
XEvent* notification = (XEvent*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == notification->xselection.requestor &&
event->xproperty.atom == notification->xselection.property;
}
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
// Translates an X event modifier state mask
//
Formatting.
2013-05-30 22:09:37 +00:00
static int translateState(int state)
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
{
int mods = 0;
if (state & ShiftMask)
mods |= GLFW_MOD_SHIFT;
if (state & ControlMask)
Renamed control modifier bit to match key token.
2013-05-23 12:11:05 +00:00
mods |= GLFW_MOD_CONTROL;
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
if (state & Mod1Mask)
mods |= GLFW_MOD_ALT;
Added super modifier bit. Edited during merge.
2013-05-23 11:22:27 +00:00
if (state & Mod4Mask)
mods |= GLFW_MOD_SUPER;
Add lock key modifier bits input mode This adds the GLFW_MOD_CAPS_LOCK and GLFW_MOD_NUM_LOCK modifier bits. Set the GLFW_LOCK_KEY_MODS input mode to enable these for all callbacks that receive modifier bits. Fixes #946.
2017-11-29 19:42:37 +00:00
if (state & LockMask)
mods |= GLFW_MOD_CAPS_LOCK;
if (state & Mod2Mask)
mods |= GLFW_MOD_NUM_LOCK;
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
return mods;
}
Clarify comment for X11 translateKey
2015-08-16 13:12:02 +00:00
// Translates an X11 key code to a GLFW key token
Simplified function comment headers.
2013-02-04 12:22:10 +00:00
//
Changed all key translation to arrays.
2014-03-30 14:23:22 +00:00
static int translateKey(int scancode)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Changed all key translation to arrays.
2014-03-30 14:23:22 +00:00
// Use the pre-filled LUT (see createKeyTables() in x11_init.c)
if (scancode < 0 || scancode > 255)
Formatting.
2014-03-30 10:32:17 +00:00
return GLFW_KEY_UNKNOWN;
Added scancode to key callback.
2013-05-30 15:19:12 +00:00
Cleanup
2016-09-07 13:43:39 +00:00
return _glfw.x11.keycodes[scancode];
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Simplified sending events to WM.
2015-06-02 15:05:00 +00:00
// Sends an EWMH or ICCCM event to the window manager
Added GLFW_FLOATING. Fixes #23.
2014-05-23 12:01:02 +00:00
//
Simplified sending events to WM.
2015-06-02 15:05:00 +00:00
static void sendEventToWM(_GLFWwindow* window, Atom type,
long a, long b, long c, long d, long e)
Added GLFW_FLOATING. Fixes #23.
2014-05-23 12:01:02 +00:00
{
X11: Let the language initialize XEvent structs
2019-06-04 14:59:04 +00:00
XEvent event = { ClientMessage };
Added GLFW_FLOATING. Fixes #23.
2014-05-23 12:01:02 +00:00
event.xclient.window = window->x11.handle;
event.xclient.format = 32; // Data is 32-bit longs
Simplified sending events to WM.
2015-06-02 15:05:00 +00:00
event.xclient.message_type = type;
event.xclient.data.l[0] = a;
event.xclient.data.l[1] = b;
event.xclient.data.l[2] = c;
event.xclient.data.l[3] = d;
event.xclient.data.l[4] = e;
Added GLFW_FLOATING. Fixes #23.
2014-05-23 12:01:02 +00:00
Formatting.
2015-06-02 15:27:35 +00:00
XSendEvent(_glfw.x11.display, _glfw.x11.root,
Added GLFW_FLOATING. Fixes #23.
2014-05-23 12:01:02 +00:00
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&event);
}
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
// Updates the normal hints according to the window settings
//
Fix GLFW_RESIZABLE on X11 when exiting full screen The WM normal hints were set with the wrong window dimensions. Fixes #737.
2016-05-03 09:28:23 +00:00
static void updateNormalHints(_GLFWwindow* window, int width, int height)
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
{
XSizeHints* hints = XAllocSizeHints();
X11: Preserve unrelated values in WM_NORMAL_HINTS This stops GLFW overwriting the whole WM_NORMAL_HINTS property every time it updates size-related parts of it.
2021-10-26 18:30:29 +00:00
long supplied;
XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied);
hints->flags &= ~(PMinSize | PMaxSize | PAspect);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
if (!window->monitor)
{
if (window->resizable)
{
X11: Fix application of window size limits Closes #805.
2016-07-13 21:31:51 +00:00
if (window->minwidth != GLFW_DONT_CARE &&
window->minheight != GLFW_DONT_CARE)
{
Cleanup Cleanup of a42d27011b3ef1e6229a1b83aaa075727a5521f3.
2016-07-22 15:39:39 +00:00
hints->flags |= PMinSize;
X11: Fix application of window size limits Closes #805.
2016-07-13 21:31:51 +00:00
hints->min_width = window->minwidth;
hints->min_height = window->minheight;
}
if (window->maxwidth != GLFW_DONT_CARE &&
window->maxheight != GLFW_DONT_CARE)
{
Cleanup Cleanup of a42d27011b3ef1e6229a1b83aaa075727a5521f3.
2016-07-22 15:39:39 +00:00
hints->flags |= PMaxSize;
X11: Fix application of window size limits Closes #805.
2016-07-13 21:31:51 +00:00
hints->max_width = window->maxwidth;
hints->max_height = window->maxheight;
}
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
if (window->numer != GLFW_DONT_CARE &&
window->denom != GLFW_DONT_CARE)
{
hints->flags |= PAspect;
hints->min_aspect.x = hints->max_aspect.x = window->numer;
hints->min_aspect.y = hints->max_aspect.y = window->denom;
}
}
else
{
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);
}
// Updates the full screen status of the window
//
static void updateWindowMode(_GLFWwindow* window)
{
if (window->monitor)
{
if (_glfw.x11.xinerama.available &&
_glfw.x11.NET_WM_FULLSCREEN_MONITORS)
{
sendEventToWM(window,
_glfw.x11.NET_WM_FULLSCREEN_MONITORS,
window->monitor->x11.index,
window->monitor->x11.index,
window->monitor->x11.index,
window->monitor->x11.index,
0);
}
if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_FULLSCREEN,
0, 1, 0);
}
else
{
// 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 full screen windows
// easy to do; the bad thing is that we have to do everything
// manually and some things (like iconify/restore) won't work at
// all, as those are tasks usually performed by the window manager
XSetWindowAttributes attributes;
attributes.override_redirect = True;
XChangeWindowAttributes(_glfw.x11.display,
window->x11.handle,
CWOverrideRedirect,
&attributes);
window->x11.overrideRedirect = GLFW_TRUE;
}
Unconditionally use some EWMH atoms These window properties do no harm if they're declared even if the WM doesn't support them. This makes GLFW slightly more tolerant of WM changes as well as things like Ubuntu Unity reading _NET_WM_ICON without declaring support for it.
2016-05-03 09:58:25 +00:00
// Enable compositor bypass
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
if (!window->x11.transparent)
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
{
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);
}
}
else
{
if (_glfw.x11.xinerama.available &&
_glfw.x11.NET_WM_FULLSCREEN_MONITORS)
{
XDeleteProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_FULLSCREEN_MONITORS);
}
if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_REMOVE,
_glfw.x11.NET_WM_STATE_FULLSCREEN,
0, 1, 0);
}
else
{
XSetWindowAttributes attributes;
attributes.override_redirect = False;
XChangeWindowAttributes(_glfw.x11.display,
window->x11.handle,
CWOverrideRedirect,
&attributes);
window->x11.overrideRedirect = GLFW_FALSE;
}
Unconditionally use some EWMH atoms These window properties do no harm if they're declared even if the WM doesn't support them. This makes GLFW slightly more tolerant of WM changes as well as things like Ubuntu Unity reading _NET_WM_ICON without declaring support for it.
2016-05-03 09:58:25 +00:00
// Disable compositor bypass
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
if (!window->x11.transparent)
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
{
XDeleteProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_BYPASS_COMPOSITOR);
}
}
}
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
// Decode a Unicode code point from a UTF-8 stream
// Based on cutef8 by Jeff Bezanson (Public Domain)
//
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
static uint32_t decodeUTF8(const char** s)
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
{
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
uint32_t codepoint = 0, count = 0;
static const uint32_t offsets[] =
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
{
0x00000000u, 0x00003080u, 0x000e2080u,
0x03c82080u, 0xfa082080u, 0x82082080u
};
do
{
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
codepoint = (codepoint << 6) + (unsigned char) **s;
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
(*s)++;
count++;
} while ((**s & 0xc0) == 0x80);
assert(count <= 6);
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
return codepoint - offsets[count - 1];
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
}
// Convert the specified Latin-1 string to UTF-8
//
static char* convertLatin1toUTF8(const char* source)
{
size_t size = 1;
const char* sp;
for (sp = source; *sp; sp++)
size += (*sp & 0x80) ? 2 : 1;
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
char* target = _glfw_calloc(size, 1);
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
char* tp = target;
for (sp = source; *sp; sp++)
Move UTF-8 encoding to shared code This will be used by the Wayland code too.
2021-12-30 17:22:16 +00:00
tp += _glfwEncodeUTF8(tp, *sp);
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
return target;
}
Simplify cursor window logic
2016-05-30 19:21:09 +00:00
// Updates the cursor image according to its cursor mode
//
static void updateCursorImage(_GLFWwindow* window)
{
Add cursor mode GLFW_CURSOR_CAPTURED This adds a cursor mode that provides a visible cursor confined to the content area of the window. Fixes #58
2019-12-03 16:58:20 +00:00
if (window->cursorMode == GLFW_CURSOR_NORMAL ||
window->cursorMode == GLFW_CURSOR_CAPTURED)
Simplify cursor window logic
2016-05-30 19:21:09 +00:00
{
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_glfw.x11.display, window->x11.handle);
}
else
Cleanup
2016-09-06 14:21:15 +00:00
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
_glfw.x11.hiddenCursorHandle);
}
Simplify cursor window logic
2016-05-30 19:21:09 +00:00
}
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
// Grabs the cursor and confines it to the window
//
static void captureCursor(_GLFWwindow* window)
{
XGrabPointer(_glfw.x11.display, window->x11.handle, True,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync,
window->x11.handle,
None,
CurrentTime);
}
// Ungrabs the cursor
//
static void releaseCursor(void)
{
XUngrabPointer(_glfw.x11.display, CurrentTime);
}
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
// Enable XI2 raw mouse motion events
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
//
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
static void enableRawMouseMotion(_GLFWwindow* window)
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
{
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
XIEventMask em;
unsigned char mask[XIMaskLen(XI_RawMotion)] = { 0 };
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
em.deviceid = XIAllMasterDevices;
em.mask_len = sizeof(mask);
em.mask = mask;
XISetMask(mask, XI_RawMotion);
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
XISelectEvents(_glfw.x11.display, _glfw.x11.root, &em, 1);
}
// Disable XI2 raw mouse motion events
//
static void disableRawMouseMotion(_GLFWwindow* window)
{
XIEventMask em;
unsigned char mask[] = { 0 };
em.deviceid = XIAllMasterDevices;
em.mask_len = sizeof(mask);
em.mask = mask;
XISelectEvents(_glfw.x11.display, _glfw.x11.root, &em, 1);
}
// Apply disabled cursor mode to a focused window
//
static void disableCursor(_GLFWwindow* window)
{
if (window->rawMouseMotion)
enableRawMouseMotion(window);
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
_glfw.x11.disabledCursorWindow = window;
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetCursorPosX11(window,
&_glfw.x11.restoreCursorPosX,
&_glfw.x11.restoreCursorPosY);
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
updateCursorImage(window);
Cleanup Replace client area with content area.
2019-01-22 19:54:16 +00:00
_glfwCenterCursorInContentArea(window);
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
captureCursor(window);
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
}
// Exit disabled cursor mode for the specified window
//
static void enableCursor(_GLFWwindow* window)
{
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
if (window->rawMouseMotion)
disableRawMouseMotion(window);
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
_glfw.x11.disabledCursorWindow = NULL;
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
releaseCursor();
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwSetCursorPosX11(window,
_glfw.x11.restoreCursorPosX,
_glfw.x11.restoreCursorPosY);
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
updateCursorImage(window);
}
X11: Add support for XIM callbacks This adds support for the XIM instantiate and destroy callbacks, letting GLFW detect both when the current input method disappears and when a new one is started. Tested with ibus.
2020-01-22 19:12:36 +00:00
// Clear its handle when the input context has been destroyed
//
static void inputContextDestroyCallback(XIC ic, XPointer clientData, XPointer callData)
{
_GLFWwindow* window = (_GLFWwindow*) clientData;
window->x11.ic = NULL;
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
// Create the X11 window (and its colormap)
Simplified function comment headers.
2013-02-04 12:22:10 +00:00
//
Cleanup
2016-07-25 17:36:25 +00:00
static GLFWbool createNativeWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
Visual* visual, int depth)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Add GLFW_SCALE_TO_MONITOR This adds the GLFW_SCALE_TO_MONITOR window hint for automatically resizing the content area of a window to the requested size times the monitor content scale each time it is placed on a new monitor. This only applies to windowed mode windows and includes the initial placement at window creation. This hint only has an effect on platforms where screen coordinates and pixels always map 1:1 such as Windows and X11. Platforms like macOS instead change the resolution of the framebuffer independently of the window size. Related to #676. Related to #1115.
2018-08-31 11:33:48 +00:00
int width = wndconfig->width;
int height = wndconfig->height;
if (wndconfig->scaleToMonitor)
{
width *= _glfw.x11.contentScaleX;
height *= _glfw.x11.contentScaleY;
}
Add window hints for initial position This adds window hints for the initial position, in screen coordinates, of a window. The special value GLFW_ANY_POSITION means the window manager will be allowed to position the window. It is not possible to set window positions on Wayland and GLFW will always behave as if these hints are set to GLFW_ANY_POSITION. Fixes #1603 Fixes #1747
2021-10-26 12:25:03 +00:00
int xpos = 0, ypos = 0;
if (wndconfig->xpos != GLFW_ANY_POSITION && wndconfig->ypos != GLFW_ANY_POSITION)
{
xpos = wndconfig->xpos;
ypos = wndconfig->ypos;
}
Remove completed todo
2016-05-23 20:59:11 +00:00
// Create a colormap based on the visual used by the current context
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
window->x11.colormap = XCreateColormap(_glfw.x11.display,
_glfw.x11.root,
Add GLFW_NO_API for creating context-less windows
2015-06-18 12:03:02 +00:00
visual,
Removed duplicate width and height parameters already included in window struct.
2010-09-13 21:42:51 +00:00
AllocNone);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
window->x11.transparent = _glfwIsVisualTransparentX11(visual);
X11: Cleanup We can use C99 now and also we will need the event mask below.
2019-12-22 08:12:59 +00:00
XSetWindowAttributes wa = { 0 };
wa.colormap = window->x11.colormap;
wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
ExposureMask | FocusChangeMask | VisibilityChangeMask |
EnterWindowMask | LeaveWindowMask | PropertyChangeMask;
_glfwGrabErrorHandlerX11();
X11: Fix parent window handle initialization This should have been initialized to the screen root, not None. This issue was introduced by fe57e3c2921a1901390534e1e51053df70b5644b. Fixes #1620.
2020-01-12 16:18:21 +00:00
window->x11.parent = _glfw.x11.root;
X11: Cleanup We can use C99 now and also we will need the event mask below.
2019-12-22 08:12:59 +00:00
window->x11.handle = XCreateWindow(_glfw.x11.display,
_glfw.x11.root,
Add window hints for initial position This adds window hints for the initial position, in screen coordinates, of a window. The special value GLFW_ANY_POSITION means the window manager will be allowed to position the window. It is not possible to set window positions on Wayland and GLFW will always behave as if these hints are set to GLFW_ANY_POSITION. Fixes #1603 Fixes #1747
2021-10-26 12:25:03 +00:00
xpos, ypos,
X11: Cleanup We can use C99 now and also we will need the event mask below.
2019-12-22 08:12:59 +00:00
width, height,
0, // Border width
depth, // Color depth
InputOutput,
visual,
CWBorderPixel | CWColormap | CWEventMask,
&wa);
_glfwReleaseErrorHandlerX11();
if (!window->x11.handle)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
X11: Cleanup We can use C99 now and also we will need the event mask below.
2019-12-22 08:12:59 +00:00
_glfwInputErrorX11(GLFW_PLATFORM_ERROR,
"X11: Failed to create window");
return GLFW_FALSE;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
X11: Cleanup We can use C99 now and also we will need the event mask below.
2019-12-22 08:12:59 +00:00
XSaveContext(_glfw.x11.display,
window->x11.handle,
_glfw.x11.context,
(XPointer) window);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
if (!wndconfig->decorated)
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwSetWindowDecoratedX11(window, GLFW_FALSE);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
if (_glfw.x11.NET_WM_STATE && !window->monitor)
Cleanup.
2015-06-16 10:10:20 +00:00
{
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
Atom states[3];
int count = 0;
if (wndconfig->floating)
Fix Motif hints being set for X11 full screen Related to #575.
2015-08-12 15:21:46 +00:00
{
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
if (_glfw.x11.NET_WM_STATE_ABOVE)
states[count++] = _glfw.x11.NET_WM_STATE_ABOVE;
Cleanup.
2015-06-16 10:10:20 +00:00
}
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
if (wndconfig->maximized)
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
if (_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
states[count++] = _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT;
states[count++] = _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ;
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
window->x11.maximized = GLFW_TRUE;
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
}
}
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
Fix NET_WM_STATE clobbering at creation
2016-05-03 09:38:45 +00:00
if (count)
{
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_STATE, XA_ATOM, 32,
X11: Cleanup This is technically valid but misleading and may inspire future bugs like the one fixed by 0b652a44d2afe593d6eca8a0d586c20555a0497c.
2019-12-17 01:17:31 +00:00
PropModeReplace, (unsigned char*) states, count);
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
}
Cleanup.
2015-06-16 10:10:20 +00:00
}
Comment updates and formatting.
2012-08-26 13:38:18 +00:00
// Declare the WM protocols supported by GLFW
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Unconditionally use some EWMH atoms These window properties do no harm if they're declared even if the WM doesn't support them. This makes GLFW slightly more tolerant of WM changes as well as things like Ubuntu Unity reading _NET_WM_ICON without declaring support for it.
2016-05-03 09:58:25 +00:00
Atom protocols[] =
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Unconditionally use some EWMH atoms These window properties do no harm if they're declared even if the WM doesn't support them. This makes GLFW slightly more tolerant of WM changes as well as things like Ubuntu Unity reading _NET_WM_ICON without declaring support for it.
2016-05-03 09:58:25 +00:00
_glfw.x11.WM_DELETE_WINDOW,
_glfw.x11.NET_WM_PING
};
XSetWMProtocols(_glfw.x11.display, window->x11.handle,
protocols, sizeof(protocols) / sizeof(Atom));
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Unconditionally use some EWMH atoms These window properties do no harm if they're declared even if the WM doesn't support them. This makes GLFW slightly more tolerant of WM changes as well as things like Ubuntu Unity reading _NET_WM_ICON without declaring support for it.
2016-05-03 09:58:25 +00:00
// Declare our PID
Added setting of _NET_WM_PID.
2013-05-02 14:31:27 +00:00
{
X11: Fix read past top of stack on 64-bit Fixes #951.
2017-02-23 02:26:55 +00:00
const long pid = getpid();
Added setting of _NET_WM_PID.
2013-05-02 14:31:27 +00:00
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_PID, XA_CARDINAL, 32,
PropModeReplace,
(unsigned char*) &pid, 1);
}
Add support for EWMH _NET_WM_WINDOW_TYPE
2016-03-14 19:47:48 +00:00
if (_glfw.x11.NET_WM_WINDOW_TYPE && _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL)
{
Atom type = _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_WINDOW_TYPE, XA_ATOM, 32,
PropModeReplace, (unsigned char*) &type, 1);
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
// Set ICCCM WM_HINTS property
{
Formatting pass (no code changes).
2010-09-08 13:58:43 +00:00
XWMHints* hints = XAllocWMHints();
Formatting pass (no code changes).
2010-09-08 13:51:25 +00:00
if (!hints)
Added basic error reporting to X11 port.
2010-09-09 19:52:31 +00:00
{
Renamed _glfwInputError and moved to event API.
2012-12-31 20:05:28 +00:00
_glfwInputError(GLFW_OUT_OF_MEMORY,
"X11: Failed to allocate WM hints");
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_FALSE;
Added basic error reporting to X11 port.
2010-09-09 19:52:31 +00:00
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
hints->flags = StateHint;
hints->initial_state = NormalState;
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XSetWMHints(_glfw.x11.display, window->x11.handle, hints);
Formatting pass (no code changes).
2010-09-08 13:51:25 +00:00
XFree(hints);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
X11: Preserve unrelated values in WM_NORMAL_HINTS This stops GLFW overwriting the whole WM_NORMAL_HINTS property every time it updates size-related parts of it.
2021-10-26 18:30:29 +00:00
// Set ICCCM WM_NORMAL_HINTS property
{
XSizeHints* hints = XAllocSizeHints();
if (!hints)
{
_glfwInputError(GLFW_OUT_OF_MEMORY, "X11: Failed to allocate size hints");
return GLFW_FALSE;
}
if (!wndconfig->resizable)
{
hints->flags |= (PMinSize | PMaxSize);
hints->min_width = hints->max_width = width;
hints->min_height = hints->max_height = height;
}
Add window hints for initial position This adds window hints for the initial position, in screen coordinates, of a window. The special value GLFW_ANY_POSITION means the window manager will be allowed to position the window. It is not possible to set window positions on Wayland and GLFW will always behave as if these hints are set to GLFW_ANY_POSITION. Fixes #1603 Fixes #1747
2021-10-26 12:25:03 +00:00
// HACK: Explicitly setting PPosition to any value causes some WMs, notably
// Compiz and Metacity, to honor the position of unmapped windows
if (wndconfig->xpos != GLFW_ANY_POSITION && wndconfig->ypos != GLFW_ANY_POSITION)
{
hints->flags |= PPosition;
hints->x = 0;
hints->y = 0;
}
X11: Preserve unrelated values in WM_NORMAL_HINTS This stops GLFW overwriting the whole WM_NORMAL_HINTS property every time it updates size-related parts of it.
2021-10-26 18:30:29 +00:00
hints->flags |= PWinGravity;
hints->win_gravity = StaticGravity;
XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
XFree(hints);
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Added hack for setting WM_CLASS.
2013-10-04 11:41:19 +00:00
// Set ICCCM WM_CLASS property
{
XClassHint* hint = XAllocClassHint();
Add glfwInitHintString Adds string type init hints. Adds X11 specific init hints for WM_CLASS components. Documentation work. Fixes #893.
2017-07-24 23:55:08 +00:00
Change glfwInitHintString to glfwWindowHintString Fixes #1139.
2017-12-12 09:54:18 +00:00
if (strlen(wndconfig->x11.instanceName) &&
strlen(wndconfig->x11.className))
Add glfwInitHintString Adds string type init hints. Adds X11 specific init hints for WM_CLASS components. Documentation work. Fixes #893.
2017-07-24 23:55:08 +00:00
{
Change glfwInitHintString to glfwWindowHintString Fixes #1139.
2017-12-12 09:54:18 +00:00
hint->res_name = (char*) wndconfig->x11.instanceName;
hint->res_class = (char*) wndconfig->x11.className;
Add glfwInitHintString Adds string type init hints. Adds X11 specific init hints for WM_CLASS components. Documentation work. Fixes #893.
2017-07-24 23:55:08 +00:00
}
else
{
Change glfwInitHintString to glfwWindowHintString Fixes #1139.
2017-12-12 09:54:18 +00:00
const char* resourceName = getenv("RESOURCE_NAME");
if (resourceName && strlen(resourceName))
hint->res_name = (char*) resourceName;
else if (strlen(wndconfig->title))
hint->res_name = (char*) wndconfig->title;
else
hint->res_name = (char*) "glfw-application";
if (strlen(wndconfig->title))
hint->res_class = (char*) wndconfig->title;
else
hint->res_class = (char*) "GLFW-Application";
Add glfwInitHintString Adds string type init hints. Adds X11 specific init hints for WM_CLASS components. Documentation work. Fixes #893.
2017-07-24 23:55:08 +00:00
}
Added hack for setting WM_CLASS.
2013-10-04 11:41:19 +00:00
XSetClassHint(_glfw.x11.display, window->x11.handle, hint);
XFree(hint);
}
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
// Announce support for Xdnd (drag and drop)
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
{
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
const Atom version = _GLFW_XDND_VERSION;
Cleanup.
2013-12-22 15:38:56 +00:00
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.XdndAware, XA_ATOM, 32,
PropModeReplace, (unsigned char*) &version, 1);
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
}
Cleanup of basic XIM support. Shortened and simplified the code. Removed reporting of XIM sentinel key press event. Added credit. Updated changelog. Closes #151.
2014-09-21 00:13:41 +00:00
if (_glfw.x11.im)
X11: Add support for XIM callbacks This adds support for the XIM instantiate and destroy callbacks, letting GLFW detect both when the current input method disappears and when a new one is started. Tested with ibus.
2020-01-22 19:12:36 +00:00
_glfwCreateInputContextX11(window);
X11: Fix IC event mask not being added to our window
2019-12-22 08:23:22 +00:00
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwSetWindowTitleX11(window, wndconfig->title);
_glfwGetWindowPosX11(window, &window->x11.xpos, &window->x11.ypos);
_glfwGetWindowSizeX11(window, &window->x11.width, &window->x11.height);
Fixed duplicate events being reported.
2013-06-16 16:29:46 +00:00
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_TRUE;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
// Set the specified property to the selection converted to the requested target
//
static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
{
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
char* selectionString = NULL;
X11: Stop reporting support for COMPOUND_TEXT
2017-08-08 12:04:51 +00:00
const Atom formats[] = { _glfw.x11.UTF8_STRING, XA_STRING };
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
const int formatCount = sizeof(formats) / sizeof(formats[0]);
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
if (request->selection == _glfw.x11.PRIMARY)
selectionString = _glfw.x11.primarySelectionString;
else
selectionString = _glfw.x11.clipboardString;
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
if (request->property == None)
{
Comment and string spell check pass.
2015-01-05 20:55:15 +00:00
// The requester is a legacy client (ICCCM section 2.2)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
// 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,
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;
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
const unsigned long count =
_glfwGetWindowPropertyX11(request->requestor,
request->property,
_glfw.x11.ATOM_PAIR,
(unsigned char**) &targets);
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (unsigned long i = 0; i < count; i += 2)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
{
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,
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
(unsigned char *) selectionString,
strlen(selectionString));
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
}
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,
Added support for Cygwin-X. Fixes #406.
2015-01-27 23:04:59 +00:00
_glfw.x11.NULL_,
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
32,
PropModeReplace,
NULL,
0);
return request->property;
}
// Conversion to a data target was requested
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (int i = 0; i < formatCount; i++)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
{
if (request->target == formats[i])
{
// The requested target is one we support
XChangeProperty(_glfw.x11.display,
request->requestor,
request->property,
request->target,
8,
PropModeReplace,
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
(unsigned char *) selectionString,
strlen(selectionString));
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
return request->property;
}
}
// The requested target is not supported
return None;
}
static void handleSelectionRequest(XEvent* event)
{
const XSelectionRequestEvent* request = &event->xselectionrequest;
X11: Let the language initialize XEvent structs
2019-06-04 14:59:04 +00:00
XEvent reply = { SelectionNotify };
Formatting.
2015-06-02 15:26:23 +00:00
reply.xselection.property = writeTargetToProperty(request);
reply.xselection.display = request->display;
reply.xselection.requestor = request->requestor;
reply.xselection.selection = request->selection;
reply.xselection.target = request->target;
reply.xselection.time = request->time;
XSendEvent(_glfw.x11.display, request->requestor, False, 0, &reply);
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
}
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
static const char* getSelectionString(Atom selection)
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
{
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
char** selectionString = NULL;
X11: Stop reporting support for COMPOUND_TEXT
2017-08-08 12:04:51 +00:00
const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
if (selection == _glfw.x11.PRIMARY)
selectionString = &_glfw.x11.primarySelectionString;
else
selectionString = &_glfw.x11.clipboardString;
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
if (XGetSelectionOwner(_glfw.x11.display, selection) ==
_glfw.x11.helperWindowHandle)
{
// 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
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
return *selectionString;
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
}
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(*selectionString);
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
*selectionString = NULL;
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
Convert some declarations to C99 style
2019-06-04 14:51:31 +00:00
for (size_t i = 0; i < targetCount; i++)
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
{
char* data;
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XEvent notification, dummy;
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
XConvertSelection(_glfw.x11.display,
selection,
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
targets[i],
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
_glfw.x11.GLFW_SELECTION,
_glfw.x11.helperWindowHandle,
CurrentTime);
while (!XCheckTypedWindowEvent(_glfw.x11.display,
_glfw.x11.helperWindowHandle,
SelectionNotify,
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
&notification))
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
{
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
waitForX11Event(NULL);
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
}
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
if (notification.xselection.property == None)
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
continue;
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
XCheckIfEvent(_glfw.x11.display,
&dummy,
isSelPropNewValueNotify,
(XPointer) &notification);
XGetWindowProperty(_glfw.x11.display,
notification.xselection.requestor,
notification.xselection.property,
0,
LONG_MAX,
True,
AnyPropertyType,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
(unsigned char**) &data);
if (actualType == _glfw.x11.INCR)
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
{
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
size_t size = 1;
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
char* string = NULL;
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
for (;;)
{
while (!XCheckIfEvent(_glfw.x11.display,
&dummy,
isSelPropNewValueNotify,
(XPointer) &notification))
{
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
waitForX11Event(NULL);
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
}
XFree(data);
XGetWindowProperty(_glfw.x11.display,
notification.xselection.requestor,
notification.xselection.property,
0,
LONG_MAX,
True,
AnyPropertyType,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
(unsigned char**) &data);
if (itemCount)
{
size += itemCount;
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
string = _glfw_realloc(string, size);
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
string[size - itemCount - 1] = '\0';
strcat(string, data);
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
}
if (!itemCount)
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
{
X11: Fix segfault on malformed INCR response The code assumed that at least some data would be received via the INCR mechanism and that, as a result, the string buffer would be allocated. Bug found by Clang static analysis.
2022-04-18 21:22:25 +00:00
if (string)
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
{
X11: Fix segfault on malformed INCR response The code assumed that at least some data would be received via the INCR mechanism and that, as a result, the string buffer would be allocated. Bug found by Clang static analysis.
2022-04-18 21:22:25 +00:00
if (targets[i] == XA_STRING)
{
*selectionString = convertLatin1toUTF8(string);
_glfw_free(string);
}
else
*selectionString = string;
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
}
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
break;
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
}
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
}
}
else if (actualType == targets[i])
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
{
if (targets[i] == XA_STRING)
*selectionString = convertLatin1toUTF8(data);
else
Remove use of non-standard function strdup Related to #873.
2018-01-17 10:56:35 +00:00
*selectionString = _glfw_strdup(data);
X11: Fix Latin-1 text not being converted to UTF-8
2017-08-08 14:25:13 +00:00
}
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
X11: Add support for reading clipboard via INCR This allows glfwGetClipboardString to retrieve clipboard contents larger than (typically) 2^18 bytes. Related to #275.
2017-08-07 21:23:37 +00:00
XFree(data);
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
if (*selectionString)
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
break;
}
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
if (!*selectionString)
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
X11: Fix selection error nomenclature [ci skip]
2017-09-17 11:54:17 +00:00
"X11: Failed to convert selection to string");
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
}
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
return *selectionString;
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
}
Add tracking of which window 'owns' a monitor
2016-02-23 11:34:35 +00:00
// Make the specified window and its video mode active on its monitor
Simplified function comment headers.
2013-02-04 12:22:10 +00:00
//
Cleanup Allow window creation despite video mode setting failure. Video mode setting failure is ignored the rest of the time and the desired video mode has never been a hard constraint anyway.
2018-02-05 16:11:04 +00:00
static void acquireMonitor(_GLFWwindow* window)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Fixed possible X11 screensaver race condition.
2013-07-04 15:52:15 +00:00
if (_glfw.x11.saver.count == 0)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
// Remember old screen saver settings
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XGetScreenSaver(_glfw.x11.display,
&_glfw.x11.saver.timeout,
&_glfw.x11.saver.interval,
&_glfw.x11.saver.blanking,
&_glfw.x11.saver.exposure);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
// Disable screen saver
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XSetScreenSaver(_glfw.x11.display, 0, 0, DontPreferBlanking,
Formatting pass (no code changes).
2010-09-08 13:51:25 +00:00
DefaultExposures);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
if (!window->monitor->window)
_glfw.x11.saver.count++;
Fixed possible X11 screensaver race condition.
2013-07-04 15:52:15 +00:00
Cleanup Allow window creation despite video mode setting failure. Video mode setting failure is ignored the rest of the time and the desired video mode has never been a hard constraint anyway.
2018-02-05 16:11:04 +00:00
_glfwSetVideoModeX11(window->monitor, &window->videoMode);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
if (window->x11.overrideRedirect)
Always pre-position X11 full screen windows.
2015-06-15 12:45:05 +00:00
{
int xpos, ypos;
GLFWvidmode mode;
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
// Manually position the window over its monitor
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetMonitorPosX11(window->monitor, &xpos, &ypos);
_glfwGetVideoModeX11(window->monitor, &mode);
Always pre-position X11 full screen windows.
2015-06-15 12:45:05 +00:00
XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
xpos, ypos, mode.width, mode.height);
}
Cleanup
2017-01-10 14:46:00 +00:00
_glfwInputMonitorWindow(window->monitor, window);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add tracking of which window 'owns' a monitor
2016-02-23 11:34:35 +00:00
// Remove the window and restore the original video mode
Simplified function comment headers.
2013-02-04 12:22:10 +00:00
//
Add tracking of which window 'owns' a monitor
2016-02-23 11:34:35 +00:00
static void releaseMonitor(_GLFWwindow* window)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Add tracking of which window 'owns' a monitor
2016-02-23 11:34:35 +00:00
if (window->monitor->window != window)
return;
Cleanup
2017-01-10 14:46:00 +00:00
_glfwInputMonitorWindow(window->monitor, NULL);
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 17:16:46 +00:00
_glfwRestoreVideoModeX11(window->monitor);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Fixed possible X11 screensaver race condition.
2013-07-04 15:52:15 +00:00
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
// Restore old screen saver settings
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XSetScreenSaver(_glfw.x11.display,
_glfw.x11.saver.timeout,
_glfw.x11.saver.interval,
_glfw.x11.saver.blanking,
_glfw.x11.saver.exposure);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
}
Formatting.
2012-08-12 14:21:06 +00:00
// Process the specified X event
Simplified function comment headers.
2013-02-04 12:22:10 +00:00
//
Formatting.
2012-08-12 14:04:03 +00:00
static void processEvent(XEvent *event)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
int keycode = 0;
Fixed non-pre-edit character input via XIM. Fixes #501. Fixes #473.
2015-06-09 12:41:15 +00:00
Bool filtered = False;
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
// HACK: Save scancode as some IMs clear the field in XFilterEvent
if (event->type == KeyPress || event->type == KeyRelease)
keycode = event->xkey.keycode;
X11: Add support for XIM callbacks This adds support for the XIM instantiate and destroy callbacks, letting GLFW detect both when the current input method disappears and when a new one is started. Tested with ibus.
2020-01-22 19:12:36 +00:00
filtered = XFilterEvent(event, None);
Moved to XAnyEvent for mapping to _GLFWwindows.
2013-01-28 18:56:09 +00:00
Fix monitor notifications on X11 Fixes #288.
2015-06-14 19:05:42 +00:00
if (_glfw.x11.randr.available)
{
if (event->type == _glfw.x11.randr.eventBase + RRNotify)
{
XRRUpdateConfiguration(event);
Restructure monitor enumeration This way is both kinder on event-based enumeration and less work to unwind allocations for when properly implementing GLFW_OUT_OF_MEMORY.
2016-12-05 00:19:48 +00:00
_glfwPollMonitorsX11();
Fix monitor notifications on X11 Fixes #288.
2015-06-14 19:05:42 +00:00
return;
}
}
Cleanup Related to #1528.
2019-07-11 17:06:06 +00:00
if (_glfw.x11.xkb.available)
X11: Query and keep track of Xkb group index For users with multiple keyboard layouts configured, glfwGetKeyName works fine only with the primary layout. Switching layouts results in changing the group index. This commit querries the current group index when initializing keyboard input and keeps track of any change to it. As a result the scancode -> keyname mapping may change while the program is running (needs to be documented). Fixes #1462. Closes #1528.
2019-05-29 22:37:26 +00:00
{
Cleanup Related to #1528.
2019-07-11 17:06:06 +00:00
if (event->type == _glfw.x11.xkb.eventBase + XkbEventCode)
X11: Query and keep track of Xkb group index For users with multiple keyboard layouts configured, glfwGetKeyName works fine only with the primary layout. Switching layouts results in changing the group index. This commit querries the current group index when initializing keyboard input and keeps track of any change to it. As a result the scancode -> keyname mapping may change while the program is running (needs to be documented). Fixes #1462. Closes #1528.
2019-05-29 22:37:26 +00:00
{
Cleanup Related to #1528.
2019-07-11 17:06:06 +00:00
if (((XkbEvent*) event)->any.xkb_type == XkbStateNotify &&
(((XkbEvent*) event)->state.changed & XkbGroupStateMask))
{
_glfw.x11.xkb.group = ((XkbEvent*) event)->state.group;
}
X11: Fix XKB events being passed on to core path
2020-05-19 15:55:28 +00:00
return;
X11: Query and keep track of Xkb group index For users with multiple keyboard layouts configured, glfwGetKeyName works fine only with the primary layout. Switching layouts results in changing the group index. This commit querries the current group index when initializing keyboard input and keeps track of any change to it. As a result the scancode -> keyname mapping may change while the program is running (needs to be documented). Fixes #1462. Closes #1528.
2019-05-29 22:37:26 +00:00
}
}
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
if (event->type == GenericEvent)
Moved to XAnyEvent for mapping to _GLFWwindows.
2013-01-28 18:56:09 +00:00
{
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
if (_glfw.x11.xi.available)
Moved to XAnyEvent for mapping to _GLFWwindows.
2013-01-28 18:56:09 +00:00
{
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
_GLFWwindow* window = _glfw.x11.disabledCursorWindow;
if (window &&
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
window->rawMouseMotion &&
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
event->xcookie.extension == _glfw.x11.xi.majorOpcode &&
XGetEventData(_glfw.x11.display, &event->xcookie) &&
event->xcookie.evtype == XI_RawMotion)
{
XIRawEvent* re = event->xcookie.data;
if (re->valuators.mask_len)
{
const double* values = re->raw_values;
double xpos = window->virtualCursorPosX;
double ypos = window->virtualCursorPosY;
if (XIMaskIsSet(re->valuators.mask, 0))
{
xpos += *values;
values++;
}
if (XIMaskIsSet(re->valuators.mask, 1))
ypos += *values;
_glfwInputCursorPos(window, xpos, ypos);
}
}
XFreeEventData(_glfw.x11.display, &event->xcookie);
Moved to XAnyEvent for mapping to _GLFWwindows.
2013-01-28 18:56:09 +00:00
}
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
return;
}
X11: Fix returned clipboard string freed too early The clipboard string should not be freed on SelectionClear. The user may have received it from glfwGetClipboardString and it should remain valid until the next call to a public clipboard string function.
2022-04-18 21:21:40 +00:00
if (event->type == SelectionRequest)
X11: Handle Selection* events despite NULL window X11 event processing currently discards events that can not be mapped to a current GLFW window. However, this breaks clipboard functionality by failing to respond to SelectionRequest and SelectionClear events. This commit moves processing of these important clipboard events to before the NULL window test so that they are always considered. Fixes #961. Closes #963.
2017-03-07 18:24:31 +00:00
{
handleSelectionRequest(event);
return;
}
Convert some declarations to C99 style
2019-06-04 14:51:31 +00:00
_GLFWwindow* window = NULL;
X11: Clean up context lookup
2018-08-22 18:18:36 +00:00
if (XFindContext(_glfw.x11.display,
event->xany.window,
_glfw.x11.context,
(XPointer*) &window) != 0)
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
{
// This is an event for a window that has already been destroyed
return;
Moved to XAnyEvent for mapping to _GLFWwindows.
2013-01-28 18:56:09 +00:00
}
Initial pass for multi-window support.
2010-09-09 16:15:32 +00:00
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
switch (event->type)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
X11: Fix no window position events during resize A window resize action that also resulting in the window being moved did not emit any window positions events, as the position of real ConfigureNotify events was ignored. The real events use parent coordinates instead of root coordinates so this adds parent tracking and conditional translation. Fixes #1613.
2020-01-01 15:56:32 +00:00
case ReparentNotify:
{
window->x11.parent = event->xreparent.parent;
return;
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
case KeyPress:
{
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
const int key = translateKey(keycode);
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
const int mods = translateState(event->xkey.state);
Cleanup of basic XIM support. Shortened and simplified the code. Removed reporting of XIM sentinel key press event. Added credit. Updated changelog. Closes #151.
2014-09-21 00:13:41 +00:00
const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
No characters from Ctrl and Alt chords. This makes the behavior on X11 consistent with Win32 and Cocoa.
2013-04-04 15:13:28 +00:00
Cleanup of basic XIM support. Shortened and simplified the code. Removed reporting of XIM sentinel key press event. Added credit. Updated changelog. Closes #151.
2014-09-21 00:13:41 +00:00
if (window->x11.ic)
Added character with modifiers callback. The undefined behaviour changed with #40 has been reverted, making the character-only callback again behave like a system text field. This behavior has now been documentated. Fixes #203. Fixes #305.
2014-06-12 21:04:20 +00:00
{
X11: Fix detection of key events duplicated by XIM Background: The IM will filter out key events, instead sending exact duplicate events that are not filtered. It does not send these for every event, however, so the duplicate events cannot be relied on for key input. Instead we need to identify and discard them. Since they are identical, they have the same timestamp as the originals. The previous duplicate event detection would consume unrelated key events if the keys were pressed simultaneously, as it only tracked a single timestamp. This fixes that issue for any combination of keys, at the expense of a 1 KB array per GLFW window. This fix is a stopgap until explicit IME support is done. Based on #1472 by @LucaRood. Fixes #1112. Fixes #1415. Fixes #1616. Fixes #1663. Closes #1472.
2020-06-30 18:57:24 +00:00
// HACK: Do not report the key press events duplicated by XIM
// Duplicate key releases are filtered out implicitly by
// the GLFW key repeat logic in _glfwInputKey
// A timestamp per key is used to handle simultaneous keys
// NOTE: Always allow the first event for each key through
// (the server never sends a timestamp of zero)
// NOTE: Timestamp difference is compared to handle wrap-around
Time diff = event->xkey.time - window->x11.keyPressTimes[keycode];
X11: Fix undefined behavior in bit shift of int Closes #1951
2021-08-20 04:41:59 +00:00
if (diff == event->xkey.time || (diff > 0 && diff < ((Time)1 << 31)))
Fixed duplicate key presses caused by XIM. Probably.
2015-06-24 18:24:52 +00:00
{
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
if (keycode)
_glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
X11: Fix detection of key events duplicated by XIM Background: The IM will filter out key events, instead sending exact duplicate events that are not filtered. It does not send these for every event, however, so the duplicate events cannot be relied on for key input. Instead we need to identify and discard them. Since they are identical, they have the same timestamp as the originals. The previous duplicate event detection would consume unrelated key events if the keys were pressed simultaneously, as it only tracked a single timestamp. This fixes that issue for any combination of keys, at the expense of a 1 KB array per GLFW window. This fix is a stopgap until explicit IME support is done. Based on #1472 by @LucaRood. Fixes #1112. Fixes #1415. Fixes #1616. Fixes #1663. Closes #1472.
2020-06-30 18:57:24 +00:00
window->x11.keyPressTimes[keycode] = event->xkey.time;
X11: Fix IM-duplicated key events leaking through Fixes #747. Fixes #964.
2017-03-26 23:19:41 +00:00
}
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
if (!filtered)
Fixed duplicate key presses caused by XIM. Probably.
2015-06-24 18:24:52 +00:00
{
Fix XBufferOverflow handling for XIM input
2015-10-09 11:37:44 +00:00
int count;
Fix XIM input on non-UTF-8 locales
2015-10-09 11:23:34 +00:00
Status status;
Fix decoding overrun in UTF-8 XIM path
2015-10-27 22:01:02 +00:00
char buffer[100];
Fix XBufferOverflow handling for XIM input
2015-10-09 11:37:44 +00:00
char* chars = buffer;
Fix XIM input on non-UTF-8 locales
2015-10-09 11:23:34 +00:00
Fix XBufferOverflow handling for XIM input
2015-10-09 11:37:44 +00:00
count = Xutf8LookupString(window->x11.ic,
&event->xkey,
Fix decoding overrun in UTF-8 XIM path
2015-10-27 22:01:02 +00:00
buffer, sizeof(buffer) - 1,
Fix XBufferOverflow handling for XIM input
2015-10-09 11:37:44 +00:00
NULL, &status);
Fix XIM input on non-UTF-8 locales
2015-10-09 11:23:34 +00:00
Fix XBufferOverflow handling for XIM input
2015-10-09 11:37:44 +00:00
if (status == XBufferOverflow)
{
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
chars = _glfw_calloc(count + 1, 1);
Fix XBufferOverflow handling for XIM input
2015-10-09 11:37:44 +00:00
count = Xutf8LookupString(window->x11.ic,
&event->xkey,
chars, count,
NULL, &status);
}
if (status == XLookupChars || status == XLookupBoth)
{
const char* c = chars;
Fix decoding overrun in UTF-8 XIM path
2015-10-27 22:01:02 +00:00
chars[count] = '\0';
Fix XBufferOverflow handling for XIM input
2015-10-09 11:37:44 +00:00
while (c - chars < count)
_glfwInputChar(window, decodeUTF8(&c), mods, plain);
}
if (chars != buffer)
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(chars);
Fixed duplicate key presses caused by XIM. Probably.
2015-06-24 18:24:52 +00:00
}
Cleanup of basic XIM support. Shortened and simplified the code. Removed reporting of XIM sentinel key press event. Added credit. Updated changelog. Closes #151.
2014-09-21 00:13:41 +00:00
}
else
{
KeySym keysym;
XLookupString(&event->xkey, NULL, 0, &keysym, NULL);
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
_glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
Fixed duplicate key presses caused by XIM. Probably.
2015-06-24 18:24:52 +00:00
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
if (codepoint != GLFW_INVALID_CODEPOINT)
_glfwInputChar(window, codepoint, mods, plain);
Added character with modifiers callback. The undefined behaviour changed with #40 has been reverted, making the character-only callback again behave like a system text field. This behavior has now been documentated. Fixes #203. Fixes #305.
2014-06-12 21:04:20 +00:00
}
No characters from Ctrl and Alt chords. This makes the behavior on X11 consistent with Win32 and Cocoa.
2013-04-04 15:13:28 +00:00
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
case KeyRelease:
{
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
const int key = translateKey(keycode);
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
const int mods = translateState(event->xkey.state);
Cleanup of XKB detection code.
2014-05-18 10:24:29 +00:00
if (!_glfw.x11.xkb.detectable)
{
Clarified comments for X11 key repeat hack.
2014-09-02 23:44:08 +00:00
// HACK: Key repeat events will arrive as KeyRelease/KeyPress
// pairs with similar or identical time stamps
Comment and string spell check pass.
2015-01-05 20:55:15 +00:00
// The key repeat logic in _glfwInputKey expects only key
Clarified comments for X11 key repeat hack.
2014-09-02 23:44:08 +00:00
// presses to repeat, so detect and discard release events
Cleanup of XKB detection code.
2014-05-18 10:24:29 +00:00
if (XEventsQueued(_glfw.x11.display, QueuedAfterReading))
{
Formatting.
2015-07-07 08:58:55 +00:00
XEvent next;
XPeekEvent(_glfw.x11.display, &next);
Cleanup of XKB detection code.
2014-05-18 10:24:29 +00:00
Formatting.
2015-07-07 08:58:55 +00:00
if (next.type == KeyPress &&
next.xkey.window == event->xkey.window &&
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
next.xkey.keycode == keycode)
Cleanup of XKB detection code.
2014-05-18 10:24:29 +00:00
{
Decrease amount of Hocus Pocus
2016-03-02 22:14:55 +00:00
// HACK: The time of repeat events sometimes doesn't
// match that of the press event, 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)
Formatting.
2015-07-07 08:58:55 +00:00
if ((next.xkey.time - event->xkey.time) < 20)
Cleanup of XKB detection code.
2014-05-18 10:24:29 +00:00
{
Clarified comments for X11 key repeat hack.
2014-09-02 23:44:08 +00:00
// This is very likely a server-generated key repeat
// event, so ignore it
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Cleanup of XKB detection code.
2014-05-18 10:24:29 +00:00
}
}
}
}
Fixed filtering of events duplicated by XIM. Duplicate events cannot be filtered by the return value of XFilterEvent, as that discards dead key events on some IMs (ibus), nor by its inverse, as that discards all key events on other IMs (?). This solution is based on the workaround in SDL2 and takes advantage of the identical time of the duplicate events. Fixes #548. Closes #554. Closes #571.
2015-07-28 19:56:12 +00:00
_glfwInputKey(window, key, keycode, GLFW_RELEASE, mods);
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
case ButtonPress:
{
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
const int mods = translateState(event->xbutton.state);
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
if (event->xbutton.button == Button1)
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, mods);
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
else if (event->xbutton.button == Button2)
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS, mods);
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
else if (event->xbutton.button == Button3)
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS, mods);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
X11 event comment cleanup.
2013-01-12 20:11:41 +00:00
// Modern X provides scroll events as mouse button presses
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
else if (event->xbutton.button == Button4)
Made scrolling deltas floating point.
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 0.0, 1.0);
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
else if (event->xbutton.button == Button5)
Made scrolling deltas floating point.
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 0.0, -1.0);
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
else if (event->xbutton.button == Button6)
Made scrolling deltas floating point.
2012-03-28 19:54:09 +00:00
_glfwInputScroll(window, 1.0, 0.0);
Fixed X-axis scroll offset inversion (take two). Fixed #239 (properly).
2014-10-26 12:53:45 +00:00
else if (event->xbutton.button == Button7)
_glfwInputScroll(window, -1.0, 0.0);
Added two-dimensional scrolling API and X11 implementation.
2010-09-27 00:09:54 +00:00
Added support for mouse buttons 4-n.
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,
Fixed hole in mouse button sequence on X11.
2015-02-22 16:31:32 +00:00
event->xbutton.button - Button1 - 4,
Added support for mouse buttons 4-n.
2013-09-08 14:08:15 +00:00
GLFW_PRESS,
mods);
}
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
case ButtonRelease:
{
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
const int mods = translateState(event->xbutton.state);
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
if (event->xbutton.button == Button1)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Initial pass for multi-window support.
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_LEFT,
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
GLFW_RELEASE,
mods);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
else if (event->xbutton.button == Button2)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Initial pass for multi-window support.
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_MIDDLE,
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
GLFW_RELEASE,
mods);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Added support for multithreaded use of Xlib.
2012-08-12 13:57:52 +00:00
else if (event->xbutton.button == Button3)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Initial pass for multi-window support.
2010-09-09 16:15:32 +00:00
_glfwInputMouseClick(window,
GLFW_MOUSE_BUTTON_RIGHT,
Added a conservative set of key modifiers.
2012-12-09 18:19:00 +00:00
GLFW_RELEASE,
mods);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Added support for mouse buttons 4-n.
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,
Fixed X11 mouse button mismatch. Bug introduced by 4d146cb39d. Closes #449.
2015-02-23 04:14:24 +00:00
event->xbutton.button - Button1 - 4,
Added support for mouse buttons 4-n.
2013-09-08 14:08:15 +00:00
GLFW_RELEASE,
mods);
}
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Added API and X11 implementation of cursor enter and leave callbacks.
2012-01-30 21:18:05 +00:00
case EnterNotify:
{
x11 window: update cursor position on enter event click events would have an incorrect position after changing workspace, if the mouse didn't move in between. (Another example where this matters is a new window, if it appears under the cursor, clicking would lead the application to think the user clicked at 0,0)
2018-10-26 04:22:10 +00:00
// XEnterWindowEvent is XCrossingEvent
const int x = event->xcrossing.x;
const int y = event->xcrossing.y;
Documented hidden cursor workaround.
2015-02-22 13:59:55 +00:00
// HACK: This is a workaround for WMs (KWM, Fluxbox) that otherwise
// ignore the defined cursor for hidden cursor mode
Added workaround for cursor hiding on some WMs. Closes #431. Fixes #309.
2015-01-23 17:38:12 +00:00
if (window->cursorMode == GLFW_CURSOR_HIDDEN)
Fix cursor mode application for unfocused windows Fixes #1239. Fixes #1247.
2018-04-17 17:54:36 +00:00
updateCursorImage(window);
Added workaround for cursor hiding on some WMs. Closes #431. Fixes #309.
2015-01-23 17:38:12 +00:00
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
_glfwInputCursorEnter(window, GLFW_TRUE);
x11 window: update cursor position on enter event click events would have an incorrect position after changing workspace, if the mouse didn't move in between. (Another example where this matters is a new window, if it appears under the cursor, clicking would lead the application to think the user clicked at 0,0)
2018-10-26 04:22:10 +00:00
_glfwInputCursorPos(window, x, y);
window->x11.lastCursorPosX = x;
window->x11.lastCursorPosY = y;
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Added API and X11 implementation of cursor enter and leave callbacks.
2012-01-30 21:18:05 +00:00
}
case LeaveNotify:
{
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
_glfwInputCursorEnter(window, GLFW_FALSE);
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Added API and X11 implementation of cursor enter and leave callbacks.
2012-01-30 21:18:05 +00:00
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
case MotionNotify:
{
Made glfwGetCursorPos query system directly. Fixes #103. Fixes #153. Fixes #193. Fixes #355. Fixes #381.
2014-02-11 17:24:01 +00:00
const int x = event->xmotion.x;
const int y = event->xmotion.y;
Cleanup Break up some overly long lines.
2017-09-17 12:39:17 +00:00
if (x != window->x11.warpCursorPosX ||
y != window->x11.warpCursorPosY)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Comment updates and formatting.
2012-08-26 13:38:18 +00:00
// The cursor was moved by something other than GLFW
Renamed CURSOR_CAPTURED to CURSOR_DISABLED.
2013-04-26 15:20:31 +00:00
if (window->cursorMode == GLFW_CURSOR_DISABLED)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Simplify cursor window logic
2016-05-30 19:21:09 +00:00
if (_glfw.x11.disabledCursorWindow != window)
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
if (window->rawMouseMotion)
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
return;
Replaced GLFW_MOUSE_CURSOR enable with glfwSetCursorMode.
2011-09-06 11:55:29 +00:00
Move all cursor positioning to platform code Due to Wayland, shared code cannot rely on cursor positioning being supported by the underlying platform. This implicitly fixes #617 as it moves cursor centering into _glfwPlatformSetCursorMode, thus separating it from the stale value of _glfw.cursorWindow. Fixes #617.
2016-05-25 12:06:02 +00:00
const int dx = x - window->x11.lastCursorPosX;
const int dy = y - window->x11.lastCursorPosY;
_glfwInputCursorPos(window,
window->virtualCursorPosX + dx,
window->virtualCursorPosY + dy);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
else
Move all cursor positioning to platform code Due to Wayland, shared code cannot rely on cursor positioning being supported by the underlying platform. This implicitly fixes #617 as it moves cursor centering into _glfwPlatformSetCursorMode, thus separating it from the stale value of _glfw.cursorWindow. Fixes #617.
2016-05-25 12:06:02 +00:00
_glfwInputCursorPos(window, x, y);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Replaced GLFW_MOUSE_CURSOR enable with glfwSetCursorMode.
2011-09-06 11:55:29 +00:00
Clarify cursor position variable names
2016-05-24 10:23:58 +00:00
window->x11.lastCursorPosX = x;
window->x11.lastCursorPosY = y;
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
case ConfigureNotify:
{
Fixed duplicate events being reported.
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);
Separated window and framebuffer sizes.
2013-06-03 10:51:57 +00:00
Fixed duplicate events being reported.
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;
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
X11: Fix no window position events during resize A window resize action that also resulting in the window being moved did not emit any window positions events, as the position of real ConfigureNotify events was ignored. The real events use parent coordinates instead of root coordinates so this adds parent tracking and conditional translation. Fixes #1613.
2020-01-01 15:56:32 +00:00
int xpos = event->xconfigure.x;
int ypos = event->xconfigure.y;
// NOTE: ConfigureNotify events from the server are in local
// coordinates, so if we are reparented we need to translate
// the position into root (screen) coordinates
if (!event->xany.send_event && window->x11.parent != _glfw.x11.root)
Fixed duplicate events being reported.
2013-06-16 16:29:46 +00:00
{
X11: Improve window handle race condition The non-root parent window owned by the WM could be destroyed before we process the ConfigureNotify event using the cached parent handle. Bug was found by unmapping a decorated window. This like all uses of the Xlib error handler is not thread safe and there is nothing we can do about that short of moving to XCB. Fixes #1633.
2020-03-19 22:28:21 +00:00
_glfwGrabErrorHandlerX11();
X11: Fix no window position events during resize A window resize action that also resulting in the window being moved did not emit any window positions events, as the position of real ConfigureNotify events was ignored. The real events use parent coordinates instead of root coordinates so this adds parent tracking and conditional translation. Fixes #1613.
2020-01-01 15:56:32 +00:00
Window dummy;
XTranslateCoordinates(_glfw.x11.display,
window->x11.parent,
_glfw.x11.root,
xpos, ypos,
&xpos, &ypos,
&dummy);
X11: Improve window handle race condition The non-root parent window owned by the WM could be destroyed before we process the ConfigureNotify event using the cached parent handle. Bug was found by unmapping a decorated window. This like all uses of the Xlib error handler is not thread safe and there is nothing we can do about that short of moving to XCB. Fixes #1633.
2020-03-19 22:28:21 +00:00
_glfwReleaseErrorHandlerX11();
if (_glfw.x11.errorCode == BadWindow)
return;
X11: Fix no window position events during resize A window resize action that also resulting in the window being moved did not emit any window positions events, as the position of real ConfigureNotify events was ignored. The real events use parent coordinates instead of root coordinates so this adds parent tracking and conditional translation. Fixes #1613.
2020-01-01 15:56:32 +00:00
}
Fixed duplicate events being reported.
2013-06-16 16:29:46 +00:00
X11: Fix no window position events during resize A window resize action that also resulting in the window being moved did not emit any window positions events, as the position of real ConfigureNotify events was ignored. The real events use parent coordinates instead of root coordinates so this adds parent tracking and conditional translation. Fixes #1613.
2020-01-01 15:56:32 +00:00
if (xpos != window->x11.xpos || ypos != window->x11.ypos)
{
_glfwInputWindowPos(window, xpos, ypos);
window->x11.xpos = xpos;
window->x11.ypos = ypos;
Fixed duplicate events being reported.
2013-06-16 16:29:46 +00:00
}
Added glfwGetWindowPos.
2010-09-14 01:53:22 +00:00
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
case ClientMessage:
{
Initial multi-window support pass.
2010-09-09 22:06:23 +00:00
// Custom client message, probably from the window manager
Fixed non-pre-edit character input via XIM. Fixes #501. Fixes #473.
2015-06-09 12:41:15 +00:00
if (filtered)
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Fixed non-pre-edit character input via XIM. Fixes #501. Fixes #473.
2015-06-09 12:41:15 +00:00
Fixed missing ICCCM protocol message checks.
2014-03-09 12:24:17 +00:00
if (event->xclient.message_type == None)
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Fixed missing ICCCM protocol message checks.
2014-03-09 12:24:17 +00:00
if (event->xclient.message_type == _glfw.x11.WM_PROTOCOLS)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Clarified WM_PROTOCOLS event handling.
2015-06-02 15:49:49 +00:00
const Atom protocol = event->xclient.data.l[0];
if (protocol == None)
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Clarified WM_PROTOCOLS event handling.
2015-06-02 15:49:49 +00:00
if (protocol == _glfw.x11.WM_DELETE_WINDOW)
Fixed missing ICCCM protocol message checks.
2014-03-09 12:24:17 +00:00
{
Cleanup Break up some overly long lines.
2017-09-17 12:39:17 +00:00
// The window manager was asked to close the window, for
// example by the user pressing a 'close' window decoration
// button
Fixed missing ICCCM protocol message checks.
2014-03-09 12:24:17 +00:00
_glfwInputWindowCloseRequest(window);
}
Clarified WM_PROTOCOLS event handling.
2015-06-02 15:49:49 +00:00
else if (protocol == _glfw.x11.NET_WM_PING)
Fixed missing ICCCM protocol message checks.
2014-03-09 12:24:17 +00:00
{
Cleanup Break up some overly long lines.
2017-09-17 12:39:17 +00:00
// The window manager is pinging the application to ensure
// it's still responding to events
Fixed missing ICCCM protocol message checks.
2014-03-09 12:24:17 +00:00
Fixed destination of _NET_WM_PING reply.
2015-06-02 15:25:09 +00:00
XEvent reply = *event;
reply.xclient.window = _glfw.x11.root;
Formatting.
2015-06-02 15:27:35 +00:00
XSendEvent(_glfw.x11.display, _glfw.x11.root,
Formatting.
2015-06-02 15:05:21 +00:00
False,
SubstructureNotifyMask | SubstructureRedirectMask,
Fixed destination of _NET_WM_PING reply.
2015-06-02 15:25:09 +00:00
&reply);
Fixed missing ICCCM protocol message checks.
2014-03-09 12:24:17 +00:00
}
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
}
Cleanup.
2013-12-22 15:38:56 +00:00
else if (event->xclient.message_type == _glfw.x11.XdndEnter)
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
{
Cleanup.
2014-01-22 00:34:44 +00:00
// A drag operation has entered the window
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
unsigned long count;
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
Atom* formats = NULL;
const GLFWbool list = event->xclient.data.l[1] & 1;
_glfw.x11.xdnd.source = event->xclient.data.l[0];
_glfw.x11.xdnd.version = event->xclient.data.l[1] >> 24;
_glfw.x11.xdnd.format = None;
if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
return;
if (list)
{
count = _glfwGetWindowPropertyX11(_glfw.x11.xdnd.source,
_glfw.x11.XdndTypeList,
XA_ATOM,
(unsigned char**) &formats);
}
else
{
count = 3;
formats = (Atom*) event->xclient.data.l + 2;
}
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (unsigned int i = 0; i < count; i++)
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
{
if (formats[i] == _glfw.x11.text_uri_list)
{
_glfw.x11.xdnd.format = _glfw.x11.text_uri_list;
break;
}
}
if (list && formats)
XFree(formats);
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
}
Cleanup.
2013-12-22 15:38:56 +00:00
else if (event->xclient.message_type == _glfw.x11.XdndDrop)
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
{
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
// The drag operation has finished by dropping on the window
Time time = CurrentTime;
if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
return;
if (_glfw.x11.xdnd.format)
{
if (_glfw.x11.xdnd.version >= 1)
time = event->xclient.data.l[2];
// Request the chosen format from the source window
XConvertSelection(_glfw.x11.display,
_glfw.x11.XdndSelection,
_glfw.x11.xdnd.format,
_glfw.x11.XdndSelection,
window->x11.handle,
time);
}
else if (_glfw.x11.xdnd.version >= 2)
{
X11: Let the language initialize XEvent structs
2019-06-04 14:59:04 +00:00
XEvent reply = { ClientMessage };
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
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] = 0; // The drag was rejected
reply.xclient.data.l[2] = None;
XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
False, NoEventMask, &reply);
XFlush(_glfw.x11.display);
}
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
}
Cleanup.
2013-12-22 15:38:56 +00:00
else if (event->xclient.message_type == _glfw.x11.XdndPosition)
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
{
Cleanup.
2014-01-22 00:34:44 +00:00
// The drag operation has moved over the window
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
const int xabs = (event->xclient.data.l[2] >> 16) & 0xffff;
const int yabs = (event->xclient.data.l[2]) & 0xffff;
Window dummy;
int xpos, ypos;
if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
return;
XTranslateCoordinates(_glfw.x11.display,
_glfw.x11.root,
X11: Fix inverted coordinate transform
2017-03-17 13:09:07 +00:00
window->x11.handle,
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
xabs, yabs,
&xpos, &ypos,
&dummy);
Cleanup.
2013-12-22 15:38:56 +00:00
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
_glfwInputCursorPos(window, xpos, ypos);
Cleanup.
2013-12-22 15:38:56 +00:00
X11: Let the language initialize XEvent structs
2019-06-04 14:59:04 +00:00
XEvent reply = { ClientMessage };
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
reply.xclient.window = _glfw.x11.xdnd.source;
Cleanup.
2013-12-22 15:38:56 +00:00
reply.xclient.message_type = _glfw.x11.XdndStatus;
reply.xclient.format = 32;
reply.xclient.data.l[0] = window->x11.handle;
reply.xclient.data.l[2] = 0; // Specify an empty rectangle
reply.xclient.data.l[3] = 0;
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
if (_glfw.x11.xdnd.format)
{
// Reply that we are ready to copy the dragged data
reply.xclient.data.l[1] = 1; // Accept with no rectangle
if (_glfw.x11.xdnd.version >= 2)
reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy;
}
XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
Cleanup.
2013-12-22 15:38:56 +00:00
False, NoEventMask, &reply);
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Cleanup.
2013-12-22 15:38:56 +00:00
Initial drag and drop support.
2013-07-10 09:42:14 +00:00
case SelectionNotify:
Cleanup.
2013-12-22 15:38:56 +00:00
{
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
if (event->xselection.property == _glfw.x11.XdndSelection)
Cleanup.
2013-12-22 15:38:56 +00:00
{
Cleanup.
2014-01-22 00:34:44 +00:00
// The converted data from the drag operation has arrived
Cleanup.
2013-12-22 15:38:56 +00:00
char* data;
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
const unsigned long result =
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 17:16:46 +00:00
_glfwGetWindowPropertyX11(event->xselection.requestor,
event->xselection.property,
event->xselection.target,
(unsigned char**) &data);
Cleanup.
2013-12-22 15:38:56 +00:00
if (result)
{
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
int count;
Move URI list parsing to shared code This will soon be used by the Wayland backend.
2022-03-24 19:17:32 +00:00
char** paths = _glfwParseUriList(data, &count);
Cleaned up drop callback design.
2013-12-22 18:28:46 +00:00
Fixed name of path drop list.
2015-01-27 22:04:22 +00:00
_glfwInputDrop(window, count, (const char**) paths);
Cleaned up drop callback design.
2013-12-22 18:28:46 +00:00
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (int i = 0; i < count; i++)
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(paths[i]);
_glfw_free(paths);
Cleanup.
2013-12-22 15:38:56 +00:00
}
X11: Fix potential window property data leaks
2017-01-16 00:36:14 +00:00
if (data)
XFree(data);
Cleaned up drop callback design.
2013-12-22 18:28:46 +00:00
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
if (_glfw.x11.xdnd.version >= 2)
{
X11: Let the language initialize XEvent structs
2019-06-04 14:59:04 +00:00
XEvent reply = { ClientMessage };
X11: Fix multiple issues in XDND support The code blindly expected UTF8_STRING for files. It did not downgrade based on source protocol version. It did not handle hostnames in text/uri-list data. It did not specify the source time stamp when converting the selection. It did not search the XdndTypeList when necessary. It did not ignore sources that specified invalid versions. While better, this is still not fully conformant. Hostnames are not validated and it does not guard against source crashes. Fixes #968.
2017-03-16 22:07:59 +00:00
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;
XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
False, NoEventMask, &reply);
XFlush(_glfw.x11.display);
}
Cleanup.
2013-12-22 15:38:56 +00:00
}
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Cleanup.
2013-12-22 15:38:56 +00:00
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
case FocusIn:
{
Improved X11 focus event filtering. Some focus events need to be ignored to allow functionality like Alt+Tab and volume indicators to not affect application-visible window focus. However, the previous filtering was too broad and missed virtual desktop switching, Alt+Tab and programmatic iconification. Fixes #405.
2015-06-15 13:11:29 +00:00
if (event->xfocus.mode == NotifyGrab ||
event->xfocus.mode == NotifyUngrab)
Fixed focus events triggered by window frame.
2014-04-02 11:29:07 +00:00
{
Improved X11 focus event filtering. Some focus events need to be ignored to allow functionality like Alt+Tab and volume indicators to not affect application-visible window focus. However, the previous filtering was too broad and missed virtual desktop switching, Alt+Tab and programmatic iconification. Fixes #405.
2015-06-15 13:11:29 +00:00
// Ignore focus events from popup indicator windows, window menu
// key chords and window dragging
return;
}
X11: Fix focus events not being filtered The filter condition had ended up below the action.
2019-07-10 22:36:34 +00:00
if (window->cursorMode == GLFW_CURSOR_DISABLED)
disableCursor(window);
Add cursor mode GLFW_CURSOR_CAPTURED This adds a cursor mode that provides a visible cursor confined to the content area of the window. Fixes #58
2019-12-03 16:58:20 +00:00
else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
captureCursor(window);
X11: Fix focus events not being filtered The filter condition had ended up below the action.
2019-07-10 22:36:34 +00:00
Improved X11 focus event filtering. Some focus events need to be ignored to allow functionality like Alt+Tab and volume indicators to not affect application-visible window focus. However, the previous filtering was too broad and missed virtual desktop switching, Alt+Tab and programmatic iconification. Fixes #405.
2015-06-15 13:11:29 +00:00
if (window->x11.ic)
XSetICFocus(window->x11.ic);
Fixed non-pre-edit character input via XIM. Fixes #501. Fixes #473.
2015-06-09 12:41:15 +00:00
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
_glfwInputWindowFocus(window, GLFW_TRUE);
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
case FocusOut:
{
Improved X11 focus event filtering. Some focus events need to be ignored to allow functionality like Alt+Tab and volume indicators to not affect application-visible window focus. However, the previous filtering was too broad and missed virtual desktop switching, Alt+Tab and programmatic iconification. Fixes #405.
2015-06-15 13:11:29 +00:00
if (event->xfocus.mode == NotifyGrab ||
event->xfocus.mode == NotifyUngrab)
Fixed focus events triggered by window frame.
2014-04-02 11:29:07 +00:00
{
Improved X11 focus event filtering. Some focus events need to be ignored to allow functionality like Alt+Tab and volume indicators to not affect application-visible window focus. However, the previous filtering was too broad and missed virtual desktop switching, Alt+Tab and programmatic iconification. Fixes #405.
2015-06-15 13:11:29 +00:00
// Ignore focus events from popup indicator windows, window menu
// key chords and window dragging
return;
}
X11: Fix focus events not being filtered The filter condition had ended up below the action.
2019-07-10 22:36:34 +00:00
if (window->cursorMode == GLFW_CURSOR_DISABLED)
enableCursor(window);
Add cursor mode GLFW_CURSOR_CAPTURED This adds a cursor mode that provides a visible cursor confined to the content area of the window. Fixes #58
2019-12-03 16:58:20 +00:00
else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
releaseCursor();
X11: Fix focus events not being filtered The filter condition had ended up below the action.
2019-07-10 22:36:34 +00:00
Improved X11 focus event filtering. Some focus events need to be ignored to allow functionality like Alt+Tab and volume indicators to not affect application-visible window focus. However, the previous filtering was too broad and missed virtual desktop switching, Alt+Tab and programmatic iconification. Fixes #405.
2015-06-15 13:11:29 +00:00
if (window->x11.ic)
XUnsetICFocus(window->x11.ic);
Fixed non-pre-edit character input via XIM. Fixes #501. Fixes #473.
2015-06-09 12:41:15 +00:00
Implemented auto-iconification on X11. Fixes #531.
2015-06-15 13:25:31 +00:00
if (window->monitor && window->autoIconify)
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwIconifyWindowX11(window);
Implemented auto-iconification on X11. Fixes #531.
2015-06-15 13:25:31 +00:00
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
_glfwInputWindowFocus(window, GLFW_FALSE);
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
case Expose:
{
Added input function for window damage events.
2011-10-09 19:12:13 +00:00
_glfwInputWindowDamage(window);
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Moved to WM_STATE for iconify events.
2013-01-21 18:57:03 +00:00
case PropertyNotify:
{
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
if (event->xproperty.state != PropertyNewValue)
return;
if (event->xproperty.atom == _glfw.x11.WM_STATE)
Moved to WM_STATE for iconify events.
2013-01-21 18:57:03 +00:00
{
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
const int state = getWindowState(window);
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
if (state != IconicState && state != NormalState)
return;
const GLFWbool iconified = (state == IconicState);
if (window->x11.iconified != iconified)
Fix glfwIconifyWindow not restoring video mode Fixes #590.
2015-08-28 10:00:06 +00:00
{
if (window->monitor)
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
{
if (iconified)
releaseMonitor(window);
else
acquireMonitor(window);
}
Fix glfwIconifyWindow not restoring video mode Fixes #590.
2015-08-28 10:00:06 +00:00
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
window->x11.iconified = iconified;
_glfwInputWindowIconify(window, iconified);
Fix glfwIconifyWindow not restoring video mode Fixes #590.
2015-08-28 10:00:06 +00:00
}
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
}
else if (event->xproperty.atom == _glfw.x11.NET_WM_STATE)
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
const GLFWbool maximized = _glfwWindowMaximizedX11(window);
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
if (window->x11.maximized != maximized)
Fix glfwIconifyWindow not restoring video mode Fixes #590.
2015-08-28 10:00:06 +00:00
{
Add glfwSetWindowMaximizeCallback Fixes #778.
2016-06-16 11:09:28 +00:00
window->x11.maximized = maximized;
_glfwInputWindowMaximize(window, maximized);
Fix glfwIconifyWindow not restoring video mode Fixes #590.
2015-08-28 10:00:06 +00:00
}
Moved to WM_STATE for iconify events.
2013-01-21 18:57:03 +00:00
}
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
return;
Moved to WM_STATE for iconify events.
2013-01-21 18:57:03 +00:00
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
case DestroyNotify:
Initial multi-window support pass.
2010-09-09 22:06:23 +00:00
return;
Clarified control flow in X11 event processing.
2015-06-11 15:06:35 +00:00
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Moved to WM_STATE for iconify events.
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
Simplified function comment headers.
2013-02-04 12:22:10 +00:00
//
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 17:16:46 +00:00
unsigned long _glfwGetWindowPropertyX11(Window window,
Atom property,
Atom type,
unsigned char** value)
Moved to WM_STATE for iconify events.
2013-01-21 18:57:03 +00:00
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetWindowProperty(_glfw.x11.display,
window,
property,
0,
LONG_MAX,
False,
type,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
value);
return itemCount;
}
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
GLFWbool _glfwIsVisualTransparentX11(Visual* visual)
{
if (!_glfw.x11.xrender.available)
return GLFW_FALSE;
XRenderPictFormat* pf = XRenderFindVisualFormat(_glfw.x11.display, visual);
return pf && pf->direct.alphaMask;
}
X11: Make clipboard IPC use helper window
2015-10-24 20:54:30 +00:00
// Push contents of our selection to clipboard manager
//
void _glfwPushSelectionToManagerX11(void)
{
XConvertSelection(_glfw.x11.display,
_glfw.x11.CLIPBOARD_MANAGER,
_glfw.x11.SAVE_TARGETS,
None,
_glfw.x11.helperWindowHandle,
CurrentTime);
for (;;)
{
XEvent event;
while (XCheckIfEvent(_glfw.x11.display, &event, isSelectionEvent, NULL))
{
switch (event.type)
{
case SelectionRequest:
handleSelectionRequest(&event);
break;
case SelectionNotify:
{
if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
{
Cleanup Break up some overly long lines.
2017-09-17 12:39:17 +00:00
// 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
X11: Make clipboard IPC use helper window
2015-10-24 20:54:30 +00:00
// In either case, it means we are done here
return;
}
break;
}
}
}
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
waitForX11Event(NULL);
X11: Make clipboard IPC use helper window
2015-10-24 20:54:30 +00:00
}
}
X11: Add support for XIM callbacks This adds support for the XIM instantiate and destroy callbacks, letting GLFW detect both when the current input method disappears and when a new one is started. Tested with ibus.
2020-01-22 19:12:36 +00:00
void _glfwCreateInputContextX11(_GLFWwindow* window)
{
XIMCallback callback;
callback.callback = (XIMProc) inputContextDestroyCallback;
callback.client_data = (XPointer) window;
window->x11.ic = XCreateIC(_glfw.x11.im,
XNInputStyle,
XIMPreeditNothing | XIMStatusNothing,
XNClientWindow,
window->x11.handle,
XNFocusWindow,
window->x11.handle,
XNDestroyCallback,
&callback,
NULL);
if (window->x11.ic)
{
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
unsigned long filter = 0;
if (XGetICValues(window->x11.ic, XNFilterEvents, &filter, NULL) == NULL)
{
XSelectInput(_glfw.x11.display,
window->x11.handle,
attribs.your_event_mask | filter);
}
}
}
Moved to WM_STATE for iconify events.
2013-01-21 18:57:03 +00:00
Formatting.
2010-09-15 14:44:43 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwCreateWindowX11(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
X11: Clarify code flow for Clang static analysis
2020-05-19 15:59:18 +00:00
Visual* visual = NULL;
Add GLFW_NO_API for creating context-less windows
2015-06-18 12:03:02 +00:00
int depth;
Add GLFW_OSMESA_CONTEXT_API This allows the creation of OpenGL contexts via OSMesa on existing platforms. It does not add a compile- or link-time dependency on OSMesa. Fixes #281.
2017-02-28 18:23:25 +00:00
if (ctxconfig->client != GLFW_NO_API)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
{
Initialize context creation APIs on demand
2016-07-20 10:52:06 +00:00
if (!_glfwInitGLX())
return GLFW_FALSE;
Add GLFW_TRANSPARENT and X11 implementation This is a squashed extract of several commits, minimally edited to ensure it compiles. Related to #197. Related to #715.
2016-02-22 17:08:15 +00:00
if (!_glfwChooseVisualGLX(wndconfig, ctxconfig, fbconfig, &visual, &depth))
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
return GLFW_FALSE;
}
Add GLFW_OSMESA_CONTEXT_API This allows the creation of OpenGL contexts via OSMesa on existing platforms. It does not add a compile- or link-time dependency on OSMesa. Fixes #281.
2017-02-28 18:23:25 +00:00
else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
{
Initialize context creation APIs on demand
2016-07-20 10:52:06 +00:00
if (!_glfwInitEGL())
return GLFW_FALSE;
Add GLFW_TRANSPARENT and X11 implementation This is a squashed extract of several commits, minimally edited to ensure it compiles. Related to #197. Related to #715.
2016-02-22 17:08:15 +00:00
if (!_glfwChooseVisualEGL(wndconfig, ctxconfig, fbconfig, &visual, &depth))
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
return GLFW_FALSE;
}
Add GLFW_OSMESA_CONTEXT_API This allows the creation of OpenGL contexts via OSMesa on existing platforms. It does not add a compile- or link-time dependency on OSMesa. Fixes #281.
2017-02-28 18:23:25 +00:00
else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
{
if (!_glfwInitOSMesa())
return GLFW_FALSE;
}
}
X11: Clarify code flow for Clang static analysis
2020-05-19 15:59:18 +00:00
if (!visual)
Add GLFW_OSMESA_CONTEXT_API This allows the creation of OpenGL contexts via OSMesa on existing platforms. It does not add a compile- or link-time dependency on OSMesa. Fixes #281.
2017-02-28 18:23:25 +00:00
{
visual = DefaultVisual(_glfw.x11.display, _glfw.x11.screen);
depth = DefaultDepth(_glfw.x11.display, _glfw.x11.screen);
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Cleanup
2016-07-25 17:36:25 +00:00
if (!createNativeWindow(window, wndconfig, visual, depth))
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_FALSE;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
if (ctxconfig->client != GLFW_NO_API)
Add GLFW_NO_API for creating context-less windows
2015-06-18 12:03:02 +00:00
{
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
{
if (!_glfwCreateContextGLX(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
Add GLFW_OSMESA_CONTEXT_API This allows the creation of OpenGL contexts via OSMesa on existing platforms. It does not add a compile- or link-time dependency on OSMesa. Fixes #281.
2017-02-28 18:23:25 +00:00
else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
{
if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
Add GLFW_OSMESA_CONTEXT_API This allows the creation of OpenGL contexts via OSMesa on existing platforms. It does not add a compile- or link-time dependency on OSMesa. Fixes #281.
2017-02-28 18:23:25 +00:00
else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
{
if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
Move last bits of window setup to platform code This avoids glfwCreateWindow emitting GLFW_FEATURE_UNAVAILABLE or GLFW_FEATURE_UNIMPLEMENTED on Wayland because shared code was calling unimplemented or unavailable platform functions during final setup. It also makes it consistent with the final setup of full screen windows.
2022-04-06 19:13:48 +00:00
if (!_glfwRefreshContextAttribs(window, ctxconfig))
return GLFW_FALSE;
Add GLFW_NO_API for creating context-less windows
2015-06-18 12:03:02 +00:00
}
Move last bits of window setup to platform code This avoids glfwCreateWindow emitting GLFW_FEATURE_UNAVAILABLE or GLFW_FEATURE_UNIMPLEMENTED on Wayland because shared code was calling unimplemented or unavailable platform functions during final setup. It also makes it consistent with the final setup of full screen windows.
2022-04-06 19:13:48 +00:00
if (wndconfig->mousePassthrough)
_glfwSetWindowMousePassthroughX11(window, GLFW_TRUE);
Remove monitor from _GLFWwndconfig
2016-03-14 14:17:28 +00:00
if (window->monitor)
Added x11 support for monitor PnP detection.
2012-01-30 15:21:21 +00:00
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwShowWindowX11(window);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
updateWindowMode(window);
Cleanup Allow window creation despite video mode setting failure. Video mode setting failure is ignored the rest of the time and the desired video mode has never been a hard constraint anyway.
2018-02-05 16:11:04 +00:00
acquireMonitor(window);
Move last bits of window setup to platform code This avoids glfwCreateWindow emitting GLFW_FEATURE_UNAVAILABLE or GLFW_FEATURE_UNIMPLEMENTED on Wayland because shared code was calling unimplemented or unavailable platform functions during final setup. It also makes it consistent with the final setup of full screen windows.
2022-04-06 19:13:48 +00:00
if (wndconfig->centerCursor)
_glfwCenterCursorInContentArea(window);
}
else
{
if (wndconfig->visible)
{
_glfwShowWindowX11(window);
if (wndconfig->focused)
_glfwFocusWindowX11(window);
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add missing XFlush calls
2016-05-30 20:14:13 +00:00
XFlush(_glfw.x11.display);
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_TRUE;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwDestroyWindowX11(_GLFWwindow* window)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Simplify cursor window logic
2016-05-30 19:21:09 +00:00
if (_glfw.x11.disabledCursorWindow == window)
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
enableCursor(window);
Simplify cursor window logic
2016-05-30 19:21:09 +00:00
Begun integrating monitor and window.
2012-09-27 19:37:36 +00:00
if (window->monitor)
Add tracking of which window 'owns' a monitor
2016-02-23 11:34:35 +00:00
releaseMonitor(window);
Cleanup of basic XIM support. Shortened and simplified the code. Removed reporting of XIM sentinel key press event. Added credit. Updated changelog. Closes #151.
2014-09-21 00:13:41 +00:00
Fixed dead keys in X11. The library will now try to create an X input context to handle dead keys properly on international keyboards. This makes it possible to enter for example an e with accent grave on a German keyboard without further efforts. A fallback mechanism is provided in case the client does not support X input method / context creation. In that case, the library will behave as it did before.
2013-10-06 19:19:38 +00:00
if (window->x11.ic)
{
XDestroyIC(window->x11.ic);
window->x11.ic = NULL;
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Fix potential context resource leaks There is a gap between the creation of the context and the call to _glfwRefreshContextAttribs.
2016-08-05 09:22:55 +00:00
if (window->context.destroy)
Cleanup
2016-05-25 12:43:51 +00:00
window->context.destroy(window);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
if (window->x11.handle)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Moved to use X11 context manager.
2013-04-15 00:16:51 +00:00
XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context);
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XUnmapWindow(_glfw.x11.display, window->x11.handle);
XDestroyWindow(_glfw.x11.display, window->x11.handle);
window->x11.handle = (Window) 0;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
if (window->x11.colormap)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XFreeColormap(_glfw.x11.display, window->x11.colormap);
window->x11.colormap = (Colormap) 0;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Fixed glfwDestroyWindow not flushing the output buffer.
2014-03-12 19:53:57 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowTitleX11(_GLFWwindow* window, const char* title)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
X11: Remove non-UTF-8 fallback paths It seems it has not been possible to compile GLFW on systems without the UTF-8 extensions to Xlib since a0a5cc57dff620f97428168a2580714bebc22381 was merged five months ago. The UTF-8 extension functions were introduced with XFree86 4.0.2 in December 2000 and are likely widely available at this point. This removes the locale-dependent fallback paths and uses the UTF-8 extension functions where available.
2020-07-02 16:53:26 +00:00
if (_glfw.x11.xlib.utf8)
{
Xutf8SetWMProperties(_glfw.x11.display,
window->x11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
}
Formatting.
2012-02-01 13:43:42 +00:00
Unconditionally use some EWMH atoms These window properties do no harm if they're declared even if the WM doesn't support them. This makes GLFW slightly more tolerant of WM changes as well as things like Ubuntu Unity reading _NET_WM_ICON without declaring support for it.
2016-05-03 09:58:25 +00:00
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_NAME, _glfw.x11.UTF8_STRING, 8,
PropModeReplace,
(unsigned char*) title, strlen(title));
Added support for _NET_WM_ICON_NAME.
2012-02-02 16:20:14 +00:00
Unconditionally use some EWMH atoms These window properties do no harm if they're declared even if the WM doesn't support them. This makes GLFW slightly more tolerant of WM changes as well as things like Ubuntu Unity reading _NET_WM_ICON without declaring support for it.
2016-05-03 09:58:25 +00:00
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON_NAME, _glfw.x11.UTF8_STRING, 8,
PropModeReplace,
(unsigned char*) title, strlen(title));
Added missing X command flushing.
2014-04-07 11:36:25 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowIconX11(_GLFWwindow* window, int count, const GLFWimage* images)
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
{
if (count)
{
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
int longCount = 0;
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (int i = 0; i < count; i++)
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
longCount += 2 + images[i].width * images[i].height;
X11: Fix undefined behavior in glfwSetWindowIcon The conversion of window icon image data involves unsigned char color values being promoted to int and then shifted to the left by 24. For 32-bit ints this is just far enough to trigger undefined behavior. It worked by accident because of how current compilers translate this piece of code. This was caught by @slimsag while working on [Zig bindings for GLFW][1], and diagnosed together with @Andoryuuta, as described [in an article][2]. Zig has UBSan enabled by default, which caught this undefined behavior. [1]: https://github.com/hexops/mach-glfw [2]: https://devlog.hexops.com/2021/perfecting-glfw-for-zig-and-finding-undefined-behavior#finding-lurking-undefined-behavior-in-6-year-old-glfw-code Thanks to Maato, martinhath, dcousens, drfuchs and Validark for helping to refine the solution. This commit message was rewritten by @elmindreda to hopefully reflect the conclusions of the pull request thread. Related to hexops/mach#20 Closes #1986
2021-10-31 18:22:40 +00:00
unsigned long* icon = _glfw_calloc(longCount, sizeof(unsigned long));
unsigned long* target = icon;
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (int i = 0; i < count; i++)
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
{
*target++ = images[i].width;
*target++ = images[i].height;
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (int j = 0; j < images[i].width * images[i].height; j++)
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
{
Cleanup
2021-11-30 19:34:47 +00:00
*target++ = (((unsigned long) images[i].pixels[j * 4 + 0]) << 16) |
(((unsigned long) images[i].pixels[j * 4 + 1]) << 8) |
(((unsigned long) images[i].pixels[j * 4 + 2]) << 0) |
(((unsigned long) images[i].pixels[j * 4 + 3]) << 24);
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
}
}
Cleanup
2021-11-30 19:34:47 +00:00
// NOTE: XChangeProperty expects 32-bit values like the image data above to be
// placed in the 32 least significant bits of individual longs. This is
// true even if long is 64-bit and a WM protocol calls for "packed" data.
// This is because of a historical mistake that then became part of the Xlib
// ABI. Xlib will pack these values into a regular array of 32-bit values
// before sending it over the wire.
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON,
XA_CARDINAL, 32,
PropModeReplace,
(unsigned char*) icon,
longCount);
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(icon);
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
}
else
{
XDeleteProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON);
}
XFlush(_glfw.x11.display);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowPosX11(_GLFWwindow* window, int* xpos, int* ypos)
Reintroduced glfwGetWindowPos, glfwSetWindowPos.
2013-01-24 18:30:31 +00:00
{
X11: Fix glfw*WindowPos operating on window frame Fixes #800.
2016-08-16 23:11:32 +00:00
Window dummy;
Reintroduced glfwGetWindowPos, glfwSetWindowPos.
2013-01-24 18:30:31 +00:00
int x, y;
XTranslateCoordinates(_glfw.x11.display, window->x11.handle, _glfw.x11.root,
X11: Fix glfw*WindowPos operating on window frame Fixes #800.
2016-08-16 23:11:32 +00:00
0, 0, &x, &y, &dummy);
Fixed window position being incorrect on some WMs.
2013-07-30 13:52:23 +00:00
Reintroduced glfwGetWindowPos, glfwSetWindowPos.
2013-01-24 18:30:31 +00:00
if (xpos)
*xpos = x;
if (ypos)
*ypos = y;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowPosX11(_GLFWwindow* window, int xpos, int ypos)
Reintroduced glfwGetWindowPos, glfwSetWindowPos.
2013-01-24 18:30:31 +00:00
{
Move X11 PPosition hack to glfwSetWindowPos
2016-03-14 19:39:27 +00:00
// HACK: Explicitly setting PPosition to any value causes some WMs, notably
// Compiz and Metacity, to honor the position of unmapped windows
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (!_glfwWindowVisibleX11(window))
Move X11 PPosition hack to glfwSetWindowPos
2016-03-14 19:39:27 +00:00
{
long supplied;
XSizeHints* hints = XAllocSizeHints();
if (XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied))
{
hints->flags |= PPosition;
hints->x = hints->y = 0;
XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
}
XFree(hints);
}
Reintroduced glfwGetWindowPos, glfwSetWindowPos.
2013-01-24 18:30:31 +00:00
XMoveWindow(_glfw.x11.display, window->x11.handle, xpos, ypos);
Fixed window position for EWMH full screen. Also added flushing after setting window position and size.
2013-05-19 07:08:42 +00:00
XFlush(_glfw.x11.display);
Reintroduced glfwGetWindowPos, glfwSetWindowPos.
2013-01-24 18:30:31 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowSizeX11(_GLFWwindow* window, int* width, int* height)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Made glfwGetWindowSize immediate. Conflicts: src/internal.h
2012-11-25 13:53:33 +00:00
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
if (width)
*width = attribs.width;
if (height)
*height = attribs.height;
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowSizeX11(_GLFWwindow* window, int width, int height)
Made glfwGetWindowSize immediate. Conflicts: src/internal.h
2012-11-25 13:53:33 +00:00
{
Begun integrating monitor and window.
2012-09-27 19:37:36 +00:00
if (window->monitor)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
if (window->monitor->window == window)
acquireMonitor(window);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Made glfwGetWindowSize immediate. Conflicts: src/internal.h
2012-11-25 13:53:33 +00:00
else
Cleanup.
2013-06-19 11:46:18 +00:00
{
if (!window->resizable)
Fix GLFW_RESIZABLE on X11 when exiting full screen The WM normal hints were set with the wrong window dimensions. Fixes #737.
2016-05-03 09:28:23 +00:00
updateNormalHints(window, width, height);
Cleanup.
2013-06-19 11:46:18 +00:00
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XResizeWindow(_glfw.x11.display, window->x11.handle, width, height);
Cleanup.
2013-06-19 11:46:18 +00:00
}
Fixed window position for EWMH full screen. Also added flushing after setting window position and size.
2013-05-19 07:08:42 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowSizeLimitsX11(_GLFWwindow* window,
int minwidth, int minheight,
int maxwidth, int maxheight)
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
{
Fix GLFW_RESIZABLE on X11 when exiting full screen The WM normal hints were set with the wrong window dimensions. Fixes #737.
2016-05-03 09:28:23 +00:00
int width, height;
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetWindowSizeX11(window, &width, &height);
Fix GLFW_RESIZABLE on X11 when exiting full screen The WM normal hints were set with the wrong window dimensions. Fixes #737.
2016-05-03 09:28:23 +00:00
updateNormalHints(window, width, height);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
XFlush(_glfw.x11.display);
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowAspectRatioX11(_GLFWwindow* window, int numer, int denom)
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
{
Fix GLFW_RESIZABLE on X11 when exiting full screen The WM normal hints were set with the wrong window dimensions. Fixes #737.
2016-05-03 09:28:23 +00:00
int width, height;
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetWindowSizeX11(window, &width, &height);
Fix GLFW_RESIZABLE on X11 when exiting full screen The WM normal hints were set with the wrong window dimensions. Fixes #737.
2016-05-03 09:28:23 +00:00
updateNormalHints(window, width, height);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
XFlush(_glfw.x11.display);
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetFramebufferSizeX11(_GLFWwindow* window, int* width, int* height)
Separated window and framebuffer sizes.
2013-06-03 10:51:57 +00:00
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetWindowSizeX11(window, width, height);
Separated window and framebuffer sizes.
2013-06-03 10:51:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowFrameSizeX11(_GLFWwindow* window,
int* left, int* top,
int* right, int* bottom)
Added glfwGetWindowFrameSize.
2014-03-25 20:30:13 +00:00
{
long* extents = NULL;
Avoid X11 frame size query of undecorated windows This also works around an issue where Xfwm4 ignores Motif hints when calculating frame extents.
2016-02-28 17:41:10 +00:00
if (window->monitor || !window->decorated)
return;
Added glfwGetWindowFrameSize.
2014-03-25 20:30:13 +00:00
if (_glfw.x11.NET_FRAME_EXTENTS == None)
return;
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (!_glfwWindowVisibleX11(window) &&
Moved _NET_REQUEST_FRAME_EXTENTS to frame query. The request is now only made when necessary and times out after 500ms. This breaks our end of the protocol to work around broken implementations at the other end. It uses the GLFW timer instead of select, as select is not guaranteed to update the timeout with the time remaining and a single select is not sufficient as other events may be incoming. Fixes #368 (mostly). Fixes #429 (mostly).
2015-03-12 14:42:06 +00:00
_glfw.x11.NET_REQUEST_FRAME_EXTENTS)
{
XEvent event;
X11: Clean up event wait timeout logic Simplify interface and implement timeout updating.
2016-08-09 22:33:07 +00:00
double timeout = 0.5;
Simplified sending events to WM.
2015-06-02 15:05:00 +00:00
// Ensure _NET_FRAME_EXTENTS is set, allowing glfwGetWindowFrameSize to
// function before the window is mapped
sendEventToWM(window, _glfw.x11.NET_REQUEST_FRAME_EXTENTS,
0, 0, 0, 0, 0);
Moved _NET_REQUEST_FRAME_EXTENTS to frame query. The request is now only made when necessary and times out after 500ms. This breaks our end of the protocol to work around broken implementations at the other end. It uses the GLFW timer instead of select, as select is not guaranteed to update the timeout with the time remaining and a single select is not sufficient as other events may be incoming. Fixes #368 (mostly). Fixes #429 (mostly).
2015-03-12 14:42:06 +00:00
Comment work
2016-07-24 19:55:36 +00:00
// HACK: Use a timeout because earlier versions of some window managers
// (at least Unity, Fluxbox and Xfwm) failed to send the reply
Moved _NET_REQUEST_FRAME_EXTENTS to frame query. The request is now only made when necessary and times out after 500ms. This breaks our end of the protocol to work around broken implementations at the other end. It uses the GLFW timer instead of select, as select is not guaranteed to update the timeout with the time remaining and a single select is not sufficient as other events may be incoming. Fixes #368 (mostly). Fixes #429 (mostly).
2015-03-12 14:42:06 +00:00
// They have been fixed but broken versions are still in the wild
// If you are affected by this and your window manager is NOT
// listed above, PLEASE report it to their and our issue trackers
Added select to all custom X11 event polling. All loops waiting for specific events now use select to sleep while there is no new data.
2015-03-16 17:19:50 +00:00
while (!XCheckIfEvent(_glfw.x11.display,
&event,
isFrameExtentsEvent,
(XPointer) window))
Moved _NET_REQUEST_FRAME_EXTENTS to frame query. The request is now only made when necessary and times out after 500ms. This breaks our end of the protocol to work around broken implementations at the other end. It uses the GLFW timer instead of select, as select is not guaranteed to update the timeout with the time remaining and a single select is not sufficient as other events may be incoming. Fixes #368 (mostly). Fixes #429 (mostly).
2015-03-12 14:42:06 +00:00
{
X11: Fix joystick events causing busy waiting On Linux, the inotify descriptor was included in the set used for select, but could not break the outer loop, leading to busy waiting until timeout or the correct X11 event arrived. This commit adds a new function for waiting just on X11 events. Fixes #1872
2022-02-18 14:19:16 +00:00
if (!waitForX11Event(&timeout))
Moved _NET_REQUEST_FRAME_EXTENTS to frame query. The request is now only made when necessary and times out after 500ms. This breaks our end of the protocol to work around broken implementations at the other end. It uses the GLFW timer instead of select, as select is not guaranteed to update the timeout with the time remaining and a single select is not sufficient as other events may be incoming. Fixes #368 (mostly). Fixes #429 (mostly).
2015-03-12 14:42:06 +00:00
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Various error fixes. Fixed incorrect error types. Added missing error string prefixes. Removed some invalid or superfluous error emissions. Clarified some error strings. Joined error string lines to aid grep. Replaced some generic error strings with specific ones. Documentation work. Fixes #450.
2015-03-10 18:51:14 +00:00
"X11: The window manager has a broken _NET_REQUEST_FRAME_EXTENTS implementation; please report this issue");
Added select to all custom X11 event polling. All loops waiting for specific events now use select to sleep while there is no new data.
2015-03-16 17:19:50 +00:00
return;
Moved _NET_REQUEST_FRAME_EXTENTS to frame query. The request is now only made when necessary and times out after 500ms. This breaks our end of the protocol to work around broken implementations at the other end. It uses the GLFW timer instead of select, as select is not guaranteed to update the timeout with the time remaining and a single select is not sufficient as other events may be incoming. Fixes #368 (mostly). Fixes #429 (mostly).
2015-03-12 14:42:06 +00:00
}
}
}
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 17:16:46 +00:00
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_FRAME_EXTENTS,
XA_CARDINAL,
(unsigned char**) &extents) == 4)
Added glfwGetWindowFrameSize.
2014-03-25 20:30:13 +00:00
{
if (left)
*left = extents[0];
if (top)
*top = extents[2];
if (right)
*right = extents[1];
if (bottom)
*bottom = extents[3];
}
if (extents)
XFree(extents);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowContentScaleX11(_GLFWwindow* window, float* xscale, float* yscale)
Add content scale queries This adds glfwGetWindowContentScale and glfwGetMonitorContentScale for querying the recommended drawing scale factor for DPI-aware rendering. Parts of this patch are based on code by @ferreiradaselva. Fixes #235. Fixes #439. Fixes #677. Fixes #845. Fixes #898.
2017-08-29 17:19:00 +00:00
{
if (xscale)
*xscale = _glfw.x11.contentScaleX;
if (yscale)
*yscale = _glfw.x11.contentScaleY;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwIconifyWindowX11(_GLFWwindow* window)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Add back tracking of X11 override-redirect
2016-02-28 15:05:02 +00:00
if (window->x11.overrideRedirect)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Comment updates and formatting.
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
Various error fixes. Fixed incorrect error types. Added missing error string prefixes. Removed some invalid or superfluous error emissions. Clarified some error strings. Joined error string lines to aid grep. Replaced some generic error strings with specific ones. Documentation work. Fixes #450.
2015-03-10 18:51:14 +00:00
_glfwInputError(GLFW_PLATFORM_ERROR,
Clarified EWMH full screen error messages.
2015-06-15 12:39:56 +00:00
"X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
return;
}
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XIconifyWindow(_glfw.x11.display, window->x11.handle, _glfw.x11.screen);
Added missing X command flushing.
2014-04-07 11:36:25 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwRestoreWindowX11(_GLFWwindow* window)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Add back tracking of X11 override-redirect
2016-02-28 15:05:02 +00:00
if (window->x11.overrideRedirect)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Comment updates and formatting.
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
Various error fixes. Fixed incorrect error types. Added missing error string prefixes. Removed some invalid or superfluous error emissions. Clarified some error strings. Joined error string lines to aid grep. Replaced some generic error strings with specific ones. Documentation work. Fixes #450.
2015-03-10 18:51:14 +00:00
_glfwInputError(GLFW_PLATFORM_ERROR,
Clarified EWMH full screen error messages.
2015-06-15 12:39:56 +00:00
"X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
return;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfwWindowIconifiedX11(window))
X11: Fix BadMatch on XSetInputFocus Input focus was in some cases set before the window was visible (ICCCM section 4.2.2). Related to #798. Fixes #789.
2016-08-10 14:22:03 +00:00
{
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
XMapWindow(_glfw.x11.display, window->x11.handle);
X11: Fix BadMatch on XSetInputFocus Input focus was in some cases set before the window was visible (ICCCM section 4.2.2). Related to #798. Fixes #789.
2016-08-10 14:22:03 +00:00
waitForVisibilityNotify(window);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
else if (_glfwWindowVisibleX11(window))
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
if (_glfw.x11.NET_WM_STATE &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_REMOVE,
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
1, 0);
}
}
Added missing X command flushing.
2014-04-07 11:36:25 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwMaximizeWindowX11(_GLFWwindow* window)
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
X11: Fix maximization of hidden windows This fixes glfwMaximizeWindow having no effect on hidden windows by manually appending the maximization states to the EWMH state property.
2019-12-16 13:53:06 +00:00
if (!_glfw.x11.NET_WM_STATE ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
return;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfwWindowVisibleX11(window))
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
sendEventToWM(window,
X11: Fix maximization of hidden windows This fixes glfwMaximizeWindow having no effect on hidden windows by manually appending the maximization states to the EWMH state property.
2019-12-16 13:53:06 +00:00
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
1, 0);
}
else
{
Atom* states = NULL;
unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
(unsigned char**) &states);
// NOTE: We don't check for failure as this property may not exist yet
// and that's fine (and we'll create it implicitly with append)
Atom missing[2] =
{
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ
};
unsigned long missingCount = 2;
for (unsigned long i = 0; i < count; i++)
{
for (unsigned long j = 0; j < missingCount; j++)
{
if (states[i] == missing[j])
{
missing[j] = missing[missingCount - 1];
missingCount--;
}
}
}
if (states)
XFree(states);
if (!missingCount)
return;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_STATE, XA_ATOM, 32,
PropModeAppend,
(unsigned char*) missing,
missingCount);
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
}
X11: Fix maximization of hidden windows This fixes glfwMaximizeWindow having no effect on hidden windows by manually appending the maximization states to the EWMH state property.
2019-12-16 13:53:06 +00:00
XFlush(_glfw.x11.display);
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwShowWindowX11(_GLFWwindow* window)
Add glfwShowWindow, glfwHideWindow Add glfwShowWindow and glfwHideWindow functions to allow explicit control over show/hide window. Remove platform specific show window code from _glfwPlatformCreateWindow but call glfwShowWindow from glfwCreateWindow to avoid breaking things (for now).
2012-08-21 18:01:57 +00:00
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfwWindowVisibleX11(window))
X11: Fix BadMatch on XSetInputFocus Input focus was in some cases set before the window was visible (ICCCM section 4.2.2). Related to #798. Fixes #789.
2016-08-10 14:22:03 +00:00
return;
Add glfwFocusWindow This removes the (undocumented) behavior where glfwShowWindow would bring the window to front and set input focus. That function now does what it says.
2016-02-21 14:42:49 +00:00
XMapWindow(_glfw.x11.display, window->x11.handle);
X11: Fix BadMatch on XSetInputFocus Input focus was in some cases set before the window was visible (ICCCM section 4.2.2). Related to #798. Fixes #789.
2016-08-10 14:22:03 +00:00
waitForVisibilityNotify(window);
Add glfwShowWindow, glfwHideWindow Add glfwShowWindow and glfwHideWindow functions to allow explicit control over show/hide window. Remove platform specific show window code from _glfwPlatformCreateWindow but call glfwShowWindow from glfwCreateWindow to avoid breaking things (for now).
2012-08-21 18:01:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwHideWindowX11(_GLFWwindow* window)
Added GLFW_FOCUSED window hint. Fixes #101.
2014-06-20 11:39:06 +00:00
{
Add glfwFocusWindow This removes the (undocumented) behavior where glfwShowWindow would bring the window to front and set input focus. That function now does what it says.
2016-02-21 14:42:49 +00:00
XUnmapWindow(_glfw.x11.display, window->x11.handle);
Added GLFW_FOCUSED window hint. Fixes #101.
2014-06-20 11:39:06 +00:00
XFlush(_glfw.x11.display);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwRequestWindowAttentionX11(_GLFWwindow* window)
Add glfwRequestWindowAttention Related to #988.
2017-03-21 13:02:57 +00:00
{
X11: Fix missing checks for EWMH attention atoms
2019-12-16 14:08:54 +00:00
if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION)
return;
Cleanup Closes #988.
2017-05-11 12:36:56 +00:00
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION,
0, 1, 0);
Add glfwRequestWindowAttention Related to #988.
2017-03-21 13:02:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwFocusWindowX11(_GLFWwindow* window)
Add glfwShowWindow, glfwHideWindow Add glfwShowWindow and glfwHideWindow functions to allow explicit control over show/hide window. Remove platform specific show window code from _glfwPlatformCreateWindow but call glfwShowWindow from glfwCreateWindow to avoid breaking things (for now).
2012-08-21 18:01:57 +00:00
{
Add glfwFocusWindow This removes the (undocumented) behavior where glfwShowWindow would bring the window to front and set input focus. That function now does what it says.
2016-02-21 14:42:49 +00:00
if (_glfw.x11.NET_ACTIVE_WINDOW)
sendEventToWM(window, _glfw.x11.NET_ACTIVE_WINDOW, 1, 0, 0, 0, 0);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
else if (_glfwWindowVisibleX11(window))
Add glfwFocusWindow This removes the (undocumented) behavior where glfwShowWindow would bring the window to front and set input focus. That function now does what it says.
2016-02-21 14:42:49 +00:00
{
XRaiseWindow(_glfw.x11.display, window->x11.handle);
XSetInputFocus(_glfw.x11.display, window->x11.handle,
RevertToParent, CurrentTime);
}
Renamed global struct and substructs. Renamed _glfwLibrary to _glfw and made all substructs lower-case, making global variable names easier to read and type. Partially inspired by the internal naming conventions of glwt.
2013-01-02 00:40:42 +00:00
XFlush(_glfw.x11.display);
Add glfwShowWindow, glfwHideWindow Add glfwShowWindow and glfwHideWindow functions to allow explicit control over show/hide window. Remove platform specific show window code from _glfwPlatformCreateWindow but call glfwShowWindow from glfwCreateWindow to avoid breaking things (for now).
2012-08-21 18:01:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowMonitorX11(_GLFWwindow* window,
_GLFWmonitor* monitor,
int xpos, int ypos,
int width, int height,
int refreshRate)
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
{
if (window->monitor == monitor)
{
if (monitor)
{
if (monitor->window == window)
acquireMonitor(window);
}
else
{
X11: Fix glfwSetWindowMonitor not updating hints This makes glfwSetWindowMonitor update the WM_NORMAL_HINTS when resizing non-user-resizable windowed mode windows.
2019-01-01 17:24:11 +00:00
if (!window->resizable)
updateNormalHints(window, width, height);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
xpos, ypos, width, height);
}
X11: Fix glfwSetWindowMonitor not flushing buffer
2019-01-01 17:32:45 +00:00
XFlush(_glfw.x11.display);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
return;
}
if (window->monitor)
X11: Fix attribs not applied on leaving fullscreen If the GLFW_DECORATED and/or GLFW_FLOATING window attributes were changed while in fullscreen mode, the changes did not take effect when the window entered windowed mode. Bug reported on the GLFW forum. https://discourse.glfw.org/t/turning-on-off-window-decorations-while-in-full-screen-wont-work-properly/1780
2021-03-08 18:32:36 +00:00
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwSetWindowDecoratedX11(window, window->decorated);
_glfwSetWindowFloatingX11(window, window->floating);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
releaseMonitor(window);
X11: Fix attribs not applied on leaving fullscreen If the GLFW_DECORATED and/or GLFW_FLOATING window attributes were changed while in fullscreen mode, the changes did not take effect when the window entered windowed mode. Bug reported on the GLFW forum. https://discourse.glfw.org/t/turning-on-off-window-decorations-while-in-full-screen-wont-work-properly/1780
2021-03-08 18:32:36 +00:00
}
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
Cleanup
2017-10-26 16:05:56 +00:00
_glfwInputWindowMonitor(window, monitor);
Fix GLFW_RESIZABLE on X11 when exiting full screen The WM normal hints were set with the wrong window dimensions. Fixes #737.
2016-05-03 09:28:23 +00:00
updateNormalHints(window, width, height);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
if (window->monitor)
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (!_glfwWindowVisibleX11(window))
X11: Fix EWMH state update for hidden windows The EWMH window state code assumed the window was mapped. Fixes #1358.
2019-01-30 23:02:16 +00:00
{
XMapRaised(_glfw.x11.display, window->x11.handle);
waitForVisibilityNotify(window);
}
updateWindowMode(window);
acquireMonitor(window);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
}
else
{
X11: Fix EWMH state update for hidden windows The EWMH window state code assumed the window was mapped. Fixes #1358.
2019-01-30 23:02:16 +00:00
updateWindowMode(window);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
xpos, ypos, width, height);
}
XFlush(_glfw.x11.display);
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowFocusedX11(_GLFWwindow* window)
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
{
Window focused;
int state;
XGetInputFocus(_glfw.x11.display, &focused, &state);
return window->x11.handle == focused;
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowIconifiedX11(_GLFWwindow* window)
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
{
return getWindowState(window) == IconicState;
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowVisibleX11(_GLFWwindow* window)
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
{
XWindowAttributes wa;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &wa);
return wa.map_state == IsViewable;
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowMaximizedX11(_GLFWwindow* window)
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
Atom* states;
GLFWbool maximized = GLFW_FALSE;
X11: Fix missing check for NET_WM_STATE Closes #1356.
2018-10-13 05:54:50 +00:00
if (!_glfw.x11.NET_WM_STATE ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
return maximized;
}
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
(unsigned char**) &states);
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (unsigned long i = 0; i < count; i++)
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
if (states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
maximized = GLFW_TRUE;
break;
}
}
X11: Fix potential window property data leaks
2017-01-16 00:36:14 +00:00
if (states)
XFree(states);
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
return maximized;
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowHoveredX11(_GLFWwindow* window)
Add GLFW_HOVERED for polling cursor hover state This window attribute corresponds to the cursor enter/leave callback. Fixes #1166.
2018-01-04 12:50:58 +00:00
{
Window w = _glfw.x11.root;
while (w)
{
Window root;
int rootX, rootY, childX, childY;
unsigned int mask;
X11: Fix race in window hovered query The window decoration window can go away between calls to XQueryPointer, for example if the GLFW_DECORATED window attribute was just cleared.
2020-07-08 13:53:01 +00:00
_glfwGrabErrorHandlerX11();
const Bool result = XQueryPointer(_glfw.x11.display, w,
&root, &w, &rootX, &rootY,
&childX, &childY, &mask);
_glfwReleaseErrorHandlerX11();
if (_glfw.x11.errorCode == BadWindow)
w = _glfw.x11.root;
X11: Fix cursor hover query retry behavior XQueryPointer returns zero on BadWindow so the retry did not happen. Related to ceb20c7f97994106db17cc66bd8abad331bc355e.
2020-07-09 22:03:53 +00:00
else if (!result)
Add GLFW_HOVERED for polling cursor hover state This window attribute corresponds to the cursor enter/leave callback. Fixes #1166.
2018-01-04 12:50:58 +00:00
return GLFW_FALSE;
X11: Fix cursor hover query retry behavior XQueryPointer returns zero on BadWindow so the retry did not happen. Related to ceb20c7f97994106db17cc66bd8abad331bc355e.
2020-07-09 22:03:53 +00:00
else if (w == window->x11.handle)
Add GLFW_HOVERED for polling cursor hover state This window attribute corresponds to the cursor enter/leave callback. Fixes #1166.
2018-01-04 12:50:58 +00:00
return GLFW_TRUE;
}
return GLFW_FALSE;
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow* window)
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
{
if (!window->x11.transparent)
return GLFW_FALSE;
Add glfwGetWindowOpacity and glfwSetWindowOpacity This adds support for setting the opacity of the whole window, including any decorations. Fixes #1089.
2017-09-25 21:14:45 +00:00
return XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx) != None;
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowResizableX11(_GLFWwindow* window, GLFWbool enabled)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
int width, height;
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetWindowSizeX11(window, &width, &height);
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
updateNormalHints(window, width, height);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowDecoratedX11(_GLFWwindow* window, GLFWbool enabled)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
X11: Fix decoration enabling after window creation This fixes the enabling of window decorations after creation. Instead of removing the _MOTIF_WM_HINTS property, we now set or unset the MWM_DECOR_ALL bit of the decorations field. Fixes #1566.
2019-09-26 16:29:37 +00:00
struct
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
X11: Fix decoration enabling after window creation This fixes the enabling of window decorations after creation. Instead of removing the _MOTIF_WM_HINTS property, we now set or unset the MWM_DECOR_ALL bit of the decorations field. Fixes #1566.
2019-09-26 16:29:37 +00:00
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long input_mode;
unsigned long status;
} hints = {0};
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
X11: Fix decoration enabling after window creation This fixes the enabling of window decorations after creation. Instead of removing the _MOTIF_WM_HINTS property, we now set or unset the MWM_DECOR_ALL bit of the decorations field. Fixes #1566.
2019-09-26 16:29:37 +00:00
hints.flags = MWM_HINTS_DECORATIONS;
hints.decorations = enabled ? MWM_DECOR_ALL : 0;
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
X11: Fix decoration enabling after window creation This fixes the enabling of window decorations after creation. Instead of removing the _MOTIF_WM_HINTS property, we now set or unset the MWM_DECOR_ALL bit of the decorations field. Fixes #1566.
2019-09-26 16:29:37 +00:00
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.MOTIF_WM_HINTS,
_glfw.x11.MOTIF_WM_HINTS, 32,
PropModeReplace,
(unsigned char*) &hints,
sizeof(hints) / sizeof(long));
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowFloatingX11(_GLFWwindow* window, GLFWbool enabled)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_ABOVE)
return;
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfwWindowVisibleX11(window))
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
X11: Cleanup The window state action is not an atom.
2019-12-16 16:44:17 +00:00
const long action = enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
action,
_glfw.x11.NET_WM_STATE_ABOVE,
0, 1, 0);
}
else
{
X11: Fix updating GLFW_FLOATING on a hidden window
2019-12-16 15:09:52 +00:00
Atom* states = NULL;
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
(unsigned char**) &states);
X11: Fix updating GLFW_FLOATING on a hidden window
2019-12-16 15:09:52 +00:00
// NOTE: We don't check for failure as this property may not exist yet
// and that's fine (and we'll create it implicitly with append)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
if (enabled)
{
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
unsigned long i;
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
for (i = 0; i < count; i++)
{
if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
break;
}
X11: Fix function returning before cleanup The _glfwPlatformSetWindowFloating function would return without freeing the state array if the window was already in the requested state.
2021-08-15 12:55:13 +00:00
if (i == count)
{
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_STATE, XA_ATOM, 32,
PropModeAppend,
(unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
1);
}
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
}
X11: Fix updating GLFW_FLOATING on a hidden window
2019-12-16 15:09:52 +00:00
else if (states)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (unsigned long i = 0; i < count; i++)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
{
states[i] = states[count - 1];
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_STATE, XA_ATOM, 32,
PropModeReplace, (unsigned char*) states, count - 1);
X11: Fix updating GLFW_FLOATING on a hidden window
2019-12-16 15:09:52 +00:00
break;
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
}
X11: Fix function returning before cleanup The _glfwPlatformSetWindowFloating function would return without freeing the state array if the window was already in the requested state.
2021-08-15 12:55:13 +00:00
}
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
}
X11: Fix updating GLFW_FLOATING on a hidden window
2019-12-16 15:09:52 +00:00
if (states)
XFree(states);
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
}
XFlush(_glfw.x11.display);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowMousePassthroughX11(_GLFWwindow* window, GLFWbool enabled)
Add support for mouse input transparency This adds the GLFW_MOUSE_PASSTHROUGH window hint and attribute for controlling whether mouse input passes through the window to whatever window is behind it. Fixes #1236. Closes #1568.
2019-09-30 12:44:43 +00:00
{
if (!_glfw.x11.xshape.available)
return;
X11: Fix disabling of GLFW_MOUSE_PASSTHROUGH The client clip region was left in place when mouse passthrough was disabled, leading to missing mouse input if the window grew beyond it. Related to #1568.
2020-07-06 21:09:28 +00:00
if (enabled)
{
Region region = XCreateRegion();
XShapeCombineRegion(_glfw.x11.display, window->x11.handle,
X11: Include X Shape extension headers Related to #1568.
2020-07-06 21:15:20 +00:00
ShapeInput, 0, 0, region, ShapeSet);
X11: Fix disabling of GLFW_MOUSE_PASSTHROUGH The client clip region was left in place when mouse passthrough was disabled, leading to missing mouse input if the window grew beyond it. Related to #1568.
2020-07-06 21:09:28 +00:00
XDestroyRegion(region);
}
else
{
XShapeCombineMask(_glfw.x11.display, window->x11.handle,
X11: Include X Shape extension headers Related to #1568.
2020-07-06 21:15:20 +00:00
ShapeInput, 0, 0, None, ShapeSet);
X11: Fix disabling of GLFW_MOUSE_PASSTHROUGH The client clip region was left in place when mouse passthrough was disabled, leading to missing mouse input if the window grew beyond it. Related to #1568.
2020-07-06 21:09:28 +00:00
}
Add support for mouse input transparency This adds the GLFW_MOUSE_PASSTHROUGH window hint and attribute for controlling whether mouse input passes through the window to whatever window is behind it. Fixes #1236. Closes #1568.
2019-09-30 12:44:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
float _glfwGetWindowOpacityX11(_GLFWwindow* window)
Add glfwGetWindowOpacity and glfwSetWindowOpacity This adds support for setting the opacity of the whole window, including any decorations. Fixes #1089.
2017-09-25 21:14:45 +00:00
{
float opacity = 1.f;
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx))
{
CARD32* value = NULL;
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_WINDOW_OPACITY,
XA_CARDINAL,
(unsigned char**) &value))
{
opacity = (float) (*value / (double) 0xffffffffu);
}
if (value)
XFree(value);
}
return opacity;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowOpacityX11(_GLFWwindow* window, float opacity)
Add glfwGetWindowOpacity and glfwSetWindowOpacity This adds support for setting the opacity of the whole window, including any decorations. Fixes #1089.
2017-09-25 21:14:45 +00:00
{
const CARD32 value = (CARD32) (0xffffffffu * (double) opacity);
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_WINDOW_OPACITY, XA_CARDINAL, 32,
PropModeReplace, (unsigned char*) &value, 1);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetRawMouseMotionX11(_GLFWwindow *window, GLFWbool enabled)
Add GLFW_RAW_INPUT and glfwRawInputSupported This adds runtime per-window control of whether accelerated or raw mouse motion is provided when the cursor is disabled. Fixes #1400. Closes #1401.
2018-12-14 02:08:25 +00:00
{
Rename raw input to raw mouse motion, cleanup This renames 'raw input' to 'raw mouse motion' as there are other kinds of raw input. The update path is restructured to avoid reinitializing all of disabled cursor mode. Modification of shared state is moved out into shared code. Raw mouse motion is disabled by default for compatibility. Related to #1401.
2019-02-11 18:10:20 +00:00
if (!_glfw.x11.xi.available)
return;
if (_glfw.x11.disabledCursorWindow != window)
return;
if (enabled)
enableRawMouseMotion(window);
else
disableRawMouseMotion(window);
Add GLFW_RAW_INPUT and glfwRawInputSupported This adds runtime per-window control of whether accelerated or raw mouse motion is provided when the cursor is disabled. Fixes #1400. Closes #1401.
2018-12-14 02:08:25 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
GLFWbool _glfwRawMouseMotionSupportedX11(void)
Add GLFW_RAW_INPUT and glfwRawInputSupported This adds runtime per-window control of whether accelerated or raw mouse motion is provided when the cursor is disabled. Fixes #1400. Closes #1401.
2018-12-14 02:08:25 +00:00
{
return _glfw.x11.xi.available;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwPollEventsX11(void)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
X11: Fix empty event race condition with a pipe There is a seemingly unavoidable race condition when waiting for data on the X11 display connection, as long as any other thread is also making Xlib calls. The event data we are waiting for could be read by the other thread as part of looking for the reply to its request, before our poll has begun. This commit replaces the X11 event sent by glfwPostEmptyEvent with writing to an unnamed pipe. The race condition remains if other Xlib calls are made on other threads, but glfwPostEmptyEvent should now be race-free. This commit is based on work by pcwalton, OlivierSohn, kovidgoyal and joaodasilva. Closes #2033 Related to #379 Related to #1281 Related to #1285
2022-02-18 13:29:43 +00:00
drainEmptyEvents();
Linux: Fix joystick input being disabled Closes #2192
2022-12-15 19:18:59 +00:00
#if defined(GLFW_BUILD_LINUX_JOYSTICK)
X11: Fix joystick detection before joystick init Spotted by @Luflosi.
2020-07-23 19:14:36 +00:00
if (_glfw.joysticksInitialized)
_glfwDetectJoystickConnectionLinux();
Add null joystick backend This prepares the X11 backend to support other joystick APIs, for example the FreeBSD libusb one.
2017-01-31 02:29:28 +00:00
#endif
X11: Make event polling more robust This makes X11 event polling less likely to block if the application uses the display via native access. Fixes #1225.
2018-05-17 12:41:16 +00:00
XPending(_glfw.x11.display);
X11: Make libX11 dynamically loaded This completes the dynamic loading of all X11 libraries in preparation for run-time platform selection.
2019-12-16 12:19:37 +00:00
while (QLength(_glfw.x11.display))
Formatting.
2012-08-12 14:04:03 +00:00
{
Fixed X11 clipboard regressions, event waiting.
2013-01-30 23:26:37 +00:00
XEvent event;
XNextEvent(_glfw.x11.display, &event);
Formatting.
2012-08-12 14:04:03 +00:00
processEvent(&event);
}
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Cleanup
2022-02-18 14:35:09 +00:00
_GLFWwindow* window = _glfw.x11.disabledCursorWindow;
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
if (window)
{
int width, height;
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetWindowSizeX11(window, &width, &height);
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
// NOTE: Re-center the cursor only if it has moved since the last call,
// to avoid breaking glfwWaitEvents with MotionNotify
if (window->x11.lastCursorPosX != width / 2 ||
window->x11.lastCursorPosY != height / 2)
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwSetCursorPosX11(window, width / 2, height / 2);
X11: Use XI_RawMotion for disabled cursor motion Related to #125.
2017-01-12 19:31:59 +00:00
}
}
Add missing XFlush calls
2016-05-30 20:14:13 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwWaitEventsX11(void)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
X11: Fix glfwWaitEvents* ignoring joystick events The data available on the X11 connection may be a reply or an internal event for an X11 extension. Previously the check for whether an event was available for us was done outside waitForEvent. This prevented data available on other file descriptors from breaking the outer wait loop. This commit moves the check for whether an event is available into the wait functions, where there is enough knowledge to limit the check to the X11 connection. Related to #932
2022-02-18 14:20:10 +00:00
waitForAnyEvent(NULL);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwPollEventsX11();
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwWaitEventsTimeoutX11(double timeout)
Add glfwWaitEventsTimeout This function will put the calling thread to sleep until an event arrives or until the specified timeout has elapsed.
2016-02-02 20:11:16 +00:00
{
X11: Fix glfwWaitEvents* ignoring joystick events The data available on the X11 connection may be a reply or an internal event for an X11 extension. Previously the check for whether an event was available for us was done outside waitForEvent. This prevented data available on other file descriptors from breaking the outer wait loop. This commit moves the check for whether an event is available into the wait functions, where there is enough knowledge to limit the check to the X11 connection. Related to #932
2022-02-18 14:20:10 +00:00
waitForAnyEvent(&timeout);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwPollEventsX11();
Add glfwWaitEventsTimeout This function will put the calling thread to sleep until an event arrives or until the specified timeout has elapsed.
2016-02-02 20:11:16 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwPostEmptyEventX11(void)
Added glfwPostEmptyEvent.
2014-02-10 17:16:58 +00:00
{
X11: Fix empty event race condition with a pipe There is a seemingly unavoidable race condition when waiting for data on the X11 display connection, as long as any other thread is also making Xlib calls. The event data we are waiting for could be read by the other thread as part of looking for the reply to its request, before our poll has begun. This commit replaces the X11 event sent by glfwPostEmptyEvent with writing to an unnamed pipe. The race condition remains if other Xlib calls are made on other threads, but glfwPostEmptyEvent should now be race-free. This commit is based on work by pcwalton, OlivierSohn, kovidgoyal and joaodasilva. Closes #2033 Related to #379 Related to #1281 Related to #1285
2022-02-18 13:29:43 +00:00
writeEmptyEvent();
Added glfwPostEmptyEvent.
2014-02-10 17:16:58 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetCursorPosX11(_GLFWwindow* window, double* xpos, double* ypos)
Made glfwGetCursorPos query system directly. Fixes #103. Fixes #153. Fixes #193. Fixes #355. Fixes #381.
2014-02-11 17:24:01 +00:00
{
Window root, child;
int rootX, rootY, childX, childY;
unsigned int mask;
XQueryPointer(_glfw.x11.display, window->x11.handle,
&root, &child,
&rootX, &rootY, &childX, &childY,
&mask);
if (xpos)
*xpos = childX;
if (ypos)
*ypos = childY;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetCursorPosX11(_GLFWwindow* window, double x, double y)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Comment updates and formatting.
2012-08-26 13:38:18 +00:00
// Store the new position so it can be recognized later
Clarify cursor position variable names
2016-05-24 10:23:58 +00:00
window->x11.warpCursorPosX = (int) x;
window->x11.warpCursorPosY = (int) y;
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
Changed cursor pos to double.
2013-04-04 14:16:21 +00:00
XWarpPointer(_glfw.x11.display, None, window->x11.handle,
0,0,0,0, (int) x, (int) y);
Add missing XFlush calls
2016-05-30 20:14:13 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetCursorModeX11(_GLFWwindow* window, int mode)
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
if (_glfwWindowFocusedX11(window))
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
{
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
if (mode == GLFW_CURSOR_DISABLED)
{
_glfwGetCursorPosX11(window,
&_glfw.x11.restoreCursorPosX,
&_glfw.x11.restoreCursorPosY);
_glfwCenterCursorInContentArea(window);
if (window->rawMouseMotion)
enableRawMouseMotion(window);
}
else if (_glfw.x11.disabledCursorWindow == window)
{
if (window->rawMouseMotion)
disableRawMouseMotion(window);
}
Add cursor mode GLFW_CURSOR_CAPTURED This adds a cursor mode that provides a visible cursor confined to the content area of the window. Fixes #58
2019-12-03 16:58:20 +00:00
if (mode == GLFW_CURSOR_DISABLED || mode == GLFW_CURSOR_CAPTURED)
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
captureCursor(window);
else
releaseCursor();
if (mode == GLFW_CURSOR_DISABLED)
_glfw.x11.disabledCursorWindow = window;
else if (_glfw.x11.disabledCursorWindow == window)
{
_glfw.x11.disabledCursorWindow = NULL;
_glfwSetCursorPosX11(window,
_glfw.x11.restoreCursorPosX,
_glfw.x11.restoreCursorPosY);
}
Clean up cursor mode setting
2015-07-02 11:04:56 +00:00
}
Refactor cursor mode paths This is the refactoring part of adding GLFW_CURSOR_CAPTURED, separated out to help keep 3.3-stable similar to the main branch. Related to #58.
2019-07-08 12:45:31 +00:00
updateCursorImage(window);
Add missing XFlush calls
2016-05-30 20:14:13 +00:00
XFlush(_glfw.x11.display);
Initial import of 2.7 Lite.
2010-09-07 15:34:51 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
const char* _glfwGetScancodeNameX11(int scancode)
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
{
if (!_glfw.x11.xkb.available)
return NULL;
Check scancode before use in glfwGetKeyName
2020-01-15 15:34:58 +00:00
if (scancode < 0 || scancode > 0xff ||
_glfw.x11.keycodes[scancode] == GLFW_KEY_UNKNOWN)
{
Improve error description for invalid scancodes
2021-07-19 17:05:32 +00:00
_glfwInputError(GLFW_INVALID_VALUE, "Invalid scancode %i", scancode);
Check scancode before use in glfwGetKeyName
2020-01-15 15:34:58 +00:00
return NULL;
}
Unify key name string handling This makes key names per-key static strings for all supported platforms. Fixes #1200.
2019-08-22 19:31:46 +00:00
const int key = _glfw.x11.keycodes[scancode];
Cleanup Related to #1528.
2019-07-11 17:06:06 +00:00
const KeySym keysym = XkbKeycodeToKeysym(_glfw.x11.display,
scancode, _glfw.x11.xkb.group, 0);
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
if (keysym == NoSymbol)
X11: Make glfwGetKeyName return UTF-8 strings Fixes #981. Closes #983.
2017-04-05 01:41:12 +00:00
return NULL;
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
if (codepoint == GLFW_INVALID_CODEPOINT)
X11: Make glfwGetKeyName return UTF-8 strings Fixes #981. Closes #983.
2017-04-05 01:41:12 +00:00
return NULL;
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
const size_t count = _glfwEncodeUTF8(_glfw.x11.keynames[key], codepoint);
Cleanup Related to #983.
2017-05-17 20:12:47 +00:00
if (count == 0)
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
return NULL;
Unify key name string handling This makes key names per-key static strings for all supported platforms. Fixes #1200.
2019-08-22 19:31:46 +00:00
_glfw.x11.keynames[key][count] = '\0';
return _glfw.x11.keynames[key];
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
int _glfwGetKeyScancodeX11(int key)
Add glfwGetKeyScancode Allows retrieval of platform scancode from GLFW_KEY_*. Implemented for Win32, Cocoa and X11. Stubs for Mir and Wayland. Closes #830.
2016-08-11 17:11:40 +00:00
{
Cleanup
2016-09-07 13:43:39 +00:00
return _glfw.x11.scancodes[key];
Add glfwGetKeyScancode Allows retrieval of platform scancode from GLFW_KEY_*. Implemented for Win32, Cocoa and X11. Stubs for Mir and Wayland. Closes #830.
2016-08-11 17:11:40 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwCreateCursorX11(_GLFWcursor* cursor,
const GLFWimage* image,
int xhot, int yhot)
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
cursor->x11.handle = _glfwCreateNativeCursorX11(image, xhot, yhot);
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
if (!cursor->x11.handle)
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_FALSE;
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_TRUE;
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor* cursor, int shape)
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
{
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
if (_glfw.x11.xcursor.handle)
{
char* theme = XcursorGetTheme(_glfw.x11.display);
if (theme)
{
const int size = XcursorGetDefaultSize(_glfw.x11.display);
const char* name = NULL;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
switch (shape)
{
case GLFW_ARROW_CURSOR:
name = "default";
break;
case GLFW_IBEAM_CURSOR:
name = "text";
break;
case GLFW_CROSSHAIR_CURSOR:
name = "crosshair";
break;
case GLFW_POINTING_HAND_CURSOR:
name = "pointer";
break;
case GLFW_RESIZE_EW_CURSOR:
name = "ew-resize";
break;
case GLFW_RESIZE_NS_CURSOR:
name = "ns-resize";
break;
case GLFW_RESIZE_NWSE_CURSOR:
name = "nwse-resize";
break;
case GLFW_RESIZE_NESW_CURSOR:
name = "nesw-resize";
break;
case GLFW_RESIZE_ALL_CURSOR:
name = "all-scroll";
break;
case GLFW_NOT_ALLOWED_CURSOR:
name = "not-allowed";
break;
}
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
XcursorImage* image = XcursorLibraryLoadImage(name, theme, size);
if (image)
{
cursor->x11.handle = XcursorImageLoadCursor(_glfw.x11.display, image);
XcursorImageDestroy(image);
}
}
}
X11: Clean up cursor shape translation
2018-08-22 18:31:04 +00:00
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
if (!cursor->x11.handle)
{
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
unsigned int native = 0;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
switch (shape)
{
case GLFW_ARROW_CURSOR:
native = XC_left_ptr;
break;
case GLFW_IBEAM_CURSOR:
native = XC_xterm;
break;
case GLFW_CROSSHAIR_CURSOR:
native = XC_crosshair;
break;
case GLFW_POINTING_HAND_CURSOR:
native = XC_hand2;
break;
case GLFW_RESIZE_EW_CURSOR:
native = XC_sb_h_double_arrow;
break;
case GLFW_RESIZE_NS_CURSOR:
native = XC_sb_v_double_arrow;
break;
case GLFW_RESIZE_ALL_CURSOR:
native = XC_fleur;
break;
default:
_glfwInputError(GLFW_CURSOR_UNAVAILABLE,
"X11: Standard cursor shape unavailable");
return GLFW_FALSE;
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
}
cursor->x11.handle = XCreateFontCursor(_glfw.x11.display, native);
if (!cursor->x11.handle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to create standard cursor");
return GLFW_FALSE;
}
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
}
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_TRUE;
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwDestroyCursorX11(_GLFWcursor* cursor)
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
{
Cleanup.
2014-01-23 14:24:57 +00:00
if (cursor->x11.handle)
XFreeCursor(_glfw.x11.display, cursor->x11.handle);
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetCursorX11(_GLFWwindow* window, _GLFWcursor* cursor)
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
{
Add cursor mode GLFW_CURSOR_CAPTURED This adds a cursor mode that provides a visible cursor confined to the content area of the window. Fixes #58
2019-12-03 16:58:20 +00:00
if (window->cursorMode == GLFW_CURSOR_NORMAL ||
window->cursorMode == GLFW_CURSOR_CAPTURED)
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
{
Simplify cursor window logic
2016-05-30 19:21:09 +00:00
updateCursorImage(window);
Added support for custom system cursors. This adds 3 functions to the GLFW API: glfwCreateCursor, glfwDestroyCursor and glfwSetCursor.
2013-12-04 13:19:22 +00:00
XFlush(_glfw.x11.display);
}
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetClipboardStringX11(const char* string)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
{
X11: Fix setting the clipboard string to itself
2020-01-24 08:34:54 +00:00
char* copy = _glfw_strdup(string);
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(_glfw.x11.clipboardString);
X11: Fix setting the clipboard string to itself
2020-01-24 08:34:54 +00:00
_glfw.x11.clipboardString = copy;
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.CLIPBOARD,
X11: Make clipboard IPC use helper window
2015-10-24 20:54:30 +00:00
_glfw.x11.helperWindowHandle,
CurrentTime);
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) !=
X11: Make clipboard IPC use helper window
2015-10-24 20:54:30 +00:00
_glfw.x11.helperWindowHandle)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Various error fixes. Fixed incorrect error types. Added missing error string prefixes. Removed some invalid or superfluous error emissions. Clarified some error strings. Joined error string lines to aid grep. Replaced some generic error strings with specific ones. Documentation work. Fixes #450.
2015-03-10 18:51:14 +00:00
"X11: Failed to become owner of clipboard selection");
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
}
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
const char* _glfwGetClipboardStringX11(void)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
{
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
return getSelectionString(_glfw.x11.CLIPBOARD);
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
EGLenum _glfwGetEGLPlatformX11(EGLint** attribs)
EGL: Add support for EGL_EXT_platform_base This adds support for EGL_EXT_platform_base and its associated X11 and Wayland extensions, allowing us to explicitly tell EGL which window system we are using. This is based on work by @linkmauve in #1691. Closes #1691.
2020-06-03 20:02:25 +00:00
{
EGL: Add support for EGL_ANGLE_platform_angle This adds basic support for selecting the platform type (rendering backend) when running on ANGLE. Related to #1380.
2020-06-25 16:22:08 +00:00
if (_glfw.egl.ANGLE_platform_angle)
{
int type = 0;
if (_glfw.egl.ANGLE_platform_angle_opengl)
{
if (_glfw.hints.init.angleType == GLFW_ANGLE_PLATFORM_TYPE_OPENGL)
type = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
}
if (_glfw.egl.ANGLE_platform_angle_vulkan)
{
if (_glfw.hints.init.angleType == GLFW_ANGLE_PLATFORM_TYPE_VULKAN)
type = EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
}
if (type)
{
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
*attribs = _glfw_calloc(5, sizeof(EGLint));
EGL: Add support for EGL_ANGLE_platform_angle This adds basic support for selecting the platform type (rendering backend) when running on ANGLE. Related to #1380.
2020-06-25 16:22:08 +00:00
(*attribs)[0] = EGL_PLATFORM_ANGLE_TYPE_ANGLE;
(*attribs)[1] = type;
(*attribs)[2] = EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE;
(*attribs)[3] = EGL_PLATFORM_X11_EXT;
(*attribs)[4] = EGL_NONE;
return EGL_PLATFORM_ANGLE_ANGLE;
}
}
EGL: Add support for EGL_EXT_platform_base This adds support for EGL_EXT_platform_base and its associated X11 and Wayland extensions, allowing us to explicitly tell EGL which window system we are using. This is based on work by @linkmauve in #1691. Closes #1691.
2020-06-03 20:02:25 +00:00
if (_glfw.egl.EXT_platform_base && _glfw.egl.EXT_platform_x11)
return EGL_PLATFORM_X11_EXT;
EGL: Add support for EGL_ANGLE_platform_angle This adds basic support for selecting the platform type (rendering backend) when running on ANGLE. Related to #1380.
2020-06-25 16:22:08 +00:00
return 0;
EGL: Add support for EGL_EXT_platform_base This adds support for EGL_EXT_platform_base and its associated X11 and Wayland extensions, allowing us to explicitly tell EGL which window system we are using. This is based on work by @linkmauve in #1691. Closes #1691.
2020-06-03 20:02:25 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
EGLNativeDisplayType _glfwGetEGLNativeDisplayX11(void)
EGL: Replace native handle macros with functions This change is in preparation both for EGL_EXT_platform_base and runtime GLFW platform selection. Related to #1691.
2020-06-03 18:49:36 +00:00
{
return _glfw.x11.display;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
EGLNativeWindowType _glfwGetEGLNativeWindowX11(_GLFWwindow* window)
EGL: Replace native handle macros with functions This change is in preparation both for EGL_EXT_platform_base and runtime GLFW platform selection. Related to #1691.
2020-06-03 18:49:36 +00:00
{
EGL: Add support for EGL_EXT_platform_base This adds support for EGL_EXT_platform_base and its associated X11 and Wayland extensions, allowing us to explicitly tell EGL which window system we are using. This is based on work by @linkmauve in #1691. Closes #1691.
2020-06-03 20:02:25 +00:00
if (_glfw.egl.platform)
return &window->x11.handle;
else
return (EGLNativeWindowType) window->x11.handle;
EGL: Replace native handle macros with functions This change is in preparation both for EGL_EXT_platform_base and runtime GLFW platform selection. Related to #1691.
2020-06-03 18:49:36 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetRequiredInstanceExtensionsX11(char** extensions)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
Simplify Vulkan extension checks Related to #478.
2016-08-22 18:25:52 +00:00
if (!_glfw.vk.KHR_surface)
return;
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
if (!_glfw.vk.KHR_xcb_surface || !_glfw.x11.x11xcb.handle)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
if (!_glfw.vk.KHR_xlib_surface)
Simplify Vulkan extension checks Related to #478.
2016-08-22 18:25:52 +00:00
return;
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
}
Simplify Vulkan extension checks Related to #478.
2016-08-22 18:25:52 +00:00
extensions[0] = "VK_KHR_surface";
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
Documentation work
2016-12-11 13:42:05 +00:00
// NOTE: VK_KHR_xcb_surface is preferred due to some early ICDs exposing but
// not correctly implementing VK_KHR_xlib_surface
Fix X11 WSI extension selection logic
2016-02-21 17:36:28 +00:00
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
Simplify Vulkan extension checks Related to #478.
2016-08-22 18:25:52 +00:00
extensions[1] = "VK_KHR_xcb_surface";
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
else
Simplify Vulkan extension checks Related to #478.
2016-08-22 18:25:52 +00:00
extensions[1] = "VK_KHR_xlib_surface";
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
VisualID visualID = XVisualIDFromVisual(DefaultVisual(_glfw.x11.display,
_glfw.x11.screen));
Fix X11 WSI extension selection logic
2016-02-19 07:56:46 +00:00
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
Cleanup Break up some overly long lines.
2017-09-17 12:39:17 +00:00
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
vkGetPhysicalDeviceXcbPresentationSupportKHR =
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
(PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
if (!vkGetPhysicalDeviceXcbPresentationSupportKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xcb_surface extension");
return GLFW_FALSE;
}
Cleanup
2017-08-16 19:03:10 +00:00
xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
if (!connection)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to retrieve XCB connection");
return GLFW_FALSE;
}
return vkGetPhysicalDeviceXcbPresentationSupportKHR(device,
queuefamily,
connection,
visualID);
}
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
else
{
Cleanup Break up some overly long lines.
2017-09-17 12:39:17 +00:00
PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
vkGetPhysicalDeviceXlibPresentationSupportKHR =
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
(PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
if (!vkGetPhysicalDeviceXlibPresentationSupportKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xlib_surface extension");
return GLFW_FALSE;
}
return vkGetPhysicalDeviceXlibPresentationSupportKHR(device,
queuefamily,
_glfw.x11.display,
visualID);
}
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
VkResult _glfwCreateWindowSurfaceX11(VkInstance instance,
_GLFWwindow* window,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
Fix X11 WSI extension selection logic
2016-02-19 07:56:46 +00:00
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
VkResult err;
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
VkXcbSurfaceCreateInfoKHR sci;
PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
Cleanup
2017-08-16 19:03:10 +00:00
xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
if (!connection)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to retrieve XCB connection");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
vkCreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR)
vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR");
if (!vkCreateXcbSurfaceKHR)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
_glfwInputError(GLFW_API_UNAVAILABLE,
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
"X11: Vulkan instance missing VK_KHR_xcb_surface extension");
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
memset(&sci, 0, sizeof(sci));
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
sci.connection = connection;
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
sci.window = window->x11.handle;
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
err = vkCreateXcbSurfaceKHR(instance, &sci, allocator, surface);
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
if (err)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
"X11: Failed to create Vulkan XCB surface: %s",
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
_glfwGetVulkanResultString(err));
}
return err;
}
else
{
VkResult err;
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
VkXlibSurfaceCreateInfoKHR sci;
PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR)
vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR");
if (!vkCreateXlibSurfaceKHR)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
_glfwInputError(GLFW_API_UNAVAILABLE,
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
"X11: Vulkan instance missing VK_KHR_xlib_surface extension");
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
memset(&sci, 0, sizeof(sci));
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
sci.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
sci.dpy = _glfw.x11.display;
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
sci.window = window->x11.handle;
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
err = vkCreateXlibSurfaceKHR(instance, &sci, allocator, surface);
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
if (err)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Change priority order of X11 WSI extensions
2016-02-18 18:35:48 +00:00
"X11: Failed to create Vulkan X11 surface: %s",
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
_glfwGetVulkanResultString(err));
}
return err;
}
}
Updated native API and merged into related files.
2013-01-15 21:38:14 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
GLFWAPI Display* glfwGetX11Display(void)
{
Added macros for library initialization check.
2013-02-19 23:28:08 +00:00
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "X11: Platform not initialized");
return NULL;
}
Updated native API and merged into related files.
2013-01-15 21:38:14 +00:00
return _glfw.x11.display;
}
GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
Added macros for library initialization check.
2013-02-19 23:28:08 +00:00
_GLFW_REQUIRE_INIT_OR_RETURN(None);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "X11: Platform not initialized");
return None;
}
Updated native API and merged into related files.
2013-01-15 21:38:14 +00:00
return window->x11.handle;
}
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
GLFWAPI void glfwSetX11SelectionString(const char* string)
{
_GLFW_REQUIRE_INIT();
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "X11: Platform not initialized");
return;
}
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(_glfw.x11.primarySelectionString);
Remove use of non-standard function strdup Related to #873.
2018-01-17 10:56:35 +00:00
_glfw.x11.primarySelectionString = _glfw_strdup(string);
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.PRIMARY,
_glfw.x11.helperWindowHandle,
CurrentTime);
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.PRIMARY) !=
_glfw.x11.helperWindowHandle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to become owner of primary selection");
}
}
GLFWAPI const char* glfwGetX11SelectionString(void)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "X11: Platform not initialized");
return NULL;
}
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
return getSelectionString(_glfw.x11.PRIMARY);
X11: Add native access to primary selection This adds the native access functions glfwSetX11SelectionString and glfwGetX11SelectionString under GLFW_EXPOSE_NATIVE_X11. They are similar to glfwSetClipboardString and glfwGetClipboardString but operate on the PRIMARY selection. The primary selection is widely used in X11, and so seems important to support. Primary selection is mostly an X11-specific thing, hence it's exposed as an X11 native interface. Fixes #894. Closes #1056. Signed-off-by: Kristian Nielsen <knielsen@knielsen-hq.org>
2017-08-02 14:10:13 +00:00
}
Cleanup Don't advertise native functions in public API guides. Don't list primary selection access as most notable new feature. Don't have different levels of abstraction among selection helper functions. Don't forget to take credit. Related to #1056.
2017-08-13 16:11:35 +00:00
Add conditional compilation for platform units This is a step towards being able to compile GLFW manually without needing to duplicate a lot of platform- or OS-specific logic.
2021-11-09 18:44:00 +00:00
#endif // _GLFW_X11
Reference in New Issue Copy Permalink