mirrors/SDL
1
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2025-09-05 19:08:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

x11: store all atoms in a specific struct

Browse Source
This commit is contained in:
David Fort
2024-09-30 19:43:49 +02:00
committed by Sam Lantinga
parent 801870c8cf
commit 818d7d892a
6 changed files with 129 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/video/x11/SDL_x11clipboard.c
View File

@@ -198,7 +198,7 @@ static void *GetSelectionData(SDL_VideoDevice *_this, Atom selection_type,
} else {
// Request that the selection owner copy the data to our window
owner = window;
selection = videodata->SDL_SELECTION;
selection = videodata->atoms.SDL_SELECTION;
X11_XConvertSelection(display, selection_type, XA_MIME, selection, owner,
CurrentTime);
@@ -212,7 +212,7 @@ static void *GetSelectionData(SDL_VideoDevice *_this, Atom selection_type,
if (seln_type == XA_MIME) {
*length = (size_t)count;
data = CloneDataBuffer(src, count);
} else if (seln_type == videodata->INCR) {
} else if (seln_type == videodata->atoms.INCR) {
while (1) {
// Only delete the property after being done with the previous "chunk".
X11_XDeleteProperty(display, owner, selection);
@@ -267,13 +267,13 @@ const char **X11_GetTextMimeTypes(SDL_VideoDevice *_this, size_t *num_mime_types
bool X11_SetClipboardData(SDL_VideoDevice *_this)
{
SDL_VideoData *videodata = _this->internal;
return SetSelectionData(_this, videodata->CLIPBOARD, _this->clipboard_callback, _this->clipboard_userdata, (const char **)_this->clipboard_mime_types, _this->num_clipboard_mime_types, _this->clipboard_sequence);
return SetSelectionData(_this, videodata->atoms.CLIPBOARD, _this->clipboard_callback, _this->clipboard_userdata, (const char **)_this->clipboard_mime_types, _this->num_clipboard_mime_types, _this->clipboard_sequence);
}
void *X11_GetClipboardData(SDL_VideoDevice *_this, const char *mime_type, size_t *length)
{
SDL_VideoData *videodata = _this->internal;
return GetSelectionData(_this, videodata->CLIPBOARD, mime_type, length);
return GetSelectionData(_this, videodata->atoms.CLIPBOARD, mime_type, length);
}
bool X11_HasClipboardData(SDL_VideoDevice *_this, const char *mime_type)

50
src/video/x11/SDL_x11events.c
View File

@@ -525,7 +525,7 @@ static void X11_UpdateUserTime(SDL_WindowData *data, const unsigned long latest)
if (latest && (latest != data->user_time)) {
SDL_VideoData *videodata = data->videodata;
Display *display = videodata->display;
X11_XChangeProperty(display, data->xwindow, videodata->_NET_WM_USER_TIME,
X11_XChangeProperty(display, data->xwindow, videodata->atoms._NET_WM_USER_TIME,
XA_CARDINAL, 32, PropModeReplace,
(const unsigned char *)&latest, 1);
#ifdef DEBUG_XEVENTS
@@ -918,7 +918,7 @@ void X11_GetBorderValues(SDL_WindowData *data)
// Some compositors will send extents even when the border hint is turned off. Ignore them in this case.
if (!(data->window->flags & SDL_WINDOW_BORDERLESS)) {
if (X11_XGetWindowProperty(display, data->xwindow, videodata->_NET_FRAME_EXTENTS, 0, 16, 0, XA_CARDINAL, &type, &format, &nitems, &bytes_after, &property) == Success) {
if (X11_XGetWindowProperty(display, data->xwindow, videodata->atoms._NET_FRAME_EXTENTS, 0, 16, 0, XA_CARDINAL, &type, &format, &nitems, &bytes_after, &property) == Success) {
if (type != None && nitems == 4) {
data->border_left = (int)((long *)property)[0];
data->border_right = (int)((long *)property)[1];
@@ -995,7 +995,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
#endif
if (ev->selection == XA_PRIMARY ||
(videodata->CLIPBOARD != None && ev->selection == videodata->CLIPBOARD)) {
(videodata->atoms.CLIPBOARD != None && ev->selection == videodata->atoms.CLIPBOARD)) {
SDL_SendClipboardUpdate();
return;
}
@@ -1331,7 +1331,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
static int xdnd_version = 0;
if (xevent->xclient.message_type == videodata->XdndEnter) {
if (xevent->xclient.message_type == videodata->atoms.XdndEnter) {
bool use_list = xevent->xclient.data.l[1] & 1;
data->xdnd_source = xevent->xclient.data.l[0];
@@ -1345,7 +1345,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
if (use_list) {
// fetch conversion targets
SDL_x11Prop p;
X11_ReadProperty(&p, display, data->xdnd_source, videodata->XdndTypeList);
X11_ReadProperty(&p, display, data->xdnd_source, videodata->atoms.XdndTypeList);
// pick one
data->xdnd_req = X11_PickTarget(display, (Atom *)p.data, p.count);
X11_XFree(p.data);
@@ -1353,10 +1353,10 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
// pick from list of three
data->xdnd_req = X11_PickTargetFromAtoms(display, xevent->xclient.data.l[2], xevent->xclient.data.l[3], xevent->xclient.data.l[4]);
}
} else if (xevent->xclient.message_type == videodata->XdndPosition) {
} else if (xevent->xclient.message_type == videodata->atoms.XdndPosition) {
#ifdef DEBUG_XEVENTS
Atom act = videodata->XdndActionCopy;
Atom act = videodata->atoms.XdndActionCopy;
if (xdnd_version >= 2) {
act = xevent->xclient.data.l[4];
}
@@ -1380,24 +1380,24 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
m.type = ClientMessage;
m.display = xevent->xclient.display;
m.window = xevent->xclient.data.l[0];
m.message_type = videodata->XdndStatus;
m.message_type = videodata->atoms.XdndStatus;
m.format = 32;
m.data.l[0] = data->xwindow;
m.data.l[1] = (data->xdnd_req != None);
m.data.l[2] = 0; // specify an empty rectangle
m.data.l[3] = 0;
m.data.l[4] = videodata->XdndActionCopy; // we only accept copying anyway
m.data.l[4] = videodata->atoms.XdndActionCopy; // we only accept copying anyway
X11_XSendEvent(display, xevent->xclient.data.l[0], False, NoEventMask, (XEvent *)&m);
X11_XFlush(display);
} else if (xevent->xclient.message_type == videodata->XdndDrop) {
} else if (xevent->xclient.message_type == videodata->atoms.XdndDrop) {
if (data->xdnd_req == None) {
// say again - not interested!
SDL_memset(&m, 0, sizeof(XClientMessageEvent));
m.type = ClientMessage;
m.display = xevent->xclient.display;
m.window = xevent->xclient.data.l[0];
m.message_type = videodata->XdndFinished;
m.message_type = videodata->atoms.XdndFinished;
m.format = 32;
m.data.l[0] = data->xwindow;
m.data.l[1] = 0;
@@ -1406,14 +1406,14 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
} else {
// convert
if (xdnd_version >= 1) {
X11_XConvertSelection(display, videodata->XdndSelection, data->xdnd_req, videodata->PRIMARY, data->xwindow, xevent->xclient.data.l[2]);
X11_XConvertSelection(display, videodata->atoms.XdndSelection, data->xdnd_req, videodata->atoms.PRIMARY, data->xwindow, xevent->xclient.data.l[2]);
} else {
X11_XConvertSelection(display, videodata->XdndSelection, data->xdnd_req, videodata->PRIMARY, data->xwindow, CurrentTime);
X11_XConvertSelection(display, videodata->atoms.XdndSelection, data->xdnd_req, videodata->atoms.PRIMARY, data->xwindow, CurrentTime);
}
}
} else if ((xevent->xclient.message_type == videodata->WM_PROTOCOLS) &&
} else if ((xevent->xclient.message_type == videodata->atoms.WM_PROTOCOLS) &&
(xevent->xclient.format == 32) &&
(xevent->xclient.data.l[0] == videodata->_NET_WM_PING)) {
(xevent->xclient.data.l[0] == videodata->atoms._NET_WM_PING)) {
Window root = DefaultRootWindow(display);
#ifdef DEBUG_XEVENTS
@@ -1424,9 +1424,9 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
break;
}
else if ((xevent->xclient.message_type == videodata->WM_PROTOCOLS) &&
else if ((xevent->xclient.message_type == videodata->atoms.WM_PROTOCOLS) &&
(xevent->xclient.format == 32) &&
(xevent->xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) {
(xevent->xclient.data.l[0] == videodata->atoms.WM_DELETE_WINDOW)) {
#ifdef DEBUG_XEVENTS
SDL_Log("window 0x%lx: WM_DELETE_WINDOW\n", xevent->xany.window);
@@ -1553,7 +1553,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
SDL_Log(" }\n");
}
} else if (real_type == XA_STRING ||
real_type == videodata->UTF8_STRING) {
real_type == videodata->atoms.UTF8_STRING) {
SDL_Log("{ \"%s\" }\n", propdata);
} else if (real_type == XA_ATOM) {
Atom *atoms = (Atom *)propdata;
@@ -1591,7 +1591,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
data->user_time = xevent->xproperty.time;
}
if (xevent->xproperty.atom == data->videodata->_NET_WM_STATE) {
if (xevent->xproperty.atom == data->videodata->atoms._NET_WM_STATE) {
/* Get the new state from the window manager.
Compositing window managers can alter visibility of windows
without ever mapping / unmapping them, so we handle that here,
@@ -1710,7 +1710,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
if (changed & SDL_WINDOW_OCCLUDED) {
SDL_SendWindowEvent(data->window, (flags & SDL_WINDOW_OCCLUDED) ? SDL_EVENT_WINDOW_OCCLUDED : SDL_EVENT_WINDOW_EXPOSED, 0, 0);
}
} else if (xevent->xproperty.atom == videodata->XKLAVIER_STATE) {
} else if (xevent->xproperty.atom == videodata->atoms.XKLAVIER_STATE) {
/* Hack for Ubuntu 12.04 (etc) that doesn't send MappingNotify
events when the keyboard layout changes (for example,
changing from English to French on the menubar's keyboard
@@ -1718,7 +1718,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
notice and reinit our keymap here. This might not be the
right approach, but it seems to work. */
X11_UpdateKeymap(_this, true);
} else if (xevent->xproperty.atom == videodata->_NET_FRAME_EXTENTS) {
} else if (xevent->xproperty.atom == videodata->atoms._NET_FRAME_EXTENTS) {
if (data->disable_size_position_events) {
/* Re-enable size events if they were turned off waiting for the borders to come back
* when leaving fullscreen.
@@ -1758,7 +1758,7 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
if (target == data->xdnd_req) {
// read data
SDL_x11Prop p;
X11_ReadProperty(&p, display, data->xwindow, videodata->PRIMARY);
X11_ReadProperty(&p, display, data->xwindow, videodata->atoms.PRIMARY);
if (p.format == 8) {
char *saveptr = NULL;
@@ -1789,11 +1789,11 @@ static void X11_DispatchEvent(SDL_VideoDevice *_this, XEvent *xevent)
m.type = ClientMessage;
m.display = display;
m.window = data->xdnd_source;
m.message_type = videodata->XdndFinished;
m.message_type = videodata->atoms.XdndFinished;
m.format = 32;
m.data.l[0] = data->xwindow;
m.data.l[1] = 1;
m.data.l[2] = videodata->XdndActionCopy;
m.data.l[2] = videodata->atoms.XdndActionCopy;
X11_XSendEvent(display, data->xdnd_source, False, NoEventMask, (XEvent *)&m);
X11_XSync(display, False);
@@ -1857,7 +1857,7 @@ void X11_SendWakeupEvent(SDL_VideoDevice *_this, SDL_Window *window)
event.type = ClientMessage;
event.display = req_display;
event.send_event = True;
event.message_type = data->_SDL_WAKEUP;
event.message_type = data->atoms._SDL_WAKEUP;
event.format = 8;
X11_XSendEvent(req_display, xwindow, False, NoEventMask, (XEvent *)&event);

26
src/video/x11/SDL_x11pen.c
View File

@@ -36,7 +36,7 @@ static bool X11_XInput2DeviceIsPen(SDL_VideoDevice *_this, const XIDeviceInfo *d
const XIAnyClassInfo *classinfo = dev->classes[i];
if (classinfo->type == XIValuatorClass) {
const XIValuatorClassInfo *val_classinfo = (const XIValuatorClassInfo *)classinfo;
if (val_classinfo->label == data->pen_atom_abs_pressure) {
if (val_classinfo->label == data->atoms.pen_atom_abs_pressure) {
return true;
}
}
@@ -51,7 +51,7 @@ static bool X11_XInput2PenIsEraser(SDL_VideoDevice *_this, int deviceid, char *d
#define PEN_ERASER_NAME_TAG "eraser" // String constant to identify erasers
SDL_VideoData *data = (SDL_VideoData *)_this->internal;
if (data->pen_atom_wacom_tool_type != None) {
if (data->atoms.pen_atom_wacom_tool_type != None) {
Atom type_return;
int format_return;
unsigned long num_items_return;
@@ -60,7 +60,7 @@ static bool X11_XInput2PenIsEraser(SDL_VideoDevice *_this, int deviceid, char *d
// Try Wacom-specific method
if (Success == X11_XIGetProperty(data->display, deviceid,
data->pen_atom_wacom_tool_type,
data->atoms.pen_atom_wacom_tool_type,
0, 32, False,
AnyPropertyType, &type_return, &format_return,
&num_items_return, &bytes_after_return,
@@ -154,7 +154,7 @@ static bool X11_XInput2PenWacomDeviceID(SDL_VideoDevice *_this, int deviceid, Ui
Sint32 serial_id_buf[3];
int result;
if ((result = X11_XInput2PenGetIntProperty(_this, deviceid, data->pen_atom_wacom_serial_ids, serial_id_buf, 3)) == 3) {
if ((result = X11_XInput2PenGetIntProperty(_this, deviceid, data->atoms.pen_atom_wacom_serial_ids, serial_id_buf, 3)) == 3) {
*wacom_devicetype_id = serial_id_buf[2];
*wacom_serial = serial_id_buf[1];
return true;
@@ -225,11 +225,11 @@ static X11_PenHandle *X11_MaybeAddPen(SDL_VideoDevice *_this, const XIDeviceInfo
SDL_PenAxis axis = SDL_PEN_AXIS_COUNT;
// afaict, SDL_PEN_AXIS_DISTANCE is never reported by XInput2 (Wayland can offer it, though)
if (vname == data->pen_atom_abs_pressure) {
if (vname == data->atoms.pen_atom_abs_pressure) {
axis = SDL_PEN_AXIS_PRESSURE;
} else if (vname == data->pen_atom_abs_tilt_x) {
} else if (vname == data->atoms.pen_atom_abs_tilt_x) {
axis = SDL_PEN_AXIS_XTILT;
} else if (vname == data->pen_atom_abs_tilt_y) {
} else if (vname == data->atoms.pen_atom_abs_tilt_y) {
axis = SDL_PEN_AXIS_YTILT;
} else {
use_this_axis = false;
@@ -304,12 +304,12 @@ void X11_InitPen(SDL_VideoDevice *_this)
SDL_VideoData *data = (SDL_VideoData *)_this->internal;
#define LOOKUP_PEN_ATOM(X) X11_XInternAtom(data->display, X, False)
data->pen_atom_device_product_id = LOOKUP_PEN_ATOM("Device Product ID");
data->pen_atom_wacom_serial_ids = LOOKUP_PEN_ATOM("Wacom Serial IDs");
data->pen_atom_wacom_tool_type = LOOKUP_PEN_ATOM("Wacom Tool Type");
data->pen_atom_abs_pressure = LOOKUP_PEN_ATOM("Abs Pressure");
data->pen_atom_abs_tilt_x = LOOKUP_PEN_ATOM("Abs Tilt X");
data->pen_atom_abs_tilt_y = LOOKUP_PEN_ATOM("Abs Tilt Y");
data->atoms.pen_atom_device_product_id = LOOKUP_PEN_ATOM("Device Product ID");
data->atoms.pen_atom_wacom_serial_ids = LOOKUP_PEN_ATOM("Wacom Serial IDs");
data->atoms.pen_atom_wacom_tool_type = LOOKUP_PEN_ATOM("Wacom Tool Type");
data->atoms.pen_atom_abs_pressure = LOOKUP_PEN_ATOM("Abs Pressure");
data->atoms.pen_atom_abs_tilt_x = LOOKUP_PEN_ATOM("Abs Tilt X");
data->atoms.pen_atom_abs_tilt_y = LOOKUP_PEN_ATOM("Abs Tilt Y");
#undef LOOKUP_PEN_ATOM
// Do an initial check on devices. After this, we'll add/remove individual pens when XI_HierarchyChanged events alert us.

2
src/video/x11/SDL_x11video.c
View File

@@ -388,7 +388,7 @@ static bool X11_VideoInit(SDL_VideoDevice *_this)
data->window_group = (XID)(((size_t)data->pid) ^ ((size_t)_this));
// Look up some useful Atoms
#define GET_ATOM(X) data->X = X11_XInternAtom(data->display, #X, False)
#define GET_ATOM(X) data->atoms.X = X11_XInternAtom(data->display, #X, False)
GET_ATOM(WM_PROTOCOLS);
GET_ATOM(WM_DELETE_WINDOW);
GET_ATOM(WM_TAKE_FOCUS);

96
src/video/x11/SDL_x11video.h
View File

@@ -66,54 +66,56 @@ struct SDL_VideoData
bool net_wm;
// Useful atoms
Atom WM_PROTOCOLS;
Atom WM_DELETE_WINDOW;
Atom WM_TAKE_FOCUS;
Atom WM_NAME;
Atom WM_TRANSIENT_FOR;
Atom _NET_WM_STATE;
Atom _NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_FOCUSED;
Atom _NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN;
Atom _NET_WM_STATE_ABOVE;
Atom _NET_WM_STATE_SKIP_TASKBAR;
Atom _NET_WM_STATE_SKIP_PAGER;
Atom _NET_WM_STATE_MODAL;
Atom _NET_WM_ALLOWED_ACTIONS;
Atom _NET_WM_ACTION_FULLSCREEN;
Atom _NET_WM_NAME;
Atom _NET_WM_ICON_NAME;
Atom _NET_WM_ICON;
Atom _NET_WM_PING;
Atom _NET_WM_WINDOW_OPACITY;
Atom _NET_WM_USER_TIME;
Atom _NET_ACTIVE_WINDOW;
Atom _NET_FRAME_EXTENTS;
Atom _SDL_WAKEUP;
Atom UTF8_STRING;
Atom PRIMARY;
Atom CLIPBOARD;
Atom INCR;
Atom SDL_SELECTION;
Atom XdndEnter;
Atom XdndPosition;
Atom XdndStatus;
Atom XdndTypeList;
Atom XdndActionCopy;
Atom XdndDrop;
Atom XdndFinished;
Atom XdndSelection;
Atom XKLAVIER_STATE;
struct {
Atom WM_PROTOCOLS;
Atom WM_DELETE_WINDOW;
Atom WM_TAKE_FOCUS;
Atom WM_NAME;
Atom WM_TRANSIENT_FOR;
Atom _NET_WM_STATE;
Atom _NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_FOCUSED;
Atom _NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN;
Atom _NET_WM_STATE_ABOVE;
Atom _NET_WM_STATE_SKIP_TASKBAR;
Atom _NET_WM_STATE_SKIP_PAGER;
Atom _NET_WM_STATE_MODAL;
Atom _NET_WM_ALLOWED_ACTIONS;
Atom _NET_WM_ACTION_FULLSCREEN;
Atom _NET_WM_NAME;
Atom _NET_WM_ICON_NAME;
Atom _NET_WM_ICON;
Atom _NET_WM_PING;
Atom _NET_WM_WINDOW_OPACITY;
Atom _NET_WM_USER_TIME;
Atom _NET_ACTIVE_WINDOW;
Atom _NET_FRAME_EXTENTS;
Atom _SDL_WAKEUP;
Atom UTF8_STRING;
Atom PRIMARY;
Atom CLIPBOARD;
Atom INCR;
Atom SDL_SELECTION;
Atom XdndEnter;
Atom XdndPosition;
Atom XdndStatus;
Atom XdndTypeList;
Atom XdndActionCopy;
Atom XdndDrop;
Atom XdndFinished;
Atom XdndSelection;
Atom XKLAVIER_STATE;
// Pen atoms (these have names that don't map well to C symbols)
Atom pen_atom_device_product_id;
Atom pen_atom_abs_pressure;
Atom pen_atom_abs_tilt_x;
Atom pen_atom_abs_tilt_y;
Atom pen_atom_wacom_serial_ids;
Atom pen_atom_wacom_tool_type;
// Pen atoms (these have names that don't map well to C symbols)
Atom pen_atom_device_product_id;
Atom pen_atom_abs_pressure;
Atom pen_atom_abs_tilt_x;
Atom pen_atom_abs_tilt_y;
Atom pen_atom_wacom_serial_ids;
Atom pen_atom_wacom_tool_type;
} atoms;
SDL_Scancode key_layout[256];
bool selection_waiting;

74
src/video/x11/SDL_x11window.c
View File

@@ -129,16 +129,16 @@ void X11_SetNetWMState(SDL_VideoDevice *_this, Window xwindow, SDL_WindowFlags f
SDL_VideoData *videodata = _this->internal;
Display *display = videodata->display;
// !!! FIXME: just dereference videodata below instead of copying to locals.
Atom _NET_WM_STATE = videodata->_NET_WM_STATE;
// Atom _NET_WM_STATE_HIDDEN = videodata->_NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_FOCUSED = videodata->_NET_WM_STATE_FOCUSED;
Atom _NET_WM_STATE_MAXIMIZED_VERT = videodata->_NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = videodata->_NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN = videodata->_NET_WM_STATE_FULLSCREEN;
Atom _NET_WM_STATE_ABOVE = videodata->_NET_WM_STATE_ABOVE;
Atom _NET_WM_STATE_SKIP_TASKBAR = videodata->_NET_WM_STATE_SKIP_TASKBAR;
Atom _NET_WM_STATE_SKIP_PAGER = videodata->_NET_WM_STATE_SKIP_PAGER;
Atom _NET_WM_STATE_MODAL = videodata->_NET_WM_STATE_MODAL;
Atom _NET_WM_STATE = videodata->atoms._NET_WM_STATE;
// Atom _NET_WM_STATE_HIDDEN = videodata->atoms._NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_FOCUSED = videodata->atoms._NET_WM_STATE_FOCUSED;
Atom _NET_WM_STATE_MAXIMIZED_VERT = videodata->atoms._NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = videodata->atoms._NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN = videodata->atoms._NET_WM_STATE_FULLSCREEN;
Atom _NET_WM_STATE_ABOVE = videodata->atoms._NET_WM_STATE_ABOVE;
Atom _NET_WM_STATE_SKIP_TASKBAR = videodata->atoms._NET_WM_STATE_SKIP_TASKBAR;
Atom _NET_WM_STATE_SKIP_PAGER = videodata->atoms._NET_WM_STATE_SKIP_PAGER;
Atom _NET_WM_STATE_MODAL = videodata->atoms._NET_WM_STATE_MODAL;
Atom atoms[16];
int count = 0;
@@ -238,12 +238,12 @@ Uint32 X11_GetNetWMState(SDL_VideoDevice *_this, SDL_Window *window, Window xwin
{
SDL_VideoData *videodata = _this->internal;
Display *display = videodata->display;
Atom _NET_WM_STATE = videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_HIDDEN = videodata->_NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_FOCUSED = videodata->_NET_WM_STATE_FOCUSED;
Atom _NET_WM_STATE_MAXIMIZED_VERT = videodata->_NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = videodata->_NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN = videodata->_NET_WM_STATE_FULLSCREEN;
Atom _NET_WM_STATE = videodata->atoms._NET_WM_STATE;
Atom _NET_WM_STATE_HIDDEN = videodata->atoms._NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_FOCUSED = videodata->atoms._NET_WM_STATE_FOCUSED;
Atom _NET_WM_STATE_MAXIMIZED_VERT = videodata->atoms._NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = videodata->atoms._NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN = videodata->atoms._NET_WM_STATE_FULLSCREEN;
Atom actualType;
int actualFormat;
unsigned long i, numItems, bytesAfter;
@@ -773,12 +773,12 @@ bool X11_CreateWindow(SDL_VideoDevice *_this, SDL_Window *window, SDL_Properties
Atom protocols[3];
int proto_count = 0;
protocols[proto_count++] = data->WM_DELETE_WINDOW; // Allow window to be deleted by the WM
protocols[proto_count++] = data->WM_TAKE_FOCUS; // Since we will want to set input focus explicitly
protocols[proto_count++] = data->atoms.WM_DELETE_WINDOW; // Allow window to be deleted by the WM
protocols[proto_count++] = data->atoms.WM_TAKE_FOCUS; // Since we will want to set input focus explicitly
// Default to using ping if there is no hint
if (SDL_GetHintBoolean(SDL_HINT_VIDEO_X11_NET_WM_PING, true)) {
protocols[proto_count++] = data->_NET_WM_PING; // Respond so WM knows we're alive
protocols[proto_count++] = data->atoms._NET_WM_PING; // Respond so WM knows we're alive
}
SDL_assert(proto_count <= sizeof(protocols) / sizeof(protocols[0]));
@@ -855,8 +855,8 @@ char *X11_GetWindowTitle(SDL_VideoDevice *_this, Window xwindow)
unsigned char *propdata;
char *title = NULL;
status = X11_XGetWindowProperty(display, xwindow, data->_NET_WM_NAME,
0L, 8192L, False, data->UTF8_STRING, &real_type, &real_format,
status = X11_XGetWindowProperty(display, xwindow, data->atoms._NET_WM_NAME,
0L, 8192L, False, data->atoms.UTF8_STRING, &real_type, &real_format,
&items_read, &items_left, &propdata);
if (status == Success && propdata) {
title = SDL_strdup(SDL_static_cast(char *, propdata));
@@ -971,7 +971,7 @@ bool X11_SetWindowIcon(SDL_VideoDevice *_this, SDL_Window *window, SDL_Surface *
{
SDL_WindowData *data = window->internal;
Display *display = data->videodata->display;
Atom _NET_WM_ICON = data->videodata->_NET_WM_ICON;
Atom _NET_WM_ICON = data->videodata->atoms._NET_WM_ICON;
int (*prevHandler)(Display *, XErrorEvent *) = NULL;
bool result = true;
@@ -1226,7 +1226,7 @@ bool X11_SetWindowOpacity(SDL_VideoDevice *_this, SDL_Window *window, float opac
{
SDL_WindowData *data = window->internal;
Display *display = data->videodata->display;
Atom _NET_WM_WINDOW_OPACITY = data->videodata->_NET_WM_WINDOW_OPACITY;
Atom _NET_WM_WINDOW_OPACITY = data->videodata->atoms._NET_WM_WINDOW_OPACITY;
if (opacity == 1.0f) {
X11_XDeleteProperty(display, data->xwindow, _NET_WM_WINDOW_OPACITY);
@@ -1250,7 +1250,7 @@ bool X11_SetWindowParent(SDL_VideoDevice *_this, SDL_Window *window, SDL_Window
if (parent_data) {
X11_XSetTransientForHint(display, data->xwindow, parent_data->xwindow);
} else {
X11_XDeleteProperty(display, data->xwindow, video_data->WM_TRANSIENT_FOR);
X11_XDeleteProperty(display, data->xwindow, video_data->atoms.WM_TRANSIENT_FOR);
}
return true;
@@ -1263,14 +1263,14 @@ bool X11_SetWindowModal(SDL_VideoDevice *_this, SDL_Window *window, bool modal)
SDL_DisplayData *displaydata = SDL_GetDisplayDriverDataForWindow(window);
Display *display = video_data->display;
Uint32 flags = window->flags;
Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_MODAL = data->videodata->_NET_WM_STATE_MODAL;
Atom _NET_WM_STATE = data->videodata->atoms._NET_WM_STATE;
Atom _NET_WM_STATE_MODAL = data->videodata->atoms._NET_WM_STATE_MODAL;
if (modal) {
flags |= SDL_WINDOW_MODAL;
} else {
flags &= ~SDL_WINDOW_MODAL;
X11_XDeleteProperty(display, data->xwindow, video_data->WM_TRANSIENT_FOR);
X11_XDeleteProperty(display, data->xwindow, video_data->atoms.WM_TRANSIENT_FOR);
}
if (X11_IsWindowMapped(_this, window)) {
@@ -1363,8 +1363,8 @@ void X11_SetWindowAlwaysOnTop(SDL_VideoDevice *_this, SDL_Window *window, bool o
SDL_WindowData *data = window->internal;
SDL_DisplayData *displaydata = SDL_GetDisplayDriverDataForWindow(window);
Display *display = data->videodata->display;
Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_ABOVE = data->videodata->_NET_WM_STATE_ABOVE;
Atom _NET_WM_STATE = data->videodata->atoms._NET_WM_STATE;
Atom _NET_WM_STATE_ABOVE = data->videodata->atoms._NET_WM_STATE_ABOVE;
if (X11_IsWindowMapped(_this, window)) {
XEvent e;
@@ -1504,7 +1504,7 @@ static bool X11_SetWindowActive(SDL_VideoDevice *_this, SDL_Window *window)
SDL_WindowData *data = window->internal;
SDL_DisplayData *displaydata = SDL_GetDisplayDriverDataForWindow(window);
Display *display = data->videodata->display;
Atom _NET_ACTIVE_WINDOW = data->videodata->_NET_ACTIVE_WINDOW;
Atom _NET_ACTIVE_WINDOW = data->videodata->atoms._NET_ACTIVE_WINDOW;
if (X11_IsWindowMapped(_this, window)) {
XEvent e;
@@ -1548,9 +1548,9 @@ static bool X11_SetWindowMaximized(SDL_VideoDevice *_this, SDL_Window *window, b
SDL_WindowData *data = window->internal;
SDL_DisplayData *displaydata = SDL_GetDisplayDriverDataForWindow(window);
Display *display = data->videodata->display;
Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_MAXIMIZED_VERT = data->videodata->_NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = data->videodata->_NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE = data->videodata->atoms._NET_WM_STATE;
Atom _NET_WM_STATE_MAXIMIZED_VERT = data->videodata->atoms._NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = data->videodata->atoms._NET_WM_STATE_MAXIMIZED_HORZ;
if (!maximized && window->flags & SDL_WINDOW_FULLSCREEN) {
/* Fullscreen windows are maximized on some window managers,
@@ -1654,8 +1654,8 @@ static SDL_FullscreenResult X11_SetWindowFullscreenViaWM(SDL_VideoDevice *_this,
SDL_WindowData *data = window->internal;
SDL_DisplayData *displaydata = _display->internal;
Display *display = data->videodata->display;
Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_FULLSCREEN = data->videodata->_NET_WM_STATE_FULLSCREEN;
Atom _NET_WM_STATE = data->videodata->atoms._NET_WM_STATE;
Atom _NET_WM_STATE_FULLSCREEN = data->videodata->atoms._NET_WM_STATE_FULLSCREEN;
if (X11_IsWindowMapped(_this, window)) {
XEvent e;
@@ -1737,8 +1737,8 @@ static SDL_FullscreenResult X11_SetWindowFullscreenViaWM(SDL_VideoDevice *_this,
} else {
e.xclient.data.l[0] = _NET_WM_STATE_REMOVE;
}
e.xclient.data.l[1] = data->videodata->_NET_WM_STATE_MAXIMIZED_VERT;
e.xclient.data.l[2] = data->videodata->_NET_WM_STATE_MAXIMIZED_HORZ;
e.xclient.data.l[1] = data->videodata->atoms._NET_WM_STATE_MAXIMIZED_VERT;
e.xclient.data.l[2] = data->videodata->atoms._NET_WM_STATE_MAXIMIZED_HORZ;
e.xclient.data.l[3] = 0l;
X11_XSendEvent(display, RootWindow(display, displaydata->screen), 0,
SubstructureNotifyMask | SubstructureRedirectMask, &e);