|
#if 0 |
|
|
|
#// Various window management fixes for the Linux Steam client. |
|
#// |
|
#// You can set the following environment variables to 0 to disable individual features: |
|
#// |
|
#// STEAMWM_FORCE_BORDERS Force borders on non-menu windows. |
|
#// |
|
#// STEAMWM_PREVENT_MOVE Let the WM position non-menu/tooltip windows. |
|
#// |
|
#// STEAMWM_GROUP_WINDOWS Group all steam windows. |
|
#// This helps WMs with their focus stealing preventions, |
|
#// and also prevents all Steam windows from being dimmed |
|
#// (by KWin) if any Steam window has focus (is a KWin setting). |
|
#// NOTE: Window is still dimmed when showing menus/tooltips :( |
|
#// |
|
#// STEAMWM_SET_WINDOW_TYPE Tell the WM which Steam windows are dialogs. |
|
#// This lets the window manager place them more intelligently. |
|
#// For example, the WM might center dialogs. |
|
#// NOTE: We simply treat every window with a title other than |
|
#// "Steam" or "Friends" as a dialog window. |
|
#// The startup window is also marked as a dialog. |
|
#// |
|
#// STEAMWM_MANAGE_ERRORS Steam sets error dialogs as unmanaged windows - fix that. |
|
#// |
|
#// |
|
#// Obsolete fixes (now disabled by default): |
|
#// |
|
#// STEAMWM_FIX_NET_WM_NAME Set _NET_WM_NAME to the WM_NAME value to get better window |
|
#// titles (and add " - Steam" suffix if needed). |
|
#// Steam now doesn't set WM_ICON_NAME, _NET_WM_NAME or |
|
#// _NET_WM_ICON_NAME anymore - while it would be better to set |
|
#// them, their absence is unlikely to cause problems. |
|
#// |
|
#// STEAMWM_SET_FIXED_SIZE Set fixed size hints for windows with a fixed layout. |
|
#// |
|
#// |
|
#// Requires: g++ with support for x86 targets, Xlib + headers |
|
#// |
|
#// |
|
#// Use: |
|
#// $ chmod +x steamwm.cpp |
|
#// and then |
|
#// |
|
#// |
|
#// $ DEBUGGER="$(pwd)/steamwm.cpp" steam |
|
#// |
|
#// *or* |
|
#// |
|
#// $ ./steamwm.cpp steam // Prints ld.so errors on 64-bit systems |
|
#// |
|
#// *or* |
|
#// |
|
#// $ ./steamwm.cpp // Compile |
|
#// $ LD_PRELOAD="$(pwd)/steamwm.so" steam // Prints ld.so errors on 64-bit systems |
|
#// |
|
#// |
|
#// DISCLAIMER: Use at your own risk! This is in no way endorsed by VALVE. |
|
#// |
|
#// This program is free software. It comes without any warranty, to |
|
#// the extent permitted by applicable law. You can redistribute it |
|
#// and/or modify it under the terms of the Do What The Fuck You Want |
|
#// To Public License, Version 2, as published by Sam Hocevar. See |
|
#// http://sam.zoy.org/wtfpl/COPYING for more details. |
|
#// |
|
|
|
|
|
[ -z $STEAMWM_FORCE_BORDERS ] && export STEAMWM_FORCE_BORDERS=1 |
|
[ -z $STEAMWM_PREVENT_MOVE ] && export STEAMWM_PREVENT_MOVE=1 |
|
[ -z $STEAMWM_FIX_NET_WM_NAME ] && export STEAMWM_FIX_NET_WM_NAME=0 |
|
[ -z $STEAMWM_GROUP_WINDOWS ] && export STEAMWM_GROUP_WINDOWS=1 |
|
[ -z $STEAMWM_SET_WINDOW_TYPE ] && export STEAMWM_SET_WINDOW_TYPE=1 |
|
[ -z $STEAMWM_SET_FIXED_SIZE ] && export STEAMWM_SET_FIXED_SIZE=0 |
|
[ -z $STEAMWM_MANAGE_ERRORS ] && export STEAMWM_MANAGE_ERRORS=1 |
|
|
|
|
|
self="$(readlink -f "$(which "$0")")" |
|
name="$(basename "$self" .cpp)" |
|
out="$(dirname "$self")/$name" |
|
soname="$name.so" |
|
|
|
|
|
#// On amd64 platforms, compile a dummy 64-bit steamwm.so, |
|
#// so that native 64-bit tools invoked by Steam and its |
|
#// launch script won't spam (harmless) ld.so errors. |
|
if [ -f '/lib64/ld-linux-x86-64.so.2' ] ; then |
|
dout="$out/64" |
|
mkdir -p "$dout" |
|
if ! [ -f "$dout/$soname" ] ; then |
|
echo -e "\n" | gcc -shared -fPIC -m64 -x c - -o "$dout/$soname" &> /dev/null |
|
strip "$dout/$soname" &> /dev/null |
|
#// ignore all errors - this may at worst cause warnings later |
|
fi |
|
export LD_LIBRARY_PATH="$dout:$LD_LIBRARY_PATH" |
|
fi |
|
|
|
|
|
#// Compile the LD_PRELOAD library |
|
mkdir -p "$out" |
|
if [ "$self" -nt "$out/$soname" ] ; then |
|
echo "Compiling $soname..." |
|
g++ -shared -fPIC -m32 -x c++ "$self" -o "$out/$soname" \ |
|
-lX11 -static-libgcc -static-libstdc++ \ |
|
-O3 -Wall -Wextra -DSONAME="$soname" \ |
|
|| exit 1 |
|
fi |
|
|
|
|
|
#// Run the executable |
|
export LD_PRELOAD="$soname:$LD_PRELOAD" |
|
export LD_LIBRARY_PATH="$out:$LD_LIBRARY_PATH" |
|
[ -z "$1" ] || exec "$@" |
|
|
|
|
|
exit |
|
|
|
#endif // 0 |
|
|
|
|
|
#ifndef _GNU_SOURCE |
|
#define _GNU_SOURCE |
|
#endif |
|
|
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
#include <dlfcn.h> |
|
#include <X11/Xlib.h> |
|
#include <X11/Xatom.h> |
|
#include <X11/Xutil.h> |
|
|
|
#define STR_(x) # x |
|
#define STR(x) STR_(x) |
|
|
|
|
|
// List of window titles for windows that should not be marked as dialogs |
|
static const char * main_windows[] = { |
|
"Steam", |
|
"Friends", |
|
}; |
|
// List of window titles for windows that should be dialogs even if unmanaged |
|
static const char * dialog_windows[] = { |
|
"Untitled", |
|
"Steam - Go Online", |
|
}; |
|
static const char * fixed_size_windows[] = { |
|
"Settings", |
|
"About Steam", |
|
"Backup and Restore Programs", |
|
"Steam - Error", |
|
"Steam - Self Updater", |
|
}; |
|
static const char * fixed_size_suffixes[] = { |
|
" - Properties", |
|
" - Category", |
|
}; |
|
|
|
|
|
static bool force_borders = false; |
|
static bool prevent_move = false; |
|
static bool fix_net_wm_name = false; |
|
static bool group_windows = false; |
|
static bool set_window_type = false; |
|
static bool set_fixed_size = false; |
|
static bool manage_errors = false; |
|
|
|
extern "C" { |
|
extern char * program_invocation_short_name; // provided by glibc |
|
} |
|
|
|
static bool get_setting(const char * name) { |
|
char * setting = getenv(name); |
|
return (setting && setting[0] != '\0' && setting[0] != '0'); |
|
} |
|
|
|
void steamwm_init(void) __attribute__((constructor)); |
|
void steamwm_init(void) { |
|
|
|
// Only attach to steam! |
|
if(strcmp(program_invocation_short_name, "steam") != 0) { |
|
return; |
|
} |
|
|
|
// Prevent steamwm.so from being attached to processes started by steam |
|
const char * envname = "LD_PRELOAD"; |
|
const char * oldenv = getenv(envname); |
|
if(oldenv) { |
|
char * env = strdup(oldenv); |
|
char * pos = strstr(env, STR(SONAME)); |
|
if(pos) { |
|
size_t len1 = strlen(STR(SONAME)); |
|
size_t len2 = strlen(pos + len1); |
|
memmove(pos, pos + len1, len2); |
|
*(pos + len2) = '\0'; |
|
setenv(envname, env, 1); |
|
} |
|
free(env); |
|
} |
|
|
|
force_borders = get_setting("STEAMWM_FORCE_BORDERS"); |
|
prevent_move = get_setting("STEAMWM_PREVENT_MOVE"); |
|
fix_net_wm_name = get_setting("STEAMWM_FIX_NET_WM_NAME"); |
|
group_windows = get_setting("STEAMWM_GROUP_WINDOWS"); |
|
set_window_type = get_setting("STEAMWM_SET_WINDOW_TYPE"); |
|
set_fixed_size = get_setting("STEAMWM_SET_FIXED_SIZE"); |
|
manage_errors = get_setting("STEAMWM_MANAGE_ERRORS"); |
|
|
|
|
|
fprintf(stderr, "\n[steamwm] attached to steam:\n force_borders %d\n" |
|
" prevent_move %d\n fix_net_wm_name %d\n" |
|
" group_windows %d\n set_window_type %d\n" |
|
" set_fixed_size %d\n manage_errors %d\n\n", |
|
int(force_borders), int(prevent_move), int(fix_net_wm_name), |
|
int(group_windows), int(set_window_type), int(set_fixed_size), |
|
int(manage_errors)); |
|
|
|
} |
|
|
|
|
|
/* helper functions */ |
|
|
|
#define BASE_NAME(SymbolName) base_ ## SymbolName |
|
#define TYPE_NAME(SymbolName) SymbolName ## _t |
|
#define INTERCEPT(ReturnType, SymbolName, ...) \ |
|
typedef ReturnType (*TYPE_NAME(SymbolName))(__VA_ARGS__); \ |
|
static void * const BASE_NAME(SymbolName) = dlsym(RTLD_NEXT, STR(SymbolName)); \ |
|
ReturnType SymbolName(__VA_ARGS__) |
|
#define BASE(SymbolName) ((TYPE_NAME(SymbolName))BASE_NAME(SymbolName)) |
|
|
|
static bool is_unmanaged_window(Display * dpy, Window w); |
|
static void set_is_unmanaged_window(Display * dpy, Window w, bool is_unmanaged); |
|
static bool is_fixed_size_window_name(const char * name); |
|
static bool is_main_window_name(const char * name); |
|
static bool is_dialog_window_name(const char * name); |
|
static void set_window_desired_size(Display * dpy, Window w, int width, int height, |
|
bool set_fixed); |
|
static void set_window_property(Display * dpy, Window w, Atom property, Atom type, |
|
long value); |
|
static void set_window_group_hint(Display * dpy, Window w, XID window_group); |
|
static void set_window_is_dialog(Display * dpy, Window w, bool is_dialog); |
|
static void set_window_modal(Display * dpy, Window w); |
|
|
|
|
|
/* fix window titles and types, and add window borders & title bars */ |
|
|
|
static Window first_window = None, second_window = None; |
|
|
|
static void name_changed(Display * dpy, Window w, const unsigned char * data, int n); |
|
|
|
INTERCEPT(void, XSetWMName, |
|
Display * dpy, |
|
Window w, |
|
XTextProperty * prop |
|
) { |
|
|
|
if(prop->format == 8) { |
|
// The libX11 pulled in with STEAM_RUNTIME=1 has XSetWMName (or XSetTextProperty?) |
|
// liked/optimized to use internal functions and not the global XChangeProperty, |
|
// so our override below won't work -> also intercept XSetWMName(). |
|
name_changed(dpy, w, prop->value, prop->nitems); |
|
} |
|
|
|
return BASE(XSetWMName)(dpy, w, prop); |
|
} |
|
|
|
INTERCEPT(int, XChangeProperty, |
|
Display * dpy, |
|
Window w, |
|
Atom property, |
|
Atom type, |
|
int format, |
|
int mode, |
|
const unsigned char * data, |
|
int n |
|
) { |
|
|
|
if(property == XA_WM_NAME && format == 8) { |
|
name_changed(dpy, w, data, n); |
|
} |
|
|
|
if(manage_errors && property == XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False)) { |
|
if(!is_unmanaged_window(dpy, w) && type == XA_ATOM && format == 32 && n > 0) { |
|
Atom menu = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_MENU", False); |
|
Atom type = reinterpret_cast<const long * /* sic */>(data)[0]; |
|
if(type == menu) { |
|
// Ignore the window type Steam sets on error dialogs. |
|
return 1; |
|
} |
|
} |
|
} |
|
|
|
if(force_borders && property == XInternAtom(dpy, "_MOTIF_WM_HINTS", False)) { |
|
// Don't suppress window borders! |
|
return 1; |
|
} |
|
|
|
return BASE(XChangeProperty)(dpy, w, property, type, format, mode, data, n); |
|
} |
|
|
|
static void name_changed(Display * dpy, Window w, const unsigned char * data, int n) { |
|
|
|
char * value = (char *)data; |
|
|
|
if(fix_net_wm_name) { |
|
// Use the XA_WM_NAME as both XA_WM_NAME and _NET_WM_NAME. |
|
// Steam sets _NET_WM_NAME to just "Steam" for all windows. |
|
const unsigned char * name = data; |
|
unsigned char * buffer = NULL; |
|
int nn = n; |
|
if(n > 0 && strstr((char *)data, "Steam") == 0) { |
|
// Make sure "Steam" is in all window titles. |
|
char suffix[] = " - Steam"; |
|
nn = n + sizeof(suffix) - 1; |
|
name = buffer = (unsigned char *)malloc(nn + 1); |
|
memcpy(buffer, data, n); |
|
memcpy(buffer + n, suffix, sizeof(suffix)); |
|
} |
|
Atom net_wm_name = XInternAtom(dpy, "_NET_WM_NAME", False); |
|
Atom utf8_string = XInternAtom(dpy, "UTF8_STRING", False); |
|
BASE(XChangeProperty)(dpy, w, net_wm_name, utf8_string, 8, PropModeReplace, name, nn); |
|
if(buffer) { |
|
free(buffer); |
|
} |
|
} |
|
|
|
if(manage_errors && is_unmanaged_window(dpy, w) && is_dialog_window_name(value)) { |
|
// Error dialogs should be managed by the window manager. |
|
set_is_unmanaged_window(dpy, w, false); |
|
set_window_modal(dpy, w); |
|
set_window_desired_size(dpy, w, -1, -1, true); |
|
} |
|
|
|
if(set_window_type && !is_unmanaged_window(dpy, w) |
|
&& w != first_window && w != second_window) { |
|
// Set the window type for non-menu windows. |
|
// This should probably be done *before* mapping the windows, |
|
// but then we don't have a title yet. |
|
// Try to guess the window type from the title. |
|
set_window_is_dialog(dpy, w, !is_main_window_name(value)); |
|
} |
|
|
|
if(set_fixed_size && is_fixed_size_window_name(value)) { |
|
// Set fixed size hints for windows with static layouts. |
|
set_window_desired_size(dpy, w, -1, -1, true); |
|
} |
|
|
|
} |
|
|
|
|
|
/* ignore window move requests for non-menu windows */ |
|
|
|
INTERCEPT(int, XResizeWindow, |
|
Display * dpy, |
|
Window w, |
|
unsigned int width, |
|
unsigned int height |
|
) { |
|
|
|
if(set_fixed_size || manage_errors) { |
|
// Set fixed size hints for windows with static layouts. |
|
set_window_desired_size(dpy, w, width, height, false); |
|
} |
|
|
|
return BASE(XResizeWindow)(dpy, w, width, height); |
|
} |
|
|
|
INTERCEPT(int, XMoveResizeWindow, |
|
Display * dpy, |
|
Window w, |
|
int x, |
|
int y, |
|
unsigned int width, |
|
unsigned int height |
|
) { |
|
|
|
if(set_fixed_size || manage_errors) { |
|
// Set fixed size hints for windows with static layouts. |
|
set_window_desired_size(dpy, w, width, height, false); |
|
} |
|
|
|
if(prevent_move && !is_unmanaged_window(dpy, w)) { |
|
// Ignore the position request for non-menu windows. |
|
return BASE(XResizeWindow)(dpy, w, width, height); |
|
} |
|
|
|
return BASE(XMoveResizeWindow)(dpy, w, x, y, width, height); |
|
} |
|
|
|
INTERCEPT(int, XMoveWindow, |
|
Display * dpy, |
|
Window w, |
|
int x, |
|
int y |
|
) { |
|
|
|
if(prevent_move && !is_unmanaged_window(dpy, w)) { |
|
// Ignore the position request for non-menu windows. |
|
return 1; |
|
} |
|
|
|
return BASE(XMoveWindow)(dpy, w, x, y); |
|
} |
|
|
|
|
|
/* group windows and force the first and second window to be dialogs */ |
|
|
|
INTERCEPT(int, XMapWindow, |
|
Display * dpy, |
|
Window w |
|
) { |
|
|
|
if(first_window == None) { |
|
first_window = w; |
|
} |
|
|
|
if(group_windows) { |
|
// Group all steam windows. |
|
Atom leader = XInternAtom(dpy, "WM_CLIENT_LEADER", False); |
|
set_window_property(dpy, w, leader, XA_WINDOW, first_window); |
|
set_window_group_hint(dpy, w, first_window); |
|
} |
|
|
|
if(set_window_type && (w == first_window || second_window == None)) { |
|
// Force the first and second windows to be marked as dialogs. |
|
set_window_is_dialog(dpy, w, true); |
|
if(w != first_window) { |
|
// Give the second window a proper size *now* so that the WM can center it. |
|
second_window = w; |
|
XResizeWindow(dpy, w, 384, 107); |
|
} |
|
} |
|
|
|
return BASE(XMapWindow)(dpy, w); |
|
} |
|
|
|
INTERCEPT(void, XSetWMNormalHints, |
|
Display * dpy, |
|
Window w, |
|
XSizeHints * hints |
|
) { |
|
XSizeHints old_hints; |
|
long supplied; |
|
// Prevent steam from overriding the max size hints |
|
if((set_fixed_size || manage_errors) |
|
&& XGetWMNormalHints(dpy, w, &old_hints, &supplied)) { |
|
if(!(hints->flags & PSize) && (old_hints.flags & PSize)) { |
|
hints->flags |= PSize; |
|
hints->width = old_hints.width; |
|
hints->height = old_hints.height; |
|
} |
|
if((old_hints.flags & PMinSize) && (old_hints.flags & PMaxSize) |
|
&& old_hints.min_width == old_hints.max_width |
|
&& old_hints.min_height == old_hints.max_height) { |
|
hints->flags |= PMinSize | PMaxSize; |
|
hints->min_width = hints->max_width = old_hints.max_width; |
|
hints->min_height = hints->max_height = old_hints.max_height; |
|
} |
|
} |
|
BASE(XSetWMNormalHints)(dpy, w, hints); |
|
} |
|
|
|
|
|
/* helper function implementations */ |
|
|
|
static bool is_unmanaged_window(Display * dpy, Window w) { |
|
XWindowAttributes xwa; |
|
if(!XGetWindowAttributes(dpy, w, &xwa)) { |
|
return false; |
|
} |
|
return xwa.override_redirect; |
|
} |
|
|
|
static void set_is_unmanaged_window(Display * dpy, Window w, bool is_unmanaged) { |
|
XSetWindowAttributes xswa; |
|
xswa.override_redirect = is_unmanaged; |
|
XChangeWindowAttributes(dpy, w, CWOverrideRedirect, &xswa); |
|
} |
|
|
|
template <size_t N> |
|
static bool is_in_array(const char * (&array)[N], const char * needle) { |
|
|
|
for(unsigned i = 0; i < N; i++) { |
|
if(strcmp(needle, array[i]) == 0) { |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
static bool is_main_window_name(const char * name) { |
|
return is_in_array(main_windows, name); |
|
} |
|
|
|
static bool is_dialog_window_name(const char * name) { |
|
return is_in_array(dialog_windows, name); |
|
} |
|
|
|
static bool is_fixed_size_window_name(const char * name) { |
|
|
|
if(is_in_array(fixed_size_windows, name)) { |
|
return true; |
|
} |
|
|
|
int len = strlen(name); |
|
for(unsigned i = 0; i < sizeof(fixed_size_suffixes)/sizeof(*fixed_size_suffixes); i++) { |
|
int plen = strlen(fixed_size_suffixes[i]); |
|
if(len > plen && strcmp(name + len - plen, fixed_size_suffixes[i]) == 0) { |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
static void set_window_desired_size(Display * dpy, Window w, int width, int height, |
|
bool set_fixed) { |
|
XSizeHints xsh; |
|
long supplied; |
|
if(!XGetWMNormalHints(dpy, w, &xsh, &supplied)) { |
|
xsh.flags = 0; |
|
} |
|
if(width > 0 && height > 0) { |
|
// Store the desired size. |
|
// PBaseSize (base_width and base_height) sounds more appropriate |
|
// (and is not obsolete), but some window managers won't let the window |
|
// get smaller than the base size. |
|
xsh.flags |= PSize; |
|
xsh.width = width, xsh.height = height; |
|
} else if(xsh.flags & PSize) { |
|
// Retrieve the desired size. |
|
width = xsh.width, height = xsh.height; |
|
} else { |
|
Window root; |
|
int x, y; |
|
unsigned int cwidth, cheight, border_width, depth; |
|
if(!XGetGeometry(dpy, w, &root, &x, &y, &cwidth, &cheight, &border_width, &depth)) { |
|
return; |
|
} |
|
width = cwidth, height = cheight; |
|
} |
|
if(set_fixed || ((xsh.flags & PMinSize) && (xsh.flags & PMaxSize) |
|
&& xsh.min_width == xsh.max_width && xsh.min_height == xsh.max_height)) { |
|
xsh.flags |= PMinSize | PMaxSize; |
|
xsh.min_width = xsh.max_width = width; |
|
xsh.min_height = xsh.max_height = height; |
|
} |
|
BASE(XSetWMNormalHints)(dpy, w, &xsh); |
|
} |
|
|
|
static void set_window_property(Display * dpy, Window w, Atom property, Atom type, |
|
long value) { |
|
unsigned char data[sizeof(long)]; |
|
memcpy(&data, &value, sizeof(long)); |
|
BASE(XChangeProperty)(dpy, w, property, type, 32, PropModeReplace, data, 1); |
|
} |
|
|
|
static void set_window_group_hint(Display * dpy, Window w, XID window_group) { |
|
XWMHints base_hints; |
|
XWMHints * h = XGetWMHints(dpy, w); |
|
if(!h) { |
|
h = &base_hints; |
|
h->flags = 0; |
|
} |
|
h->flags |= WindowGroupHint; |
|
h->window_group = window_group; |
|
XSetWMHints(dpy, w, h); |
|
if(h != &base_hints) { |
|
XFree(h); |
|
} |
|
} |
|
|
|
static void set_window_is_dialog(Display * dpy, Window w, bool is_dialog) { |
|
Atom window_type = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False); |
|
if(is_dialog) { |
|
Atom dialog = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False); |
|
set_window_property(dpy, w, window_type, XA_ATOM, dialog); |
|
} else { |
|
Atom normal = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_NORMAL", False); |
|
set_window_property(dpy, w, window_type, XA_ATOM, normal); |
|
} |
|
} |
|
|
|
static void set_window_modal(Display * dpy, Window w) { |
|
XWindowAttributes xwa; |
|
if(!XGetWindowAttributes(dpy, w, &xwa)) { |
|
return; |
|
} |
|
Atom state = XInternAtom(dpy, "_NET_WM_STATE", False); |
|
Atom state_modal = XInternAtom(dpy, "_NET_WM_STATE_MODAL", False); |
|
if(xwa.map_state == IsUnmapped) { |
|
set_window_property(dpy, w, state, XA_ATOM, state_modal); |
|
} else { |
|
XEvent event; |
|
event.type = ClientMessage; |
|
event.xclient.message_type = state; |
|
event.xclient.window = w; |
|
event.xclient.format = 32; |
|
event.xclient.data.l[0] = 1; // add |
|
event.xclient.data.l[1] = state_modal; |
|
event.xclient.data.l[2] = 0; |
|
event.xclient.data.l[3] = 1; |
|
event.xclient.data.l[4] = 0; |
|
XSendEvent(dpy, DefaultRootWindow(dpy), False, |
|
(SubstructureNotifyMask | SubstructureRedirectMask), &event); |
|
} |
|
} |
