Paste #LHYh59nTZmgPS1WO7ZJ4 at spacepaste

#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);
}
}

spacepaste

Paste details