/* * Copyright (c) 2009-2015 Marco Peereboom * Copyright (c) 2009-2011 Ryan McBride * Copyright (c) 2009 Darrin Chandler * Copyright (c) 2009 Pierre-Yves Ritschard * Copyright (c) 2010 Tuukka Kataja * Copyright (c) 2011 Jason L. Wright * Copyright (c) 2011-2018 Reginald Kennedy * Copyright (c) 2011-2012 Lawrence Teo * Copyright (c) 2011-2012 Tiago Cunha * Copyright (c) 2012-2015 David Hill * Copyright (c) 2014-2015 Yuri D'Elia * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* kernel includes */ #include #include #include #include #ifdef __OSX__ #include "queue.h" #else #include #endif #include #include #if defined(__linux__) #include "tree.h" #elif defined(__OpenBSD__) #include #elif defined(__FreeBSD__) #include #elif defined(__NetBSD__) #include #else #include "tree.h" #endif /* /usr/includes */ #include #include #include #include #include #include #include #if !defined(__OpenBSD__) #include "pledge.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(__linux__) || defined(__FreeBSD__) #include #define SWM_XCB_HAS_XINPUT #endif #include #include /* local includes */ #include "version.h" #ifdef __OSX__ #include #endif #ifdef SPECTRWM_BUILDSTR static const char *buildstr = SPECTRWM_BUILDSTR; #else static const char *buildstr = SPECTRWM_VERSION; #endif #if !defined(__CYGWIN__) /* cygwin chokes on randr stuff */ # if RANDR_MAJOR < 1 # error RandR versions less than 1.0 are not supported #endif # if RANDR_MAJOR >= 1 # if RANDR_MINOR >= 2 # define SWM_XRR_HAS_CRTC # endif # endif #endif /* __CYGWIN__ */ #ifndef XCB_ICCCM_NUM_WM_HINTS_ELEMENTS #define XCB_ICCCM_SIZE_HINT_P_MIN_SIZE XCB_SIZE_HINT_P_MIN_SIZE #define XCB_ICCCM_SIZE_HINT_P_MAX_SIZE XCB_SIZE_HINT_P_MAX_SIZE #define XCB_ICCCM_SIZE_HINT_P_RESIZE_INC XCB_SIZE_HINT_P_RESIZE_INC #define XCB_ICCCM_WM_HINT_INPUT XCB_WM_HINT_INPUT #define XCB_ICCCM_WM_HINT_X_URGENCY XCB_WM_HINT_X_URGENCY #define XCB_ICCCM_WM_STATE_ICONIC XCB_WM_STATE_ICONIC #define XCB_ICCCM_WM_STATE_WITHDRAWN XCB_WM_STATE_WITHDRAWN #define XCB_ICCCM_WM_STATE_NORMAL XCB_WM_STATE_NORMAL #define xcb_icccm_get_text_property_reply_t xcb_get_text_property_reply_t #define xcb_icccm_get_text_property_reply_wipe xcb_get_text_property_reply_wipe #define xcb_icccm_get_wm_class xcb_get_wm_class #define xcb_icccm_get_wm_class_reply xcb_get_wm_class_reply #define xcb_icccm_get_wm_class_reply_t xcb_get_wm_class_reply_t #define xcb_icccm_get_wm_class_reply_wipe xcb_get_wm_class_reply_wipe #define xcb_icccm_get_wm_hints xcb_get_wm_hints #define xcb_icccm_wm_hints_get_urgency xcb_wm_hints_get_urgency #define xcb_icccm_get_wm_hints_reply xcb_get_wm_hints_reply #define xcb_icccm_get_wm_name xcb_get_wm_name #define xcb_icccm_get_wm_name_reply xcb_get_wm_name_reply #define xcb_icccm_get_wm_normal_hints xcb_get_wm_normal_hints #define xcb_icccm_get_wm_normal_hints_reply xcb_get_wm_normal_hints_reply #define xcb_icccm_get_wm_protocols xcb_get_wm_protocols #define xcb_icccm_get_wm_protocols_reply xcb_get_wm_protocols_reply #define xcb_icccm_get_wm_protocols_reply_t xcb_get_wm_protocols_reply_t #define xcb_icccm_get_wm_protocols_reply_wipe xcb_get_wm_protocols_reply_wipe #define xcb_icccm_get_wm_transient_for xcb_get_wm_transient_for #define xcb_icccm_get_wm_transient_for_reply xcb_get_wm_transient_for_reply #define xcb_icccm_wm_hints_t xcb_wm_hints_t #endif /*#define SWM_DEBUG*/ #ifdef SWM_DEBUG #define DPRINTF(x...) do { \ if (swm_debug) \ fprintf(stderr, x); \ } while (0) #define DNPRINTF(n, fmt, args...) do { \ if (swm_debug & n) \ fprintf(stderr, "%ld %s: " fmt, \ (long)(time(NULL) - time_started), __func__, ## args); \ } while (0) #define SWM_D_MISC 0x0001 #define SWM_D_EVENT 0x0002 #define SWM_D_WS 0x0004 #define SWM_D_FOCUS 0x0008 #define SWM_D_MOVE 0x0010 #define SWM_D_STACK 0x0020 #define SWM_D_MOUSE 0x0040 #define SWM_D_PROP 0x0080 #define SWM_D_CLASS 0x0100 #define SWM_D_KEY 0x0200 #define SWM_D_QUIRK 0x0400 #define SWM_D_SPAWN 0x0800 #define SWM_D_EVENTQ 0x1000 #define SWM_D_CONF 0x2000 #define SWM_D_BAR 0x4000 #define SWM_D_INIT 0x8000 uint32_t swm_debug = 0 | SWM_D_MISC | SWM_D_EVENT | SWM_D_WS | SWM_D_FOCUS | SWM_D_MOVE | SWM_D_STACK | SWM_D_MOUSE | SWM_D_PROP | SWM_D_CLASS | SWM_D_KEY | SWM_D_QUIRK | SWM_D_SPAWN | SWM_D_EVENTQ | SWM_D_CONF | SWM_D_BAR | SWM_D_INIT ; #else #define DPRINTF(x...) #define DNPRINTF(n,x...) #endif #define SWM_EWMH_ACTION_COUNT_MAX (8) #define EWMH_F_FULLSCREEN (0x001) #define EWMH_F_ABOVE (0x002) #define EWMH_F_HIDDEN (0x004) #define EWMH_F_MAXIMIZED_VERT (0x008) #define EWMH_F_MAXIMIZED_HORZ (0x010) #define EWMH_F_SKIP_PAGER (0x020) #define EWMH_F_SKIP_TASKBAR (0x040) #define SWM_F_MANUAL (0x080) #define EWMH_F_MAXIMIZED (EWMH_F_MAXIMIZED_VERT | EWMH_F_MAXIMIZED_HORZ) /* convert 8-bit to 16-bit */ #define RGB_8_TO_16(col) (((col) << 8) + (col)) #define PIXEL_TO_XRENDERCOLOR(px, xrc) \ xrc.red = RGB_8_TO_16((px) >> 16 & 0xff); \ xrc.green = RGB_8_TO_16((px) >> 8 & 0xff); \ xrc.blue = RGB_8_TO_16((px) & 0xff); \ xrc.alpha = 0xffff; #define LENGTH(x) (int)(sizeof (x) / sizeof (x)[0]) #define MODKEY XCB_MOD_MASK_1 #define ANYMOD XCB_MOD_MASK_ANY #define CLEANMASK(mask) ((mask) & (XCB_KEY_BUT_MASK_SHIFT | \ XCB_KEY_BUT_MASK_CONTROL | XCB_KEY_BUT_MASK_MOD_1 | \ XCB_KEY_BUT_MASK_MOD_2 | XCB_KEY_BUT_MASK_MOD_3 | \ XCB_KEY_BUT_MASK_MOD_4 | XCB_KEY_BUT_MASK_MOD_5) & ~(numlockmask)) #define BUTTONMASK (XCB_EVENT_MASK_BUTTON_PRESS | \ XCB_EVENT_MASK_BUTTON_RELEASE) #define MOUSEMASK (BUTTONMASK|XCB_EVENT_MASK_POINTER_MOTION) #define SWM_PROPLEN (16) #define SWM_FUNCNAME_LEN (32) #define SWM_QUIRK_LEN (64) #define X(r) ((r)->g.x) #define Y(r) ((r)->g.y) #define WIDTH(r) ((r)->g.w) #define HEIGHT(r) ((r)->g.h) #define MAX_X(r) ((r)->g.x + (r)->g.w) #define MAX_Y(r) ((r)->g.y + (r)->g.h) #define SH_MIN(w) ((w)->sh.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE) #define SH_MIN_W(w) ((w)->sh.min_width) #define SH_MIN_H(w) ((w)->sh.min_height) #define SH_MAX(w) ((w)->sh.flags & XCB_ICCCM_SIZE_HINT_P_MAX_SIZE) #define SH_MAX_W(w) ((w)->sh.max_width) #define SH_MAX_H(w) ((w)->sh.max_height) #define SH_INC(w) ((w)->sh.flags & XCB_ICCCM_SIZE_HINT_P_RESIZE_INC) #define SH_INC_W(w) ((w)->sh.width_inc) #define SH_INC_H(w) ((w)->sh.height_inc) #define SWM_MAX_FONT_STEPS (3) #define WINID(w) ((w) ? (w)->id : XCB_WINDOW_NONE) #define ACCEPTS_FOCUS(w) (!((w)->hints.flags & XCB_ICCCM_WM_HINT_INPUT) \ || ((w)->hints.input)) #define WS_FOCUSED(ws) ((ws)->r && (ws)->r->s->r_focus == (ws)->r) #define YESNO(x) ((x) ? "yes" : "no") #define ICONIC(w) ((w)->ewmh_flags & EWMH_F_HIDDEN) #define ABOVE(w) ((w)->ewmh_flags & EWMH_F_ABOVE) #define FULLSCREEN(w) ((w)->ewmh_flags & EWMH_F_FULLSCREEN) #define MAXIMIZED_VERT(w) ((w)->ewmh_flags & EWMH_F_MAXIMIZED_VERT) #define MAXIMIZED_HORZ(w) ((w)->ewmh_flags & EWMH_F_MAXIMIZED_HORZ) #define MAXIMIZED(w) (MAXIMIZED_VERT(w) || MAXIMIZED_HORZ(w)) #define MANUAL(w) ((w)->ewmh_flags & SWM_F_MANUAL) #define TRANS(w) ((w)->transient != XCB_WINDOW_NONE) #define FLOATING(w) (ABOVE(w) || TRANS(w) || FULLSCREEN(w) || \ MAXIMIZED(w)) /* Constrain Window flags */ #define SWM_CW_RESIZABLE (0x01) #define SWM_CW_SOFTBOUNDARY (0x02) #define SWM_CW_HARDBOUNDARY (0x04) #define SWM_CW_RIGHT (0x10) #define SWM_CW_LEFT (0x20) #define SWM_CW_BOTTOM (0x40) #define SWM_CW_TOP (0x80) #define SWM_CW_ALLSIDES (0xf0) #define SWM_FOCUS_DEFAULT (0) #define SWM_FOCUS_FOLLOW (1) #define SWM_FOCUS_MANUAL (2) #define SWM_CK_ALL (0xf) #define SWM_CK_FOCUS (0x1) #define SWM_CK_POINTER (0x2) #define SWM_CK_FALLBACK (0x4) #define SWM_CK_REGION (0x8) #define SWM_WSI_LISTCURRENT (0x001) #define SWM_WSI_LISTACTIVE (0x002) #define SWM_WSI_LISTEMPTY (0x004) #define SWM_WSI_LISTNAMED (0x008) #define SWM_WSI_LISTURGENT (0x010) #define SWM_WSI_LISTALL (0x0ff) #define SWM_WSI_HIDECURRENT (0x100) #define SWM_WSI_MARKCURRENT (0x200) #define SWM_WSI_MARKURGENT (0x400) #define SWM_WSI_PRINTNAMES (0x800) #define SWM_WSI_DEFAULT (SWM_WSI_LISTCURRENT | SWM_WSI_LISTACTIVE | \ SWM_WSI_MARKCURRENT | SWM_WSI_PRINTNAMES) #define SWM_CONF_DEFAULT (0) #define SWM_CONF_KEYMAPPING (1) #ifndef SWM_LIB #define SWM_LIB "/usr/local/lib/libswmhack.so" #endif char **start_argv; xcb_atom_t a_state; xcb_atom_t a_prot; xcb_atom_t a_delete; xcb_atom_t a_net_frame_extents; xcb_atom_t a_net_wm_check; xcb_atom_t a_net_supported; xcb_atom_t a_takefocus; xcb_atom_t a_utf8_string; xcb_atom_t a_swm_ws; volatile sig_atomic_t running = 1; volatile sig_atomic_t restart_wm = 0; xcb_timestamp_t last_event_time = 0; int outputs = 0; bool randr_support = false; int randr_eventbase; unsigned int numlockmask = 0; bool xinput2_support = false; Display *display; xcb_connection_t *conn; xcb_key_symbols_t *syms; int boundary_width = 50; bool cycle_empty = false; bool cycle_visible = false; int term_width = 0; int font_adjusted = 0; uint16_t mod_key = MODKEY; bool warp_focus = false; bool warp_pointer = false; bool workspace_clamp = false; /* dmenu search */ struct swm_region *search_r; int select_list_pipe[2]; int select_resp_pipe[2]; pid_t searchpid; volatile sig_atomic_t search_resp; int search_resp_action; struct search_window { TAILQ_ENTRY(search_window) entry; int idx; struct ws_win *win; xcb_gcontext_t gc; xcb_window_t indicator; }; TAILQ_HEAD(search_winlist, search_window) search_wl = TAILQ_HEAD_INITIALIZER(search_wl); /* search actions */ enum { SWM_SEARCH_NONE, SWM_SEARCH_UNICONIFY, SWM_SEARCH_NAME_WORKSPACE, SWM_SEARCH_SEARCH_WORKSPACE, SWM_SEARCH_SEARCH_WINDOW }; #define SWM_STACK_TOP (0) #define SWM_STACK_BOTTOM (1) #define SWM_STACK_ABOVE (2) #define SWM_STACK_BELOW (3) /* dialog windows */ double dialog_ratio = 0.6; /* status bar */ #define SWM_BAR_MAX (256) #define SWM_BAR_JUSTIFY_LEFT (0) #define SWM_BAR_JUSTIFY_CENTER (1) #define SWM_BAR_JUSTIFY_RIGHT (2) #define SWM_BAR_OFFSET (4) #define SWM_BAR_FONTS "-*-terminus-medium-*-*-*-12-*-*-*-*-*-*-*," \ "-*-profont-*-*-*-*-12-*-*-*-*-*-*-*," \ "-*-times-medium-r-*-*-12-*-*-*-*-*-*-*," \ "-misc-fixed-medium-r-*-*-12-*-*-*-*-*-*-*," \ "-*-*-*-r-*-*-*-*-*-*-*-*-*-*" #ifdef X_HAVE_UTF8_STRING #define DRAWSTRING(x...) Xutf8DrawString(x) #else #define DRAWSTRING(x...) XmbDrawString(x) #endif char *bar_argv[] = { NULL, NULL }; int bar_pipe[2]; char bar_ext[SWM_BAR_MAX]; char bar_ext_buf[SWM_BAR_MAX]; char bar_vertext[SWM_BAR_MAX]; bool bar_version = false; bool bar_enabled = true; int bar_border_width = 1; bool bar_at_bottom = false; bool bar_extra = false; int bar_height = 0; int bar_justify = SWM_BAR_JUSTIFY_LEFT; char *bar_format = NULL; bool stack_enabled = true; bool clock_enabled = true; bool iconic_enabled = false; bool maximize_hide_bar = false; bool urgent_enabled = false; bool urgent_collapse = false; char *clock_format = NULL; bool window_class_enabled = false; bool window_instance_enabled = false; bool window_name_enabled = false; uint32_t workspace_indicator = SWM_WSI_DEFAULT; int focus_mode = SWM_FOCUS_DEFAULT; int focus_close = SWM_STACK_BELOW; bool focus_close_wrap = true; int focus_default = SWM_STACK_TOP; int spawn_position = SWM_STACK_TOP; bool disable_border = false; bool disable_border_always = false; int border_width = 1; int region_padding = 0; int tile_gap = 0; bool verbose_layout = false; #ifdef SWM_DEBUG bool debug_enabled; time_t time_started; #endif pid_t bar_pid; XFontSet bar_fs = NULL; XFontSetExtents *bar_fs_extents; XftFont *bar_font = NULL; bool bar_font_legacy = true; char *bar_fonts = NULL; XftColor bar_font_color; XftColor search_font_color; char *startup_exception = NULL; unsigned int nr_exceptions = 0; /* layout manager data */ struct swm_geometry { int x; int y; int w; int h; }; struct swm_screen; struct workspace; struct swm_bar { xcb_window_t id; xcb_pixmap_t buffer; struct swm_geometry g; struct swm_region *r; /* Associated region. */ }; /* virtual "screens" */ struct swm_region { TAILQ_ENTRY(swm_region) entry; xcb_window_t id; struct swm_geometry g; struct workspace *ws; /* current workspace on this region */ struct workspace *ws_prior; /* prior workspace on this region */ struct swm_screen *s; /* screen idx */ struct swm_bar *bar; }; TAILQ_HEAD(swm_region_list, swm_region); enum { SWM_WIN_STATE_REPARENTING, SWM_WIN_STATE_REPARENTED, SWM_WIN_STATE_UNPARENTING, SWM_WIN_STATE_UNPARENTED, }; struct ws_win { TAILQ_ENTRY(ws_win) entry; TAILQ_ENTRY(ws_win) stack_entry; xcb_window_t id; xcb_window_t frame; xcb_window_t transient; xcb_visualid_t visual; struct ws_win *focus_child; /* focus on child transient */ struct swm_geometry g; /* current geometry */ struct swm_geometry g_prev; /* prev configured geometry */ struct swm_geometry g_float; /* region coordinates */ bool g_floatvalid; /* g_float geometry validity */ bool mapped; uint8_t state; bool bordered; uint32_t ewmh_flags; int font_size_boundary[SWM_MAX_FONT_STEPS]; int font_steps; int last_inc; bool can_delete; bool take_focus; bool java; uint32_t quirks; struct workspace *ws; /* always valid */ struct swm_screen *s; /* always valid, never changes */ xcb_size_hints_t sh; xcb_icccm_get_wm_class_reply_t ch; xcb_icccm_wm_hints_t hints; #ifdef SWM_DEBUG xcb_window_t debug; #endif }; TAILQ_HEAD(ws_win_list, ws_win); TAILQ_HEAD(ws_win_stack, ws_win); /* pid goo */ struct pid_e { TAILQ_ENTRY(pid_e) entry; pid_t pid; int ws; }; TAILQ_HEAD(pid_list, pid_e) pidlist = TAILQ_HEAD_INITIALIZER(pidlist); /* layout handlers */ void stack(struct swm_region *); void vertical_config(struct workspace *, int); void vertical_stack(struct workspace *, struct swm_geometry *); void horizontal_config(struct workspace *, int); void horizontal_stack(struct workspace *, struct swm_geometry *); void max_stack(struct workspace *, struct swm_geometry *); void plain_stacker(struct workspace *); void fancy_stacker(struct workspace *); struct layout { void (*l_stack)(struct workspace *, struct swm_geometry *); void (*l_config)(struct workspace *, int); uint32_t flags; #define SWM_L_FOCUSPREV (1<<0) #define SWM_L_MAPONFOCUS (1<<1) void (*l_string)(struct workspace *); } layouts[] = { /* stack, configure */ { vertical_stack, vertical_config, 0, plain_stacker }, { horizontal_stack, horizontal_config, 0, plain_stacker }, { max_stack, NULL, SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV, plain_stacker }, { NULL, NULL, 0, NULL }, }; /* position of max_stack mode in the layouts array, index into layouts! */ #define SWM_V_STACK (0) #define SWM_H_STACK (1) #define SWM_MAX_STACK (2) #define SWM_H_SLICE (32) #define SWM_V_SLICE (32) /* define work spaces */ struct workspace { int idx; /* workspace index */ char *name; /* workspace name */ bool always_raise; /* raise windows on focus */ bool bar_enabled; /* bar visibility */ struct layout *cur_layout; /* current layout handlers */ struct ws_win *focus; /* may be NULL */ struct ws_win *focus_prev; /* may be NULL */ struct ws_win *focus_pending; /* may be NULL */ struct ws_win *focus_raise; /* may be NULL */ struct swm_region *r; /* may be NULL */ struct swm_region *old_r; /* may be NULL */ struct ws_win_list winlist; /* list of windows in ws */ struct ws_win_list unmanagedlist; /* list of dead windows in ws */ struct ws_win_stack stack; /* stacking order */ int state; /* mapping state */ char stacker[10]; /* display stacker and layout */ /* stacker state */ struct { int horizontal_msize; int horizontal_mwin; int horizontal_stacks; bool horizontal_flip; int vertical_msize; int vertical_mwin; int vertical_stacks; bool vertical_flip; } l_state; }; enum { SWM_WS_STATE_HIDDEN, SWM_WS_STATE_MAPPING, SWM_WS_STATE_MAPPED, }; enum { SWM_S_COLOR_BAR, SWM_S_COLOR_BAR_SELECTED, SWM_S_COLOR_BAR_BORDER, SWM_S_COLOR_BAR_BORDER_UNFOCUS, SWM_S_COLOR_BAR_FONT, SWM_S_COLOR_BAR_FONT_SELECTED, SWM_S_COLOR_FOCUS, SWM_S_COLOR_FOCUS_MAXIMIZED, SWM_S_COLOR_UNFOCUS, SWM_S_COLOR_UNFOCUS_MAXIMIZED, SWM_S_COLOR_MAX }; /* physical screen mapping */ #define SWM_WS_MAX (22) /* hard limit */ int workspace_limit = 10; /* soft limit */ #define SWM_RATE_DEFAULT (60) /* Default for swm_screen. */ struct swm_screen { int idx; /* screen index */ struct swm_region_list rl; /* list of regions on this screen */ struct swm_region_list orl; /* list of old regions */ xcb_window_t root; struct workspace ws[SWM_WS_MAX]; struct swm_region *r_focus; /* colors */ struct { uint32_t pixel; char *name; int manual; } c[SWM_S_COLOR_MAX]; uint8_t depth; xcb_timestamp_t rate; /* Max updates/sec for move and resize */ xcb_visualid_t visual; Visual *xvisual; /* Needed for Xft. */ xcb_colormap_t colormap; xcb_gcontext_t gc; }; struct swm_screen *screens; /* args to functions */ union arg { int id; #define SWM_ARG_ID_FOCUSNEXT (0) #define SWM_ARG_ID_FOCUSPREV (1) #define SWM_ARG_ID_FOCUSMAIN (2) #define SWM_ARG_ID_FOCUSURGENT (3) #define SWM_ARG_ID_SWAPNEXT (10) #define SWM_ARG_ID_SWAPPREV (11) #define SWM_ARG_ID_SWAPMAIN (12) #define SWM_ARG_ID_MOVELAST (13) #define SWM_ARG_ID_MASTERSHRINK (20) #define SWM_ARG_ID_MASTERGROW (21) #define SWM_ARG_ID_MASTERADD (22) #define SWM_ARG_ID_MASTERDEL (23) #define SWM_ARG_ID_FLIPLAYOUT (24) #define SWM_ARG_ID_STACKRESET (30) #define SWM_ARG_ID_STACKINIT (31) #define SWM_ARG_ID_STACKBALANCE (32) #define SWM_ARG_ID_CYCLEWS_UP (40) #define SWM_ARG_ID_CYCLEWS_DOWN (41) #define SWM_ARG_ID_CYCLERG_UP (42) #define SWM_ARG_ID_CYCLERG_DOWN (43) #define SWM_ARG_ID_CYCLEWS_UP_ALL (44) #define SWM_ARG_ID_CYCLEWS_DOWN_ALL (45) #define SWM_ARG_ID_CYCLEWS_MOVE_UP (46) #define SWM_ARG_ID_CYCLEWS_MOVE_DOWN (47) #define SWM_ARG_ID_STACKINC (50) #define SWM_ARG_ID_STACKDEC (51) #define SWM_ARG_ID_CYCLE_LAYOUT (60) #define SWM_ARG_ID_LAYOUT_VERTICAL (61) #define SWM_ARG_ID_LAYOUT_HORIZONTAL (62) #define SWM_ARG_ID_LAYOUT_MAX (63) #define SWM_ARG_ID_DONTCENTER (70) #define SWM_ARG_ID_CENTER (71) #define SWM_ARG_ID_KILLWINDOW (80) #define SWM_ARG_ID_DELETEWINDOW (81) #define SWM_ARG_ID_WIDTHGROW (90) #define SWM_ARG_ID_WIDTHSHRINK (91) #define SWM_ARG_ID_HEIGHTGROW (92) #define SWM_ARG_ID_HEIGHTSHRINK (93) #define SWM_ARG_ID_MOVEUP (100) #define SWM_ARG_ID_MOVEDOWN (101) #define SWM_ARG_ID_MOVELEFT (102) #define SWM_ARG_ID_MOVERIGHT (103) #define SWM_ARG_ID_BAR_TOGGLE (110) #define SWM_ARG_ID_BAR_TOGGLE_WS (111) #define SWM_ARG_ID_CYCLERG_MOVE_UP (112) #define SWM_ARG_ID_CYCLERG_MOVE_DOWN (113) #define SWM_ARG_ID_WS_EMPTY (120) #define SWM_ARG_ID_WS_EMPTY_MOVE (121) char **argv; }; /* quirks */ struct quirk { TAILQ_ENTRY(quirk) entry; char *class; /* WM_CLASS:class */ char *instance; /* WM_CLASS:instance */ char *name; /* WM_NAME */ regex_t regex_class; regex_t regex_instance; regex_t regex_name; uint32_t quirk; int ws; /* Initial workspace. */ #define SWM_Q_FLOAT (1<<0) /* Float this window. */ #define SWM_Q_TRANSSZ (1<<1) /* Transient window size too small. */ #define SWM_Q_ANYWHERE (1<<2) /* Don't position this window */ #define SWM_Q_XTERM_FONTADJ (1<<3) /* Adjust xterm fonts when resizing. */ #define SWM_Q_FULLSCREEN (1<<4) /* Remove border when fullscreen. */ #define SWM_Q_FOCUSPREV (1<<5) /* Focus on caller. */ #define SWM_Q_NOFOCUSONMAP (1<<6) /* Don't focus on window when mapped. */ #define SWM_Q_FOCUSONMAP_SINGLE (1<<7) /* Only focus if single win of type. */ #define SWM_Q_OBEYAPPFOCUSREQ (1<<8) /* Focus when applications ask. */ #define SWM_Q_IGNOREPID (1<<9) /* Ignore PID when determining ws. */ #define SWM_Q_IGNORESPAWNWS (1<<10) /* Ignore _SWM_WS when managing win. */ #define SWM_Q_NOFOCUSCYCLE (1<<11) /* Remove from normal focus cycle. */ #define SWM_Q_MINIMALBORDER (1<<12) /* No border when floating/unfocused. */ }; TAILQ_HEAD(quirk_list, quirk) quirks = TAILQ_HEAD_INITIALIZER(quirks); /* * Supported EWMH hints should be added to * both the enum and the ewmh array */ enum { _NET_ACTIVE_WINDOW, _NET_CLIENT_LIST, _NET_CLOSE_WINDOW, _NET_CURRENT_DESKTOP, _NET_DESKTOP_GEOMETRY, _NET_DESKTOP_NAMES, _NET_DESKTOP_VIEWPORT, _NET_MOVERESIZE_WINDOW, _NET_NUMBER_OF_DESKTOPS, _NET_REQUEST_FRAME_EXTENTS, _NET_RESTACK_WINDOW, _NET_WM_ACTION_ABOVE, _NET_WM_ACTION_CLOSE, _NET_WM_ACTION_FULLSCREEN, _NET_WM_ACTION_MOVE, _NET_WM_ACTION_RESIZE, _NET_WM_ALLOWED_ACTIONS, _NET_WM_DESKTOP, _NET_WM_FULL_PLACEMENT, _NET_WM_NAME, _NET_WM_STATE, _NET_WM_STATE_ABOVE, _NET_WM_STATE_FULLSCREEN, _NET_WM_STATE_HIDDEN, _NET_WM_STATE_MAXIMIZED_VERT, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_SKIP_PAGER, _NET_WM_STATE_SKIP_TASKBAR, _NET_WM_WINDOW_TYPE, _NET_WM_WINDOW_TYPE_DIALOG, _NET_WM_WINDOW_TYPE_DOCK, _NET_WM_WINDOW_TYPE_NORMAL, _NET_WM_WINDOW_TYPE_SPLASH, _NET_WM_WINDOW_TYPE_TOOLBAR, _NET_WM_WINDOW_TYPE_UTILITY, _SWM_WM_STATE_MANUAL, SWM_EWMH_HINT_MAX }; struct ewmh_hint { char *name; xcb_atom_t atom; } ewmh[SWM_EWMH_HINT_MAX] = { /* must be in same order as in the enum */ {"_NET_ACTIVE_WINDOW", XCB_ATOM_NONE}, {"_NET_CLIENT_LIST", XCB_ATOM_NONE}, {"_NET_CLOSE_WINDOW", XCB_ATOM_NONE}, {"_NET_CURRENT_DESKTOP", XCB_ATOM_NONE}, {"_NET_DESKTOP_GEOMETRY", XCB_ATOM_NONE}, {"_NET_DESKTOP_NAMES", XCB_ATOM_NONE}, {"_NET_DESKTOP_VIEWPORT", XCB_ATOM_NONE}, {"_NET_MOVERESIZE_WINDOW", XCB_ATOM_NONE}, {"_NET_NUMBER_OF_DESKTOPS", XCB_ATOM_NONE}, {"_NET_REQUEST_FRAME_EXTENTS", XCB_ATOM_NONE}, {"_NET_RESTACK_WINDOW", XCB_ATOM_NONE}, {"_NET_WM_ACTION_ABOVE", XCB_ATOM_NONE}, {"_NET_WM_ACTION_CLOSE", XCB_ATOM_NONE}, {"_NET_WM_ACTION_FULLSCREEN", XCB_ATOM_NONE}, {"_NET_WM_ACTION_MOVE", XCB_ATOM_NONE}, {"_NET_WM_ACTION_RESIZE", XCB_ATOM_NONE}, {"_NET_WM_ALLOWED_ACTIONS", XCB_ATOM_NONE}, {"_NET_WM_DESKTOP", XCB_ATOM_NONE}, {"_NET_WM_FULL_PLACEMENT", XCB_ATOM_NONE}, {"_NET_WM_NAME", XCB_ATOM_NONE}, {"_NET_WM_STATE", XCB_ATOM_NONE}, {"_NET_WM_STATE_ABOVE", XCB_ATOM_NONE}, {"_NET_WM_STATE_FULLSCREEN", XCB_ATOM_NONE}, {"_NET_WM_STATE_HIDDEN", XCB_ATOM_NONE}, {"_NET_WM_STATE_MAXIMIZED_VERT", XCB_ATOM_NONE}, {"_NET_WM_STATE_MAXIMIZED_HORZ", XCB_ATOM_NONE}, {"_NET_WM_STATE_SKIP_PAGER", XCB_ATOM_NONE}, {"_NET_WM_STATE_SKIP_TASKBAR", XCB_ATOM_NONE}, {"_NET_WM_WINDOW_TYPE", XCB_ATOM_NONE}, {"_NET_WM_WINDOW_TYPE_DIALOG", XCB_ATOM_NONE}, {"_NET_WM_WINDOW_TYPE_DOCK", XCB_ATOM_NONE}, {"_NET_WM_WINDOW_TYPE_NORMAL", XCB_ATOM_NONE}, {"_NET_WM_WINDOW_TYPE_SPLASH", XCB_ATOM_NONE}, {"_NET_WM_WINDOW_TYPE_TOOLBAR", XCB_ATOM_NONE}, {"_NET_WM_WINDOW_TYPE_UTILITY", XCB_ATOM_NONE}, {"_SWM_WM_STATE_MANUAL", XCB_ATOM_NONE}, }; /* EWMH source type */ enum { EWMH_SOURCE_TYPE_NONE = 0, EWMH_SOURCE_TYPE_NORMAL = 1, EWMH_SOURCE_TYPE_OTHER = 2, }; /* Cursors */ enum { XC_FLEUR, XC_LEFT_PTR, XC_BOTTOM_LEFT_CORNER, XC_BOTTOM_RIGHT_CORNER, XC_SIZING, XC_TOP_LEFT_CORNER, XC_TOP_RIGHT_CORNER, XC_MAX }; struct cursors { char *name; /* Name used by Xcursor .*/ uint8_t cf_char; /* cursorfont index. */ xcb_cursor_t cid; } cursors[XC_MAX] = { {"fleur", XC_fleur, XCB_CURSOR_NONE}, {"left_ptr", XC_left_ptr, XCB_CURSOR_NONE}, {"bottom_left_corner", XC_bottom_left_corner, XCB_CURSOR_NONE}, {"bottom_right_corner", XC_bottom_right_corner, XCB_CURSOR_NONE}, {"sizing", XC_sizing, XCB_CURSOR_NONE}, {"top_left_corner", XC_top_left_corner, XCB_CURSOR_NONE}, {"top_right_corner", XC_top_right_corner, XCB_CURSOR_NONE}, }; #define SWM_SPAWN_OPTIONAL 0x1 /* spawn */ struct spawn_prog { TAILQ_ENTRY(spawn_prog) entry; char *name; int argc; char **argv; int flags; }; TAILQ_HEAD(spawn_list, spawn_prog) spawns = TAILQ_HEAD_INITIALIZER(spawns); enum { FN_F_NOREPLAY = 0x1, }; /* User callable function IDs. */ enum actionid { FN_BAR_TOGGLE, FN_BAR_TOGGLE_WS, FN_BUTTON2, FN_CYCLE_LAYOUT, FN_FLIP_LAYOUT, FN_FLOAT_TOGGLE, FN_FOCUS, FN_FOCUS_MAIN, FN_FOCUS_NEXT, FN_FOCUS_PREV, FN_FOCUS_URGENT, FN_FULLSCREEN_TOGGLE, FN_MAXIMIZE_TOGGLE, FN_HEIGHT_GROW, FN_HEIGHT_SHRINK, FN_ICONIFY, FN_LAYOUT_VERTICAL, FN_LAYOUT_HORIZONTAL, FN_LAYOUT_MAX, FN_MASTER_SHRINK, FN_MASTER_GROW, FN_MASTER_ADD, FN_MASTER_DEL, FN_MOVE, FN_MOVE_DOWN, FN_MOVE_LEFT, FN_MOVE_RIGHT, FN_MOVE_UP, FN_MVRG_1, FN_MVRG_2, FN_MVRG_3, FN_MVRG_4, FN_MVRG_5, FN_MVRG_6, FN_MVRG_7, FN_MVRG_8, FN_MVRG_9, KF_MVRG_NEXT, KF_MVRG_PREV, FN_MVWS_1, FN_MVWS_2, FN_MVWS_3, FN_MVWS_4, FN_MVWS_5, FN_MVWS_6, FN_MVWS_7, FN_MVWS_8, FN_MVWS_9, FN_MVWS_10, FN_MVWS_11, FN_MVWS_12, FN_MVWS_13, FN_MVWS_14, FN_MVWS_15, FN_MVWS_16, FN_MVWS_17, FN_MVWS_18, FN_MVWS_19, FN_MVWS_20, FN_MVWS_21, FN_MVWS_22, FN_NAME_WORKSPACE, FN_QUIT, FN_RAISE, FN_RAISE_TOGGLE, FN_RESIZE, FN_RESIZE_CENTERED, FN_RESTART, FN_RG_1, FN_RG_2, FN_RG_3, FN_RG_4, FN_RG_5, FN_RG_6, FN_RG_7, FN_RG_8, FN_RG_9, FN_RG_MOVE_NEXT, FN_RG_MOVE_PREV, FN_RG_NEXT, FN_RG_PREV, FN_SCREEN_NEXT, FN_SCREEN_PREV, FN_SEARCH_WIN, FN_SEARCH_WORKSPACE, FN_SPAWN_CUSTOM, FN_STACK_BALANCE, FN_STACK_INC, FN_STACK_DEC, FN_STACK_RESET, FN_SWAP_MAIN, FN_SWAP_NEXT, FN_SWAP_PREV, FN_UNICONIFY, FN_VERSION, FN_WIDTH_GROW, FN_WIDTH_SHRINK, FN_WIND_DEL, FN_WIND_KILL, FN_WS_1, FN_WS_2, FN_WS_3, FN_WS_4, FN_WS_5, FN_WS_6, FN_WS_7, FN_WS_8, FN_WS_9, FN_WS_10, FN_WS_11, FN_WS_12, FN_WS_13, FN_WS_14, FN_WS_15, FN_WS_16, FN_WS_17, FN_WS_18, FN_WS_19, FN_WS_20, FN_WS_21, FN_WS_22, FN_WS_EMPTY, FN_WS_EMPTY_MOVE, FN_WS_NEXT, FN_WS_NEXT_ALL, FN_WS_NEXT_MOVE, FN_WS_PREV, FN_WS_PREV_ALL, FN_WS_PREV_MOVE, FN_WS_PRIOR, /* SWM_DEBUG actions MUST be here: */ FN_DEBUG_TOGGLE, FN_DUMPWINS, /* ALWAYS last: */ FN_INVALID }; enum binding_type { KEYBIND, BTNBIND }; enum { BINDING_F_REPLAY = 0x1, }; struct binding { RB_ENTRY(binding) entry; uint16_t mod; /* Modifier Mask. */ enum binding_type type; /* Key or Button. */ uint32_t value; /* KeySym or Button Index. */ enum actionid action; /* Action Identifier. */ uint32_t flags; char *spawn_name; }; RB_HEAD(binding_tree, binding) bindings = RB_INITIALIZER(&bindings); /* function prototypes */ void adjust_font(struct ws_win *); char *argsep(char **); void bar_cleanup(struct swm_region *); void bar_extra_setup(void); void bar_extra_stop(void); int bar_extra_update(void); void bar_fmt(const char *, char *, struct swm_region *, size_t); void bar_fmt_expand(char *, size_t); void bar_draw(struct swm_bar *); void bar_print(struct swm_region *, const char *); void bar_print_legacy(struct swm_region *, const char *); void bar_replace(char *, char *, struct swm_region *, size_t); void bar_replace_pad(char *, int *, size_t); char *bar_replace_seq(char *, char *, struct swm_region *, size_t *, size_t); void bar_setup(struct swm_region *); void bar_toggle(struct binding *, struct swm_region *, union arg *); void bar_urgent(char *, size_t); void bar_window_class(char *, size_t, struct swm_region *); void bar_window_class_instance(char *, size_t, struct swm_region *); void bar_window_float(char *, size_t, struct swm_region *); void bar_window_instance(char *, size_t, struct swm_region *); void bar_window_name(char *, size_t, struct swm_region *); void bar_window_state(char *, size_t, struct swm_region *); void bar_workspace_indicator(char *, size_t, struct swm_region *); void bar_workspace_name(char *, size_t, struct swm_region *); int binding_cmp(struct binding *, struct binding *); void binding_insert(uint16_t, enum binding_type, uint32_t, enum actionid, uint32_t, const char *); struct binding *binding_lookup(uint16_t, enum binding_type, uint32_t); void binding_remove(struct binding *); void buttonpress(xcb_button_press_event_t *); void buttonrelease(xcb_button_release_event_t *); void center_pointer(struct swm_region *); const struct xcb_setup_t *get_setup(void); void clear_bindings(void); void clear_keybindings(void); int clear_maximized(struct workspace *); void clear_quirks(void); void clear_spawns(void); void clientmessage(xcb_client_message_event_t *); void client_msg(struct ws_win *, xcb_atom_t, xcb_timestamp_t); int conf_load(const char *, int); void configurenotify(xcb_configure_notify_event_t *); void configurerequest(xcb_configure_request_event_t *); void config_win(struct ws_win *, xcb_configure_request_event_t *); void constrain_window(struct ws_win *, struct swm_geometry *, int *); int count_win(struct workspace *, bool); void cursors_cleanup(void); void cursors_load(void); void custom_region(const char *); void cyclerg(struct binding *, struct swm_region *, union arg *); void cyclews(struct binding *, struct swm_region *, union arg *); #ifdef SWM_DEBUG void debug_refresh(struct ws_win *); #endif void debug_toggle(struct binding *, struct swm_region *, union arg *); void destroynotify(xcb_destroy_notify_event_t *); void dumpwins(struct binding *, struct swm_region *, union arg *); void emptyws(struct binding *, struct swm_region *, union arg *); int enable_wm(void); void enternotify(xcb_enter_notify_event_t *); void event_drain(uint8_t); void event_error(xcb_generic_error_t *); void event_handle(xcb_generic_event_t *); void ewmh_apply_flags(struct ws_win *, uint32_t); void ewmh_autoquirk(struct ws_win *); void ewmh_get_desktop_names(void); void ewmh_get_wm_state(struct ws_win *); void ewmh_update_actions(struct ws_win *); void ewmh_update_client_list(void); void ewmh_update_current_desktop(void); void ewmh_update_desktop_names(void); void ewmh_update_desktops(void); void ewmh_change_wm_state(struct ws_win *, xcb_atom_t, long); void ewmh_update_wm_state(struct ws_win *); char *expand_tilde(const char *); void expose(xcb_expose_event_t *); void fake_keypress(struct ws_win *, xcb_keysym_t, uint16_t); struct swm_bar *find_bar(xcb_window_t); struct pid_e *find_pid(pid_t); struct swm_region *find_region(xcb_window_t); struct ws_win *find_unmanaged_window(xcb_window_t); struct ws_win *find_window(xcb_window_t); void floating_toggle(struct binding *, struct swm_region *, union arg *); void focus(struct binding *, struct swm_region *, union arg *); void focus_flush(void); void focus_pointer(struct binding *, struct swm_region *, union arg *); void focus_region(struct swm_region *); void focus_win(struct ws_win *); void focusin(xcb_focus_in_event_t *); #ifdef SWM_DEBUG void focusout(xcb_focus_out_event_t *); #endif void focusrg(struct binding *, struct swm_region *, union arg *); void fontset_init(void); void free_window(struct ws_win *); void fullscreen_toggle(struct binding *, struct swm_region *, union arg *); xcb_atom_t get_atom_from_string(const char *); #ifdef SWM_DEBUG char *get_atom_name(xcb_atom_t); #endif xcb_keycode_t get_binding_keycode(struct binding *); struct ws_win *get_focus_magic(struct ws_win *); struct ws_win *get_focus_prev(struct ws_win *); xcb_generic_event_t *get_next_event(bool); #ifdef SWM_DEBUG char *get_notify_detail_label(uint8_t); char *get_notify_mode_label(uint8_t); #endif struct ws_win *get_pointer_win(xcb_window_t); struct ws_win *get_region_focus(struct swm_region *); int get_region_index(struct swm_region *); xcb_screen_t *get_screen(int); int get_screen_count(void); #ifdef SWM_DEBUG char *get_source_type_label(uint32_t); char *get_stack_mode_name(uint8_t); char *get_state_mask_label(uint16_t); #endif int32_t get_swm_ws(xcb_window_t); bool get_urgent(struct ws_win *); #ifdef SWM_DEBUG char *get_win_input_model(struct ws_win *); #endif char *get_win_name(xcb_window_t); uint8_t get_win_state(xcb_window_t); void get_wm_protocols(struct ws_win *); #ifdef SWM_DEBUG char *get_wm_state_label(uint8_t); #endif int get_ws_idx(struct ws_win *); void grab_windows(void); void grabbuttons(void); void grabkeys(void); void iconify(struct binding *, struct swm_region *, union arg *); bool isxlfd(char *); bool keybindreleased(struct binding *, xcb_key_release_event_t *); void keypress(xcb_key_press_event_t *); void keyrelease(xcb_key_release_event_t *); bool keyrepeating(xcb_key_release_event_t *); void kill_bar_extra_atexit(void); void kill_refs(struct ws_win *); #ifdef SWM_DEBUG void leavenotify(xcb_leave_notify_event_t *); #endif void load_float_geom(struct ws_win *); void lower_window(struct ws_win *); struct ws_win *manage_window(xcb_window_t, int, bool); void map_window(struct ws_win *); void mapnotify(xcb_map_notify_event_t *); void mappingnotify(xcb_mapping_notify_event_t *); void maprequest(xcb_map_request_event_t *); void maximize_toggle(struct binding *, struct swm_region *, union arg *); void motionnotify(xcb_motion_notify_event_t *); void move(struct binding *, struct swm_region *, union arg *); void move_win(struct ws_win *, struct binding *, int); uint32_t name_to_pixel(struct swm_screen *, const char *); void name_workspace(struct binding *, struct swm_region *, union arg *); void new_region(struct swm_screen *, int, int, int, int); int parse_rgb(const char *, uint16_t *, uint16_t *, uint16_t *); int parsebinding(const char *, uint16_t *, enum binding_type *, uint32_t *, uint32_t *); int parsequirks(const char *, uint32_t *, int *); int parse_workspace_indicator(const char *, uint32_t *); void pressbutton(struct binding *, struct swm_region *, union arg *); void priorws(struct binding *, struct swm_region *, union arg *); #ifdef SWM_DEBUG void print_win_geom(xcb_window_t); #endif void propertynotify(xcb_property_notify_event_t *); void put_back_event(xcb_generic_event_t *); void quirk_free(struct quirk *); void quirk_insert(const char *, const char *, const char *, uint32_t, int); void quirk_remove(struct quirk *); void quirk_replace(struct quirk *, const char *, const char *, const char *, uint32_t, int); void quit(struct binding *, struct swm_region *, union arg *); void raise_focus(struct binding *, struct swm_region *, union arg *); void raise_toggle(struct binding *, struct swm_region *, union arg *); void raise_window(struct ws_win *); void region_containment(struct ws_win *, struct swm_region *, int); struct swm_region *region_under(struct swm_screen *, int, int); void regionize(struct ws_win *, int, int); void reparent_window(struct ws_win *); void reparentnotify(xcb_reparent_notify_event_t *); void resize(struct binding *, struct swm_region *, union arg *); void resize_win(struct ws_win *, struct binding *, int); void restart(struct binding *, struct swm_region *, union arg *); struct swm_region *root_to_region(xcb_window_t, int); void screenchange(xcb_randr_screen_change_notify_event_t *); void scan_randr(int); void search_do_resp(void); void search_resp_name_workspace(const char *, size_t); void search_resp_search_window(const char *); void search_resp_search_workspace(const char *); void search_resp_uniconify(const char *, size_t); void search_win(struct binding *, struct swm_region *, union arg *); void search_win_cleanup(void); void search_workspace(struct binding *, struct swm_region *, union arg *); void send_to_rg(struct binding *, struct swm_region *, union arg *); void send_to_rg_relative(struct binding *, struct swm_region *, union arg *); void send_to_ws(struct binding *, struct swm_region *, union arg *); void set_region(struct swm_region *); int setautorun(const char *, const char *, int); void setbinding(uint16_t, enum binding_type, uint32_t, enum actionid, uint32_t, const char *); int setconfbinding(const char *, const char *, int); int setconfcolor(const char *, const char *, int); int setconfmodkey(const char *, const char *, int); int setconfquirk(const char *, const char *, int); int setconfregion(const char *, const char *, int); int setconfspawn(const char *, const char *, int); int setconfvalue(const char *, const char *, int); int setkeymapping(const char *, const char *, int); int setlayout(const char *, const char *, int); void setquirk(const char *, const char *, const char *, uint32_t, int); void setscreencolor(const char *, int, int); void setspawn(const char *, const char *, int); void setup_btnbindings(void); void setup_ewmh(void); void setup_extensions(void); void setup_globals(void); void setup_keybindings(void); void setup_quirks(void); void setup_screens(void); void setup_spawn(void); void set_child_transient(struct ws_win *, xcb_window_t *); void set_win_state(struct ws_win *, uint8_t); void shutdown_cleanup(void); void sighdlr(int); void socket_setnonblock(int); void sort_windows(struct ws_win_list *); void spawn(int, union arg *, bool); void spawn_custom(struct swm_region *, union arg *, const char *); int spawn_expand(struct swm_region *, union arg *, const char *, char ***); void spawn_insert(const char *, const char *, int); struct spawn_prog *spawn_find(const char *); void spawn_remove(struct spawn_prog *); void spawn_replace(struct spawn_prog *, const char *, const char *, int); void spawn_select(struct swm_region *, union arg *, const char *, int *); void stack_config(struct binding *, struct swm_region *, union arg *); void stack_master(struct workspace *, struct swm_geometry *, int, bool); void store_float_geom(struct ws_win *); char *strdupsafe(const char *); void swapwin(struct binding *, struct swm_region *, union arg *); void switchlayout(struct binding *, struct swm_region *, union arg *); void switchws(struct binding *, struct swm_region *, union arg *); void teardown_ewmh(void); void unescape_selector(char *); void unfocus_win(struct ws_win *); void uniconify(struct binding *, struct swm_region *, union arg *); void unmanage_window(struct ws_win *); void unmap_all(void); void unmap_window(struct ws_win *); void unmapnotify(xcb_unmap_notify_event_t *); void unparent_window(struct ws_win *); void update_floater(struct ws_win *); void update_modkey(uint16_t); void update_win_stacking(struct ws_win *); void update_window(struct ws_win *); void draw_frame(struct ws_win *); void update_wm_state(struct ws_win *win); void updatenumlockmask(void); void validate_spawns(void); int validate_win(struct ws_win *); int validate_ws(struct workspace *); void version(struct binding *, struct swm_region *, union arg *); void win_to_ws(struct ws_win *, int, bool); pid_t window_get_pid(xcb_window_t); void wkill(struct binding *, struct swm_region *, union arg *); void update_ws_stack(struct workspace *); void xft_init(struct swm_region *); void _add_startup_exception(const char *, va_list); void add_startup_exception(const char *, ...); RB_PROTOTYPE(binding_tree, binding, entry, binding_cmp); #ifndef __clang_analyzer__ /* Suppress false warnings. */ RB_GENERATE(binding_tree, binding, entry, binding_cmp); #endif void cursors_load(void) { xcb_font_t cf = XCB_NONE; int i; for (i = 0; i < LENGTH(cursors); ++i) { /* try to load Xcursor first. */ cursors[i].cid = XcursorLibraryLoadCursor(display, cursors[i].name); /* fallback to cursorfont. */ if (cursors[i].cid == XCB_CURSOR_NONE) { if (cf == XCB_NONE) { cf = xcb_generate_id(conn); xcb_open_font(conn, cf, strlen("cursor"), "cursor"); } cursors[i].cid = xcb_generate_id(conn); xcb_create_glyph_cursor(conn, cursors[i].cid, cf, cf, cursors[i].cf_char, cursors[i].cf_char + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff); } } if (cf != XCB_NONE) xcb_close_font(conn, cf); } void cursors_cleanup(void) { int i; for (i = 0; i < LENGTH(cursors); ++i) xcb_free_cursor(conn, cursors[i].cid); } char * expand_tilde(const char *s) { struct passwd *ppwd; int i; long max; char *user; const char *sc = s; char *result; if (s == NULL) errx(1, "expand_tilde: NULL string."); if (s[0] != '~') { result = strdup(sc); goto out; } ++s; if ((max = sysconf(_SC_LOGIN_NAME_MAX)) == -1) errx(1, "expand_tilde: sysconf"); if ((user = calloc(1, max + 1)) == NULL) errx(1, "expand_tilde: calloc"); for (i = 0; s[i] != '/' && s[i] != '\0'; ++i) user[i] = s[i]; user[i] = '\0'; s = &s[i]; ppwd = strlen(user) == 0 ? getpwuid(getuid()) : getpwnam(user); free(user); if (ppwd == NULL) result = strdup(sc); else if (asprintf(&result, "%s%s", ppwd->pw_dir, s) == -1) result = NULL; out: if (result == NULL) errx(1, "expand_tilde: failed to allocate memory."); return (result); } int parse_rgb(const char *rgb, uint16_t *rr, uint16_t *gg, uint16_t *bb) { unsigned int tmpr, tmpg, tmpb; if (sscanf(rgb, "rgb:%x/%x/%x", &tmpr, &tmpg, &tmpb) != 3) return (-1); *rr = RGB_8_TO_16(tmpr); *gg = RGB_8_TO_16(tmpg); *bb = RGB_8_TO_16(tmpb); return (0); } const struct xcb_setup_t * get_setup(void) { int errcode = xcb_connection_has_error(conn); #ifdef XCB_CONN_ERROR char *s; switch (errcode) { case XCB_CONN_ERROR: s = "Socket error, pipe error or other stream error."; break; case XCB_CONN_CLOSED_EXT_NOTSUPPORTED: s = "Extension not supported."; break; case XCB_CONN_CLOSED_MEM_INSUFFICIENT: s = "Insufficient memory."; break; case XCB_CONN_CLOSED_REQ_LEN_EXCEED: s = "Request length was exceeded."; break; case XCB_CONN_CLOSED_PARSE_ERR: s = "Error parsing display string."; break; default: s = "Unknown error."; } if (errcode) errx(errcode, "X CONNECTION ERROR: %s", s); #else if (errcode) errx(errcode, "X CONNECTION ERROR"); #endif return (xcb_get_setup(conn)); } xcb_screen_t * get_screen(int screen) { const xcb_setup_t *r; xcb_screen_iterator_t iter; r = get_setup(); iter = xcb_setup_roots_iterator(r); for (; iter.rem; --screen, xcb_screen_next(&iter)) if (screen == 0) return (iter.data); return (NULL); } int get_screen_count(void) { return (xcb_setup_roots_length(get_setup())); } int get_region_index(struct swm_region *r) { struct swm_region *rr; int ridx = 0; if (r == NULL) return (-1); TAILQ_FOREACH(rr, &r->s->rl, entry) { if (rr == r) break; ++ridx; } if (rr == NULL) return (-1); return (ridx); } void focus_flush(void) { if (focus_mode == SWM_FOCUS_DEFAULT) event_drain(XCB_ENTER_NOTIFY); else xcb_flush(conn); } xcb_atom_t get_atom_from_string(const char *str) { xcb_intern_atom_cookie_t c; xcb_intern_atom_reply_t *r; xcb_atom_t atom; c = xcb_intern_atom(conn, 0, strlen(str), str); r = xcb_intern_atom_reply(conn, c, NULL); if (r) { atom = r->atom; free(r); return (atom); } return (XCB_ATOM_NONE); } void get_wm_protocols(struct ws_win *win) { int i; xcb_icccm_get_wm_protocols_reply_t wpr; if (xcb_icccm_get_wm_protocols_reply(conn, xcb_icccm_get_wm_protocols(conn, win->id, a_prot), &wpr, NULL)) { for (i = 0; i < (int)wpr.atoms_len; i++) { if (wpr.atoms[i] == a_takefocus) win->take_focus = true; if (wpr.atoms[i] == a_delete) win->can_delete = true; } xcb_icccm_get_wm_protocols_reply_wipe(&wpr); } } void setup_ewmh(void) { xcb_window_t root, win; int i, j, num_screens; for (i = 0; i < LENGTH(ewmh); i++) ewmh[i].atom = get_atom_from_string(ewmh[i].name); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { root = screens[i].root; /* Set up _NET_SUPPORTING_WM_CHECK. */ win = xcb_generate_id(conn); xcb_create_window(conn, XCB_COPY_FROM_PARENT, win, root, 0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, NULL); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, a_net_wm_check, XCB_ATOM_WINDOW, 32, 1, &win); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, a_net_wm_check, XCB_ATOM_WINDOW, 32, 1, &win); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, ewmh[_NET_WM_NAME].atom, a_utf8_string, 8, strlen("spectrwm"), "spectrwm"); /* Report supported atoms */ xcb_delete_property(conn, root, a_net_supported); for (j = 0; j < LENGTH(ewmh); j++) xcb_change_property(conn, XCB_PROP_MODE_APPEND, root, a_net_supported, XCB_ATOM_ATOM, 32, 1, &ewmh[j].atom); } ewmh_update_desktops(); ewmh_get_desktop_names(); } void teardown_ewmh(void) { int i, num_screens; xcb_window_t id; xcb_get_property_cookie_t pc; xcb_get_property_reply_t *pr; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { /* Get the support check window and destroy it */ pc = xcb_get_property(conn, 0, screens[i].root, a_net_wm_check, XCB_ATOM_WINDOW, 0, 1); pr = xcb_get_property_reply(conn, pc, NULL); if (pr == NULL) continue; if (pr->format == a_net_wm_check) { id = *((xcb_window_t *)xcb_get_property_value(pr)); xcb_destroy_window(conn, id); xcb_delete_property(conn, screens[i].root, a_net_wm_check); xcb_delete_property(conn, screens[i].root, a_net_supported); } free(pr); } } void ewmh_autoquirk(struct ws_win *win) { xcb_get_property_reply_t *r; xcb_get_property_cookie_t c; xcb_atom_t *type; int i, n; c = xcb_get_property(conn, 0, win->id, ewmh[_NET_WM_WINDOW_TYPE].atom, XCB_ATOM_ATOM, 0, UINT32_MAX); r = xcb_get_property_reply(conn, c, NULL); if (r == NULL) return; type = xcb_get_property_value(r); n = xcb_get_property_value_length(r) / sizeof(xcb_atom_t); for (i = 0; i < n; i++) { if (type[i] == ewmh[_NET_WM_WINDOW_TYPE_NORMAL].atom) break; if (type[i] == ewmh[_NET_WM_WINDOW_TYPE_DOCK].atom || type[i] == ewmh[_NET_WM_WINDOW_TYPE_TOOLBAR].atom || type[i] == ewmh[_NET_WM_WINDOW_TYPE_UTILITY].atom) { win->quirks = SWM_Q_FLOAT | SWM_Q_ANYWHERE; break; } if (type[i] == ewmh[_NET_WM_WINDOW_TYPE_SPLASH].atom || type[i] == ewmh[_NET_WM_WINDOW_TYPE_DIALOG].atom) { win->quirks = SWM_Q_FLOAT; break; } } free(r); } void ewmh_update_actions(struct ws_win *win) { xcb_atom_t actions[SWM_EWMH_ACTION_COUNT_MAX]; int n = 0; if (win == NULL) return; actions[n++] = ewmh[_NET_WM_ACTION_CLOSE].atom; if (ABOVE(win)) { actions[n++] = ewmh[_NET_WM_ACTION_MOVE].atom; actions[n++] = ewmh[_NET_WM_ACTION_RESIZE].atom; actions[n++] = ewmh[_NET_WM_ACTION_ABOVE].atom; } xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, ewmh[_NET_WM_ALLOWED_ACTIONS].atom, XCB_ATOM_ATOM, 32, 1, actions); } #define _NET_WM_STATE_REMOVE 0 /* remove/unset property */ #define _NET_WM_STATE_ADD 1 /* add/set property */ #define _NET_WM_STATE_TOGGLE 2 /* toggle property */ void ewmh_change_wm_state(struct ws_win *win, xcb_atom_t state, long action) { uint32_t flag = 0; uint32_t new_flags; #ifdef SWM_DEBUG char *name; name = get_atom_name(state); DNPRINTF(SWM_D_PROP, "win %#x, state: %s, " "action: %ld\n", WINID(win), name, action); free(name); #endif if (win == NULL) goto out; if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom) flag = EWMH_F_FULLSCREEN; else if (state == ewmh[_NET_WM_STATE_ABOVE].atom) flag = EWMH_F_ABOVE; else if (state == ewmh[_NET_WM_STATE_HIDDEN].atom) flag = EWMH_F_HIDDEN; else if (state == ewmh[_NET_WM_STATE_MAXIMIZED_VERT].atom || state == ewmh[_NET_WM_STATE_MAXIMIZED_HORZ].atom) flag = EWMH_F_MAXIMIZED; else if (state == ewmh[_SWM_WM_STATE_MANUAL].atom) flag = SWM_F_MANUAL; else if (state == ewmh[_NET_WM_STATE_SKIP_PAGER].atom) flag = EWMH_F_SKIP_PAGER; else if (state == ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom) flag = EWMH_F_SKIP_TASKBAR; /* Disallow unfloating transients. */ if (TRANS(win) && flag == EWMH_F_ABOVE) goto out; new_flags = win->ewmh_flags; switch (action) { case _NET_WM_STATE_REMOVE: new_flags &= ~flag; break; case _NET_WM_STATE_ADD: new_flags |= flag; break; case _NET_WM_STATE_TOGGLE: new_flags ^= flag; break; } ewmh_apply_flags(win, new_flags); out: DNPRINTF(SWM_D_PROP, "done\n"); } void ewmh_apply_flags(struct ws_win *win, uint32_t pending) { struct workspace *ws; uint32_t changed; changed = win->ewmh_flags ^ pending; if (changed == 0) return; DNPRINTF(SWM_D_PROP, "pending: %d\n", pending); win->ewmh_flags = pending; ws = win->ws; if (changed & EWMH_F_HIDDEN) { if (ICONIC(win)) { if (focus_mode != SWM_FOCUS_FOLLOW) ws->focus_pending = get_focus_prev(win); unfocus_win(win); unmap_window(win); } else { /* Reload floating geometry in case region changed. */ if (FLOATING(win)) load_float_geom(win); /* The window is no longer iconic, prepare focus. */ if (focus_mode != SWM_FOCUS_FOLLOW) ws->focus_pending = get_focus_magic(win); raise_window(win); } } if (changed & EWMH_F_ABOVE) { if (ws->cur_layout != &layouts[SWM_MAX_STACK]) { if (ABOVE(win)) load_float_geom(win); else if (!MAXIMIZED(win)) store_float_geom(win); win->ewmh_flags &= ~EWMH_F_MAXIMIZED; changed &= ~EWMH_F_MAXIMIZED; raise_window(win); } else { /* Revert. */ win->ewmh_flags ^= EWMH_F_ABOVE & pending; } } if (changed & EWMH_F_MAXIMIZED) { /* VERT and/or HORZ changed. */ if (ABOVE(win)) { if (!MAXIMIZED(win)) load_float_geom(win); else store_float_geom(win); } if (MAXIMIZED(win)) { if (focus_mode != SWM_FOCUS_FOLLOW && ws->cur_layout != &layouts[SWM_MAX_STACK]) { if (WS_FOCUSED(ws)) focus_win(win); else ws->focus_pending = win; } } draw_frame(win); raise_window(win); } if (changed & EWMH_F_FULLSCREEN) { if (FULLSCREEN(win)) { if (focus_mode != SWM_FOCUS_FOLLOW) { if (WS_FOCUSED(ws)) focus_win(win); else ws->focus_pending = win; } } else { load_float_geom(win); } win->ewmh_flags &= ~EWMH_F_MAXIMIZED; raise_window(win); } DNPRINTF(SWM_D_PROP, "done\n"); } void ewmh_update_wm_state(struct ws_win *win) { xcb_atom_t vals[SWM_EWMH_ACTION_COUNT_MAX]; int n = 0; if (ICONIC(win)) vals[n++] = ewmh[_NET_WM_STATE_HIDDEN].atom; if (FULLSCREEN(win)) vals[n++] = ewmh[_NET_WM_STATE_FULLSCREEN].atom; if (MAXIMIZED_VERT(win)) vals[n++] = ewmh[_NET_WM_STATE_MAXIMIZED_VERT].atom; if (MAXIMIZED_HORZ(win)) vals[n++] = ewmh[_NET_WM_STATE_MAXIMIZED_HORZ].atom; if (win->ewmh_flags & EWMH_F_SKIP_PAGER) vals[n++] = ewmh[_NET_WM_STATE_SKIP_PAGER].atom; if (win->ewmh_flags & EWMH_F_SKIP_TASKBAR) vals[n++] = ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom; if (win->ewmh_flags & EWMH_F_ABOVE) vals[n++] = ewmh[_NET_WM_STATE_ABOVE].atom; if (win->ewmh_flags & SWM_F_MANUAL) vals[n++] = ewmh[_SWM_WM_STATE_MANUAL].atom; if (n > 0) xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, n, vals); else xcb_delete_property(conn, win->id, ewmh[_NET_WM_STATE].atom); } void ewmh_get_wm_state(struct ws_win *win) { xcb_atom_t *states; xcb_get_property_cookie_t c; xcb_get_property_reply_t *r; int i, n; if (win == NULL) return; win->ewmh_flags = 0; c = xcb_get_property(conn, 0, win->id, ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 0, UINT32_MAX); r = xcb_get_property_reply(conn, c, NULL); if (r == NULL) return; states = xcb_get_property_value(r); n = xcb_get_property_value_length(r) / sizeof(xcb_atom_t); for (i = 0; i < n; i++) ewmh_change_wm_state(win, states[i], _NET_WM_STATE_ADD); free(r); } /* events */ #ifdef SWM_DEBUG void dumpwins(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *w; uint32_t state; xcb_get_window_attributes_cookie_t c; xcb_get_window_attributes_reply_t *wa; /* suppress unused warning since var is needed */ (void)bp; (void)args; if (r->ws == NULL) { DPRINTF("dumpwins: invalid workspace\n"); return; } DPRINTF("=== managed window list ws %02d ===\n", r->ws->idx); TAILQ_FOREACH(w, &r->ws->winlist, entry) { state = get_win_state(w->id); c = xcb_get_window_attributes(conn, w->id); wa = xcb_get_window_attributes_reply(conn, c, NULL); if (wa) { DPRINTF("win %#x (%#x), map_state: %d, state: %u, " "transient: %#x\n", w->frame, w->id, wa->map_state, state, w->transient); free(wa); } else DPRINTF("win %#x, failed xcb_get_window_attributes\n", w->id); } DPRINTF("=== stacking order (top down) === \n"); TAILQ_FOREACH(w, &r->ws->stack, stack_entry) { DPRINTF("win %#x (%#x), fs: %s, maximized: %s, above: %s, " "iconic: %s\n", w->frame, w->id, YESNO(FULLSCREEN(w)), YESNO(MAXIMIZED(w)), YESNO(ABOVE(w)), YESNO(ICONIC(w))); } DPRINTF("===== unmanaged window list =====\n"); TAILQ_FOREACH(w, &r->ws->unmanagedlist, entry) { state = get_win_state(w->id); c = xcb_get_window_attributes(conn, w->id); wa = xcb_get_window_attributes_reply(conn, c, NULL); if (wa) { DPRINTF("win %#x, map_state: %d, state: %u, " "transient: %#x\n", w->id, wa->map_state, state, w->transient); free(wa); } else DPRINTF("win %#x, failed xcb_get_window_attributes\n", w->id); } DPRINTF("=================================\n"); } void debug_toggle(struct binding *b, struct swm_region *r, union arg *s) { struct ws_win *win; int num_screens, i, j; /* Suppress warnings. */ (void)b; (void)r; (void)s; debug_enabled = !debug_enabled; DNPRINTF(SWM_D_MISC, "debug_enabled: %s\n", YESNO(debug_enabled)); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) for (j = 0; j < workspace_limit; j++) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) debug_refresh(win); xcb_flush(conn); } void debug_refresh(struct ws_win *win) { struct ws_win *w; XftDraw *draw; XGlyphInfo info; GC l_draw; XGCValues l_gcv; XRectangle l_ibox, l_lbox; xcb_rectangle_t rect; size_t len; uint32_t wc[4], mask, width, height, gcv[1]; int widx, sidx; char *s; xcb_screen_t *screen; if (debug_enabled) { /* Create debug window if it doesn't exist. */ if (win->debug == XCB_WINDOW_NONE) { if ((screen = get_screen(win->s->idx)) == NULL) errx(1, "ERROR: can't get screen %d.", win->s->idx); win->debug = xcb_generate_id(conn); wc[0] = win->s->c[SWM_S_COLOR_BAR].pixel; wc[1] = win->s->c[SWM_S_COLOR_BAR_BORDER].pixel; wc[2] = win->s->colormap; xcb_create_window(conn, win->s->depth, win->debug, win->frame, 0, 0, 10, 10, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT, win->s->visual, XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP, wc); xcb_map_window(conn, win->debug); } /* Determine workspace window list index. */ widx = 0; TAILQ_FOREACH(w, &win->ws->winlist, entry) { ++widx; if (w == win) break; } /* Determine stacking index (top down). */ sidx = 0; TAILQ_FOREACH(w, &win->ws->stack, stack_entry) { ++sidx; if (w == win) break; } if (asprintf(&s, "%#x f:%#x wl:%d s:%d visual: %#x " "colormap: %#x im: %s", win->id, win->frame, widx, sidx, win->s->visual, win->s->colormap, get_win_input_model(win)) == -1) return; len = strlen(s); /* Update window to an appropriate dimension. */ if (bar_font_legacy) { XmbTextExtents(bar_fs, s, len, &l_ibox, &l_lbox); width = l_lbox.width + 4; height = bar_fs_extents->max_logical_extent.height + 4; } else { XftTextExtentsUtf8(display, bar_font, (FcChar8 *)s, len, &info); width = info.width + 4; height = bar_font->height + 4; } mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT; if (win->bordered) wc[0] = wc[1] = border_width; else wc[0] = wc[1] = 0; wc[2] = width; wc[3] = height; xcb_configure_window(conn, win->debug, mask, wc); /* Draw a filled rectangle to 'clear' window. */ rect.x = 0; rect.y = 0; rect.width = width; rect.height = height; gcv[0] = win->s->c[SWM_S_COLOR_BAR].pixel; xcb_change_gc(conn, win->s->gc, XCB_GC_FOREGROUND, gcv); xcb_poly_fill_rectangle(conn, win->debug, win->s->gc, 1, &rect); /* Draw text. */ if (bar_font_legacy) { l_gcv.graphics_exposures = 0; l_draw = XCreateGC(display, win->debug, 0, &l_gcv); XSetForeground(display, l_draw, win->s->c[SWM_S_COLOR_BAR_FONT].pixel); DRAWSTRING(display, win->debug, bar_fs, l_draw, 2, (bar_fs_extents->max_logical_extent.height - l_lbox.height) / 2 - l_lbox.y, s, len); XFreeGC(display, l_draw); } else { draw = XftDrawCreate(display, win->debug, win->s->xvisual, win->s->colormap); XftDrawStringUtf8(draw, &bar_font_color, bar_font, 2, (bar_height + bar_font->height) / 2 - bar_font->descent, (FcChar8 *)s, len); XftDrawDestroy(draw); } free(s); } else if (win->debug != XCB_WINDOW_NONE) { xcb_destroy_window(conn, win->debug); win->debug = XCB_WINDOW_NONE; } } #else void dumpwins(struct binding *b, struct swm_region *r, union arg *s) { (void)b; (void)r; (void)s; } void debug_toggle(struct binding *b, struct swm_region *r, union arg *s) { (void)b; (void)r; (void)s; } #endif /* SWM_DEBUG */ void sighdlr(int sig) { int saved_errno, status; pid_t pid; saved_errno = errno; switch (sig) { case SIGCHLD: while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) != 0) { if (pid == -1) { if (errno == EINTR) continue; #ifdef SWM_DEBUG if (errno != ECHILD) warn("sighdlr: waitpid"); #endif /* SWM_DEBUG */ break; } if (pid == searchpid) search_resp = 1; #ifdef SWM_DEBUG if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) warnx("sighdlr: child exit status: %d", WEXITSTATUS(status)); } else warnx("sighdlr: child is terminated " "abnormally"); #endif /* SWM_DEBUG */ } break; case SIGHUP: restart_wm = 1; break; case SIGINT: case SIGTERM: case SIGQUIT: running = 0; break; } errno = saved_errno; } struct pid_e * find_pid(pid_t pid) { struct pid_e *p = NULL; DNPRINTF(SWM_D_MISC, "pid: %d\n", pid); if (pid == 0) return (NULL); TAILQ_FOREACH(p, &pidlist, entry) { if (p->pid == pid) return (p); } return (NULL); } uint32_t name_to_pixel(struct swm_screen *s, const char *colorname) { uint32_t result = 0; char cname[32] = "#"; xcb_alloc_color_reply_t *cr; xcb_alloc_named_color_reply_t *nr; uint16_t rr, gg, bb; /* color is in format rgb://rr/gg/bb */ if (strncmp(colorname, "rgb:", 4) == 0) { if (parse_rgb(colorname, &rr, &gg, &bb) == -1) warnx("could not parse rgb %s", colorname); else { cr = xcb_alloc_color_reply(conn, xcb_alloc_color(conn, s->colormap, rr, gg, bb), NULL); if (cr) { result = cr->pixel; free(cr); } else warnx("color '%s' not found", colorname); } } else { nr = xcb_alloc_named_color_reply(conn, xcb_alloc_named_color(conn, s->colormap, strlen(colorname), colorname), NULL); if (nr == NULL) { strlcat(cname, colorname + 2, sizeof cname - 1); nr = xcb_alloc_named_color_reply(conn, xcb_alloc_named_color(conn, s->colormap, strlen(cname), cname), NULL); } if (nr) { result = nr->pixel; free(nr); } else warnx("color '%s' not found", colorname); } return (result); } void setscreencolor(const char *val, int i, int c) { if (i < 0 || i >= get_screen_count()) return; screens[i].c[c].pixel = name_to_pixel(&screens[i], val); free(screens[i].c[c].name); if ((screens[i].c[c].name = strdup(val)) == NULL) err(1, "strdup"); } void fancy_stacker(struct workspace *ws) { strlcpy(ws->stacker, "[ ]", sizeof ws->stacker); if (ws->cur_layout->l_stack == vertical_stack) snprintf(ws->stacker, sizeof ws->stacker, ws->l_state.vertical_flip ? "[%d>%d]" : "[%d|%d]", ws->l_state.vertical_mwin, ws->l_state.vertical_stacks); else if (ws->cur_layout->l_stack == horizontal_stack) snprintf(ws->stacker, sizeof ws->stacker, ws->l_state.horizontal_flip ? "[%dv%d]" : "[%d-%d]", ws->l_state.horizontal_mwin, ws->l_state.horizontal_stacks); } void plain_stacker(struct workspace *ws) { strlcpy(ws->stacker, "[ ]", sizeof ws->stacker); if (ws->cur_layout->l_stack == vertical_stack) strlcpy(ws->stacker, ws->l_state.vertical_flip ? "[>]" : "[|]", sizeof ws->stacker); else if (ws->cur_layout->l_stack == horizontal_stack) strlcpy(ws->stacker, ws->l_state.horizontal_flip ? "[v]" : "[-]", sizeof ws->stacker); } void custom_region(const char *val) { unsigned int x, y, w, h; int sidx, num_screens; xcb_screen_t *screen; DNPRINTF(SWM_D_CONF, "%s\n", val); num_screens = get_screen_count(); if (sscanf(val, "screen[%d]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5) errx(1, "invalid custom region, " "should be 'screen[]:x++"); if (sidx < 1 || sidx > num_screens) errx(1, "invalid screen index: %d out of bounds (maximum %d)", sidx, num_screens); sidx--; if ((screen = get_screen(sidx)) == NULL) errx(1, "ERROR: can't get screen %d.", sidx); if (w < 1 || h < 1) errx(1, "region %ux%u+%u+%u too small", w, h, x, y); if (x > screen->width_in_pixels || y > screen->height_in_pixels || w + x > screen->width_in_pixels || h + y > screen->height_in_pixels) { warnx("ignoring region %ux%u+%u+%u - not within screen " "boundaries (%ux%u)", w, h, x, y, screen->width_in_pixels, screen->height_in_pixels); return; } new_region(&screens[sidx], x, y, w, h); } void socket_setnonblock(int fd) { int flags; if ((flags = fcntl(fd, F_GETFL, 0)) == -1) err(1, "fcntl F_GETFL"); flags |= O_NONBLOCK; if ((flags = fcntl(fd, F_SETFL, flags)) == -1) err(1, "fcntl F_SETFL"); } void bar_print_legacy(struct swm_region *r, const char *s) { xcb_rectangle_t rect; uint32_t gcv[1]; XGCValues gcvd; int x = 0; size_t len; XRectangle ibox, lbox; GC draw; len = strlen(s); XmbTextExtents(bar_fs, s, len, &ibox, &lbox); switch (bar_justify) { case SWM_BAR_JUSTIFY_LEFT: x = SWM_BAR_OFFSET; break; case SWM_BAR_JUSTIFY_CENTER: x = (WIDTH(r) - lbox.width) / 2; break; case SWM_BAR_JUSTIFY_RIGHT: x = WIDTH(r) - lbox.width - SWM_BAR_OFFSET; break; } if (x < SWM_BAR_OFFSET) x = SWM_BAR_OFFSET; /* clear back buffer */ rect.x = 0; rect.y = 0; rect.width = WIDTH(r->bar); rect.height = HEIGHT(r->bar); gcv[0] = r->s->c[SWM_S_COLOR_BAR].pixel; xcb_change_gc(conn, r->s->gc, XCB_GC_FOREGROUND, gcv); xcb_poly_fill_rectangle(conn, r->bar->buffer, r->s->gc, 1, &rect); /* draw back buffer */ gcvd.graphics_exposures = 0; draw = XCreateGC(display, r->bar->buffer, GCGraphicsExposures, &gcvd); XSetForeground(display, draw, r->s->c[SWM_S_COLOR_BAR_FONT].pixel); DRAWSTRING(display, r->bar->buffer, bar_fs, draw, x, (bar_fs_extents->max_logical_extent.height - lbox.height) / 2 - lbox.y, s, len); XFreeGC(display, draw); /* blt */ xcb_copy_area(conn, r->bar->buffer, r->bar->id, r->s->gc, 0, 0, 0, 0, WIDTH(r->bar), HEIGHT(r->bar)); } void bar_print(struct swm_region *r, const char *s) { size_t len; xcb_rectangle_t rect; uint32_t gcv[1]; int32_t x = 0; XGlyphInfo info; XftDraw *draw; len = strlen(s); XftTextExtentsUtf8(display, bar_font, (FcChar8 *)s, len, &info); switch (bar_justify) { case SWM_BAR_JUSTIFY_LEFT: x = SWM_BAR_OFFSET; break; case SWM_BAR_JUSTIFY_CENTER: x = (WIDTH(r) - info.width) / 2; break; case SWM_BAR_JUSTIFY_RIGHT: x = WIDTH(r) - info.width - SWM_BAR_OFFSET; break; } if (x < SWM_BAR_OFFSET) x = SWM_BAR_OFFSET; /* clear back buffer */ rect.x = 0; rect.y = 0; rect.width = WIDTH(r->bar); rect.height = HEIGHT(r->bar); gcv[0] = r->s->c[SWM_S_COLOR_BAR].pixel; xcb_change_gc(conn, r->s->gc, XCB_GC_FOREGROUND, gcv); xcb_poly_fill_rectangle(conn, r->bar->buffer, r->s->gc, 1, &rect); /* draw back buffer */ draw = XftDrawCreate(display, r->bar->buffer, r->s->xvisual, r->s->colormap); XftDrawStringUtf8(draw, &bar_font_color, bar_font, x, (HEIGHT(r->bar) + bar_font->height) / 2 - bar_font->descent, (FcChar8 *)s, len); XftDrawDestroy(draw); /* blt */ xcb_copy_area(conn, r->bar->buffer, r->bar->id, r->s->gc, 0, 0, 0, 0, WIDTH(r->bar), HEIGHT(r->bar)); } void bar_extra_stop(void) { if (bar_pipe[0]) { close(bar_pipe[0]); bzero(bar_pipe, sizeof bar_pipe); } if (bar_pid) { kill(bar_pid, SIGTERM); bar_pid = 0; } strlcpy(bar_ext, "", sizeof bar_ext); bar_extra = false; } void bar_window_class(char *s, size_t sz, struct swm_region *r) { if (r == NULL || r->ws == NULL || r->ws->focus == NULL) return; if (r->ws->focus->ch.class_name != NULL) strlcat(s, r->ws->focus->ch.class_name, sz); } void bar_window_instance(char *s, size_t sz, struct swm_region *r) { if (r == NULL || r->ws == NULL || r->ws->focus == NULL) return; if (r->ws->focus->ch.instance_name != NULL) strlcat(s, r->ws->focus->ch.instance_name, sz); } void bar_window_class_instance(char *s, size_t sz, struct swm_region *r) { if (r == NULL || r->ws == NULL || r->ws->focus == NULL) return; bar_window_class(s, sz, r); strlcat(s, ":", sz); bar_window_instance(s, sz, r); } void bar_window_state(char *s, size_t sz, struct swm_region *r) { if (r == NULL || r ->ws == NULL || r->ws->focus == NULL) return; if (MAXIMIZED(r->ws->focus)) strlcat(s, "(m)", sz); else if (ABOVE(r->ws->focus)) strlcat(s, "(f)", sz); } void bar_window_name(char *s, size_t sz, struct swm_region *r) { char *title; if (r == NULL || r->ws == NULL || r->ws->focus == NULL) return; title = get_win_name(r->ws->focus->id); strlcat(s, title, sz); free(title); } bool get_urgent(struct ws_win *win) { xcb_icccm_wm_hints_t hints; xcb_get_property_cookie_t c; bool urgent = false; if (win) { c = xcb_icccm_get_wm_hints(conn, win->id); if (xcb_icccm_get_wm_hints_reply(conn, c, &hints, NULL)) urgent = xcb_icccm_wm_hints_get_urgency(&hints); } return (urgent); } void bar_urgent(char *s, size_t sz) { struct ws_win *win; int i, j, num_screens, urgent[SWM_WS_MAX]; char b[8]; memset(&urgent, 0, sizeof(urgent)); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) for (j = 0; j < workspace_limit; j++) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) if (get_urgent(win)) urgent[j] = 1; for (i = 0; i < workspace_limit; i++) { if (urgent[i]) { snprintf(b, sizeof b, "%d ", i + 1); strlcat(s, b, sz); } else if (!urgent_collapse) { strlcat(s, "- ", sz); } } if (urgent_collapse && s[0]) s[strlen(s) - 1] = 0; } void bar_workspace_indicator(char *s, size_t sz, struct swm_region *r) { struct ws_win *w; struct workspace *ws; int i, count = 0; char tmp[SWM_BAR_MAX], *mark; bool current, active, named, urgent, collapse; if (r == NULL) return; for (i = 0; i < workspace_limit; i++) { ws = &r->s->ws[i]; current = (ws == r->ws); named = (ws->name != NULL); urgent = false; active = false; TAILQ_FOREACH(w, &ws->winlist, entry) { active = true; /* Only get urgent if needed. */ if (!(workspace_indicator & SWM_WSI_LISTURGENT || workspace_indicator & SWM_WSI_MARKURGENT) || (urgent = get_urgent(w))) break; } collapse = !(workspace_indicator & SWM_WSI_MARKCURRENT || workspace_indicator & SWM_WSI_MARKURGENT); if (!(current && workspace_indicator & SWM_WSI_HIDECURRENT) && ((current && workspace_indicator & SWM_WSI_LISTCURRENT) || (active && workspace_indicator & SWM_WSI_LISTACTIVE) || (!active && workspace_indicator & SWM_WSI_LISTEMPTY) || (urgent && workspace_indicator & SWM_WSI_LISTURGENT) || (named && workspace_indicator & SWM_WSI_LISTNAMED))) { if (count > 0) strlcat(s, " ", sz); if (current && workspace_indicator & SWM_WSI_MARKCURRENT) mark = "*"; else if (urgent && workspace_indicator & SWM_WSI_MARKURGENT) mark = "!"; else if (!collapse) mark = " "; else mark = ""; strlcat(s, mark, sz); if (named && workspace_indicator & SWM_WSI_PRINTNAMES) snprintf(tmp, sizeof tmp, "%d:%s", ws->idx + 1, ws->name); else snprintf(tmp, sizeof tmp, "%d", ws->idx + 1); strlcat(s, tmp, sz); count++; } } } void bar_workspace_name(char *s, size_t sz, struct swm_region *r) { if (r == NULL || r->ws == NULL) return; if (r->ws->name != NULL) strlcat(s, r->ws->name, sz); } /* build the default bar format according to the defined enabled options */ void bar_fmt(const char *fmtexp, char *fmtnew, struct swm_region *r, size_t sz) { struct ws_win *w; /* if format provided, just copy the buffers */ if (bar_format != NULL) { strlcpy(fmtnew, fmtexp, sz); return; } /* reset the output buffer */ *fmtnew = '\0'; strlcat(fmtnew, "+N:+I ", sz); if (stack_enabled) strlcat(fmtnew, "+S", sz); strlcat(fmtnew, " ", sz); /* only show the workspace name if there's actually one */ if (r != NULL && r->ws != NULL && r->ws->name != NULL) strlcat(fmtnew, "<+D>", sz); /* If enabled, only show the iconic count if there are iconic wins. */ if (iconic_enabled && r != NULL && r->ws != NULL) TAILQ_FOREACH(w, &r->ws->winlist, entry) if (ICONIC(w)) { strlcat(fmtnew, "{+M}", sz); break; } strlcat(fmtnew, "+3<", sz); if (clock_enabled) { strlcat(fmtnew, fmtexp, sz); strlcat(fmtnew, "+4<", sz); } /* bar_urgent already adds the space before the last asterisk */ if (urgent_enabled) strlcat(fmtnew, (urgent_collapse ? "*+U*+4<" : "* +U*+4<"), sz); if (window_class_enabled) { strlcat(fmtnew, "+C", sz); if (!window_instance_enabled) strlcat(fmtnew, "+4<", sz); } /* checks needed by the colon and floating strlcat(3) calls below */ if (r != NULL && r->ws != NULL && r->ws->focus != NULL) { if (window_instance_enabled) { if (window_class_enabled) strlcat(fmtnew, ":", sz); strlcat(fmtnew, "+T+4<", sz); } if (window_name_enabled) { if (ABOVE(r->ws->focus) || MAXIMIZED(r->ws->focus)) strlcat(fmtnew, "+F ", sz); strlcat(fmtnew, "+64W ", sz); } } /* finally add the action script output and the version */ strlcat(fmtnew, "+4<+A+4<+V", sz); } void bar_replace_pad(char *tmp, int *limit, size_t sz) { /* special case; no limit given, pad one space, instead */ if (*limit == (int)sz - 1) *limit = 1; snprintf(tmp, sz, "%*s", *limit, " "); } /* replaces the bar format character sequences (like in tmux(1)) */ char * bar_replace_seq(char *fmt, char *fmtrep, struct swm_region *r, size_t *offrep, size_t sz) { struct ws_win *w; char *ptr, *cur = fmt; char tmp[SWM_BAR_MAX]; int limit, size, count; size_t len; int pre_padding = 0; int post_padding = 0; int padding_len = 0; /* Reset replace buffer. */ bzero(tmp, sizeof tmp); cur++; /* determine if pre-padding is requested */ if (*cur == '_') { pre_padding = 1; cur++; } /* get number, if any */ size = 0; if (sscanf(cur, "%d%n", &limit, &size) != 1) limit = sizeof tmp - 1; if (limit <= 0 || limit >= (int)sizeof tmp) limit = sizeof tmp - 1; cur += size; /* determine if post padding is requested */ if (*cur == '_') { post_padding = 1; cur++; } /* character sequence */ switch (*cur) { case '<': bar_replace_pad(tmp, &limit, sizeof tmp); break; case 'A': snprintf(tmp, sizeof tmp, "%s", bar_ext); break; case 'C': bar_window_class(tmp, sizeof tmp, r); break; case 'D': bar_workspace_name(tmp, sizeof tmp, r); break; case 'F': bar_window_state(tmp, sizeof tmp, r); break; case 'I': snprintf(tmp, sizeof tmp, "%d", r->ws->idx + 1); break; case 'L': bar_workspace_indicator(tmp, sizeof tmp, r); break; case 'M': count = 0; TAILQ_FOREACH(w, &r->ws->winlist, entry) if (ICONIC(w)) ++count; snprintf(tmp, sizeof tmp, "%d", count); break; case 'N': snprintf(tmp, sizeof tmp, "%d", r->s->idx + 1); break; case 'P': bar_window_class_instance(tmp, sizeof tmp, r); break; case 'R': snprintf(tmp, sizeof tmp, "%d", get_region_index(r) + 1); break; case 'S': snprintf(tmp, sizeof tmp, "%s", r->ws->stacker); break; case 'T': bar_window_instance(tmp, sizeof tmp, r); break; case 'U': bar_urgent(tmp, sizeof tmp); break; case 'V': snprintf(tmp, sizeof tmp, "%s", bar_vertext); break; case 'W': bar_window_name(tmp, sizeof tmp, r); break; default: /* Unknown character sequence or EOL; copy as-is. */ strlcpy(tmp, fmt, cur - fmt + 2); break; } len = strlen(tmp); /* calculate the padding lengths */ padding_len = limit - (int)len; if (padding_len > 0) { limit = len; if (pre_padding) pre_padding = padding_len / (pre_padding + post_padding); if (post_padding) post_padding = padding_len - pre_padding; } else { pre_padding = 0; post_padding = 0; } /* do pre padding */ while (pre_padding-- > 0) { if (*offrep >= sz - 1) break; fmtrep[(*offrep)++] = ' '; } ptr = tmp; while (limit-- > 0) { if (*offrep >= sz - 1) break; fmtrep[(*offrep)++] = *ptr++; } /* do post padding */ while (post_padding-- > 0) { if (*offrep >= sz - 1) break; fmtrep[(*offrep)++] = ' '; } if (*cur != '\0') cur++; return (cur); } void bar_replace(char *fmt, char *fmtrep, struct swm_region *r, size_t sz) { size_t off; off = 0; while (*fmt != '\0') { if (*fmt != '+') { /* skip ordinary characters */ if (off >= sz - 1) break; fmtrep[off++] = *fmt++; continue; } /* character sequence found; replace it */ fmt = bar_replace_seq(fmt, fmtrep, r, &off, sz); if (off >= sz - 1) break; } fmtrep[off] = '\0'; } void bar_fmt_expand(char *fmtexp, size_t sz) { char *fmt = NULL; size_t len; struct tm tm; time_t tmt; /* start by grabbing the current time and date */ time(&tmt); localtime_r(&tmt, &tm); /* figure out what to expand */ if (bar_format != NULL) fmt = bar_format; else if (bar_format == NULL && clock_enabled) fmt = clock_format; /* if nothing to expand bail out */ if (fmt == NULL) { *fmtexp = '\0'; return; } /* copy as-is, just in case the format shouldn't be expanded below */ strlcpy(fmtexp, fmt, sz); /* finally pass the string through strftime(3) */ #ifndef SWM_DENY_CLOCK_FORMAT if ((len = strftime(fmtexp, sz, fmt, &tm)) == 0) warnx("format too long"); fmtexp[len] = '\0'; #endif } /* Redraws a region bar; need to follow with xcb_flush() or focus_flush(). */ void bar_draw(struct swm_bar *bar) { struct swm_region *r; char fmtexp[SWM_BAR_MAX], fmtnew[SWM_BAR_MAX]; char fmtrep[SWM_BAR_MAX]; /* expand the format by first passing it through strftime(3) */ bar_fmt_expand(fmtexp, sizeof fmtexp); if (bar == NULL) return; r = bar->r; if (bar_enabled && r->ws->bar_enabled) xcb_map_window(conn, bar->id); else { xcb_unmap_window(conn, bar->id); return; } if (startup_exception) snprintf(fmtrep, sizeof fmtrep, "total " "exceptions: %d, first exception: %s", nr_exceptions, startup_exception); else { bar_fmt(fmtexp, fmtnew, r, sizeof fmtnew); bar_replace(fmtnew, fmtrep, r, sizeof fmtrep); } if (bar_font_legacy) bar_print_legacy(r, fmtrep); else bar_print(r, fmtrep); } /* * Reads external script output; call when stdin is readable. * Returns 1 if bar_ext was updated; otherwise 0. */ int bar_extra_update(void) { size_t len; char b[SWM_BAR_MAX]; bool changed = false; if (!bar_extra) return (changed); while (fgets(b, sizeof(b), stdin) != NULL) { if (bar_enabled) { len = strlen(b); if (len > 0 && b[len - 1] == '\n') { /* Remove newline. */ b[--len] = '\0'; /* "Clear" bar_ext. */ bar_ext[0] = '\0'; /* Flush buffered output. */ strlcpy(bar_ext, bar_ext_buf, sizeof(bar_ext)); bar_ext_buf[0] = '\0'; /* Append new output to bar. */ strlcat(bar_ext, b, sizeof(bar_ext)); changed = true; } else { /* Buffer output. */ strlcat(bar_ext_buf, b, sizeof(bar_ext_buf)); } } } if (errno != EAGAIN) { warn("bar_action failed"); bar_extra_stop(); changed = true; } return (changed); } void bar_toggle(struct binding *bp, struct swm_region *r, union arg *args) { struct swm_region *tmpr; int i, num_screens; /* suppress unused warnings since vars are needed */ (void)bp; (void)r; (void)args; switch (args->id) { case SWM_ARG_ID_BAR_TOGGLE_WS: /* Only change if master switch is enabled. */ if (bar_enabled) r->ws->bar_enabled = !r->ws->bar_enabled; else bar_enabled = r->ws->bar_enabled = true; DNPRINTF(SWM_D_BAR, "ws%d->bar_enabled: %s\n", r->ws->idx, YESNO(bar_enabled)); break; case SWM_ARG_ID_BAR_TOGGLE: bar_enabled = !bar_enabled; break; } DNPRINTF(SWM_D_BAR, "bar_enabled: %s\n", YESNO(bar_enabled)); /* update bars as necessary */ num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) TAILQ_FOREACH(tmpr, &screens[i].rl, entry) if (tmpr->bar) { if (bar_enabled && tmpr->ws->bar_enabled) xcb_map_window(conn, tmpr->bar->id); else xcb_unmap_window(conn, tmpr->bar->id); } /* Restack all regions and redraw bar. */ num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) TAILQ_FOREACH(tmpr, &screens[i].rl, entry) { stack(tmpr); bar_draw(tmpr->bar); } focus_flush(); } void bar_extra_setup(void) { /* do this here because the conf file is in memory */ if (!bar_extra && bar_argv[0]) { /* launch external status app */ bar_extra = true; if (pipe(bar_pipe) == -1) err(1, "pipe error"); socket_setnonblock(bar_pipe[0]); socket_setnonblock(bar_pipe[1]); /* XXX hmmm, really? */ /* Set stdin to read from the pipe. */ if (dup2(bar_pipe[0], STDIN_FILENO) == -1) err(1, "dup2"); /* Set stdout to write to the pipe. */ if (dup2(bar_pipe[1], STDOUT_FILENO) == -1) err(1, "dup2"); if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) err(1, "could not disable SIGPIPE"); switch (bar_pid = fork()) { case -1: err(1, "cannot fork"); break; case 0: /* child */ close(bar_pipe[0]); execvp(bar_argv[0], bar_argv); err(1, "%s external app failed", bar_argv[0]); break; default: /* parent */ close(bar_pipe[1]); break; } atexit(kill_bar_extra_atexit); } } void kill_bar_extra_atexit(void) { if (bar_pid) kill(bar_pid, SIGTERM); } bool isxlfd(char *s) { int count = 0; while ((s = index(s, '-'))) { ++count; ++s; } return (count == 14); } void fontset_init(void) { char *default_string; char **missing_charsets; int num_missing_charsets = 0; int i; if (bar_fs) { XFreeFontSet(display, bar_fs); bar_fs = NULL; } DNPRINTF(SWM_D_INIT, "loading bar_fonts: %s\n", bar_fonts); bar_fs = XCreateFontSet(display, bar_fonts, &missing_charsets, &num_missing_charsets, &default_string); if (num_missing_charsets > 0) { warnx("Unable to load charset(s):"); for (i = 0; i < num_missing_charsets; ++i) warnx("%s", missing_charsets[i]); XFreeStringList(missing_charsets); if(bar_fs && default_string) { if (strcmp(default_string, "")) warnx("Glyphs from those sets will be replaced " "by '%s'.", default_string); else warnx("Glyphs from those sets won't be drawn."); } } if (bar_fs == NULL) errx(1, "Error creating font set structure."); bar_fs_extents = XExtentsOfFontSet(bar_fs); bar_height = bar_fs_extents->max_logical_extent.height + 2 * bar_border_width; if (bar_height < 1) bar_height = 1; } void xft_init(struct swm_region *r) { char *font, *str, *search; XRenderColor color; if (bar_font == NULL) { if ((search = str = strdup(bar_fonts)) == NULL) errx(1, "insufficient memory."); while ((font = strsep(&search, ",")) != NULL) { if (*font == '\0') continue; DNPRINTF(SWM_D_INIT, "try font %s\n", font); if (isxlfd(font)) { bar_font = XftFontOpenXlfd(display, r->s->idx, font); } else { bar_font = XftFontOpenName(display, r->s->idx, font); } if (bar_font == NULL) { warnx("unable to load font %s", font); continue; } else { DNPRINTF(SWM_D_INIT, "successfully opened " "font %s\n", font); break; } } free(str); } if (bar_font == NULL) errx(1, "unable to open a font"); PIXEL_TO_XRENDERCOLOR(r->s->c[SWM_S_COLOR_BAR_FONT].pixel, color); if (!XftColorAllocValue(display, r->s->xvisual, r->s->colormap, &color, &bar_font_color)) warn("Xft error: unable to allocate color."); PIXEL_TO_XRENDERCOLOR(r->s->c[SWM_S_COLOR_BAR].pixel, color); if (!XftColorAllocValue(display, r->s->xvisual, r->s->colormap, &color, &search_font_color)) warn("Xft error: unable to allocate color."); bar_height = bar_font->height + 2 * bar_border_width; if (bar_height < 1) bar_height = 1; } void bar_setup(struct swm_region *r) { xcb_screen_t *screen; uint32_t wa[4]; DNPRINTF(SWM_D_BAR, "screen %d.\n", r->s->idx); if ((screen = get_screen(r->s->idx)) == NULL) errx(1, "ERROR: can't get screen %d.", r->s->idx); if (r->bar != NULL) return; if ((r->bar = calloc(1, sizeof(struct swm_bar))) == NULL) err(1, "bar_setup: calloc: failed to allocate memory."); if (bar_font_legacy) fontset_init(); else xft_init(r); r->bar->r = r; X(r->bar) = X(r); Y(r->bar) = bar_at_bottom ? (Y(r) + HEIGHT(r) - bar_height) : Y(r); WIDTH(r->bar) = WIDTH(r) - 2 * bar_border_width; HEIGHT(r->bar) = bar_height - 2 * bar_border_width; /* Assume region is unfocused when we create the bar. */ r->bar->id = xcb_generate_id(conn); wa[0] = r->s->c[SWM_S_COLOR_BAR].pixel; wa[1] = r->s->c[SWM_S_COLOR_BAR_BORDER_UNFOCUS].pixel; wa[2] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_POINTER_MOTION_HINT; wa[3] = r->s->colormap; xcb_create_window(conn, r->s->depth, r->bar->id, r->s->root, X(r->bar), Y(r->bar), WIDTH(r->bar), HEIGHT(r->bar), bar_border_width, XCB_WINDOW_CLASS_INPUT_OUTPUT, r->s->visual, XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_COLORMAP, wa); /* Stack bar window above region window to start. */ wa[0] = r->id; wa[1] = XCB_STACK_MODE_ABOVE; xcb_configure_window(conn, r->bar->id, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, wa); r->bar->buffer = xcb_generate_id(conn); xcb_create_pixmap(conn, r->s->depth, r->bar->buffer, r->bar->id, WIDTH(r->bar), HEIGHT(r->bar)); if (randr_support) xcb_randr_select_input(conn, r->bar->id, XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE); if (bar_enabled) xcb_map_window(conn, r->bar->id); DNPRINTF(SWM_D_BAR, "win %#x, (x,y) w x h: (%d,%d) %d x %d\n", WINID(r->bar), X(r->bar), Y(r->bar), WIDTH(r->bar), HEIGHT(r->bar)); bar_extra_setup(); } void bar_cleanup(struct swm_region *r) { if (r->bar == NULL) return; xcb_destroy_window(conn, r->bar->id); xcb_free_pixmap(conn, r->bar->buffer); free(r->bar); r->bar = NULL; } void set_win_state(struct ws_win *win, uint8_t state) { uint32_t data[2] = { state, XCB_ATOM_NONE }; DNPRINTF(SWM_D_EVENT, "win %#x, state: %s(%u)\n", WINID(win), get_wm_state_label(state), state); if (win == NULL) return; xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, a_state, a_state, 32, 2, data); } uint8_t get_win_state(xcb_window_t w) { xcb_get_property_reply_t *r; xcb_get_property_cookie_t c; uint32_t result = 0; c = xcb_get_property(conn, 0, w, a_state, a_state, 0L, 2L); r = xcb_get_property_reply(conn, c, NULL); if (r) { if (r->type == a_state && r->format == 32 && r->length == 2) result = *((uint32_t *)xcb_get_property_value(r)); free(r); } DNPRINTF(SWM_D_MISC, "property: win %#x, state: %s(%u)\n", w, get_wm_state_label(result), result); return (result); } void version(struct binding *bp, struct swm_region *r, union arg *args) { struct swm_region *tmpr; int i, num_screens; /* suppress unused warnings since vars are needed */ (void)bp; (void)r; (void)args; bar_version = !bar_version; if (bar_version) snprintf(bar_vertext, sizeof bar_vertext, "Version: %s Build: %s", SPECTRWM_VERSION, buildstr); else strlcpy(bar_vertext, "", sizeof bar_vertext); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { TAILQ_FOREACH(tmpr, &screens[i].rl, entry) { bar_draw(tmpr->bar); xcb_flush(conn); } } } void client_msg(struct ws_win *win, xcb_atom_t a, xcb_timestamp_t t) { xcb_client_message_event_t ev; #ifdef SWM_DEBUG char *name; #endif if (win == NULL) return; #ifdef SWM_DEBUG name = get_atom_name(a); DNPRINTF(SWM_D_EVENT, "win %#x, atom: %s(%u), time: %#x\n", win->id, name, a, t); free(name); #endif bzero(&ev, sizeof ev); ev.response_type = XCB_CLIENT_MESSAGE; ev.window = win->id; ev.type = a_prot; ev.format = 32; ev.data.data32[0] = a; ev.data.data32[1] = t; xcb_send_event(conn, 0, win->id, XCB_EVENT_MASK_NO_EVENT, (const char *)&ev); } /* synthetic response to a ConfigureRequest when not making a change */ void config_win(struct ws_win *win, xcb_configure_request_event_t *ev) { xcb_configure_notify_event_t ce; if (win == NULL) return; /* send notification of unchanged state. */ bzero(&ce, sizeof(ce)); ce.response_type = XCB_CONFIGURE_NOTIFY; ce.x = X(win); ce.y = Y(win); ce.width = WIDTH(win); ce.height = HEIGHT(win); ce.border_width = 0; ce.override_redirect = 0; if (ev == NULL) { /* EWMH */ ce.event = win->id; ce.window = win->id; ce.above_sibling = XCB_WINDOW_NONE; } else { /* normal */ ce.event = ev->window; ce.window = ev->window; /* make response appear more WM_SIZE_HINTS-compliant */ if (win->sh.flags) { DNPRINTF(SWM_D_MISC, "hints: win %#x, sh.flags: %u, " "min: %d x %d, max: %d x %d, inc: %d x %d\n", win->id, win->sh.flags, SH_MIN_W(win), SH_MIN_H(win), SH_MAX_W(win), SH_MAX_H(win), SH_INC_W(win), SH_INC_H(win)); } /* min size */ if (SH_MIN(win)) { /* the hint may be set... to 0! */ if (SH_MIN_W(win) > 0 && ce.width < SH_MIN_W(win)) ce.width = SH_MIN_W(win); if (SH_MIN_H(win) > 0 && ce.height < SH_MIN_H(win)) ce.height = SH_MIN_H(win); } /* max size */ if (SH_MAX(win)) { /* may also be advertized as 0 */ if (SH_MAX_W(win) > 0 && ce.width > SH_MAX_W(win)) ce.width = SH_MAX_W(win); if (SH_MAX_H(win) > 0 && ce.height > SH_MAX_H(win)) ce.height = SH_MAX_H(win); } /* resize increment. */ if (SH_INC(win)) { if (SH_INC_W(win) > 1 && ce.width > SH_INC_W(win)) ce.width -= (ce.width - SH_MIN_W(win)) % SH_INC_W(win); if (SH_INC_H(win) > 1 && ce.height > SH_INC_H(win)) ce.height -= (ce.height - SH_MIN_H(win)) % SH_INC_H(win); } /* adjust x and y for requested border_width. */ ce.x += ev->border_width; ce.y += ev->border_width; ce.above_sibling = ev->sibling; } DNPRINTF(SWM_D_MISC, "ewmh: %s, win %#x, (x,y) w x h: (%d,%d) %d x %d, " "border: %d\n", YESNO(ev == NULL), win->id, ce.x, ce.y, ce.width, ce.height, ce.border_width); xcb_send_event(conn, 0, win->id, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (char *)&ce); } int count_win(struct workspace *ws, bool count_transient) { struct ws_win *win; int count = 0; TAILQ_FOREACH(win, &ws->winlist, entry) { if (!count_transient && FLOATING(win)) continue; if (ICONIC(win)) continue; count++; } DNPRINTF(SWM_D_MISC, "count: %d\n", count); return (count); } void quit(struct binding *bp, struct swm_region *r, union arg *args) { /* suppress unused warnings since vars are needed */ (void)bp; (void)r; (void)args; DNPRINTF(SWM_D_MISC, "shutting down...\n"); running = 0; } void lower_window(struct ws_win *win) { struct ws_win *target = NULL; struct workspace *ws; DNPRINTF(SWM_D_EVENT, "win %#x\n", WINID(win)); if (win == NULL) return; ws = win->ws; TAILQ_FOREACH(target, &ws->stack, stack_entry) { if (target == win || ICONIC(target)) continue; if (ws->cur_layout == &layouts[SWM_MAX_STACK]) break; if (TRANS(win)) { if (win->transient == target->transient) continue; if (win->transient == target->id) break; } if (FULLSCREEN(target)) continue; if (FULLSCREEN(win)) break; if (MAXIMIZED(target)) continue; if (MAXIMIZED(win)) break; if (ABOVE(target) || TRANS(target)) continue; if (ABOVE(win) || TRANS(win)) break; } /* Change stack position. */ TAILQ_REMOVE(&ws->stack, win, stack_entry); if (target) TAILQ_INSERT_BEFORE(target, win, stack_entry); else TAILQ_INSERT_TAIL(&ws->stack, win, stack_entry); update_win_stacking(win); #ifdef SWM_DEBUG if (swm_debug & SWM_D_STACK) { DPRINTF("=== stacking order (top down) === \n"); TAILQ_FOREACH(target, &ws->stack, stack_entry) { DPRINTF("win %#x, fs: %s, maximized: %s, above: %s, " "iconic: %s\n", target->id, YESNO(FULLSCREEN(target)), YESNO(MAXIMIZED(target)), YESNO(ABOVE(target)), YESNO(ICONIC(target))); } } #endif DNPRINTF(SWM_D_EVENT, "done\n"); } void raise_window(struct ws_win *win) { struct ws_win *target = NULL; struct workspace *ws; DNPRINTF(SWM_D_EVENT, "win %#x\n", WINID(win)); if (win == NULL) return; ws = win->ws; TAILQ_FOREACH(target, &ws->stack, stack_entry) { if (target == win || ICONIC(target)) continue; if (ws->cur_layout == &layouts[SWM_MAX_STACK]) break; if (TRANS(win) && (win->transient == target->transient || win->transient == target->id)) break; if (FULLSCREEN(win)) break; if (FULLSCREEN(target)) continue; if (MAXIMIZED(win)) break; if (MAXIMIZED(target)) continue; if (ABOVE(win) || TRANS(win) || (win->ws->focus == win && ws->always_raise)) break; if (!ABOVE(target) && !TRANS(target)) break; } TAILQ_REMOVE(&ws->stack, win, stack_entry); if (target) TAILQ_INSERT_BEFORE(target, win, stack_entry); else TAILQ_INSERT_TAIL(&ws->stack, win, stack_entry); update_win_stacking(win); #ifdef SWM_DEBUG if (swm_debug & SWM_D_STACK) { DPRINTF("=== stacking order (top down) === \n"); TAILQ_FOREACH(target, &ws->stack, stack_entry) { DPRINTF("win %#x, fs: %s, maximized: %s, above: %s, " "iconic: %s\n", target->id, YESNO(FULLSCREEN(target)), YESNO(MAXIMIZED(target)), YESNO(ABOVE(target)), YESNO(ICONIC(target))); } } #endif DNPRINTF(SWM_D_EVENT, "done\n"); } void update_win_stacking(struct ws_win *win) { struct ws_win *sibling; #ifdef SWM_DEBUG struct ws_win *w; #endif struct swm_region *r; uint32_t val[2]; if (win == NULL || (r = win->ws->r) == NULL) return; if (win->frame == XCB_WINDOW_NONE) { DNPRINTF(SWM_D_EVENT, "win %#x not reparented.\n", win->id); return; } sibling = TAILQ_NEXT(win, stack_entry); if (sibling != NULL && (FLOATING(win) == FLOATING(sibling) || (win->ws->always_raise && win->ws->focus == win))) val[0] = sibling->frame; else if (FLOATING(win) || (win->ws->always_raise && win->ws->focus == win)) val[0] = r->bar->id; else val[0] = r->id; DNPRINTF(SWM_D_EVENT, "win %#x (%#x), sibling %#x\n", win->frame, win->id, val[0]); val[1] = XCB_STACK_MODE_ABOVE; xcb_configure_window(conn, win->frame, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, val); #ifdef SWM_DEBUG TAILQ_FOREACH(w, &win->ws->winlist, entry) debug_refresh(w); #endif } void map_window(struct ws_win *win) { if (win == NULL) return; DNPRINTF(SWM_D_EVENT, "win %#x, mapped: %s\n", win->id, YESNO(win->mapped)); if (win->mapped) return; xcb_map_window(conn, win->frame); xcb_map_window(conn, win->id); set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL); win->mapped = true; } void unmap_window(struct ws_win *win) { if (win == NULL) return; DNPRINTF(SWM_D_EVENT, "win %#x, mapped: %s\n", win->id, YESNO(win->mapped)); if (!win->mapped) return; xcb_unmap_window(conn, win->id); xcb_unmap_window(conn, win->frame); set_win_state(win, XCB_ICCCM_WM_STATE_ICONIC); win->mapped = false; } void unmap_all(void) { struct ws_win *win; int i, j, num_screens; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) for (j = 0; j < workspace_limit; j++) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) unmap_window(win); } void fake_keypress(struct ws_win *win, xcb_keysym_t keysym, uint16_t modifiers) { xcb_key_press_event_t event; xcb_keycode_t *keycode; if (win == NULL) return; keycode = xcb_key_symbols_get_keycode(syms, keysym); DNPRINTF(SWM_D_MISC, "win %#x, keycode %u\n", win->id, *keycode); bzero(&event, sizeof(event)); event.event = win->id; event.root = win->s->root; event.child = XCB_WINDOW_NONE; event.time = XCB_CURRENT_TIME; event.event_x = X(win); event.event_y = Y(win); event.root_x = 1; event.root_y = 1; event.same_screen = 1; event.detail = *keycode; event.state = modifiers; event.response_type = XCB_KEY_PRESS; xcb_send_event(conn, 1, win->id, XCB_EVENT_MASK_KEY_PRESS, (const char *)&event); event.response_type = XCB_KEY_RELEASE; xcb_send_event(conn, 1, win->id, XCB_EVENT_MASK_KEY_RELEASE, (const char *)&event); free(keycode); } void restart(struct binding *bp, struct swm_region *r, union arg *args) { /* suppress unused warning since var is needed */ (void)bp; (void)r; (void)args; DNPRINTF(SWM_D_MISC, "%s\n", start_argv[0]); shutdown_cleanup(); execvp(start_argv[0], start_argv); warn("execvp failed"); quit(NULL, NULL, NULL); } struct ws_win * get_pointer_win(xcb_window_t root) { struct ws_win *win = NULL; xcb_query_pointer_reply_t *r; DNPRINTF(SWM_D_EVENT, "root: %#x.\n", root); r = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, root), NULL); if (r) { win = find_window(r->child); if (win) { DNPRINTF(SWM_D_EVENT, "win %#x\n", win->id); } else { DNPRINTF(SWM_D_EVENT, "none\n"); } free(r); } return (win); } void center_pointer(struct swm_region *r) { struct ws_win *win; xcb_window_t dwinid; int dx, dy; #ifdef SWM_XCB_HAS_XINPUT xcb_input_xi_get_client_pointer_reply_t *gcpr; #endif if (!warp_pointer || r == NULL) return; win = r->ws->focus; DNPRINTF(SWM_D_EVENT, "win %#x\n", WINID(win)); if (win && win->mapped) { dwinid = win->frame; dx = WIDTH(win) / 2; dy = HEIGHT(win) / 2; } else { dwinid = r->id; dx = WIDTH(r) / 2; dy = HEIGHT(r) / 2; } #ifdef SWM_XCB_HAS_XINPUT if (xinput2_support) { gcpr = xcb_input_xi_get_client_pointer_reply(conn, xcb_input_xi_get_client_pointer(conn, XCB_NONE), NULL); if (gcpr) /* XIWarpPointer takes FP1616. */ xcb_input_xi_warp_pointer(conn, XCB_NONE, dwinid, 0, 0, 0, 0, dx << 16, dy << 16, gcpr->deviceid); } else { #endif xcb_warp_pointer(conn, XCB_NONE, dwinid, 0, 0, 0, 0, dx, dy); #ifdef SWM_XCB_HAS_XINPUT } #endif } struct swm_region * root_to_region(xcb_window_t root, int check) { struct ws_win *cfw; struct swm_region *r = NULL; int i, num_screens; xcb_query_pointer_reply_t *qpr; xcb_get_input_focus_reply_t *gifr; DNPRINTF(SWM_D_MISC, "win %#x\n", root); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) if (screens[i].root == root) break; if (check & SWM_CK_REGION) r = screens[i].r_focus; if (r == NULL && check & SWM_CK_FOCUS) { /* Try to find an actively focused window */ gifr = xcb_get_input_focus_reply(conn, xcb_get_input_focus(conn), NULL); if (gifr) { cfw = find_window(gifr->focus); if (cfw && cfw->ws->r) r = cfw->ws->r; free(gifr); } } if (r == NULL && check & SWM_CK_POINTER) { /* No region with an active focus; try to use pointer. */ qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, screens[i].root), NULL); if (qpr) { DNPRINTF(SWM_D_MISC, "pointer: (%d,%d)\n", qpr->root_x, qpr->root_y); TAILQ_FOREACH(r, &screens[i].rl, entry) if (X(r) <= qpr->root_x && qpr->root_x < MAX_X(r) && Y(r) <= qpr->root_y && qpr->root_y < MAX_Y(r)) break; free(qpr); } } /* Last resort. */ if (r == NULL && check & SWM_CK_FALLBACK) r = TAILQ_FIRST(&screens[i].rl); DNPRINTF(SWM_D_MISC, "idx: %d\n", get_region_index(r)); return (r); } struct swm_region * find_region(xcb_window_t id) { struct swm_region *r; int i, num_screens; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) if (r->id == id) return (r); return (NULL); } struct swm_bar * find_bar(xcb_window_t id) { struct swm_region *r; int i, num_screens; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) if (r->bar && r->bar->id == id) return (r->bar); return (NULL); } struct ws_win * find_window(xcb_window_t id) { struct ws_win *win = NULL; int i, j, num_screens; xcb_query_tree_reply_t *qtr; DNPRINTF(SWM_D_MISC, "id: %#x\n", id); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) for (j = 0; j < workspace_limit; j++) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) if (id == win->id || id == win->frame) return (win); /* If window isn't top-level, try to find managed ancestor. */ qtr = xcb_query_tree_reply(conn, xcb_query_tree(conn, id), NULL); if (qtr) { if (qtr->parent != XCB_WINDOW_NONE && qtr->parent != qtr->root) win = find_window(qtr->parent); #ifdef SWM_DEBUG if (win) DNPRINTF(SWM_D_MISC, "%#x is decendent of %#x.\n", id, qtr->parent); #endif free(qtr); } #ifdef SWM_DEBUG if (win == NULL) DNPRINTF(SWM_D_MISC, "unmanaged.\n"); #endif return (win); } struct ws_win * find_unmanaged_window(xcb_window_t id) { struct ws_win *win; int i, j, num_screens; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) for (j = 0; j < workspace_limit; j++) TAILQ_FOREACH(win, &screens[i].ws[j].unmanagedlist, entry) if (id == win->id) return (win); return (NULL); } void spawn(int ws_idx, union arg *args, bool close_fd) { int fd; char *ret = NULL; if (args == NULL || args->argv[0] == NULL) return; DNPRINTF(SWM_D_MISC, "%s\n", args->argv[0]); close(xcb_get_file_descriptor(conn)); if ((ret = getenv("LD_PRELOAD"))) { if (asprintf(&ret, "%s:%s", SWM_LIB, ret) == -1) { warn("spawn: asprintf LD_PRELOAD"); _exit(1); } setenv("LD_PRELOAD", ret, 1); free(ret); } else { setenv("LD_PRELOAD", SWM_LIB, 1); } if (asprintf(&ret, "%d", ws_idx) == -1) { warn("spawn: asprintf SWM_WS"); _exit(1); } setenv("_SWM_WS", ret, 1); free(ret); ret = NULL; if (asprintf(&ret, "%d", getpid()) == -1) { warn("spawn: asprintf _SWM_PID"); _exit(1); } setenv("_SWM_PID", ret, 1); free(ret); ret = NULL; if (setsid() == -1) { warn("spawn: setsid"); _exit(1); } if (close_fd) { /* * close stdin and stdout to prevent interaction between apps * and the baraction script * leave stderr open to record errors */ if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1) { warn("spawn: open"); _exit(1); } dup2(fd, STDIN_FILENO); dup2(fd, STDOUT_FILENO); if (fd > 2) close(fd); } if (signal(SIGPIPE, SIG_DFL) == SIG_ERR) err(1, "could not reset SIGPIPE"); execvp(args->argv[0], args->argv); warn("spawn: execvp"); _exit(1); } void kill_refs(struct ws_win *win) { struct workspace *ws; struct ws_win *w; int i, j, num_screens; if (win == NULL) return; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { for (j = 0; j < workspace_limit; j++) { ws = &screens[i].ws[j]; if (win == ws->focus) ws->focus = NULL; if (win == ws->focus_prev) ws->focus_prev = NULL; if (win == ws->focus_pending) ws->focus_pending = NULL; if (win == ws->focus_raise) ws->focus_raise = NULL; if (TRANS(win)) TAILQ_FOREACH(w, &ws->winlist, entry) if (win == w->focus_child) w->focus_child = NULL; } } } int validate_win(struct ws_win *testwin) { struct ws_win *win; struct workspace *ws; struct swm_region *r; int i, x, num_screens; if (testwin == NULL) return (0); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) for (x = 0; x < workspace_limit; x++) { ws = &r->s->ws[x]; TAILQ_FOREACH(win, &ws->winlist, entry) if (win == testwin) return (0); } return (1); } int validate_ws(struct workspace *testws) { struct swm_region *r; struct workspace *ws; int i, x, num_screens; /* validate all ws */ num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) for (x = 0; x < workspace_limit; x++) { ws = &r->s->ws[x]; if (ws == testws) return (0); } return (1); } void unfocus_win(struct ws_win *win) { xcb_window_t none = XCB_WINDOW_NONE; DNPRINTF(SWM_D_FOCUS, "win %#x\n", WINID(win)); if (win == NULL) return; if (win->ws == NULL) { DNPRINTF(SWM_D_FOCUS, "NULL ws\n"); return; } if (validate_ws(win->ws)) { DNPRINTF(SWM_D_FOCUS, "invalid ws\n"); return; } if (win->ws->r == NULL) { DNPRINTF(SWM_D_FOCUS, "NULL region\n"); return; } if (validate_win(win)) { DNPRINTF(SWM_D_FOCUS, "invalid win\n"); kill_refs(win); return; } if (win->ws->focus == win) { win->ws->focus = NULL; win->ws->focus_prev = win; if (win->ws->focus_raise == win && !FLOATING(win)) { update_win_stacking(win); } } if (validate_win(win->ws->focus)) { kill_refs(win->ws->focus); win->ws->focus = NULL; } if (validate_win(win->ws->focus_prev)) { kill_refs(win->ws->focus_prev); win->ws->focus_prev = NULL; } draw_frame(win); /* Raise window to "top unfocused position." */ if (win->ws->always_raise) raise_window(win); /* Update border width */ if (win->bordered && (win->quirks & SWM_Q_MINIMALBORDER) && FLOATING(win)) { win->bordered = 0; X(win) += border_width; Y(win) += border_width; update_window(win); } xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root, ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1, &none); DNPRINTF(SWM_D_FOCUS, "done\n"); } void focus_win(struct ws_win *win) { struct ws_win *cfw = NULL, *parent = NULL, *w, *tmpw; struct workspace *ws; xcb_get_input_focus_reply_t *gifr = NULL; xcb_get_window_attributes_reply_t *war = NULL; DNPRINTF(SWM_D_FOCUS, "win %#x\n", WINID(win)); if (win == NULL || win->ws == NULL || !win->mapped) goto out; ws = win->ws; if (validate_ws(ws)) goto out; if (validate_win(win)) { kill_refs(win); goto out; } gifr = xcb_get_input_focus_reply(conn, xcb_get_input_focus(conn), NULL); if (gifr) { DNPRINTF(SWM_D_FOCUS, "cur focus: %#x\n", gifr->focus); cfw = find_window(gifr->focus); if (cfw) { if (cfw != win) { if (cfw->ws != ws && cfw->ws->r != NULL && cfw->frame != XCB_WINDOW_NONE) { draw_frame(cfw); } else { unfocus_win(cfw); } } } else { war = xcb_get_window_attributes_reply(conn, xcb_get_window_attributes(conn, gifr->focus), NULL); if (war && war->override_redirect && ws->focus == win) { DNPRINTF(SWM_D_FOCUS, "skip refocus " "from override_redirect.\n"); goto out; } } } if (ws->focus != win) { if (ws->focus && ws->focus != cfw) unfocus_win(ws->focus); ws->focus = win; } /* Clear focus child redirect. */ win->focus_child = NULL; /* If transient, adjust parent's focus child for focus_magic. */ if (TRANS(win)) { parent = find_window(win->transient); if (parent && parent->focus_child != win) parent->focus_child = win; } /* Update window border even if workspace is hidden. */ draw_frame(win); if (cfw == win) { DNPRINTF(SWM_D_FOCUS, "already focused\n"); goto out; } if (ws->r) { /* Set input focus if no input hint, or indicated by hint. */ if (ACCEPTS_FOCUS(win)) { DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, revert-to:" " parent, time: %#x\n", win->id, last_event_time); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, win->id, last_event_time); } else if (!win->take_focus) { DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x," " revert-to: parent, time: 0\n", ws->r->id); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, ws->r->id, XCB_CURRENT_TIME); } /* Tell app it can adjust focus to a specific window. */ if (win->take_focus) { /* java is special; always tell parent */ if (TRANS(win) && win->java) client_msg(parent, a_takefocus, last_event_time); else client_msg(win, a_takefocus, last_event_time); } if (ws->cur_layout->flags & SWM_L_MAPONFOCUS || ws->always_raise) { /* If a parent exists, map it first. */ if (parent) { raise_window(parent); map_window(parent); /* Map siblings next. */ TAILQ_FOREACH_SAFE(w, &ws->stack, stack_entry, tmpw) if (w != win && !ICONIC(w) && w->transient == parent->id) { raise_window(w); map_window(w); } } /* Map focused window. */ raise_window(win); map_window(win); /* Stack any children of focus window. */ TAILQ_FOREACH_SAFE(w, &ws->stack, stack_entry, tmpw) if (w->transient == win->id && !ICONIC(w)) { raise_window(w); map_window(w); } } else if (tile_gap < 0 && !ABOVE(win)) { /* * Windows overlap in the layout. * Raise focused win above all tiled wins. */ raise_window(win); map_window(win); } set_region(ws->r); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root, ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1, &win->id); bar_draw(ws->r->bar); } out: free(gifr); free(war); DNPRINTF(SWM_D_FOCUS, "done\n"); } /* If a child window should have focus instead, return it. */ struct ws_win * get_focus_magic(struct ws_win *win) { struct ws_win *parent = NULL; struct ws_win *child = NULL; DNPRINTF(SWM_D_FOCUS, "win %#x\n", WINID(win)); if (win == NULL) return (win); if (TRANS(win)) { parent = find_window(win->transient); /* If parent prefers focus elsewhere, then try to do so. */ if (parent && (child = parent->focus_child)) { if (validate_win(child) == 0 && child->mapped) win = child; else parent->focus_child = NULL; } } /* If this window prefers focus elsewhere, then try to do so. */ if ((child = win->focus_child)) { if (validate_win(child) == 0 && child->mapped) win = child; else win->focus_child = NULL; } return (win); } void event_drain(uint8_t rt) { xcb_generic_event_t *evt; /* ensure all pending requests have been processed before filtering. */ xcb_aux_sync(conn); while ((evt = get_next_event(false))) { if (XCB_EVENT_RESPONSE_TYPE(evt) != rt) event_handle(evt); free(evt); } } void set_region(struct swm_region *r) { struct swm_region *rf; int vals[2]; if (r == NULL) return; rf = r->s->r_focus; /* Unfocus old region bar. */ if (rf != NULL) { if (rf == r) return; xcb_change_window_attributes(conn, rf->bar->id, XCB_CW_BORDER_PIXEL, &r->s->c[SWM_S_COLOR_BAR_BORDER_UNFOCUS].pixel); } if (rf != NULL && rf != r && (X(rf) != X(r) || Y(rf) != Y(r) || WIDTH(rf) != WIDTH(r) || HEIGHT(rf) != HEIGHT(r))) { /* Set _NET_DESKTOP_GEOMETRY. */ vals[0] = WIDTH(r); vals[1] = HEIGHT(r); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, r->s->root, ewmh[_NET_DESKTOP_GEOMETRY].atom, XCB_ATOM_CARDINAL, 32, 2, &vals); } /* Set region bar border to focus_color. */ xcb_change_window_attributes(conn, r->bar->id, XCB_CW_BORDER_PIXEL, &r->s->c[SWM_S_COLOR_BAR_BORDER].pixel); r->s->r_focus = r; /* Update the focus window frame on the now unfocused region. */ if (rf && rf->ws->focus) draw_frame(rf->ws->focus); ewmh_update_current_desktop(); } void focus_region(struct swm_region *r) { struct ws_win *nfw; struct swm_region *old_r; if (r == NULL) return; old_r = r->s->r_focus; set_region(r); nfw = get_region_focus(r); if (nfw) { focus_win(nfw); } else { /* New region is empty; need to manually unfocus win. */ if (old_r) { unfocus_win(old_r->ws->focus); /* Clear bar since empty. */ bar_draw(old_r->bar); } DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, revert-to: parent," "time: 0\n", r->id); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, r->id, XCB_CURRENT_TIME); } } void switchws(struct binding *bp, struct swm_region *r, union arg *args) { struct swm_region *this_r, *other_r; struct ws_win *win; struct workspace *new_ws, *old_ws; xcb_window_t none = XCB_WINDOW_NONE; int wsid = args->id; bool unmap_old = false; if (!(r && r->s)) return; if (wsid >= workspace_limit) return; this_r = r; old_ws = this_r->ws; new_ws = &this_r->s->ws[wsid]; DNPRINTF(SWM_D_WS, "screen[%d]:%dx%d+%d+%d: %d -> %d\n", r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), old_ws->idx, wsid); if (new_ws == NULL || old_ws == NULL) return; if (new_ws == old_ws) return; other_r = new_ws->r; if (other_r && workspace_clamp && (bp == NULL || (bp->action != FN_RG_MOVE_NEXT && bp->action != FN_RG_MOVE_PREV))) { DNPRINTF(SWM_D_WS, "ws clamped.\n"); if (warp_focus) { DNPRINTF(SWM_D_WS, "warping focus to region " "with ws %d\n", wsid); focus_region(other_r); center_pointer(other_r); focus_flush(); } return; } if ((win = old_ws->focus) != NULL) { draw_frame(win); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root, ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1, &none); } if (other_r) { /* the other ws is visible in another region, exchange them */ other_r->ws_prior = new_ws; other_r->ws = old_ws; old_ws->r = other_r; } else { /* the other workspace is hidden, hide this one */ old_ws->r = NULL; unmap_old = true; } this_r->ws_prior = old_ws; this_r->ws = new_ws; new_ws->r = this_r; /* Set focus_pending before stacking, if needed. */ if (focus_mode != SWM_FOCUS_FOLLOW && (!new_ws->focus_pending || validate_win(new_ws->focus_pending))) { new_ws->focus_pending = get_region_focus(new_ws->r); new_ws->focus = new_ws->focus_prev; new_ws->focus_prev = NULL; } new_ws->state = SWM_WS_STATE_MAPPING; stack(other_r); stack(this_r); /* unmap old windows */ if (unmap_old) { TAILQ_FOREACH(win, &old_ws->winlist, entry) unmap_window(win); old_ws->state = SWM_WS_STATE_HIDDEN; } /* if workspaces were swapped, then don't wait to set focus */ if (old_ws->r && focus_mode != SWM_FOCUS_FOLLOW) { if (new_ws->focus_pending) { focus_win(new_ws->focus_pending); new_ws->focus_pending = NULL; } } /* Clear bar and set focus on region input win if new ws is empty. */ if (new_ws->focus_pending == NULL && new_ws->focus == NULL) { DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, " "revert-to: parent, time: 0\n", r->id); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, r->id, XCB_CURRENT_TIME); bar_draw(r->bar); } ewmh_update_current_desktop(); center_pointer(r); focus_flush(); new_ws->state = SWM_WS_STATE_MAPPED; DNPRINTF(SWM_D_WS, "done\n"); } void cyclews(struct binding *bp, struct swm_region *r, union arg *args) { union arg a; struct swm_screen *s = r->s; bool cycle_all = false, mv = false; DNPRINTF(SWM_D_WS, "id: %d, screen[%d]:%dx%d+%d+%d, ws: %d\n", args->id, r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx); a.id = r->ws->idx; do { switch (args->id) { case SWM_ARG_ID_CYCLEWS_MOVE_UP: mv = true; /* FALLTHROUGH */ case SWM_ARG_ID_CYCLEWS_UP_ALL: cycle_all = true; /* FALLTHROUGH */ case SWM_ARG_ID_CYCLEWS_UP: a.id = (a.id < workspace_limit - 1) ? a.id + 1 : 0; break; case SWM_ARG_ID_CYCLEWS_MOVE_DOWN: mv = true; /* FALLTHROUGH */ case SWM_ARG_ID_CYCLEWS_DOWN_ALL: cycle_all = true; /* FALLTHROUGH */ case SWM_ARG_ID_CYCLEWS_DOWN: a.id = (a.id > 0) ? a.id - 1 : workspace_limit - 1; break; default: return; }; if (!cycle_all && (!cycle_empty && TAILQ_EMPTY(&s->ws[a.id].winlist))) continue; if (!cycle_visible && s->ws[a.id].r != NULL) continue; if (mv) send_to_ws(bp, r, &a); switchws(bp, r, &a); } while (a.id != r->ws->idx); DNPRINTF(SWM_D_FOCUS, "done\n"); } void emptyws(struct binding *bp, struct swm_region *r, union arg *args) { int i, empty = -1; union arg a; struct ws_win *win; DNPRINTF(SWM_D_WS, "id: %d, screen[%d]:%dx%d+%d+%d, ws: %d\n", args->id, r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx); /* Find first empty ws. */ for (i = 0; i < workspace_limit; ++i) if (TAILQ_EMPTY(&r->s->ws[i].winlist)) { empty = i; break; } if (empty == -1) { DNPRINTF(SWM_D_FOCUS, "no empty ws.\n"); return; } a.id = empty; switch (args->id) { case SWM_ARG_ID_WS_EMPTY_MOVE: /* Only move & switch if there is a focused window. */ if (r->ws->focus) TAILQ_FOREACH(win, &r->ws->winlist, entry) if (win != r->ws->focus) { send_to_ws(bp, r, &a); switchws(bp, r, &a); break; } break; case SWM_ARG_ID_WS_EMPTY: switchws(bp, r, &a); break; default: DNPRINTF(SWM_D_FOCUS, "invalid id: %d\n", args->id); } DNPRINTF(SWM_D_FOCUS, "done\n"); } void priorws(struct binding *bp, struct swm_region *r, union arg *args) { union arg a; (void)args; DNPRINTF(SWM_D_WS, "id: %d, screen[%d]:%dx%d+%d+%d, ws: %d\n", args->id, r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx); if (r->ws_prior == NULL) return; a.id = r->ws_prior->idx; switchws(bp, r, &a); DNPRINTF(SWM_D_FOCUS, "done\n"); } void focusrg(struct binding *bp, struct swm_region *r, union arg *args) { int ridx = args->id, i, num_screens; struct swm_region *rr = NULL; (void)bp; num_screens = get_screen_count(); /* do nothing if we don't have more than one screen */ if (!(num_screens > 1 || outputs > 1)) return; DNPRINTF(SWM_D_FOCUS, "id: %d\n", ridx); rr = TAILQ_FIRST(&r->s->rl); for (i = 0; i < ridx && rr != NULL; ++i) rr = TAILQ_NEXT(rr, entry); if (rr == NULL) return; focus_region(rr); center_pointer(rr); focus_flush(); DNPRINTF(SWM_D_FOCUS, "done\n"); } void cyclerg(struct binding *bp, struct swm_region *r, union arg *args) { union arg a; struct swm_region *rr = NULL; int i, num_screens; num_screens = get_screen_count(); /* do nothing if we don't have more than one screen */ if (!(num_screens > 1 || outputs > 1)) return; i = r->s->idx; DNPRINTF(SWM_D_FOCUS, "id: %d, region: %d\n", args->id, i); switch (args->id) { case SWM_ARG_ID_CYCLERG_UP: case SWM_ARG_ID_CYCLERG_MOVE_UP: rr = TAILQ_NEXT(r, entry); if (rr == NULL) rr = TAILQ_FIRST(&screens[i].rl); break; case SWM_ARG_ID_CYCLERG_DOWN: case SWM_ARG_ID_CYCLERG_MOVE_DOWN: rr = TAILQ_PREV(r, swm_region_list, entry); if (rr == NULL) rr = TAILQ_LAST(&screens[i].rl, swm_region_list); break; default: return; }; if (rr == NULL) return; switch (args->id) { case SWM_ARG_ID_CYCLERG_UP: case SWM_ARG_ID_CYCLERG_DOWN: focus_region(rr); center_pointer(rr); focus_flush(); break; case SWM_ARG_ID_CYCLERG_MOVE_UP: case SWM_ARG_ID_CYCLERG_MOVE_DOWN: a.id = rr->ws->idx; switchws(bp, r, &a); break; default: return; }; DNPRINTF(SWM_D_FOCUS, "done\n"); } /* Sorts transients after parent. */ void sort_windows(struct ws_win_list *wl) { struct ws_win *win, *parent, *nxt; if (wl == NULL) return; for (win = TAILQ_FIRST(wl); win != TAILQ_END(wl); win = nxt) { nxt = TAILQ_NEXT(win, entry); if (TRANS(win)) { parent = find_window(win->transient); if (parent == NULL) { warnx("not possible bug"); continue; } TAILQ_REMOVE(wl, win, entry); TAILQ_INSERT_AFTER(wl, parent, win, entry); } } } void swapwin(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *target, *source; struct ws_win *cur_focus; struct ws_win_list *wl; (void)bp; DNPRINTF(SWM_D_WS, "id: %d, screen[%d]:%dx%d+%d+%d, ws: %d\n", args->id, r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx); cur_focus = r->ws->focus; if (cur_focus == NULL || FULLSCREEN(cur_focus)) return; /* Adjust stacking in floating layer. */ if (ABOVE(cur_focus)) { switch (args->id) { case SWM_ARG_ID_SWAPPREV: target = TAILQ_PREV(cur_focus, ws_win_stack, stack_entry); if (target != NULL && FLOATING(target)) { TAILQ_REMOVE(&cur_focus->ws->stack, cur_focus, stack_entry); TAILQ_INSERT_BEFORE(target, cur_focus, stack_entry); update_win_stacking(cur_focus); focus_flush(); } break; case SWM_ARG_ID_SWAPNEXT: target = TAILQ_NEXT(cur_focus, stack_entry); if (target != NULL && FLOATING(target)) { TAILQ_REMOVE(&cur_focus->ws->stack, cur_focus, stack_entry); TAILQ_INSERT_AFTER(&cur_focus->ws->stack, target, cur_focus, stack_entry); update_win_stacking(cur_focus); focus_flush(); } break; } goto out; } if (r->ws->cur_layout == &layouts[SWM_MAX_STACK]) return; clear_maximized(r->ws); source = cur_focus; wl = &source->ws->winlist; switch (args->id) { case SWM_ARG_ID_SWAPPREV: if (TRANS(source)) source = find_window(source->transient); target = TAILQ_PREV(source, ws_win_list, entry); if (target && target->transient) target = find_window(target->transient); TAILQ_REMOVE(wl, source, entry); if (target == NULL) TAILQ_INSERT_TAIL(wl, source, entry); else TAILQ_INSERT_BEFORE(target, source, entry); break; case SWM_ARG_ID_SWAPNEXT: target = TAILQ_NEXT(source, entry); /* move the parent and let the sort handle the move */ if (TRANS(source)) source = find_window(source->transient); TAILQ_REMOVE(wl, source, entry); if (target == NULL) TAILQ_INSERT_HEAD(wl, source, entry); else TAILQ_INSERT_AFTER(wl, target, source, entry); break; case SWM_ARG_ID_SWAPMAIN: target = TAILQ_FIRST(wl); if (target == source) { if (source->ws->focus_prev != NULL && source->ws->focus_prev != target) source = source->ws->focus_prev; else return; } if (target == NULL || source == NULL) return; source->ws->focus_prev = target; TAILQ_REMOVE(wl, target, entry); TAILQ_INSERT_BEFORE(source, target, entry); TAILQ_REMOVE(wl, source, entry); TAILQ_INSERT_HEAD(wl, source, entry); break; case SWM_ARG_ID_MOVELAST: TAILQ_REMOVE(wl, source, entry); TAILQ_INSERT_TAIL(wl, source, entry); break; default: DNPRINTF(SWM_D_MOVE, "invalid id: %d\n", args->id); return; } sort_windows(wl); ewmh_update_client_list(); stack(r); center_pointer(r); focus_flush(); out: DNPRINTF(SWM_D_MOVE, "done\n"); } struct ws_win * get_focus_prev(struct ws_win *win) { struct ws_win *winfocus = NULL; struct ws_win *cur_focus = NULL; struct ws_win_list *wl = NULL; struct workspace *ws = NULL; if (!(win && win->ws)) return (NULL); ws = win->ws; wl = &ws->winlist; cur_focus = ws->focus; DNPRINTF(SWM_D_FOCUS, "win %#x, cur_focus: %#x, focus_prev: %#x\n", WINID(win), WINID(cur_focus), WINID(ws->focus_prev)); /* pickle, just focus on whatever */ if (cur_focus == NULL) { /* use prev_focus if valid */ if (ws->focus_prev && find_window(ws->focus_prev->id)) winfocus = ws->focus_prev; goto done; } /* if transient focus on parent */ if (TRANS(cur_focus)) { winfocus = find_window(cur_focus->transient); goto done; } /* if in max_stack try harder */ if ((win->quirks & SWM_Q_FOCUSPREV) || (ws->cur_layout->flags & SWM_L_FOCUSPREV)) { if (cur_focus != ws->focus_prev) winfocus = ws->focus_prev; else winfocus = TAILQ_PREV(win, ws_win_list, entry); if (winfocus) goto done; } DNPRINTF(SWM_D_FOCUS, "focus_close: %d\n", focus_close); if (winfocus == NULL || winfocus == win) { switch (focus_close) { case SWM_STACK_BOTTOM: TAILQ_FOREACH(winfocus, wl, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; break; case SWM_STACK_TOP: TAILQ_FOREACH_REVERSE(winfocus, wl, ws_win_list, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; break; case SWM_STACK_ABOVE: winfocus = TAILQ_NEXT(cur_focus, entry); while (winfocus && ICONIC(winfocus)) winfocus = TAILQ_NEXT(winfocus, entry); if (winfocus == NULL) { if (focus_close_wrap) { TAILQ_FOREACH(winfocus, wl, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; } else { TAILQ_FOREACH_REVERSE(winfocus, wl, ws_win_list, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; } } break; case SWM_STACK_BELOW: winfocus = TAILQ_PREV(cur_focus, ws_win_list, entry); while (winfocus && ICONIC(winfocus)) winfocus = TAILQ_PREV(winfocus, ws_win_list, entry); if (winfocus == NULL) { if (focus_close_wrap) { TAILQ_FOREACH_REVERSE(winfocus, wl, ws_win_list, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; } else { TAILQ_FOREACH(winfocus, wl, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; } } break; } } done: if (winfocus == NULL || (winfocus && (ICONIC(winfocus) || winfocus == cur_focus))) { if (focus_default == SWM_STACK_TOP) { TAILQ_FOREACH_REVERSE(winfocus, wl, ws_win_list, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; } else { TAILQ_FOREACH(winfocus, wl, entry) if (!ICONIC(winfocus) && winfocus != cur_focus) break; } } kill_refs(win); return (get_focus_magic(winfocus)); } struct ws_win * get_region_focus(struct swm_region *r) { struct ws_win *winfocus = NULL; if (!(r && r->ws)) return (NULL); if (r->ws->focus && !ICONIC(r->ws->focus)) winfocus = r->ws->focus; else if (r->ws->focus_prev && !ICONIC(r->ws->focus_prev)) winfocus = r->ws->focus_prev; else TAILQ_FOREACH(winfocus, &r->ws->winlist, entry) if (!ICONIC(winfocus)) break; return (get_focus_magic(winfocus)); } void focus(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *head, *cur_focus = NULL, *winfocus = NULL; struct ws_win_list *wl = NULL; struct workspace *ws = NULL; union arg a; int i; if (!(r && r->ws)) goto out; cur_focus = r->ws->focus; ws = r->ws; wl = &ws->winlist; DNPRINTF(SWM_D_FOCUS, "id: %d, cur_focus: %#x\n", args->id, WINID(cur_focus)); /* Make sure an uniconified window has focus, if one exists. */ if (cur_focus == NULL) { cur_focus = TAILQ_FIRST(wl); while (cur_focus != NULL && ICONIC(cur_focus)) cur_focus = TAILQ_NEXT(cur_focus, entry); DNPRINTF(SWM_D_FOCUS, "new cur_focus: %#x\n", WINID(cur_focus)); } switch (args->id) { case SWM_ARG_ID_FOCUSPREV: if (cur_focus == NULL) goto out; winfocus = cur_focus; do { winfocus = TAILQ_PREV(winfocus, ws_win_list, entry); if (winfocus == NULL) winfocus = TAILQ_LAST(wl, ws_win_list); if (winfocus == cur_focus) break; } while (winfocus && (ICONIC(winfocus) || winfocus->id == cur_focus->transient || (cur_focus->transient != XCB_WINDOW_NONE && winfocus->transient == cur_focus->transient) || (winfocus->quirks & SWM_Q_NOFOCUSCYCLE))); break; case SWM_ARG_ID_FOCUSNEXT: if (cur_focus == NULL) goto out; winfocus = cur_focus; do { winfocus = TAILQ_NEXT(winfocus, entry); if (winfocus == NULL) winfocus = TAILQ_FIRST(wl); if (winfocus == cur_focus) break; } while (winfocus && (ICONIC(winfocus) || winfocus->id == cur_focus->transient || (cur_focus->transient != XCB_WINDOW_NONE && winfocus->transient == cur_focus->transient) || (winfocus->quirks & SWM_Q_NOFOCUSCYCLE))); break; case SWM_ARG_ID_FOCUSMAIN: if (cur_focus == NULL) goto out; winfocus = TAILQ_FIRST(wl); if (winfocus == cur_focus) winfocus = cur_focus->ws->focus_prev; break; case SWM_ARG_ID_FOCUSURGENT: /* Search forward for the next urgent window. */ winfocus = NULL; head = cur_focus; for (i = 0; i <= workspace_limit; ++i) { if (head == NULL) head = TAILQ_FIRST(&r->s->ws[(ws->idx + i) % workspace_limit].winlist); while (head) { if (head == cur_focus) { if (i > 0) { winfocus = cur_focus; break; } } else if (get_urgent(head)) { winfocus = head; break; } head = TAILQ_NEXT(head, entry); } if (winfocus) break; } /* Switch ws if new focus is on a different ws. */ if (winfocus && winfocus->ws != ws) { a.id = winfocus->ws->idx; switchws(bp, r, &a); } break; default: goto out; } if (clear_maximized(ws) > 0) stack(r); focus_win(get_focus_magic(winfocus)); center_pointer(r); focus_flush(); out: DNPRINTF(SWM_D_FOCUS, "done\n"); } void focus_pointer(struct binding *bp, struct swm_region *r, union arg *args) { (void)args; /* Not needed for buttons since this is already done in buttonpress. */ if (bp->type == KEYBIND) { focus_win(get_pointer_win(r->s->root)); focus_flush(); } } void switchlayout(struct binding *bp, struct swm_region *r, union arg *args) { struct workspace *ws = r->ws; /* suppress unused warning since var is needed */ (void)bp; DNPRINTF(SWM_D_EVENT, "workspace: %d\n", ws->idx); switch (args->id) { case SWM_ARG_ID_CYCLE_LAYOUT: ws->cur_layout++; if (ws->cur_layout->l_stack == NULL) ws->cur_layout = &layouts[0]; break; case SWM_ARG_ID_LAYOUT_VERTICAL: ws->cur_layout = &layouts[SWM_V_STACK]; break; case SWM_ARG_ID_LAYOUT_HORIZONTAL: ws->cur_layout = &layouts[SWM_H_STACK]; break; case SWM_ARG_ID_LAYOUT_MAX: ws->cur_layout = &layouts[SWM_MAX_STACK]; break; default: goto out; } clear_maximized(ws); stack(r); bar_draw(r->bar); focus_win(get_region_focus(r)); center_pointer(r); focus_flush(); out: DNPRINTF(SWM_D_FOCUS, "done\n"); } void stack_config(struct binding *bp, struct swm_region *r, union arg *args) { struct workspace *ws = r->ws; (void)bp; DNPRINTF(SWM_D_STACK, "id: %d workspace: %d\n", args->id, ws->idx); if (clear_maximized(ws) > 0) stack(r); if (ws->cur_layout->l_config != NULL) ws->cur_layout->l_config(ws, args->id); if (args->id != SWM_ARG_ID_STACKINIT) stack(r); bar_draw(r->bar); center_pointer(r); focus_flush(); } void stack(struct swm_region *r) { struct swm_geometry g; struct swm_region *r_prev; uint32_t val[2]; if (r == NULL) return; DNPRINTF(SWM_D_STACK, "begin\n"); /* Adjust stack area for region bar and padding. */ g = r->g; g.x += region_padding; g.y += region_padding; g.w -= 2 * border_width + 2 * region_padding; g.h -= 2 * border_width + 2 * region_padding; if (bar_enabled && r->ws->bar_enabled) { if (!bar_at_bottom) g.y += bar_height; g.h -= bar_height; } DNPRINTF(SWM_D_STACK, "workspace: %d (screen: %d, region: %d), (x,y) " "WxH: (%d,%d) %d x %d\n", r->ws->idx, r->s->idx, get_region_index(r), g.x, g.y, g.w, g.h); r_prev = TAILQ_PREV(r, swm_region_list, entry); if (r_prev) { /* Stack bar/input relative to prev. region. */ val[1] = XCB_STACK_MODE_ABOVE; val[0] = r_prev->id; DNPRINTF(SWM_D_STACK, "region input %#x relative to %#x.\n", r->id, val[0]); xcb_configure_window(conn, r->id, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, val); if (r->bar) { val[0] = r_prev->bar->id; DNPRINTF(SWM_D_STACK, "region bar %#x relative to " "%#x.\n", r->bar->id, val[0]); xcb_configure_window(conn, r->bar->id, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, val); } } r->ws->cur_layout->l_stack(r->ws, &g); r->ws->cur_layout->l_string(r->ws); /* save r so we can track region changes */ r->ws->old_r = r; if (font_adjusted) font_adjusted--; DNPRINTF(SWM_D_STACK, "end\n"); } void store_float_geom(struct ws_win *win) { if (win == NULL || win->ws->r == NULL) return; /* retain window geom and region geom */ win->g_float = win->g; win->g_float.x -= X(win->ws->r); win->g_float.y -= Y(win->ws->r); win->g_floatvalid = true; DNPRINTF(SWM_D_MISC, "win %#x, g: (%d,%d) %d x %d, g_float: (%d,%d) " "%d x %d\n", win->id, X(win), Y(win), WIDTH(win), HEIGHT(win), win->g_float.x, win->g_float.y, win->g_float.w, win->g_float.h); } void load_float_geom(struct ws_win *win) { if (win == NULL || win->ws->r == NULL) return; if (win->g_floatvalid) { win->g = win->g_float; X(win) += X(win->ws->r); Y(win) += Y(win->ws->r); DNPRINTF(SWM_D_MISC, "win %#x, g: (%d,%d) %d x %d\n", win->id, X(win), Y(win), WIDTH(win), HEIGHT(win)); } else { DNPRINTF(SWM_D_MISC, "win %#x, g_float is not set.\n", win->id); } } void update_floater(struct ws_win *win) { struct workspace *ws; struct swm_region *r; DNPRINTF(SWM_D_MISC, "win %#x\n", WINID(win)); if (win == NULL) return; ws = win->ws; if ((r = ws->r) == NULL) return; win->bordered = true; if (FULLSCREEN(win)) { /* _NET_WM_FULLSCREEN: fullscreen without border. */ if (!win->g_floatvalid) store_float_geom(win); win->g = r->g; win->bordered = false; } else if (MAXIMIZED(win)) { /* Maximize: like a single stacked window. */ if (!win->g_floatvalid) store_float_geom(win); win->g = r->g; if (bar_enabled && ws->bar_enabled && !maximize_hide_bar) { if (!bar_at_bottom) Y(win) += bar_height; HEIGHT(win) -= bar_height; } else if (disable_border) { win->bordered = false; } if (win->bordered) { /* Window geometry excludes frame. */ X(win) += border_width; Y(win) += border_width; HEIGHT(win) -= 2 * border_width; WIDTH(win) -= 2 * border_width; } } else { /* Normal floating window. */ /* Update geometry if new region. */ if (r != ws->old_r) load_float_geom(win); if (((win->quirks & SWM_Q_FULLSCREEN) && WIDTH(win) >= WIDTH(r) && HEIGHT(win) >= HEIGHT(r)) || ((!WS_FOCUSED(win->ws) || win->ws->focus != win) && (win->quirks & SWM_Q_MINIMALBORDER))) { /* Remove border */ win->bordered = false; } else if (!MANUAL(win)) { if (TRANS(win) && (win->quirks & SWM_Q_TRANSSZ)) { /* Adjust size on TRANSSZ quirk. */ WIDTH(win) = (double)WIDTH(r) * dialog_ratio; HEIGHT(win) = (double)HEIGHT(r) * dialog_ratio; } if (!(win->quirks & SWM_Q_ANYWHERE)) { /* * Floaters and transients are auto-centred * unless manually moved, resized or ANYWHERE * quirk is set. */ X(win) = X(r) + (WIDTH(r) - WIDTH(win)) / 2; Y(win) = Y(r) + (HEIGHT(r) - HEIGHT(win)) / 2; store_float_geom(win); } } } /* Ensure at least 1 pixel of the window is in the region. */ region_containment(win, r, SWM_CW_ALLSIDES); update_window(win); } /* * Send keystrokes to terminal to decrease/increase the font size as the * window size changes. */ void adjust_font(struct ws_win *win) { if (!(win->quirks & SWM_Q_XTERM_FONTADJ) || ABOVE(win) || TRANS(win)) return; if (win->sh.width_inc && win->last_inc != win->sh.width_inc && WIDTH(win) / win->sh.width_inc < term_width && win->font_steps < SWM_MAX_FONT_STEPS) { win->font_size_boundary[win->font_steps] = (win->sh.width_inc * term_width) + win->sh.base_width; win->font_steps++; font_adjusted++; win->last_inc = win->sh.width_inc; fake_keypress(win, XK_KP_Subtract, XCB_MOD_MASK_SHIFT); } else if (win->font_steps && win->last_inc != win->sh.width_inc && WIDTH(win) > win->font_size_boundary[win->font_steps - 1]) { win->font_steps--; font_adjusted++; win->last_inc = win->sh.width_inc; fake_keypress(win, XK_KP_Add, XCB_MOD_MASK_SHIFT); } } #define SWAPXY(g) do { \ int tmp; \ tmp = (g)->y; (g)->y = (g)->x; (g)->x = tmp; \ tmp = (g)->h; (g)->h = (g)->w; (g)->w = tmp; \ } while (0) void stack_master(struct workspace *ws, struct swm_geometry *g, int rot, bool flip) { struct swm_geometry cell, r_g = *g; struct ws_win *win; int i = 0, j = 0, s = 0, stacks = 0; int w_inc = 1, h_inc, w_base = 1, h_base; int hrh = 0, extra = 0, h_slice = 0, last_h = 0; int split = 0, colno = 0; int winno, mwin = 0, msize = 0; int remain, missing, v_slice, mscale; bool bordered = true, reconfigure = false; /* * cell: geometry for window, including frame. * mwin: # of windows in master area. * mscale: size increment of master area. * stacks: # of stack columns */ DNPRINTF(SWM_D_STACK, "workspace: %d, rot: %s, flip: %s\n", ws->idx, YESNO(rot), YESNO(flip)); memset(&cell, 0, sizeof(cell)); /* Prepare tiling variables, if needed. */ if ((winno = count_win(ws, false)) > 0) { /* Find first tiled window. */ TAILQ_FOREACH(win, &ws->winlist, entry) if (!FLOATING(win) && !ICONIC(win)) break; /* Take into account size hints of first tiled window. */ if (rot) { w_inc = win->sh.width_inc; w_base = win->sh.base_width; mwin = ws->l_state.horizontal_mwin; mscale = ws->l_state.horizontal_msize; stacks = ws->l_state.horizontal_stacks; SWAPXY(&r_g); } else { w_inc = win->sh.height_inc; w_base = win->sh.base_height; mwin = ws->l_state.vertical_mwin; mscale = ws->l_state.vertical_msize; stacks = ws->l_state.vertical_stacks; } cell = r_g; cell.x += border_width; cell.y += border_width; if (stacks > winno - mwin) stacks = winno - mwin; if (stacks < 1) stacks = 1; h_slice = r_g.h / SWM_H_SLICE; if (mwin && winno > mwin) { v_slice = r_g.w / SWM_V_SLICE; split = mwin; colno = split; cell.w = v_slice * mscale; if (w_inc > 1 && w_inc < v_slice) { /* Adjust for requested size increment. */ remain = (cell.w - w_base) % w_inc; cell.w -= remain; } msize = cell.w; if (flip) cell.x += r_g.w - msize; s = stacks; } else { msize = - 2 * border_width; colno = split = winno / stacks; cell.w = ((r_g.w - (stacks * 2 * border_width) + 2 * border_width) / stacks); s = stacks - 1; } hrh = r_g.h / colno; extra = r_g.h - (colno * hrh); cell.h = hrh - 2 * border_width; i = j = 0; } /* Update window geometry. */ TAILQ_FOREACH(win, &ws->winlist, entry) { if (ICONIC(win)) continue; if (FLOATING(win)) { update_floater(win); continue; } /* Tiled. */ if (split && i == split) { colno = (winno - mwin) / stacks; if (s <= (winno - mwin) % stacks) colno++; split += colno; hrh = r_g.h / colno; extra = r_g.h - (colno * hrh); if (!flip) cell.x += cell.w + 2 * border_width + tile_gap; cell.w = (r_g.w - msize - (stacks * (2 * border_width + tile_gap))) / stacks; if (s == 1) cell.w += (r_g.w - msize - (stacks * (2 * border_width + tile_gap))) % stacks; if (flip) cell.x -= cell.w + 2 * border_width + tile_gap; s--; j = 0; } cell.h = hrh - 2 * border_width - tile_gap; if (rot) { h_inc = win->sh.width_inc; h_base = win->sh.base_width; } else { h_inc = win->sh.height_inc; h_base = win->sh.base_height; } if (j == colno - 1) { cell.h = hrh + extra; } else if (h_inc > 1 && h_inc < h_slice) { /* adjust for window's requested size increment */ remain = (cell.h - h_base) % h_inc; missing = h_inc - remain; if (missing <= extra || j == 0) { extra -= missing; cell.h += missing; } else { cell.h -= remain; extra += remain; } } if (j == 0) cell.y = r_g.y + border_width; else cell.y += last_h + 2 * border_width + tile_gap; /* Window coordinates exclude frame. */ if (winno > 1 || !disable_border || (bar_enabled && ws->bar_enabled && !disable_border_always)) { bordered = true; } else { bordered = false; } if (rot) { if (X(win) != cell.y || Y(win) != cell.x || WIDTH(win) != cell.h || HEIGHT(win) != cell.w) { reconfigure = true; X(win) = cell.y; Y(win) = cell.x; WIDTH(win) = cell.h; HEIGHT(win) = cell.w; } } else { if (X(win) != cell.x || Y(win) != cell.y || WIDTH(win) != cell.w || HEIGHT(win) != cell.h) { reconfigure = true; X(win) = cell.x; Y(win) = cell.y; WIDTH(win) = cell.w; HEIGHT(win) = cell.h; } } if (!bordered) { X(win) -= border_width; Y(win) -= border_width; WIDTH(win) += 2 * border_width; HEIGHT(win) += 2 * border_width; } if (bordered != win->bordered) { reconfigure = true; win->bordered = bordered; } if (reconfigure) { adjust_font(win); update_window(win); } last_h = cell.h; i++; j++; } /* Stack all windows from bottom up. */ TAILQ_FOREACH_REVERSE(win, &ws->stack, ws_win_stack, stack_entry) if (!ICONIC(win)) update_win_stacking(win); /* Map all windows from top down. */ TAILQ_FOREACH(win, &ws->stack, stack_entry) if (!ICONIC(win)) map_window(win); DNPRINTF(SWM_D_STACK, "done\n"); } void vertical_config(struct workspace *ws, int id) { DNPRINTF(SWM_D_STACK, "id: %d, workspace: %d\n", id, ws->idx); switch (id) { case SWM_ARG_ID_STACKRESET: case SWM_ARG_ID_STACKINIT: ws->l_state.vertical_msize = SWM_V_SLICE / 2; ws->l_state.vertical_mwin = 1; ws->l_state.vertical_stacks = 1; break; case SWM_ARG_ID_MASTERSHRINK: if (ws->l_state.vertical_msize > 1) ws->l_state.vertical_msize--; break; case SWM_ARG_ID_MASTERGROW: if (ws->l_state.vertical_msize < SWM_V_SLICE - 1) ws->l_state.vertical_msize++; break; case SWM_ARG_ID_MASTERADD: ws->l_state.vertical_mwin++; break; case SWM_ARG_ID_MASTERDEL: if (ws->l_state.vertical_mwin > 0) ws->l_state.vertical_mwin--; break; case SWM_ARG_ID_STACKBALANCE: ws->l_state.vertical_msize = SWM_V_SLICE / (ws->l_state.vertical_stacks + 1); break; case SWM_ARG_ID_STACKINC: ws->l_state.vertical_stacks++; break; case SWM_ARG_ID_STACKDEC: if (ws->l_state.vertical_stacks > 1) ws->l_state.vertical_stacks--; break; case SWM_ARG_ID_FLIPLAYOUT: ws->l_state.vertical_flip = !ws->l_state.vertical_flip; break; default: return; } } void vertical_stack(struct workspace *ws, struct swm_geometry *g) { DNPRINTF(SWM_D_STACK, "workspace: %d\n", ws->idx); stack_master(ws, g, 0, ws->l_state.vertical_flip); } void horizontal_config(struct workspace *ws, int id) { DNPRINTF(SWM_D_STACK, "workspace: %d\n", ws->idx); switch (id) { case SWM_ARG_ID_STACKRESET: case SWM_ARG_ID_STACKINIT: ws->l_state.horizontal_mwin = 1; ws->l_state.horizontal_msize = SWM_H_SLICE / 2; ws->l_state.horizontal_stacks = 1; break; case SWM_ARG_ID_MASTERSHRINK: if (ws->l_state.horizontal_msize > 1) ws->l_state.horizontal_msize--; break; case SWM_ARG_ID_MASTERGROW: if (ws->l_state.horizontal_msize < SWM_H_SLICE - 1) ws->l_state.horizontal_msize++; break; case SWM_ARG_ID_MASTERADD: ws->l_state.horizontal_mwin++; break; case SWM_ARG_ID_MASTERDEL: if (ws->l_state.horizontal_mwin > 0) ws->l_state.horizontal_mwin--; break; case SWM_ARG_ID_STACKBALANCE: ws->l_state.horizontal_msize = SWM_H_SLICE / (ws->l_state.horizontal_stacks + 1); break; case SWM_ARG_ID_STACKINC: ws->l_state.horizontal_stacks++; break; case SWM_ARG_ID_STACKDEC: if (ws->l_state.horizontal_stacks > 1) ws->l_state.horizontal_stacks--; break; case SWM_ARG_ID_FLIPLAYOUT: ws->l_state.horizontal_flip = !ws->l_state.horizontal_flip; break; default: return; } } void horizontal_stack(struct workspace *ws, struct swm_geometry *g) { DNPRINTF(SWM_D_STACK, "workspace: %d\n", ws->idx); stack_master(ws, g, 1, ws->l_state.horizontal_flip); } void max_stack(struct workspace *ws, struct swm_geometry *g) { struct swm_geometry gg = *g; struct ws_win *w, *win = NULL, *parent = NULL, *tmpw; int winno; DNPRINTF(SWM_D_STACK, "workspace: %d\n", ws->idx); if (ws == NULL) return; winno = count_win(ws, false); if (winno == 0 && count_win(ws, true) == 0) return; /* Figure out which top level window should be visible. */ if (ws->focus_pending) win = ws->focus_pending; else if (ws->focus) win = ws->focus; else if (ws->focus_prev) win = ws->focus_prev; else win = TAILQ_FIRST(&ws->winlist); DNPRINTF(SWM_D_STACK, "focus_pending: %#x, focus: %#x, focus_prev: %#x," " first: %#x, win: %#x\n", WINID(ws->focus_pending), WINID(ws->focus), WINID(ws->focus_prev), WINID(TAILQ_FIRST(&ws->winlist)), win->id); /* Update window geometry. */ TAILQ_FOREACH(w, &ws->winlist, entry) { if (ICONIC(w)) continue; if (TRANS(w) || FULLSCREEN(w)) { update_floater(w); continue; } /* Set maximized flag for all maxed windows. */ if (!MAXIMIZED(w)) { /* Preserve floating geometry. */ if (ABOVE(w)) store_float_geom(w); ewmh_apply_flags(w, w->ewmh_flags | EWMH_F_MAXIMIZED); ewmh_update_wm_state(w); } /* Only reconfigure if necessary. */ if (X(w) != gg.x || Y(w) != gg.y || WIDTH(w) != gg.w || HEIGHT(w) != gg.h) { w->g = gg; if (disable_border && !(bar_enabled && ws->bar_enabled)) { w->bordered = false; WIDTH(w) += 2 * border_width; HEIGHT(w) += 2 * border_width; } else { w->bordered = true; X(w) += border_width; Y(w) += border_width; } update_window(w); } } /* If transient, stack parent and its children. */ if (TRANS(win) && (parent = find_window(win->transient))) { raise_window(parent); TAILQ_FOREACH_SAFE(w, &ws->stack, stack_entry, tmpw) if (w->transient == parent->id) raise_window(w); } /* Make sure focus window is on top. */ raise_window(win); /* Stack any children of focus window. */ TAILQ_FOREACH_SAFE(w, &ws->stack, stack_entry, tmpw) if (w->transient == win->id) raise_window(w); /* Map all windows. */ TAILQ_FOREACH(w, &ws->stack, stack_entry) if (!ICONIC(w)) map_window(w); } void send_to_rg(struct binding *bp, struct swm_region *r, union arg *args) { int ridx = args->id, i, num_screens; struct swm_region *rr = NULL; union arg a; num_screens = get_screen_count(); /* do nothing if we don't have more than one screen */ if (!(num_screens > 1 || outputs > 1)) return; DNPRINTF(SWM_D_FOCUS, "id: %d\n", ridx); rr = TAILQ_FIRST(&r->s->rl); for (i = 0; i < ridx && rr != NULL; ++i) rr = TAILQ_NEXT(rr, entry); if (rr == NULL) return; a.id = rr->ws->idx; send_to_ws(bp, r, &a); } struct swm_region * region_under(struct swm_screen *s, int x, int y) { struct swm_region *r = NULL; TAILQ_FOREACH(r, &s->rl, entry) { DNPRINTF(SWM_D_MISC, "ws: %d, region g: (%d,%d) %d x %d, " "coords: (%d,%d)\n", r->ws->idx, X(r), Y(r), WIDTH(r), HEIGHT(r), x, y); if (X(r) <= x && x < MAX_X(r)) if (Y(r) <= y && y < MAX_Y(r)) return (r); } return (NULL); } /* Transfer focused window to target workspace and focus. */ void send_to_ws(struct binding *bp, struct swm_region *r, union arg *args) { int wsid = args->id; struct ws_win *win = NULL; (void)bp; if (r && r->ws && r->ws->focus) win = r->ws->focus; else return; DNPRINTF(SWM_D_MOVE, "win %#x, ws %d\n", win->id, wsid); if (wsid < 0 || wsid >= workspace_limit) return; if (win->ws->idx == wsid) return; win_to_ws(win, wsid, true); /* Set new focus on target ws. */ if (focus_mode != SWM_FOCUS_FOLLOW) { win->ws->focus_prev = win->ws->focus; win->ws->focus = win; win->ws->focus_pending = NULL; if (win->ws->focus_prev) draw_frame(win->ws->focus_prev); } DNPRINTF(SWM_D_STACK, "focus_pending: %#x, focus: %#x, focus_prev: %#x," " first: %#x, win: %#x\n", WINID(r->ws->focus_pending), WINID(r->ws->focus), WINID(r->ws->focus_prev), WINID(TAILQ_FIRST(&r->ws->winlist)), win->id); ewmh_apply_flags(win, win->ewmh_flags & ~EWMH_F_MAXIMIZED); ewmh_update_wm_state(win); /* Restack focused region. */ stack(r); /* If destination ws has a region, restack. */ if (win->ws->r) { if (FLOATING(win)) load_float_geom(win); stack(win->ws->r); } /* Set new focus on current ws. */ if (focus_mode != SWM_FOCUS_FOLLOW) { if (r->ws->focus != NULL) { focus_win(r->ws->focus); } else { DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, " "revert-to: parent, time: 0\n", r->id); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, r->id, XCB_CURRENT_TIME); bar_draw(r->bar); } } center_pointer(r); focus_flush(); } /* Transfer focused window to region-relative workspace and focus. */ void send_to_rg_relative(struct binding *bp, struct swm_region *r, union arg *args) { union arg args_abs; struct swm_region *r_other; if (args->id == 1) { r_other = TAILQ_NEXT(r, entry); if (r_other == NULL) r_other = TAILQ_FIRST(&r->s->rl); } else { r_other = TAILQ_PREV(r, swm_region_list, entry); if (r_other == NULL) r_other = TAILQ_LAST(&r->s->rl, swm_region_list); } /* Map relative to absolute */ args_abs = *args; args_abs.id = r_other->ws->idx; send_to_ws(bp, r, &args_abs); } void win_to_ws(struct ws_win *win, int wsid, bool unfocus) { struct ws_win *parent; struct workspace *ws, *nws, *pws; if (wsid < 0 || wsid >= workspace_limit) return; if (win->ws->idx == wsid) return; ws = win->ws; nws = &win->s->ws[wsid]; DNPRINTF(SWM_D_MOVE, "win %#x, ws %d -> %d\n", win->id, ws->idx, wsid); /* Cleanup focus on source ws. */ if (focus_mode != SWM_FOCUS_FOLLOW && (ws->focus == win || ws->focus_pending == win)) ws->focus_pending = get_focus_prev(win); /* Move the parent if this is a transient window. */ if (TRANS(win)) { parent = find_window(win->transient); if (parent) { pws = parent->ws; /* Set new focus in parent's ws if needed. */ if (pws->focus == parent) { if (focus_mode != SWM_FOCUS_FOLLOW) pws->focus_pending = get_focus_prev(parent); unfocus_win(parent); if (focus_mode != SWM_FOCUS_FOLLOW) { pws->focus = pws->focus_pending; pws->focus_pending = NULL; } } /* Don't unmap parent if new ws is visible */ if (nws->r == NULL) unmap_window(parent); /* Transfer */ TAILQ_REMOVE(&ws->winlist, parent, entry); TAILQ_REMOVE(&ws->stack, parent, stack_entry); TAILQ_INSERT_TAIL(&nws->winlist, parent, entry); TAILQ_INSERT_TAIL(&nws->stack, parent, stack_entry); parent->ws = nws; DNPRINTF(SWM_D_PROP, "set property: " "_NET_WM_DESKTOP: %d\n", wsid); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, parent->id, ewmh[_NET_WM_DESKTOP].atom, XCB_ATOM_CARDINAL, 32, 1, &wsid); } } if (unfocus) unfocus_win(win); if (ws->focus_prev == win) ws->focus_prev = NULL; if (focus_mode != SWM_FOCUS_FOLLOW && ws->focus_pending != NULL) { ws->focus = ws->focus_pending; ws->focus_pending = NULL; } /* Don't unmap if new ws is visible */ if (nws->r == NULL) unmap_window(win); /* Transfer */ TAILQ_REMOVE(&ws->winlist, win, entry); TAILQ_REMOVE(&ws->stack, win, stack_entry); TAILQ_INSERT_TAIL(&nws->winlist, win, entry); TAILQ_INSERT_TAIL(&nws->stack, win, stack_entry); win->ws = nws; /* Update the window's workspace property: _NET_WM_DESKTOP */ DNPRINTF(SWM_D_PROP, "set property: _NET_WM_DESKTOP: %d\n", wsid); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, ewmh[_NET_WM_DESKTOP].atom, XCB_ATOM_CARDINAL, 32, 1, &wsid); ewmh_update_client_list(); DNPRINTF(SWM_D_MOVE, "done\n"); } void pressbutton(struct binding *bp, struct swm_region *r, union arg *args) { /* suppress unused warning since var is needed */ (void)bp; (void)r; xcb_test_fake_input(conn, XCB_BUTTON_PRESS, args->id, XCB_CURRENT_TIME, XCB_WINDOW_NONE, 0, 0, 0); xcb_test_fake_input(conn, XCB_BUTTON_RELEASE, args->id, XCB_CURRENT_TIME, XCB_WINDOW_NONE, 0, 0, 0); } void raise_focus(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *win; uint32_t val; /* Suppress warning. */ (void)bp; (void)args; if (r == NULL || r->ws == NULL || r->ws->focus == NULL) return; win = r->ws->focus; r->ws->focus_raise = win; raise_window(win); /* Temporarily override stacking order also in the stack */ if (!FLOATING(win)) { val = XCB_STACK_MODE_ABOVE; xcb_configure_window(conn, win->frame, XCB_CONFIG_WINDOW_STACK_MODE, &val); } } void raise_toggle(struct binding *bp, struct swm_region *r, union arg *args) { /* Suppress warning. */ (void)bp; (void)args; if (r == NULL || r->ws == NULL) return; if (r->ws->focus && MAXIMIZED(r->ws->focus)) return; r->ws->always_raise = !r->ws->always_raise; /* Update focused win stacking order based on new always_raise value. */ raise_window(r->ws->focus); focus_flush(); } void iconify(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *w; /* Suppress warning. */ (void)bp; (void)args; if ((w = r->ws->focus) == NULL) return; ewmh_apply_flags(w, w->ewmh_flags | EWMH_F_HIDDEN); ewmh_update_wm_state(w); stack(r); focus_flush(); } char * get_win_name(xcb_window_t win) { char *name = NULL; xcb_get_property_cookie_t c; xcb_get_property_reply_t *r; /* First try _NET_WM_NAME for UTF-8. */ c = xcb_get_property(conn, 0, win, ewmh[_NET_WM_NAME].atom, XCB_GET_PROPERTY_TYPE_ANY, 0, UINT_MAX); r = xcb_get_property_reply(conn, c, NULL); if (r && r->type == XCB_NONE) { free(r); /* Use WM_NAME instead; no UTF-8. */ c = xcb_get_property(conn, 0, win, XCB_ATOM_WM_NAME, XCB_GET_PROPERTY_TYPE_ANY, 0, UINT_MAX); r = xcb_get_property_reply(conn, c, NULL); } if (r && r->type != XCB_NONE && r->length > 0) name = strndup(xcb_get_property_value(r), xcb_get_property_value_length(r)); else name = strdup(""); if (name == NULL) err(1, "get_win_name: failed to allocate memory."); free(r); return (name); } void uniconify(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *win; FILE *lfile; char *name; int count = 0; (void)bp; DNPRINTF(SWM_D_MISC, "begin\n"); if (r == NULL || r->ws == NULL) return; /* make sure we have anything to uniconify */ TAILQ_FOREACH(win, &r->ws->winlist, entry) { if (win->ws == NULL) continue; /* should never happen */ if (!ICONIC(win)) continue; count++; } DNPRINTF(SWM_D_MISC, "count: %d\n", count); if (count == 0) return; search_r = r; search_resp_action = SWM_SEARCH_UNICONIFY; spawn_select(r, args, "search", &searchpid); if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) return; TAILQ_FOREACH(win, &r->ws->winlist, entry) { if (win->ws == NULL) continue; /* should never happen */ if (!ICONIC(win)) continue; name = get_win_name(win->id); fprintf(lfile, "%s.%u\n", name, win->id); free(name); } fclose(lfile); } void name_workspace(struct binding *bp, struct swm_region *r, union arg *args) { FILE *lfile; (void)bp; DNPRINTF(SWM_D_MISC, "begin\n"); if (r == NULL) return; search_r = r; search_resp_action = SWM_SEARCH_NAME_WORKSPACE; spawn_select(r, args, "name_workspace", &searchpid); if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) return; fprintf(lfile, "%s", ""); fclose(lfile); } void search_workspace(struct binding *bp, struct swm_region *r, union arg *args) { int i; struct workspace *ws; FILE *lfile; (void)bp; DNPRINTF(SWM_D_MISC, "begin\n"); if (r == NULL) return; search_r = r; search_resp_action = SWM_SEARCH_SEARCH_WORKSPACE; spawn_select(r, args, "search", &searchpid); if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) return; for (i = 0; i < workspace_limit; i++) { ws = &r->s->ws[i]; if (ws == NULL) continue; fprintf(lfile, "%d%s%s\n", ws->idx + 1, (ws->name ? ":" : ""), (ws->name ? ws->name : "")); } fclose(lfile); } void search_win_cleanup(void) { struct search_window *sw = NULL; #ifndef __clang_analyzer__ /* Suppress false warnings. */ while ((sw = TAILQ_FIRST(&search_wl)) != NULL) { xcb_destroy_window(conn, sw->indicator); TAILQ_REMOVE(&search_wl, sw, entry); free(sw); } #endif } void search_win(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *win = NULL; struct search_window *sw = NULL; xcb_window_t w; uint32_t wa[3]; xcb_screen_t *screen; int i, width, height; char s[11]; FILE *lfile; size_t len; XftDraw *draw; XGlyphInfo info; GC l_draw; XGCValues l_gcv; XRectangle l_ibox, l_lbox = {0, 0, 0, 0}; (void)bp; DNPRINTF(SWM_D_MISC, "begin\n"); search_r = r; search_resp_action = SWM_SEARCH_SEARCH_WINDOW; spawn_select(r, args, "search", &searchpid); if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) return; if ((screen = get_screen(r->s->idx)) == NULL) errx(1, "ERROR: can't get screen %d.", r->s->idx); i = 1; TAILQ_FOREACH(win, &r->ws->winlist, entry) { if (ICONIC(win)) continue; sw = calloc(1, sizeof(struct search_window)); if (sw == NULL) { warn("search_win: calloc"); fclose(lfile); search_win_cleanup(); return; } sw->idx = i; sw->win = win; snprintf(s, sizeof s, "%d", i); len = strlen(s); w = xcb_generate_id(conn); wa[0] = r->s->c[SWM_S_COLOR_FOCUS].pixel; wa[1] = r->s->c[SWM_S_COLOR_UNFOCUS].pixel; wa[2] = r->s->colormap; if (bar_font_legacy) { XmbTextExtents(bar_fs, s, len, &l_ibox, &l_lbox); width = l_lbox.width + 4; height = bar_fs_extents->max_logical_extent.height + 4; } else { XftTextExtentsUtf8(display, bar_font, (FcChar8 *)s, len, &info); width = info.width + 4; height = bar_font->height + 4; } xcb_create_window(conn, win->s->depth, w, win->frame, 0, 0, width, height, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT, win->s->visual, XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP, wa); xcb_map_window(conn, w); sw->indicator = w; TAILQ_INSERT_TAIL(&search_wl, sw, entry); if (bar_font_legacy) { l_gcv.graphics_exposures = 0; l_draw = XCreateGC(display, w, 0, &l_gcv); XSetForeground(display, l_draw, r->s->c[SWM_S_COLOR_BAR].pixel); DRAWSTRING(display, w, bar_fs, l_draw, 2, (bar_fs_extents->max_logical_extent.height - l_lbox.height) / 2 - l_lbox.y, s, len); XFreeGC(display, l_draw); } else { draw = XftDrawCreate(display, w, r->s->xvisual, r->s->colormap); XftDrawStringUtf8(draw, &search_font_color, bar_font, 2, (HEIGHT(r->bar) + bar_font->height) / 2 - bar_font->descent, (FcChar8 *)s, len); XftDrawDestroy(draw); } DNPRINTF(SWM_D_MISC, "mapped win %#x\n", w); fprintf(lfile, "%d\n", i); i++; } fclose(lfile); xcb_flush(conn); } void search_resp_uniconify(const char *resp, size_t len) { char *name; struct ws_win *win; char *s; DNPRINTF(SWM_D_MISC, "resp: %s\n", resp); TAILQ_FOREACH(win, &search_r->ws->winlist, entry) { if (!ICONIC(win)) continue; name = get_win_name(win->id); if (asprintf(&s, "%s.%u", name, win->id) == -1) { free(name); continue; } free(name); if (strncmp(s, resp, len) == 0) { /* XXX this should be a callback to generalize */ ewmh_apply_flags(win, win->ewmh_flags & ~EWMH_F_HIDDEN); ewmh_update_wm_state(win); stack(search_r); free(s); break; } free(s); } } void search_resp_name_workspace(const char *resp, size_t len) { struct workspace *ws; DNPRINTF(SWM_D_MISC, "resp: %s\n", resp); if (search_r->ws == NULL) return; ws = search_r->ws; if (ws->name) { free(search_r->ws->name); search_r->ws->name = NULL; } if (len > 1) { ws->name = strdup(resp); if (ws->name == NULL) { DNPRINTF(SWM_D_MISC, "strdup: %s", strerror(errno)); return; } ewmh_update_desktop_names(); ewmh_get_desktop_names(); } } void ewmh_update_desktop_names(void) { char *name_list = NULL, *p; int num_screens, i, j, len = 0, tot = 0; num_screens = get_screen_count(); for (i = 0; i < num_screens; ++i) { for (j = 0; j < workspace_limit; ++j) { if (screens[i].ws[j].name != NULL) len += strlen(screens[i].ws[j].name); ++len; } if ((name_list = calloc(len, sizeof(char))) == NULL) err(1, "update_desktop_names: calloc: failed to " "allocate memory."); p = name_list; for (j = 0; j < workspace_limit; ++j) { if (screens[i].ws[j].name != NULL) { len = strlen(screens[i].ws[j].name); memcpy(p, screens[i].ws[j].name, len); } else { len = 0; } p += len + 1; tot += len + 1; } xcb_change_property(conn, XCB_PROP_MODE_REPLACE, screens[i].root, ewmh[_NET_DESKTOP_NAMES].atom, a_utf8_string, 8, tot, name_list); free(name_list); name_list = NULL; } free(name_list); } void ewmh_get_desktop_names(void) { char *names = NULL; xcb_get_property_cookie_t c; xcb_get_property_reply_t *r; int num_screens, i, j, n, k; num_screens = get_screen_count(); for (i = 0; i < num_screens; ++i) { for (j = 0; j < workspace_limit; ++j) { free(screens[i].ws[j].name); screens[i].ws[j].name = NULL; } c = xcb_get_property(conn, 0, screens[i].root, ewmh[_NET_DESKTOP_NAMES].atom, a_utf8_string, 0, UINT32_MAX); r = xcb_get_property_reply(conn, c, NULL); if (r == NULL) continue; names = xcb_get_property_value(r); n = xcb_get_property_value_length(r); for (j = 0, k = 0; j < n; ++j) { if (*(names + j) != '\0') { screens[i].ws[k].name = strdup(names + j); j += strlen(names + j); } ++k; } free(r); } } void ewmh_update_client_list(void) { struct ws_win *win; int num_screens, i, j, k = 0, count = 0; xcb_window_t *wins; num_screens = get_screen_count(); for (i = 0; i < num_screens; ++i) { for (j = 0; j < workspace_limit; ++j) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) ++count; DNPRINTF(SWM_D_PROP, "win count: %d\n", count); if (count == 0) continue; wins = calloc(count, sizeof(xcb_window_t)); if (wins == NULL) err(1, "ewmh_update_client_list: calloc: failed to " "allocate memory."); for (j = 0, k = 0; j < workspace_limit; ++j) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) wins[k++] = win->id; xcb_change_property(conn, XCB_PROP_MODE_REPLACE, screens[i].root, ewmh[_NET_CLIENT_LIST].atom, XCB_ATOM_WINDOW, 32, count, wins); free(wins); } } void ewmh_update_current_desktop(void) { int num_screens, i; num_screens = get_screen_count(); for (i = 0; i < num_screens; ++i) { if (screens[i].r_focus) xcb_change_property(conn, XCB_PROP_MODE_REPLACE, screens[i].root, ewmh[_NET_CURRENT_DESKTOP].atom, XCB_ATOM_CARDINAL, 32, 1, &screens[i].r_focus->ws->idx); } } void ewmh_update_desktops(void) { int num_screens, i, j; uint32_t *vals; vals = calloc(workspace_limit * 2, sizeof(uint32_t)); if (vals == NULL) err(1, "ewmh_update_desktops: calloc: failed to allocate " "memory."); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { xcb_change_property(conn, XCB_PROP_MODE_REPLACE, screens[i].root, ewmh[_NET_NUMBER_OF_DESKTOPS].atom, XCB_ATOM_CARDINAL, 32, 1, &workspace_limit); for (j = 0; j < workspace_limit; ++j) { if (screens[i].ws[j].r != NULL) { vals[j * 2] = X(screens[i].ws[j].r); vals[j * 2 + 1] = Y(screens[i].ws[j].r); } else if (screens[i].ws[j].old_r != NULL) { vals[j * 2] = X(screens[i].ws[j].old_r); vals[j * 2 + 1] = Y(screens[i].ws[j].old_r); } else { vals[j * 2] = vals[j * 2 + 1] = 0; } } xcb_change_property(conn, XCB_PROP_MODE_REPLACE, screens[i].root, ewmh[_NET_DESKTOP_VIEWPORT].atom, XCB_ATOM_CARDINAL, 32, workspace_limit * 2, vals); } free(vals); } void search_resp_search_workspace(const char *resp) { char *p, *q; int ws_idx; const char *errstr; union arg a; DNPRINTF(SWM_D_MISC, "resp: %s\n", resp); q = strdup(resp); if (q == NULL) { DNPRINTF(SWM_D_MISC, "strdup: %s", strerror(errno)); return; } p = strchr(q, ':'); if (p != NULL) *p = '\0'; ws_idx = (int)strtonum(q, 1, workspace_limit, &errstr); if (errstr) { DNPRINTF(SWM_D_MISC, "workspace idx is %s: %s", errstr, q); free(q); return; } free(q); a.id = ws_idx - 1; switchws(NULL, search_r, &a); } void search_resp_search_window(const char *resp) { char *s; int idx; const char *errstr; struct search_window *sw; DNPRINTF(SWM_D_MISC, "resp: %s\n", resp); s = strdup(resp); if (s == NULL) { DNPRINTF(SWM_D_MISC, "strdup: %s", strerror(errno)); return; } idx = (int)strtonum(s, 1, INT_MAX, &errstr); if (errstr) { DNPRINTF(SWM_D_MISC, "window idx is %s: %s", errstr, s); free(s); return; } free(s); TAILQ_FOREACH(sw, &search_wl, entry) if (idx == sw->idx) { focus_win(sw->win); break; } } #define MAX_RESP_LEN 1024 void search_do_resp(void) { ssize_t rbytes; char *resp; size_t len; DNPRINTF(SWM_D_MISC, "begin\n"); search_resp = 0; searchpid = 0; if ((resp = calloc(1, MAX_RESP_LEN + 1)) == NULL) { warn("search: calloc"); goto done; } rbytes = read(select_resp_pipe[0], resp, MAX_RESP_LEN); if (rbytes <= 0) { warn("search: read error"); goto done; } resp[rbytes] = '\0'; /* XXX: * Older versions of dmenu (Atleast pre 4.4.1) do not send a * newline, so work around that by sanitizing the resp now. */ resp[strcspn(resp, "\n")] = '\0'; len = strlen(resp); switch (search_resp_action) { case SWM_SEARCH_UNICONIFY: search_resp_uniconify(resp, len); break; case SWM_SEARCH_NAME_WORKSPACE: search_resp_name_workspace(resp, len); break; case SWM_SEARCH_SEARCH_WORKSPACE: search_resp_search_workspace(resp); break; case SWM_SEARCH_SEARCH_WINDOW: search_resp_search_window(resp); break; } done: if (search_resp_action == SWM_SEARCH_SEARCH_WINDOW) search_win_cleanup(); search_resp_action = SWM_SEARCH_NONE; close(select_resp_pipe[0]); free(resp); xcb_flush(conn); } void wkill(struct binding *bp, struct swm_region *r, union arg *args) { (void)bp; DNPRINTF(SWM_D_MISC, "win %#x, id: %d\n", WINID(r->ws->focus), args->id); if (r->ws->focus == NULL) return; if (args->id == SWM_ARG_ID_KILLWINDOW) xcb_kill_client(conn, r->ws->focus->id); else if (r->ws->focus->can_delete) client_msg(r->ws->focus, a_delete, 0); focus_flush(); } int clear_maximized(struct workspace *ws) { struct ws_win *w; int count = 0; /* Clear any maximized win(s) on ws, from bottom up. */ TAILQ_FOREACH_REVERSE(w, &ws->stack, ws_win_stack, stack_entry) if (MAXIMIZED(w)) { ewmh_apply_flags(w, w->ewmh_flags & ~EWMH_F_MAXIMIZED); ewmh_update_wm_state(w); ++count; } return (count); } void maximize_toggle(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *w = r->ws->focus; /* suppress unused warning since var is needed */ (void)bp; (void)args; if (w == NULL) return; DNPRINTF(SWM_D_MISC, "win %#x\n", w->id); if (FULLSCREEN(w)) return; if (w->ws->cur_layout == &layouts[SWM_MAX_STACK]) return; ewmh_apply_flags(w, w->ewmh_flags ^ EWMH_F_MAXIMIZED); ewmh_update_wm_state(w); stack(r); if (w == w->ws->focus) focus_win(w); center_pointer(r); focus_flush(); DNPRINTF(SWM_D_MISC, "done\n"); } void floating_toggle(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *w = r->ws->focus; /* suppress unused warning since var is needed */ (void)bp; (void)args; if (w == NULL) return; DNPRINTF(SWM_D_MISC, "win %#x\n", w->id); if (FULLSCREEN(w) || TRANS(w)) return; if (w->ws->cur_layout == &layouts[SWM_MAX_STACK]) return; ewmh_apply_flags(w, w->ewmh_flags ^ EWMH_F_ABOVE); ewmh_update_wm_state(w); stack(r); if (w == w->ws->focus) focus_win(w); center_pointer(r); focus_flush(); DNPRINTF(SWM_D_MISC, "done\n"); } void fullscreen_toggle(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *w = r->ws->focus; /* suppress unused warning since var is needed */ (void)bp; (void)args; if (w == NULL) return; DNPRINTF(SWM_D_MISC, "win %#x\n", w->id); ewmh_apply_flags(w, w->ewmh_flags ^ EWMH_F_FULLSCREEN); ewmh_update_wm_state(w); stack(r); if (w == w->ws->focus) focus_win(w); center_pointer(r); focus_flush(); DNPRINTF(SWM_D_MISC, "done\n"); } void region_containment(struct ws_win *win, struct swm_region *r, int opts) { struct swm_geometry g = r->g; int rt, lt, tp, bm, bw; bw = (opts & SWM_CW_SOFTBOUNDARY) ? boundary_width : 0; /* * Perpendicular distance of each side of the window to the respective * side of the region boundary. Positive values indicate the side of * the window has passed beyond the region boundary. */ rt = opts & SWM_CW_RIGHT ? MAX_X(win) - MAX_X(r) : bw; lt = opts & SWM_CW_LEFT ? X(r) - X(win) : bw; bm = opts & SWM_CW_BOTTOM ? MAX_Y(win) - MAX_Y(r) : bw; tp = opts & SWM_CW_TOP ? Y(r) - Y(win) : bw; DNPRINTF(SWM_D_MISC, "win %#x, rt: %d, lt: %d, bm: %d, tp: %d, " "SOFTBOUNDARY: %s, HARDBOUNDARY: %s\n", win->id, rt, lt, bm, tp, YESNO(opts & SWM_CW_SOFTBOUNDARY), YESNO(opts & SWM_CW_HARDBOUNDARY)); /* * Disable containment if any of the flagged sides went beyond the * containment boundary, or if containment is disabled. */ if (!(opts & SWM_CW_HARDBOUNDARY || opts & SWM_CW_SOFTBOUNDARY) || (bw != 0 && ((rt > bw) || (lt > bw) || (bm > bw) || (tp > bw)))) { /* Make sure window has at least 1 pixel in the region */ g.x += 1 - WIDTH(win); g.y += 1 - HEIGHT(win); g.w += 2 * WIDTH(win) - 2; g.h += 2 * HEIGHT(win) - 2; } constrain_window(win, &g, &opts); } /* Move or resize a window so that flagged side(s) fit into the supplied box. */ void constrain_window(struct ws_win *win, struct swm_geometry *b, int *opts) { DNPRINTF(SWM_D_MISC, "win %#x, (x,y) w x h: (%d,%d) %d x %d, " "box: (x,y) w x h: (%d,%d) %d x %d, rt: %s, lt: %s, bt: %s, " "tp: %s, allow resize: %s\n", win->id, X(win), Y(win), WIDTH(win), HEIGHT(win), b->x, b->y, b->w, b->h, YESNO(*opts & SWM_CW_RIGHT), YESNO(*opts & SWM_CW_LEFT), YESNO(*opts & SWM_CW_BOTTOM), YESNO(*opts & SWM_CW_TOP), YESNO(*opts & SWM_CW_RESIZABLE)); if ((*opts & SWM_CW_RIGHT) && MAX_X(win) > b->x + b->w) { if (*opts & SWM_CW_RESIZABLE) WIDTH(win) = b->x + b->w - X(win); else X(win) = b->x + b->w - WIDTH(win); } if ((*opts & SWM_CW_LEFT) && X(win) < b->x) { if (*opts & SWM_CW_RESIZABLE) WIDTH(win) -= b->x - X(win); X(win) = b->x; } if ((*opts & SWM_CW_BOTTOM) && MAX_Y(win) > b->y + b->h) { if (*opts & SWM_CW_RESIZABLE) HEIGHT(win) = b->y + b->h - Y(win); else Y(win) = b->y + b->h - HEIGHT(win); } if ((*opts & SWM_CW_TOP) && Y(win) < b->y) { if (*opts & SWM_CW_RESIZABLE) HEIGHT(win) -= b->y - Y(win); Y(win) = b->y; } if (*opts & SWM_CW_RESIZABLE) { if (WIDTH(win) < 1) WIDTH(win) = 1; if (HEIGHT(win) < 1) HEIGHT(win) = 1; } } void draw_frame(struct ws_win *win) { xcb_rectangle_t rect[4]; uint32_t *pixel; int n = 0; if (win->frame == XCB_WINDOW_NONE) { DNPRINTF(SWM_D_EVENT, "win %#x not reparented\n", win->id); return; } if (!win->bordered) { DNPRINTF(SWM_D_EVENT, "win %#x frame disabled\n", win->id); } if (WS_FOCUSED(win->ws) && win->ws->focus == win) pixel = MAXIMIZED(win) ? &win->s->c[SWM_S_COLOR_FOCUS_MAXIMIZED].pixel : &win->s->c[SWM_S_COLOR_FOCUS].pixel; else pixel = MAXIMIZED(win) ? &win->s->c[SWM_S_COLOR_UNFOCUS_MAXIMIZED].pixel : &win->s->c[SWM_S_COLOR_UNFOCUS].pixel; /* Top (with corners) */ rect[n].x = 0; rect[n].y = 0; rect[n].width = WIDTH(win) + 2 * border_width; rect[n].height = border_width; /* Left (without corners) */ rect[++n].x = 0; rect[n].y = border_width; rect[n].width = border_width; rect[n].height = HEIGHT(win); /* Right (without corners) */ rect[++n].x = border_width + WIDTH(win); rect[n].y = border_width; rect[n].width = border_width; rect[n].height = HEIGHT(win); /* Bottom (with corners)*/ rect[++n].x = 0; rect[n].y = border_width + HEIGHT(win); rect[n].width = WIDTH(win) + 2 * border_width; rect[n].height = border_width; xcb_change_gc(conn, win->s->gc, XCB_GC_FOREGROUND, pixel); xcb_poly_fill_rectangle(conn, win->frame, win->s->gc, 4, rect); } void update_window(struct ws_win *win) { uint16_t mask; uint32_t wc[5]; if (win->frame == XCB_WINDOW_NONE) { DNPRINTF(SWM_D_EVENT, "skip win %#x; not reparented\n", win->id); return; } mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_BORDER_WIDTH; /* Reconfigure frame. */ if (win->bordered) { wc[0] = X(win) - border_width; wc[1] = Y(win) - border_width; wc[2] = WIDTH(win) + 2 * border_width; wc[3] = HEIGHT(win) + 2 * border_width; } else { wc[0] = X(win); wc[1] = Y(win); wc[2] = WIDTH(win); wc[3] = HEIGHT(win); } wc[4] = 0; DNPRINTF(SWM_D_EVENT, "win %#x frame %#x, (x,y) w x h: (%d,%d) %d x %d," " bordered: %s\n", win->id, win->frame, wc[0], wc[1], wc[2], wc[3], YESNO(win->bordered)); xcb_configure_window(conn, win->frame, mask, wc); /* Reconfigure client window. */ wc[0] = wc[1] = win->bordered ? border_width : 0; wc[2] = WIDTH(win); wc[3] = HEIGHT(win); DNPRINTF(SWM_D_EVENT, "win %#x, (x,y) w x h: (%d,%d) %d x %d, " "bordered: %s\n", win->id, wc[0], wc[1], wc[2], wc[3], YESNO(win->bordered)); xcb_configure_window(conn, win->id, mask, wc); /* ICCCM 4.2.3 Synthetic ConfigureNotify when moved and not resized. */ if ((X(win) != win->g_prev.x || Y(win) != win->g_prev.y) && (win->java || (WIDTH(win) == win->g_prev.w && HEIGHT(win) == win->g_prev.h))) { /* Java has special needs when moved together with a resize. */ config_win(win, NULL); } win->g_prev = win->g; } struct event { SIMPLEQ_ENTRY(event) entry; xcb_generic_event_t *ev; }; SIMPLEQ_HEAD(event_queue, event) events = SIMPLEQ_HEAD_INITIALIZER(events); xcb_generic_event_t * get_next_event(bool dowait) { struct event *ep; xcb_generic_event_t *evt; /* Try queue first. */ if ((ep = SIMPLEQ_FIRST(&events))) { evt = ep->ev; SIMPLEQ_REMOVE_HEAD(&events, entry); free(ep); } else if (dowait) evt = xcb_wait_for_event(conn); else evt = xcb_poll_for_event(conn); return (evt); } void put_back_event(xcb_generic_event_t *evt) { struct event *ep; if ((ep = malloc(sizeof (struct event))) == NULL) err(1, "put_back_event: failed to allocate memory."); ep->ev = evt; SIMPLEQ_INSERT_HEAD(&events, ep, entry); } /* Peeks at next event to detect auto-repeat. */ bool keyrepeating(xcb_key_release_event_t *kre) { xcb_generic_event_t *evt; /* Ensure repeating keypress is finished processing. */ xcb_aux_sync(conn); if ((evt = get_next_event(false))) { put_back_event(evt); if (XCB_EVENT_RESPONSE_TYPE(evt) == XCB_KEY_PRESS && kre->sequence == evt->sequence && kre->detail == ((xcb_key_press_event_t *)evt)->detail) return (true); } return (false); } bool keybindreleased(struct binding *bp, xcb_key_release_event_t *kre) { if (bp->type == KEYBIND && !keyrepeating(kre) && bp->value == xcb_key_press_lookup_keysym(syms, kre, 0)) return (true); return (false); } #define SWM_RESIZE_STEPS (50) void resize_win(struct ws_win *win, struct binding *bp, int opt) { xcb_timestamp_t timestamp = 0, mintime; struct swm_region *r = NULL; struct swm_geometry g; int top = 0, left = 0; int dx, dy; xcb_cursor_t cursor; xcb_query_pointer_reply_t *xpr = NULL; xcb_generic_event_t *evt; xcb_motion_notify_event_t *mne; bool resizing, step = false; if (win == NULL) return; r = win->ws->r; if (FULLSCREEN(win)) return; /* In max_stack mode, should only resize transients. */ if (win->ws->cur_layout == &layouts[SWM_MAX_STACK] && !TRANS(win)) return; DNPRINTF(SWM_D_EVENT, "win %#x, floating: %s, transient: %#x\n", win->id, YESNO(ABOVE(win)), win->transient); if (MAXIMIZED(win)) store_float_geom(win); else if (!(TRANS(win) || ABOVE(win))) return; ewmh_apply_flags(win, (win->ewmh_flags | SWM_F_MANUAL | EWMH_F_ABOVE) & ~EWMH_F_MAXIMIZED); ewmh_update_wm_state(win); stack(r); focus_flush(); /* It's possible for win to have been freed during focus_flush(). */ if (validate_win(win)) { DNPRINTF(SWM_D_EVENT, "invalid win\n"); goto out; } switch (opt) { case SWM_ARG_ID_WIDTHSHRINK: WIDTH(win) -= SWM_RESIZE_STEPS; step = true; break; case SWM_ARG_ID_WIDTHGROW: WIDTH(win) += SWM_RESIZE_STEPS; step = true; break; case SWM_ARG_ID_HEIGHTSHRINK: HEIGHT(win) -= SWM_RESIZE_STEPS; step = true; break; case SWM_ARG_ID_HEIGHTGROW: HEIGHT(win) += SWM_RESIZE_STEPS; step = true; break; default: break; } if (step) { region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_RESIZABLE | SWM_CW_HARDBOUNDARY); update_window(win); store_float_geom(win); return; } region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_RESIZABLE | SWM_CW_SOFTBOUNDARY); update_window(win); /* get cursor offset from window root */ xpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id), NULL); if (xpr == NULL) return; mintime = 1000 / r->s->rate; g = win->g; if (xpr->win_x < WIDTH(win) / 2) left = 1; if (xpr->win_y < HEIGHT(win) / 2) top = 1; if (opt == SWM_ARG_ID_CENTER) cursor = cursors[XC_SIZING].cid; else if (top) cursor = cursors[left ? XC_TOP_LEFT_CORNER : XC_TOP_RIGHT_CORNER].cid; else cursor = cursors[left ? XC_BOTTOM_LEFT_CORNER : XC_BOTTOM_RIGHT_CORNER].cid; xcb_grab_pointer(conn, 0, win->id, MOUSEMASK, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, cursor, XCB_CURRENT_TIME); /* Release keyboard freeze if called via keybind. */ if (bp->type == KEYBIND) xcb_allow_events(conn, XCB_ALLOW_ASYNC_KEYBOARD, XCB_CURRENT_TIME); xcb_flush(conn); resizing = true; while (resizing && (evt = get_next_event(true))) { switch (XCB_EVENT_RESPONSE_TYPE(evt)) { case XCB_BUTTON_RELEASE: if (bp->type == BTNBIND && bp->value == ((xcb_button_release_event_t *)evt)->detail) resizing = false; break; case XCB_KEY_RELEASE: if (keybindreleased(bp, (xcb_key_release_event_t *)evt)) resizing = false; break; case XCB_MOTION_NOTIFY: mne = (xcb_motion_notify_event_t *)evt; DNPRINTF(SWM_D_EVENT, "MOTION_NOTIFY: root: %#x\n", mne->root); /* cursor offset/delta from start of the operation */ dx = mne->root_x - xpr->root_x; dy = mne->root_y - xpr->root_y; /* vertical */ if (top) dy = -dy; if (opt == SWM_ARG_ID_CENTER) { if (g.h / 2 + dy < 1) dy = 1 - g.h / 2; Y(win) = g.y - dy; HEIGHT(win) = g.h + 2 * dy; } else { if (g.h + dy < 1) dy = 1 - g.h; if (top) Y(win) = g.y - dy; HEIGHT(win) = g.h + dy; } /* horizontal */ if (left) dx = -dx; if (opt == SWM_ARG_ID_CENTER) { if (g.w / 2 + dx < 1) dx = 1 - g.w / 2; X(win) = g.x - dx; WIDTH(win) = g.w + 2 * dx; } else { if (g.w + dx < 1) dx = 1 - g.w; if (left) X(win) = g.x - dx; WIDTH(win) = g.w + dx; } /* Don't sync faster than the current rate limit. */ if ((mne->time - timestamp) > mintime) { timestamp = mne->time; regionize(win, mne->root_x, mne->root_y); region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_RESIZABLE | SWM_CW_HARDBOUNDARY | SWM_CW_SOFTBOUNDARY); update_window(win); xcb_flush(conn); } break; case XCB_BUTTON_PRESS: /* Ignore. */ DNPRINTF(SWM_D_EVENT, "BUTTON_PRESS ignored\n"); xcb_allow_events(conn, XCB_ALLOW_ASYNC_POINTER, ((xcb_button_press_event_t *)evt)->time); xcb_flush(conn); break; case XCB_KEY_PRESS: /* Ignore. */ DNPRINTF(SWM_D_EVENT, "KEY_PRESS ignored\n"); xcb_allow_events(conn, XCB_ALLOW_ASYNC_KEYBOARD, ((xcb_key_press_event_t *)evt)->time); xcb_flush(conn); break; default: event_handle(evt); /* It's possible for win to have been freed above. */ if (validate_win(win)) { DNPRINTF(SWM_D_EVENT, "invalid win\n"); goto out; } break; } free(evt); } if (timestamp) { region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_RESIZABLE | SWM_CW_HARDBOUNDARY | SWM_CW_SOFTBOUNDARY); update_window(win); xcb_flush(conn); } store_float_geom(win); out: xcb_ungrab_pointer(conn, XCB_CURRENT_TIME); free(xpr); DNPRINTF(SWM_D_EVENT, "done\n"); } void resize(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *win = NULL; xcb_query_pointer_reply_t *qpr = NULL; if (r == NULL) return; if (args->id != SWM_ARG_ID_DONTCENTER && args->id != SWM_ARG_ID_CENTER) { /* {height,width}_{grow,shrink} use the focus window. */ if (r->ws) win = r->ws->focus; } else { /* resize uses window under pointer. */ qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, r->s->root), NULL); if (qpr) win = find_window(qpr->child); } if (win == NULL) return; resize_win(win, bp, args->id); if (args->id && bp->type == KEYBIND) center_pointer(r); focus_flush(); } /* Try to set window region based on supplied coordinates or window center. */ void regionize(struct ws_win *win, int x, int y) { struct swm_region *r = NULL; r = region_under(win->s, x, y); if (r == NULL) r = region_under(win->s, X(win) + WIDTH(win) / 2, Y(win) + HEIGHT(win) / 2); if (r && r != win->ws->r) { clear_maximized(r->ws); win_to_ws(win, r->ws->idx, false); /* Stack old and new region. */ stack(r); stack(win->ws->r); /* Set focus on new ws. */ unfocus_win(r->ws->focus); r->ws->focus = win; set_region(r); raise_window(win); } } #define SWM_MOVE_STEPS (50) void move_win(struct ws_win *win, struct binding *bp, int opt) { struct swm_region *r; xcb_timestamp_t timestamp = 0, mintime; xcb_query_pointer_reply_t *qpr = NULL; xcb_generic_event_t *evt; xcb_motion_notify_event_t *mne; bool moving, restack = false, step = false; if (win == NULL) return; if ((r = win->ws->r) == NULL) return; if (FULLSCREEN(win)) return; DNPRINTF(SWM_D_EVENT, "win %#x, floating: %s, transient: %#x\n", win->id, YESNO(ABOVE(win)), win->transient); /* in max_stack mode should only move transients */ if (win->ws->cur_layout == &layouts[SWM_MAX_STACK] && !TRANS(win)) return; if (!(ABOVE(win) || TRANS(win)) || MAXIMIZED(win)) { store_float_geom(win); restack = true; } ewmh_apply_flags(win, (win->ewmh_flags | SWM_F_MANUAL | EWMH_F_ABOVE) & ~EWMH_F_MAXIMIZED); ewmh_update_wm_state(win); if (restack) stack(r); focus_flush(); /* It's possible for win to have been freed during focus_flush(). */ if (validate_win(win)) { DNPRINTF(SWM_D_EVENT, "invalid win.\n"); goto out; } switch (opt) { case SWM_ARG_ID_MOVELEFT: X(win) -= (SWM_MOVE_STEPS - border_width); step = true; break; case SWM_ARG_ID_MOVERIGHT: X(win) += (SWM_MOVE_STEPS - border_width); step = true; break; case SWM_ARG_ID_MOVEUP: Y(win) -= (SWM_MOVE_STEPS - border_width); step = true; break; case SWM_ARG_ID_MOVEDOWN: Y(win) += (SWM_MOVE_STEPS - border_width); step = true; break; default: break; } if (step) { regionize(win, -1, -1); region_containment(win, win->ws->r, SWM_CW_ALLSIDES); update_window(win); store_float_geom(win); return; } xcb_grab_pointer(conn, 0, win->id, MOUSEMASK, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, cursors[XC_FLEUR].cid, XCB_CURRENT_TIME); /* get cursor offset from window root */ qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id), NULL); if (qpr == NULL) { xcb_ungrab_pointer(conn, XCB_CURRENT_TIME); return; } /* Release keyboard freeze if called via keybind. */ if (bp->type == KEYBIND) xcb_allow_events(conn, XCB_ALLOW_ASYNC_KEYBOARD, XCB_CURRENT_TIME); mintime = 1000 / r->s->rate; regionize(win, qpr->root_x, qpr->root_y); region_containment(win, win->ws->r, SWM_CW_ALLSIDES | SWM_CW_SOFTBOUNDARY); update_window(win); xcb_flush(conn); moving = true; while (moving && (evt = get_next_event(true))) { switch (XCB_EVENT_RESPONSE_TYPE(evt)) { case XCB_BUTTON_RELEASE: if (bp->type == BTNBIND && bp->value == ((xcb_button_release_event_t *)evt)->detail) moving = false; xcb_allow_events(conn, XCB_ALLOW_ASYNC_POINTER, ((xcb_button_release_event_t *)evt)->time); xcb_flush(conn); break; case XCB_KEY_RELEASE: if (keybindreleased(bp, (xcb_key_release_event_t *)evt)) moving = false; xcb_allow_events(conn, XCB_ALLOW_ASYNC_KEYBOARD, ((xcb_key_release_event_t *)evt)->time); xcb_flush(conn); break; case XCB_MOTION_NOTIFY: mne = (xcb_motion_notify_event_t *)evt; DNPRINTF(SWM_D_EVENT, "MOTION_NOTIFY: root: %#x time: " "%#x\n", mne->root, mne->time); X(win) = mne->root_x - qpr->win_x; Y(win) = mne->root_y - qpr->win_y; /* Don't sync faster than the current rate limit. */ if ((mne->time - timestamp) > mintime) { timestamp = mne->time; regionize(win, mne->root_x, mne->root_y); region_containment(win, win->ws->r, SWM_CW_ALLSIDES | SWM_CW_SOFTBOUNDARY); update_window(win); xcb_flush(conn); } break; case XCB_BUTTON_PRESS: /* Thaw and ignore. */ xcb_allow_events(conn, XCB_ALLOW_ASYNC_POINTER, ((xcb_button_press_event_t *)evt)->time); xcb_flush(conn); break; case XCB_KEY_PRESS: /* Ignore. */ xcb_allow_events(conn, XCB_ALLOW_ASYNC_KEYBOARD, ((xcb_key_press_event_t *)evt)->time); xcb_flush(conn); break; default: event_handle(evt); /* It's possible for win to have been freed. */ if (validate_win(win)) { DNPRINTF(SWM_D_EVENT, "invalid win\n"); goto out; } break; } free(evt); } if (timestamp) { region_containment(win, win->ws->r, SWM_CW_ALLSIDES | SWM_CW_SOFTBOUNDARY); update_window(win); xcb_flush(conn); } store_float_geom(win); /* New region set to max layout. */ if (win->ws->r && win->ws->cur_layout == &layouts[SWM_MAX_STACK]) { stack(win->ws->r); focus_flush(); } out: free(qpr); xcb_ungrab_pointer(conn, XCB_CURRENT_TIME); DNPRINTF(SWM_D_EVENT, "done\n"); } void move(struct binding *bp, struct swm_region *r, union arg *args) { struct ws_win *win = NULL; xcb_query_pointer_reply_t *qpr = NULL; if (r == NULL) return; if (args->id) { /* move_* uses focus window. */ if (r->ws) win = r->ws->focus; /* Disallow move_ on tiled. */ if (win && !(TRANS(win) || ABOVE(win))) return; } else { /* move uses window under pointer. */ qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, r->s->root), NULL); if (qpr) win = find_window(qpr->child); } if (win == NULL) return; move_win(win, bp, args->id); if (args->id && bp->type == KEYBIND) center_pointer(r); focus_flush(); } /* action definitions */ struct action { char name[SWM_FUNCNAME_LEN]; void (*func)(struct binding *, struct swm_region *, union arg *); uint32_t flags; union arg args; } actions[FN_INVALID + 2] = { /* name function argument */ { "bar_toggle", bar_toggle, 0, {.id = SWM_ARG_ID_BAR_TOGGLE} }, { "bar_toggle_ws", bar_toggle, 0, {.id = SWM_ARG_ID_BAR_TOGGLE_WS} }, { "button2", pressbutton, 0, {.id = 2} }, { "cycle_layout", switchlayout, 0, {.id = SWM_ARG_ID_CYCLE_LAYOUT} }, { "flip_layout", stack_config, 0, {.id = SWM_ARG_ID_FLIPLAYOUT} }, { "float_toggle", floating_toggle,0, {0} }, { "focus", focus_pointer, 0, {0} }, { "focus_main", focus, 0, {.id = SWM_ARG_ID_FOCUSMAIN} }, { "focus_next", focus, 0, {.id = SWM_ARG_ID_FOCUSNEXT} }, { "focus_prev", focus, 0, {.id = SWM_ARG_ID_FOCUSPREV} }, { "focus_urgent", focus, 0, {.id = SWM_ARG_ID_FOCUSURGENT} }, { "fullscreen_toggle", fullscreen_toggle, 0, {0} }, { "maximize_toggle", maximize_toggle,0, {0} }, { "height_grow", resize, 0, {.id = SWM_ARG_ID_HEIGHTGROW} }, { "height_shrink", resize, 0, {.id = SWM_ARG_ID_HEIGHTSHRINK} }, { "iconify", iconify, 0, {0} }, { "layout_vertical", switchlayout, 0, {.id = SWM_ARG_ID_LAYOUT_VERTICAL} }, { "layout_horizontal", switchlayout, 0, {.id = SWM_ARG_ID_LAYOUT_HORIZONTAL} }, { "layout_max" , switchlayout, 0, {.id = SWM_ARG_ID_LAYOUT_MAX} }, { "master_shrink", stack_config, 0, {.id = SWM_ARG_ID_MASTERSHRINK} }, { "master_grow", stack_config, 0, {.id = SWM_ARG_ID_MASTERGROW} }, { "master_add", stack_config, 0, {.id = SWM_ARG_ID_MASTERADD} }, { "master_del", stack_config, 0, {.id = SWM_ARG_ID_MASTERDEL} }, { "move", move, FN_F_NOREPLAY, {0} }, { "move_down", move, 0, {.id = SWM_ARG_ID_MOVEDOWN} }, { "move_left", move, 0, {.id = SWM_ARG_ID_MOVELEFT} }, { "move_right", move, 0, {.id = SWM_ARG_ID_MOVERIGHT} }, { "move_up", move, 0, {.id = SWM_ARG_ID_MOVEUP} }, { "mvrg_1", send_to_rg, 0, {.id = 0} }, { "mvrg_2", send_to_rg, 0, {.id = 1} }, { "mvrg_3", send_to_rg, 0, {.id = 2} }, { "mvrg_4", send_to_rg, 0, {.id = 3} }, { "mvrg_5", send_to_rg, 0, {.id = 4} }, { "mvrg_6", send_to_rg, 0, {.id = 5} }, { "mvrg_7", send_to_rg, 0, {.id = 6} }, { "mvrg_8", send_to_rg, 0, {.id = 7} }, { "mvrg_9", send_to_rg, 0, {.id = 8} }, { "mvrg_next", send_to_rg_relative, 0, {.id = 1} }, { "mvrg_prev", send_to_rg_relative, 0, {.id = -1} }, { "mvws_1", send_to_ws, 0, {.id = 0} }, { "mvws_2", send_to_ws, 0, {.id = 1} }, { "mvws_3", send_to_ws, 0, {.id = 2} }, { "mvws_4", send_to_ws, 0, {.id = 3} }, { "mvws_5", send_to_ws, 0, {.id = 4} }, { "mvws_6", send_to_ws, 0, {.id = 5} }, { "mvws_7", send_to_ws, 0, {.id = 6} }, { "mvws_8", send_to_ws, 0, {.id = 7} }, { "mvws_9", send_to_ws, 0, {.id = 8} }, { "mvws_10", send_to_ws, 0, {.id = 9} }, { "mvws_11", send_to_ws, 0, {.id = 10} }, { "mvws_12", send_to_ws, 0, {.id = 11} }, { "mvws_13", send_to_ws, 0, {.id = 12} }, { "mvws_14", send_to_ws, 0, {.id = 13} }, { "mvws_15", send_to_ws, 0, {.id = 14} }, { "mvws_16", send_to_ws, 0, {.id = 15} }, { "mvws_17", send_to_ws, 0, {.id = 16} }, { "mvws_18", send_to_ws, 0, {.id = 17} }, { "mvws_19", send_to_ws, 0, {.id = 18} }, { "mvws_20", send_to_ws, 0, {.id = 19} }, { "mvws_21", send_to_ws, 0, {.id = 20} }, { "mvws_22", send_to_ws, 0, {.id = 21} }, { "name_workspace", name_workspace, 0, {0} }, { "quit", quit, 0, {0} }, { "raise", raise_focus, 0, {0} }, { "raise_toggle", raise_toggle, 0, {0} }, { "resize", resize, FN_F_NOREPLAY, {.id = SWM_ARG_ID_DONTCENTER} }, { "resize_centered", resize, FN_F_NOREPLAY, {.id = SWM_ARG_ID_CENTER} }, { "restart", restart, 0, {0} }, { "rg_1", focusrg, 0, {.id = 0} }, { "rg_2", focusrg, 0, {.id = 1} }, { "rg_3", focusrg, 0, {.id = 2} }, { "rg_4", focusrg, 0, {.id = 3} }, { "rg_5", focusrg, 0, {.id = 4} }, { "rg_6", focusrg, 0, {.id = 5} }, { "rg_7", focusrg, 0, {.id = 6} }, { "rg_8", focusrg, 0, {.id = 7} }, { "rg_9", focusrg, 0, {.id = 8} }, { "rg_move_next", cyclerg, 0, {.id = SWM_ARG_ID_CYCLERG_MOVE_UP} }, { "rg_move_prev", cyclerg, 0, {.id = SWM_ARG_ID_CYCLERG_MOVE_DOWN} }, { "rg_next", cyclerg, 0, {.id = SWM_ARG_ID_CYCLERG_UP} }, { "rg_prev", cyclerg, 0, {.id = SWM_ARG_ID_CYCLERG_DOWN} }, { "screen_next", cyclerg, 0, {.id = SWM_ARG_ID_CYCLERG_UP} }, { "screen_prev", cyclerg, 0, {.id = SWM_ARG_ID_CYCLERG_DOWN} }, { "search_win", search_win, 0, {0} }, { "search_workspace", search_workspace, 0, {0} }, { "spawn_custom", NULL, 0, {0} }, { "stack_balance", stack_config, 0, {.id = SWM_ARG_ID_STACKBALANCE} }, { "stack_inc", stack_config, 0, {.id = SWM_ARG_ID_STACKINC} }, { "stack_dec", stack_config, 0, {.id = SWM_ARG_ID_STACKDEC} }, { "stack_reset", stack_config, 0, {.id = SWM_ARG_ID_STACKRESET} }, { "swap_main", swapwin, 0, {.id = SWM_ARG_ID_SWAPMAIN} }, { "swap_next", swapwin, 0, {.id = SWM_ARG_ID_SWAPNEXT} }, { "swap_prev", swapwin, 0, {.id = SWM_ARG_ID_SWAPPREV} }, { "uniconify", uniconify, 0, {0} }, { "version", version, 0, {0} }, { "width_grow", resize, 0, {.id = SWM_ARG_ID_WIDTHGROW} }, { "width_shrink", resize, 0, {.id = SWM_ARG_ID_WIDTHSHRINK} }, { "wind_del", wkill, 0, {.id = SWM_ARG_ID_DELETEWINDOW} }, { "wind_kill", wkill, 0, {.id = SWM_ARG_ID_KILLWINDOW} }, { "ws_1", switchws, 0, {.id = 0} }, { "ws_2", switchws, 0, {.id = 1} }, { "ws_3", switchws, 0, {.id = 2} }, { "ws_4", switchws, 0, {.id = 3} }, { "ws_5", switchws, 0, {.id = 4} }, { "ws_6", switchws, 0, {.id = 5} }, { "ws_7", switchws, 0, {.id = 6} }, { "ws_8", switchws, 0, {.id = 7} }, { "ws_9", switchws, 0, {.id = 8} }, { "ws_10", switchws, 0, {.id = 9} }, { "ws_11", switchws, 0, {.id = 10} }, { "ws_12", switchws, 0, {.id = 11} }, { "ws_13", switchws, 0, {.id = 12} }, { "ws_14", switchws, 0, {.id = 13} }, { "ws_15", switchws, 0, {.id = 14} }, { "ws_16", switchws, 0, {.id = 15} }, { "ws_17", switchws, 0, {.id = 16} }, { "ws_18", switchws, 0, {.id = 17} }, { "ws_19", switchws, 0, {.id = 18} }, { "ws_20", switchws, 0, {.id = 19} }, { "ws_21", switchws, 0, {.id = 20} }, { "ws_22", switchws, 0, {.id = 21} }, { "ws_empty", emptyws, 0, {.id = SWM_ARG_ID_WS_EMPTY} }, { "ws_empty_move", emptyws, 0, {.id = SWM_ARG_ID_WS_EMPTY_MOVE} }, { "ws_next", cyclews, 0, {.id = SWM_ARG_ID_CYCLEWS_UP} }, { "ws_next_all", cyclews, 0, {.id = SWM_ARG_ID_CYCLEWS_UP_ALL} }, { "ws_next_move", cyclews, 0, {.id = SWM_ARG_ID_CYCLEWS_MOVE_UP} }, { "ws_prev", cyclews, 0, {.id = SWM_ARG_ID_CYCLEWS_DOWN} }, { "ws_prev_all", cyclews, 0, {.id = SWM_ARG_ID_CYCLEWS_DOWN_ALL} }, { "ws_prev_move", cyclews, 0, {.id = SWM_ARG_ID_CYCLEWS_MOVE_DOWN} }, { "ws_prior", priorws, 0, {0} }, /* SWM_DEBUG actions MUST be here: */ { "debug_toggle", debug_toggle, 0, {0} }, { "dumpwins", dumpwins, 0, {0} }, /* ALWAYS last: */ { "invalid action", NULL, 0, {0} }, }; void update_modkey(uint16_t mod) { struct binding *bp; /* Replace all instances of the old mod key. */ RB_FOREACH(bp, binding_tree, &bindings) if (bp->mod & mod_key) bp->mod = (bp->mod & ~mod_key) | mod; mod_key = mod; } int spawn_expand(struct swm_region *r, union arg *args, const char *spawn_name, char ***ret_args) { struct spawn_prog *prog = NULL; int i, c; char *ap, **real_args; /* suppress unused warning since var is needed */ (void)args; DNPRINTF(SWM_D_SPAWN, "%s\n", spawn_name); /* find program */ TAILQ_FOREACH(prog, &spawns, entry) { if (strcasecmp(spawn_name, prog->name) == 0) break; } if (prog == NULL) { warnx("spawn_custom: program %s not found", spawn_name); return (-1); } /* make room for expanded args */ if ((real_args = calloc(prog->argc + 1, sizeof(char *))) == NULL) err(1, "spawn_custom: calloc real_args"); /* expand spawn_args into real_args */ for (i = c = 0; i < prog->argc; i++) { ap = prog->argv[i]; DNPRINTF(SWM_D_SPAWN, "raw arg: %s\n", ap); if (strcasecmp(ap, "$bar_border") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_BAR_BORDER].name)) == NULL) err(1, "spawn_custom border color"); } else if (strcasecmp(ap, "$bar_color") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_BAR].name)) == NULL) err(1, "spawn_custom bar color"); } else if (strcasecmp(ap, "$bar_color_selected") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_BAR_SELECTED].name)) == NULL) err(1, "spawn_custom bar color selected"); } else if (strcasecmp(ap, "$bar_font") == 0) { if ((real_args[c] = strdup(bar_fonts)) == NULL) err(1, "spawn_custom bar fonts"); } else if (strcasecmp(ap, "$bar_font_color") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_BAR_FONT].name)) == NULL) err(1, "spawn_custom color font"); } else if (strcasecmp(ap, "$bar_font_color_selected") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_BAR_FONT_SELECTED].name)) == NULL) err(1, "spawn_custom bar font color selected"); } else if (strcasecmp(ap, "$color_focus") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_FOCUS].name)) == NULL) err(1, "spawn_custom color focus"); } else if (strcasecmp(ap, "$color_focus_maximized") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_FOCUS_MAXIMIZED].name)) == NULL) err(1, "spawn_custom color focus maximized"); } else if (strcasecmp(ap, "$color_unfocus") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_UNFOCUS].name)) == NULL) err(1, "spawn_custom color unfocus"); } else if (strcasecmp(ap, "$color_unfocus_maximized") == 0) { if ((real_args[c] = strdup(r->s->c[SWM_S_COLOR_UNFOCUS_MAXIMIZED].name)) == NULL) err(1, "spawn_custom color unfocus maximized"); } else if (strcasecmp(ap, "$region_index") == 0) { if (asprintf(&real_args[c], "%d", get_region_index(r) + 1) < 1) err(1, "spawn_custom region index"); } else if (strcasecmp(ap, "$workspace_index") == 0) { if (asprintf(&real_args[c], "%d", r->ws->idx + 1) < 1) err(1, "spawn_custom workspace index"); } else if (strcasecmp(ap, "$dmenu_bottom") == 0) { if (!bar_at_bottom) continue; if ((real_args[c] = strdup("-b")) == NULL) err(1, "spawn_custom workspace index"); } else { /* no match --> copy as is */ if ((real_args[c] = strdup(ap)) == NULL) err(1, "spawn_custom strdup(ap)"); } DNPRINTF(SWM_D_SPAWN, "cooked arg: %s\n", real_args[c]); ++c; } #ifdef SWM_DEBUG DNPRINTF(SWM_D_SPAWN, "result: "); for (i = 0; i < c; ++i) DPRINTF("\"%s\" ", real_args[i]); DPRINTF("\n"); #endif *ret_args = real_args; return (c); } void spawn_custom(struct swm_region *r, union arg *args, const char *spawn_name) { union arg a; char **real_args; int spawn_argc, i; if ((spawn_argc = spawn_expand(r, args, spawn_name, &real_args)) < 0) return; a.argv = real_args; if (fork() == 0) spawn(r->ws->idx, &a, true); for (i = 0; i < spawn_argc; i++) free(real_args[i]); free(real_args); } void spawn_select(struct swm_region *r, union arg *args, const char *spawn_name, int *pid) { union arg a; char **real_args; int i, spawn_argc; if ((spawn_argc = spawn_expand(r, args, spawn_name, &real_args)) < 0) return; a.argv = real_args; if (pipe(select_list_pipe) == -1) err(1, "pipe error"); if (pipe(select_resp_pipe) == -1) err(1, "pipe error"); if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) err(1, "could not disable SIGPIPE"); switch (*pid = fork()) { case -1: err(1, "cannot fork"); break; case 0: /* child */ if (dup2(select_list_pipe[0], STDIN_FILENO) == -1) err(1, "dup2"); if (dup2(select_resp_pipe[1], STDOUT_FILENO) == -1) err(1, "dup2"); close(select_list_pipe[1]); close(select_resp_pipe[0]); spawn(r->ws->idx, &a, false); break; default: /* parent */ close(select_list_pipe[0]); close(select_resp_pipe[1]); break; } for (i = 0; i < spawn_argc; i++) free(real_args[i]); free(real_args); } /* Argument tokenizer. */ char * argsep(char **sp) { char *arg, *cp, *next; bool single_quoted = false, double_quoted = false; if (*sp == NULL) return (NULL); /* Eat and move characters until end of argument is found. */ for (arg = next = cp = *sp; *cp != '\0'; ++cp) { if (!double_quoted && *cp == '\'') { /* Eat single-quote. */ single_quoted = !single_quoted; } else if (!single_quoted && *cp == '"') { /* Eat double-quote. */ double_quoted = !double_quoted; } else if (!single_quoted && *cp == '\\' && *(cp + 1) == '"') { /* Eat backslash; copy escaped character to arg. */ *next++ = *(++cp); } else if (!single_quoted && !double_quoted && *cp == '\\' && (*(cp + 1) == '\'' || *(cp + 1) == ' ')) { /* Eat backslash; move escaped character. */ *next++ = *(++cp); } else if (!single_quoted && !double_quoted && (*cp == ' ' || *cp == '\t')) { /* Terminate argument. */ *next++ = '\0'; /* Point sp to beginning of next argument. */ *sp = ++cp; break; } else { /* Move regular character. */ *next++ = *cp; } } /* Terminate argument if end of string. */ if (*cp == '\0') { *next = '\0'; *sp = NULL; } return (arg); } void spawn_insert(const char *name, const char *args, int flags) { struct spawn_prog *sp; char *arg, *cp, *ptr; DNPRINTF(SWM_D_SPAWN, "%s[%s]\n", name, args); if (args == NULL || *args == '\0') return; if ((sp = calloc(1, sizeof *sp)) == NULL) err(1, "spawn_insert: calloc"); if ((sp->name = strdup(name)) == NULL) err(1, "spawn_insert: strdup"); /* Convert the arguments to an argument list. */ if ((ptr = cp = strdup(args)) == NULL) err(1, "spawn_insert: strdup"); while ((arg = argsep(&ptr)) != NULL) { /* Null argument; skip it. */ if (*arg == '\0') continue; sp->argc++; if ((sp->argv = realloc(sp->argv, sp->argc * sizeof *sp->argv)) == NULL) err(1, "spawn_insert: realloc"); if ((sp->argv[sp->argc - 1] = strdup(arg)) == NULL) err(1, "spawn_insert: strdup"); } free(cp); sp->flags = flags; DNPRINTF(SWM_D_SPAWN, "arg %d: [%s]\n", sp->argc, sp->argv[sp->argc-1]); TAILQ_INSERT_TAIL(&spawns, sp, entry); DNPRINTF(SWM_D_SPAWN, "leave\n"); } void spawn_remove(struct spawn_prog *sp) { int i; DNPRINTF(SWM_D_SPAWN, "name: %s\n", sp->name); TAILQ_REMOVE(&spawns, sp, entry); for (i = 0; i < sp->argc; i++) free(sp->argv[i]); free(sp->argv); free(sp->name); free(sp); DNPRINTF(SWM_D_SPAWN, "leave\n"); } void clear_spawns(void) { struct spawn_prog *sp; #ifndef __clang_analyzer__ /* Suppress false warnings. */ while ((sp = TAILQ_FIRST(&spawns)) != NULL) { spawn_remove(sp); } #endif } struct spawn_prog* spawn_find(const char *name) { struct spawn_prog *sp; TAILQ_FOREACH(sp, &spawns, entry) if (strcasecmp(sp->name, name) == 0) return (sp); return (NULL); } void setspawn(const char *name, const char *args, int flags) { struct spawn_prog *sp; DNPRINTF(SWM_D_SPAWN, "name: %s\n", name); if (name == NULL) return; #ifndef __clang_analyzer__ /* Suppress false warnings. */ /* Remove any old spawn under the same name. */ if ((sp = spawn_find(name)) != NULL) spawn_remove(sp); #endif if (*args != '\0') spawn_insert(name, args, flags); else warnx("error: setspawn: cannot find program: %s", name); DNPRINTF(SWM_D_SPAWN, "leave\n"); } int setconfspawn(const char *selector, const char *value, int flags) { char *args; if (selector == NULL || strlen(selector) == 0) return (1); args = expand_tilde(value); DNPRINTF(SWM_D_SPAWN, "[%s] [%s]\n", selector, args); setspawn(selector, args, flags); free(args); DNPRINTF(SWM_D_SPAWN, "done\n"); return (0); } void validate_spawns(void) { struct binding *bp; struct spawn_prog *sp; char which[PATH_MAX]; size_t i; RB_FOREACH(bp, binding_tree, &bindings) { if (bp->action != FN_SPAWN_CUSTOM) continue; /* find program */ sp = spawn_find(bp->spawn_name); if (sp == NULL || sp->flags & SWM_SPAWN_OPTIONAL) continue; /* verify we have the goods */ snprintf(which, sizeof which, "which %s", sp->argv[0]); DNPRINTF(SWM_D_CONF, "which %s\n", sp->argv[0]); for (i = strlen("which "); i < strlen(which); i++) if (which[i] == ' ') { which[i] = '\0'; break; } if (system(which) != 0) add_startup_exception("could not find %s", &which[strlen("which ")]); } } void setup_spawn(void) { setconfspawn("lock", "xlock", 0); setconfspawn("term", "xterm", 0); setconfspawn("spawn_term", "xterm", 0); setconfspawn("menu", "dmenu_run" " $dmenu_bottom" " -fn $bar_font" " -nb $bar_color" " -nf $bar_font_color" " -sb $bar_color_selected" " -sf $bar_font_color_selected", 0); setconfspawn("search", "dmenu" " $dmenu_bottom" " -i" " -fn $bar_font" " -nb $bar_color" " -nf $bar_font_color" " -sb $bar_color_selected" " -sf $bar_font_color_selected", 0); setconfspawn("name_workspace", "dmenu" " $dmenu_bottom" " -p Workspace" " -fn $bar_font" " -nb $bar_color" " -nf $bar_font_color" " -sb $bar_color_selected" " -sf $bar_font_color_selected", 0); /* These are not verified for existence, even with a binding set. */ setconfspawn("screenshot_all", "screenshot.sh full", SWM_SPAWN_OPTIONAL); setconfspawn("screenshot_wind", "screenshot.sh window", SWM_SPAWN_OPTIONAL); setconfspawn("initscr", "initscreen.sh", SWM_SPAWN_OPTIONAL); } /* bindings */ #define SWM_MODNAME_SIZE 32 #define SWM_KEY_WS "\n+ \t" int parsebinding(const char *bindstr, uint16_t *mod, enum binding_type *type, uint32_t *val, uint32_t *flags) { char *str, *cp, *name; KeySym ks, lks, uks; DNPRINTF(SWM_D_KEY, "enter [%s]\n", bindstr); if (mod == NULL || val == NULL) { DNPRINTF(SWM_D_KEY, "no mod or key vars\n"); return (1); } if (bindstr == NULL || strlen(bindstr) == 0) { DNPRINTF(SWM_D_KEY, "no bindstr\n"); return (1); } if ((cp = str = strdup(bindstr)) == NULL) err(1, "parsebinding: strdup"); *val = XCB_NO_SYMBOL; *mod = 0; *flags = 0; *type = KEYBIND; while ((name = strsep(&cp, SWM_KEY_WS)) != NULL) { DNPRINTF(SWM_D_KEY, "entry [%s]\n", name); if (cp) cp += (long)strspn(cp, SWM_KEY_WS); if (strncasecmp(name, "MOD", SWM_MODNAME_SIZE) == 0) *mod |= mod_key; else if (strncasecmp(name, "Mod1", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_1; else if (strncasecmp(name, "Mod2", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_2; else if (strncmp(name, "Mod3", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_3; else if (strncmp(name, "Mod4", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_4; else if (strncmp(name, "Mod5", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_5; else if (strncasecmp(name, "SHIFT", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_SHIFT; else if (strncasecmp(name, "CONTROL", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_CONTROL; else if (strncasecmp(name, "ANYMOD", SWM_MODNAME_SIZE) == 0) *mod |= XCB_MOD_MASK_ANY; else if (strncasecmp(name, "REPLAY", SWM_MODNAME_SIZE) == 0) *flags |= BINDING_F_REPLAY; else if (sscanf(name, "Button%u", val) == 1) { DNPRINTF(SWM_D_KEY, "button %u\n", *val); *type = BTNBIND; if (*val > 255 || *val == 0) { DNPRINTF(SWM_D_KEY, "invalid btn %u\n", *val); free(str); return (1); } } else { /* TODO: do this without Xlib. */ ks = XStringToKeysym(name); if (ks == NoSymbol) { DNPRINTF(SWM_D_KEY, "invalid key %s\n", name); free(str); return (1); } XConvertCase(ks, &lks, &uks); *val = (uint32_t)lks; } } /* If ANYMOD was specified, ignore the rest. */ if (*mod & XCB_MOD_MASK_ANY) *mod = XCB_MOD_MASK_ANY; free(str); DNPRINTF(SWM_D_KEY, "leave\n"); return (0); } char * strdupsafe(const char *str) { if (str == NULL) return (NULL); else return (strdup(str)); } int binding_cmp(struct binding *bp1, struct binding *bp2) { if (bp1->type < bp2->type) return (-1); if (bp1->type > bp2->type) return (1); if (bp1->value < bp2->value) return (-1); if (bp1->value > bp2->value) return (1); if (bp1->mod < bp2->mod) return (-1); if (bp1->mod > bp2->mod) return (1); return (0); } void binding_insert(uint16_t mod, enum binding_type type, uint32_t val, enum actionid aid, uint32_t flags, const char *spawn_name) { struct binding *bp; DNPRINTF(SWM_D_KEY, "mod: %u, type: %d, val: %u, action: %s(%d), " "spawn_name: %s\n", mod, type, val, actions[aid].name, aid, spawn_name); if ((bp = malloc(sizeof *bp)) == NULL) err(1, "binding_insert: malloc"); bp->mod = mod; bp->type = type; bp->value = val; bp->action = aid; bp->flags = flags; bp->spawn_name = strdupsafe(spawn_name); RB_INSERT(binding_tree, &bindings, bp); DNPRINTF(SWM_D_KEY, "leave\n"); } struct binding * binding_lookup(uint16_t mod, enum binding_type type, uint32_t val) { struct binding bp; bp.mod = mod; bp.type = type; bp.value = val; return (RB_FIND(binding_tree, &bindings, &bp)); } void binding_remove(struct binding *bp) { DNPRINTF(SWM_D_KEY, "mod: %u, type: %d, val: %u, action: %s(%d), " "spawn_name: %s\n", bp->mod, bp->type, bp->value, actions[bp->action].name, bp->action, bp->spawn_name); RB_REMOVE(binding_tree, &bindings, bp); free(bp->spawn_name); free(bp); DNPRINTF(SWM_D_KEY, "leave\n"); } void setbinding(uint16_t mod, enum binding_type type, uint32_t val, enum actionid aid, uint32_t flags, const char *spawn_name) { struct binding *bp; DNPRINTF(SWM_D_KEY, "enter %s [%s]\n", actions[aid].name, spawn_name); /* Unbind any existing. Loop is to handle MOD_MASK_ANY. */ while ((bp = binding_lookup(mod, type, val))) binding_remove(bp); if (aid != FN_INVALID) binding_insert(mod, type, val, aid, flags, spawn_name); DNPRINTF(SWM_D_KEY, "leave\n"); } int setconfbinding(const char *selector, const char *value, int flags) { struct spawn_prog *sp; uint32_t keybtn, opts; uint16_t mod; enum actionid aid; enum binding_type type; /* suppress unused warning since var is needed */ (void)flags; DNPRINTF(SWM_D_KEY, "selector: [%s], value: [%s]\n", selector, value); if (selector == NULL || strlen(selector) == 0) { DNPRINTF(SWM_D_KEY, "unbind %s\n", value); if (parsebinding(value, &mod, &type, &keybtn, &opts) == 0) { setbinding(mod, type, keybtn, FN_INVALID, opts, NULL); return (0); } else return (1); } /* search by key function name */ for (aid = 0; aid < FN_INVALID; aid++) { if (strncasecmp(selector, actions[aid].name, SWM_FUNCNAME_LEN) == 0) { DNPRINTF(SWM_D_KEY, "%s: match action\n", selector); if (parsebinding(value, &mod, &type, &keybtn, &opts) == 0) { setbinding(mod, type, keybtn, aid, opts, NULL); return (0); } else return (1); } } /* search by custom spawn name */ if ((sp = spawn_find(selector)) != NULL) { DNPRINTF(SWM_D_KEY, "%s: match spawn\n", selector); if (parsebinding(value, &mod, &type, &keybtn, &opts) == 0) { setbinding(mod, type, keybtn, FN_SPAWN_CUSTOM, opts, sp->name); return (0); } else return (1); } DNPRINTF(SWM_D_KEY, "no match\n"); return (1); } #define MODSHIFT MODKEY | XCB_MOD_MASK_SHIFT void setup_keybindings(void) { #define BINDKEY(m, k, a) setbinding(m, KEYBIND, k, a, 0, NULL) #define BINDKEYSPAWN(m, k, s) setbinding(m, KEYBIND, k, FN_SPAWN_CUSTOM, 0, s) BINDKEY(MODKEY, XK_b, FN_BAR_TOGGLE); BINDKEY(MODSHIFT, XK_b, FN_BAR_TOGGLE_WS); BINDKEY(MODKEY, XK_b, FN_BAR_TOGGLE); BINDKEY(MODSHIFT, XK_b, FN_BAR_TOGGLE_WS); BINDKEY(MODKEY, XK_v, FN_BUTTON2); BINDKEY(MODKEY, XK_space, FN_CYCLE_LAYOUT); BINDKEY(MODSHIFT, XK_backslash, FN_FLIP_LAYOUT); BINDKEY(MODKEY, XK_t, FN_FLOAT_TOGGLE); BINDKEY(MODKEY, XK_m, FN_FOCUS_MAIN); BINDKEY(MODKEY, XK_j, FN_FOCUS_NEXT); BINDKEY(MODKEY, XK_Tab, FN_FOCUS_NEXT); BINDKEY(MODKEY, XK_k, FN_FOCUS_PREV); BINDKEY(MODSHIFT, XK_Tab, FN_FOCUS_PREV); BINDKEY(MODKEY, XK_u, FN_FOCUS_URGENT); BINDKEY(MODSHIFT, XK_e, FN_FULLSCREEN_TOGGLE); BINDKEY(MODKEY, XK_e, FN_MAXIMIZE_TOGGLE); BINDKEY(MODSHIFT, XK_equal, FN_HEIGHT_GROW); BINDKEY(MODSHIFT, XK_minus, FN_HEIGHT_SHRINK); BINDKEY(MODKEY, XK_w, FN_ICONIFY); BINDKEY(MODKEY, XK_h, FN_MASTER_SHRINK); BINDKEY(MODKEY, XK_l, FN_MASTER_GROW); BINDKEY(MODKEY, XK_comma, FN_MASTER_ADD); BINDKEY(MODKEY, XK_period, FN_MASTER_DEL); BINDKEY(MODSHIFT, XK_bracketright, FN_MOVE_DOWN); BINDKEY(MODKEY, XK_bracketleft, FN_MOVE_LEFT); BINDKEY(MODKEY, XK_bracketright, FN_MOVE_RIGHT); BINDKEY(MODSHIFT, XK_bracketleft, FN_MOVE_UP); BINDKEY(MODSHIFT, XK_KP_End, FN_MVRG_1); BINDKEY(MODSHIFT, XK_KP_Down, FN_MVRG_2); BINDKEY(MODSHIFT, XK_KP_Next, FN_MVRG_3); BINDKEY(MODSHIFT, XK_KP_Left, FN_MVRG_4); BINDKEY(MODSHIFT, XK_KP_Begin, FN_MVRG_5); BINDKEY(MODSHIFT, XK_KP_Right, FN_MVRG_6); BINDKEY(MODSHIFT, XK_KP_Home, FN_MVRG_7); BINDKEY(MODSHIFT, XK_KP_Up, FN_MVRG_8); BINDKEY(MODSHIFT, XK_KP_Prior, FN_MVRG_9); BINDKEY(MODSHIFT, XK_1, FN_MVWS_1); BINDKEY(MODSHIFT, XK_2, FN_MVWS_2); BINDKEY(MODSHIFT, XK_3, FN_MVWS_3); BINDKEY(MODSHIFT, XK_4, FN_MVWS_4); BINDKEY(MODSHIFT, XK_5, FN_MVWS_5); BINDKEY(MODSHIFT, XK_6, FN_MVWS_6); BINDKEY(MODSHIFT, XK_7, FN_MVWS_7); BINDKEY(MODSHIFT, XK_8, FN_MVWS_8); BINDKEY(MODSHIFT, XK_9, FN_MVWS_9); BINDKEY(MODSHIFT, XK_0, FN_MVWS_10); BINDKEY(MODSHIFT, XK_F1, FN_MVWS_11); BINDKEY(MODSHIFT, XK_F2, FN_MVWS_12); BINDKEY(MODSHIFT, XK_F3, FN_MVWS_13); BINDKEY(MODSHIFT, XK_F4, FN_MVWS_14); BINDKEY(MODSHIFT, XK_F5, FN_MVWS_15); BINDKEY(MODSHIFT, XK_F6, FN_MVWS_16); BINDKEY(MODSHIFT, XK_F7, FN_MVWS_17); BINDKEY(MODSHIFT, XK_F8, FN_MVWS_18); BINDKEY(MODSHIFT, XK_F9, FN_MVWS_19); BINDKEY(MODSHIFT, XK_F10, FN_MVWS_20); BINDKEY(MODSHIFT, XK_F11, FN_MVWS_21); BINDKEY(MODSHIFT, XK_F12, FN_MVWS_22); BINDKEY(MODSHIFT, XK_slash, FN_NAME_WORKSPACE); BINDKEY(MODSHIFT, XK_q, FN_QUIT); BINDKEY(MODKEY, XK_r, FN_RAISE); BINDKEY(MODSHIFT, XK_r, FN_RAISE_TOGGLE); BINDKEY(MODKEY, XK_q, FN_RESTART); BINDKEY(MODKEY, XK_KP_End, FN_RG_1); BINDKEY(MODKEY, XK_KP_Down, FN_RG_2); BINDKEY(MODKEY, XK_KP_Next, FN_RG_3); BINDKEY(MODKEY, XK_KP_Left, FN_RG_4); BINDKEY(MODKEY, XK_KP_Begin, FN_RG_5); BINDKEY(MODKEY, XK_KP_Right, FN_RG_6); BINDKEY(MODKEY, XK_KP_Home, FN_RG_7); BINDKEY(MODKEY, XK_KP_Up, FN_RG_8); BINDKEY(MODKEY, XK_KP_Prior, FN_RG_9); BINDKEY(MODSHIFT, XK_Right, FN_RG_NEXT); BINDKEY(MODSHIFT, XK_Left, FN_RG_PREV); BINDKEY(MODKEY, XK_f, FN_SEARCH_WIN); BINDKEY(MODKEY, XK_slash, FN_SEARCH_WORKSPACE); BINDKEYSPAWN(MODSHIFT, XK_i, "initscr"); BINDKEYSPAWN(MODSHIFT, XK_Delete, "lock"); BINDKEYSPAWN(MODKEY, XK_p, "menu"); BINDKEYSPAWN(MODKEY, XK_s, "screenshot_all"); BINDKEYSPAWN(MODSHIFT, XK_s, "screenshot_wind"); BINDKEYSPAWN(MODSHIFT, XK_Return, "term"); BINDKEY(MODSHIFT, XK_comma, FN_STACK_INC); BINDKEY(MODSHIFT, XK_period, FN_STACK_DEC); BINDKEY(MODSHIFT, XK_space, FN_STACK_RESET); BINDKEY(MODKEY, XK_Return, FN_SWAP_MAIN); BINDKEY(MODSHIFT, XK_j, FN_SWAP_NEXT); BINDKEY(MODSHIFT, XK_k, FN_SWAP_PREV); BINDKEY(MODSHIFT, XK_w, FN_UNICONIFY); BINDKEY(MODSHIFT, XK_v, FN_VERSION); BINDKEY(MODKEY, XK_equal, FN_WIDTH_GROW); BINDKEY(MODKEY, XK_minus, FN_WIDTH_SHRINK); BINDKEY(MODKEY, XK_x, FN_WIND_DEL); BINDKEY(MODSHIFT, XK_x, FN_WIND_KILL); BINDKEY(MODKEY, XK_1, FN_WS_1); BINDKEY(MODKEY, XK_2, FN_WS_2); BINDKEY(MODKEY, XK_3, FN_WS_3); BINDKEY(MODKEY, XK_4, FN_WS_4); BINDKEY(MODKEY, XK_5, FN_WS_5); BINDKEY(MODKEY, XK_6, FN_WS_6); BINDKEY(MODKEY, XK_7, FN_WS_7); BINDKEY(MODKEY, XK_8, FN_WS_8); BINDKEY(MODKEY, XK_9, FN_WS_9); BINDKEY(MODKEY, XK_0, FN_WS_10); BINDKEY(MODKEY, XK_F1, FN_WS_11); BINDKEY(MODKEY, XK_F2, FN_WS_12); BINDKEY(MODKEY, XK_F3, FN_WS_13); BINDKEY(MODKEY, XK_F4, FN_WS_14); BINDKEY(MODKEY, XK_F5, FN_WS_15); BINDKEY(MODKEY, XK_F6, FN_WS_16); BINDKEY(MODKEY, XK_F7, FN_WS_17); BINDKEY(MODKEY, XK_F8, FN_WS_18); BINDKEY(MODKEY, XK_F9, FN_WS_19); BINDKEY(MODKEY, XK_F10, FN_WS_20); BINDKEY(MODKEY, XK_F11, FN_WS_21); BINDKEY(MODKEY, XK_F12, FN_WS_22); BINDKEY(MODKEY, XK_Right, FN_WS_NEXT); BINDKEY(MODKEY, XK_Left, FN_WS_PREV); BINDKEY(MODKEY, XK_Up, FN_WS_NEXT_ALL); BINDKEY(MODKEY, XK_Down, FN_WS_PREV_ALL); BINDKEY(MODSHIFT, XK_Up, FN_WS_NEXT_MOVE); BINDKEY(MODSHIFT, XK_Down, FN_WS_PREV_MOVE); BINDKEY(MODKEY, XK_a, FN_WS_PRIOR); #ifdef SWM_DEBUG BINDKEY(MODKEY, XK_d, FN_DEBUG_TOGGLE); BINDKEY(MODSHIFT, XK_d, FN_DUMPWINS); #endif #undef BINDKEY #undef BINDKEYSPAWN } void setup_btnbindings(void) { setbinding(ANYMOD, BTNBIND, XCB_BUTTON_INDEX_1, FN_FOCUS, BINDING_F_REPLAY, NULL); setbinding(MODKEY, BTNBIND, XCB_BUTTON_INDEX_3, FN_RESIZE, 0, NULL); setbinding(MODSHIFT, BTNBIND, XCB_BUTTON_INDEX_3, FN_RESIZE_CENTERED, 0, NULL); setbinding(MODKEY, BTNBIND, XCB_BUTTON_INDEX_1, FN_MOVE, 0, NULL); } #undef MODSHIFT void clear_bindings(void) { struct binding *bp; while ((bp = RB_ROOT(&bindings))) binding_remove(bp); } void clear_keybindings(void) { struct binding *bp, *bptmp; RB_FOREACH_SAFE(bp, binding_tree, &bindings, bptmp) { if (bp->type != KEYBIND) continue; binding_remove(bp); } } int setkeymapping(const char *selector, const char *value, int flags) { char *keymapping_file; /* suppress unused warnings since vars are needed */ (void)selector; (void)flags; DNPRINTF(SWM_D_KEY, "enter\n"); keymapping_file = expand_tilde(value); clear_keybindings(); /* load new key bindings; if it fails, revert to default bindings */ if (conf_load(keymapping_file, SWM_CONF_KEYMAPPING)) { clear_keybindings(); setup_keybindings(); } free(keymapping_file); DNPRINTF(SWM_D_KEY, "leave\n"); return (0); } void updatenumlockmask(void) { unsigned int i, j; xcb_get_modifier_mapping_reply_t *modmap_r; xcb_keycode_t *modmap, kc, *keycode; numlockmask = 0; modmap_r = xcb_get_modifier_mapping_reply(conn, xcb_get_modifier_mapping(conn), NULL); if (modmap_r) { modmap = xcb_get_modifier_mapping_keycodes(modmap_r); for (i = 0; i < 8; i++) { for (j = 0; j < modmap_r->keycodes_per_modifier; j++) { kc = modmap[i * modmap_r->keycodes_per_modifier + j]; keycode = xcb_key_symbols_get_keycode(syms, XK_Num_Lock); if (keycode) { if (kc == *keycode) numlockmask = (1 << i); free(keycode); } } } free(modmap_r); } DNPRINTF(SWM_D_MISC, "numlockmask: %#x\n", numlockmask); } xcb_keycode_t get_binding_keycode(struct binding *bp) { const xcb_setup_t *s; xcb_get_keyboard_mapping_reply_t *kmr; int col; xcb_keycode_t kc, min, max; s = get_setup(); min = s->min_keycode; max = s->max_keycode; kmr = xcb_get_keyboard_mapping_reply(conn, xcb_get_keyboard_mapping(conn, min, max - min + 1), NULL); if (kmr == NULL) return (XCB_NO_SYMBOL); /* Search for keycode by keysym column. */ for (col = 0; col < kmr->keysyms_per_keycode; col++) { /* Keycodes are unsigned, bail if kc++ is reduced to 0. */ for (kc = min; kc > 0 && kc <= max; kc++) { if (xcb_key_symbols_get_keysym(syms, kc, col) == bp->value) return (kc); } } return (XCB_NO_SYMBOL); } void grabkeys(void) { struct binding *bp; int num_screens, i, j; uint16_t modifiers[4]; xcb_keycode_t keycode; DNPRINTF(SWM_D_MISC, "begin\n"); updatenumlockmask(); modifiers[0] = 0; modifiers[1] = numlockmask; modifiers[2] = XCB_MOD_MASK_LOCK; modifiers[3] = numlockmask | XCB_MOD_MASK_LOCK; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { if (TAILQ_EMPTY(&screens[i].rl)) continue; xcb_ungrab_key(conn, XCB_GRAB_ANY, screens[i].root, XCB_MOD_MASK_ANY); RB_FOREACH(bp, binding_tree, &bindings) { if (bp->type != KEYBIND) continue; /* If there is a catch-all, only bind that. */ if ((binding_lookup(ANYMOD, KEYBIND, bp->value)) && bp->mod != ANYMOD) continue; /* Skip unused ws binds. */ if ((int)bp->action > FN_WS_1 + workspace_limit - 1 && bp->action <= FN_WS_22) continue; /* Skip unused mvws binds. */ if ((int)bp->action > FN_MVWS_1 + workspace_limit - 1 && bp->action <= FN_MVWS_22) continue; /* Try to get keycode for the grab. */ keycode = get_binding_keycode(bp); if (keycode == XCB_NO_SYMBOL) continue; if (bp->mod == XCB_MOD_MASK_ANY) { /* All modifiers are grabbed in one pass. */ DNPRINTF(SWM_D_KEY, "key: %u, modmask: %d\n", bp->value, bp->mod); xcb_grab_key(conn, 1, screens[i].root, bp->mod, keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_SYNC); } else { /* Need to grab each modifier permutation. */ for (j = 0; j < LENGTH(modifiers); j++) { DNPRINTF(SWM_D_KEY, "key: %u, " "modmask: %d\n", bp->value, bp->mod | modifiers[j]); xcb_grab_key(conn, 1, screens[i].root, bp->mod | modifiers[j], keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_SYNC); } } } } DNPRINTF(SWM_D_MISC, "done\n"); } void grabbuttons(void) { struct binding *bp; int num_screens, i, k; uint16_t modifiers[4]; DNPRINTF(SWM_D_MOUSE, "begin\n"); updatenumlockmask(); modifiers[0] = 0; modifiers[1] = numlockmask; modifiers[2] = XCB_MOD_MASK_LOCK; modifiers[3] = numlockmask | XCB_MOD_MASK_LOCK; num_screens = get_screen_count(); for (k = 0; k < num_screens; k++) { if (TAILQ_EMPTY(&screens[k].rl)) continue; xcb_ungrab_button(conn, XCB_BUTTON_INDEX_ANY, screens[k].root, XCB_MOD_MASK_ANY); RB_FOREACH(bp, binding_tree, &bindings) { if (bp->type != BTNBIND) continue; /* If there is a catch-all, only bind that. */ if ((binding_lookup(ANYMOD, BTNBIND, bp->value)) && bp->mod != ANYMOD) continue; /* Skip unused ws binds. */ if ((int)bp->action > FN_WS_1 + workspace_limit - 1 && bp->action <= FN_WS_22) continue; /* Skip unused mvws binds. */ if ((int)bp->action > FN_MVWS_1 + workspace_limit - 1 && bp->action <= FN_MVWS_22) continue; if (bp->mod == XCB_MOD_MASK_ANY) { /* All modifiers are grabbed in one pass. */ DNPRINTF(SWM_D_MOUSE, "grab btn: %u, " "modmask: %d\n", bp->value, bp->mod); xcb_grab_button(conn, 0, screens[k].root, BUTTONMASK, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, XCB_CURSOR_NONE, bp->value, bp->mod); } else { /* Need to grab each modifier permutation. */ for (i = 0; i < LENGTH(modifiers); ++i) { DNPRINTF(SWM_D_MOUSE, "grab btn: %u, " "modmask: %u\n", bp->value, bp->mod | modifiers[i]); xcb_grab_button(conn, 0, screens[k].root, BUTTONMASK, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, XCB_CURSOR_NONE, bp->value, bp->mod | modifiers[i]); } } } } DNPRINTF(SWM_D_MOUSE, "done\n"); } struct wsi_flag { char *name; uint32_t mask; } wsiflags[] = { {"listcurrent", SWM_WSI_LISTCURRENT}, {"listactive", SWM_WSI_LISTACTIVE}, {"listempty", SWM_WSI_LISTEMPTY}, {"listnamed", SWM_WSI_LISTNAMED}, {"listurgent", SWM_WSI_LISTURGENT}, {"listall", SWM_WSI_LISTALL}, {"hidecurrent", SWM_WSI_HIDECURRENT}, {"markcurrent", SWM_WSI_MARKCURRENT}, {"markurgent", SWM_WSI_MARKURGENT}, {"printnames", SWM_WSI_PRINTNAMES}, }; #define SWM_FLAGS_DELIM "," #define SWM_FLAGS_WHITESPACE " \t\n" int parse_workspace_indicator(const char *str, uint32_t *mode) { char *tmp, *cp, *name; size_t len; int i; if (str == NULL || mode == NULL) return (1); if ((cp = tmp = strdup(str)) == NULL) err(1, "parse_workspace_indicator: strdup"); *mode = 0; while ((name = strsep(&cp, SWM_FLAGS_DELIM)) != NULL) { if (cp) cp += (long)strspn(cp, SWM_FLAGS_WHITESPACE); name += strspn(name, SWM_FLAGS_WHITESPACE); len = strcspn(name, SWM_FLAGS_WHITESPACE); for (i = 0; i < LENGTH(wsiflags); i++) { if (strncasecmp(name, wsiflags[i].name, len) == 0) { DNPRINTF(SWM_D_CONF, "flag: [%s]\n", name); *mode |= wsiflags[i].mask; break; } } if (i >= LENGTH(wsiflags)) { DNPRINTF(SWM_D_CONF, "invalid flag: [%s]\n", name); free(tmp); return (1); } } free(tmp); return (0); } const char *quirkname[] = { "NONE", /* config string for "no value" */ "FLOAT", "TRANSSZ", "ANYWHERE", "XTERM_FONTADJ", "FULLSCREEN", "FOCUSPREV", "NOFOCUSONMAP", "FOCUSONMAP_SINGLE", "OBEYAPPFOCUSREQ", "IGNOREPID", "IGNORESPAWNWS", "NOFOCUSCYCLE", "MINIMALBORDER", }; /* SWM_Q_DELIM: retain '|' for back compat for now (2009-08-11) */ #define SWM_Q_DELIM "\n|+ \t" int parsequirks(const char *qstr, uint32_t *quirk, int *ws) { char *str, *cp, *name; int i; if (quirk == NULL || qstr == NULL) return (1); if ((cp = str = strdup(qstr)) == NULL) err(1, "parsequirks: strdup"); *quirk = 0; while ((name = strsep(&cp, SWM_Q_DELIM)) != NULL) { if (cp) cp += (long)strspn(cp, SWM_Q_DELIM); if (sscanf(name, "WS[%d]", ws) == 1) { if (*ws > 0) *ws -= 1; continue; } for (i = 0; i < LENGTH(quirkname); i++) { if (strncasecmp(name, quirkname[i], SWM_QUIRK_LEN) == 0) { DNPRINTF(SWM_D_QUIRK, "%s\n", name); if (i == 0) { *quirk = 0; free(str); return (0); } *quirk |= 1 << (i-1); break; } } if (i >= LENGTH(quirkname)) { DNPRINTF(SWM_D_QUIRK, "invalid quirk [%s]\n", name); free(str); return (1); } } free(str); return (0); } void quirk_insert(const char *class, const char *instance, const char *name, uint32_t quirk, int ws) { struct quirk *qp; char *str; bool failed = false; DNPRINTF(SWM_D_QUIRK, "class: %s, instance: %s, name: %s, value: %u, " "ws: %d\n", class, instance, name, quirk, ws); if ((qp = malloc(sizeof *qp)) == NULL) err(1, "quirk_insert: malloc"); if ((qp->class = strdup(class)) == NULL) err(1, "quirk_insert: strdup"); if ((qp->instance = strdup(instance)) == NULL) err(1, "quirk_insert: strdup"); if ((qp->name = strdup(name)) == NULL) err(1, "quirk_insert: strdup"); if (asprintf(&str, "^%s$", class) == -1) err(1, "quirk_insert: asprintf"); if (regcomp(&qp->regex_class, str, REG_EXTENDED | REG_NOSUB)) { add_startup_exception("regex failed to compile quirk 'class' " "field: %s", class); failed = true; } DNPRINTF(SWM_D_QUIRK, "compiled: %s\n", str); free(str); if (asprintf(&str, "^%s$", instance) == -1) err(1, "quirk_insert: asprintf"); if (regcomp(&qp->regex_instance, str, REG_EXTENDED | REG_NOSUB)) { add_startup_exception("regex failed to compile quirk 'instance'" " field: %s", instance); failed = true; } DNPRINTF(SWM_D_QUIRK, "compiled: %s\n", str); free(str); if (asprintf(&str, "^%s$", name) == -1) err(1, "quirk_insert: asprintf"); if (regcomp(&qp->regex_name, str, REG_EXTENDED | REG_NOSUB)) { add_startup_exception("regex failed to compile quirk 'name' " "field: %s", name); failed = true; } DNPRINTF(SWM_D_QUIRK, "compiled: %s\n", str); free(str); if (failed) { DNPRINTF(SWM_D_QUIRK, "regex error\n"); quirk_free(qp); } else { qp->quirk = quirk; qp->ws = ws; TAILQ_INSERT_TAIL(&quirks, qp, entry); } DNPRINTF(SWM_D_QUIRK, "leave\n"); } void quirk_remove(struct quirk *qp) { DNPRINTF(SWM_D_QUIRK, "%s:%s [%u]\n", qp->class, qp->name, qp->quirk); TAILQ_REMOVE(&quirks, qp, entry); quirk_free(qp); DNPRINTF(SWM_D_QUIRK, "leave\n"); } void quirk_free(struct quirk *qp) { regfree(&qp->regex_class); regfree(&qp->regex_instance); regfree(&qp->regex_name); free(qp->class); free(qp->instance); free(qp->name); free(qp); } void clear_quirks(void) { struct quirk *qp; #ifndef __clang_analyzer__ /* Suppress false warnings. */ while ((qp = TAILQ_FIRST(&quirks)) != NULL) { quirk_remove(qp); } #endif } void quirk_replace(struct quirk *qp, const char *class, const char *instance, const char *name, uint32_t quirk, int ws) { DNPRINTF(SWM_D_QUIRK, "%s:%s:%s [%u], ws: %d\n", qp->class, qp->instance, qp->name, qp->quirk, qp->ws); quirk_remove(qp); quirk_insert(class, instance, name, quirk, ws); DNPRINTF(SWM_D_QUIRK, "leave\n"); } void setquirk(const char *class, const char *instance, const char *name, uint32_t quirk, int ws) { struct quirk *qp; DNPRINTF(SWM_D_QUIRK, "enter %s:%s:%s [%u], ws: %d\n", class, instance, name, quirk, ws); #ifndef __clang_analyzer__ /* Suppress false warnings. */ /* Remove/replace existing quirk. */ TAILQ_FOREACH(qp, &quirks, entry) { if (strcmp(qp->class, class) == 0 && strcmp(qp->instance, instance) == 0 && strcmp(qp->name, name) == 0) { if (quirk == 0 && ws == -1) quirk_remove(qp); else quirk_replace(qp, class, instance, name, quirk, ws); goto out; } } #endif /* Only insert if quirk is not NONE or forced ws is set. */ if (quirk || ws != -1) quirk_insert(class, instance, name, quirk, ws); out: DNPRINTF(SWM_D_QUIRK, "leave\n"); } /* Eat '\' in str used to escape square brackets and colon. */ void unescape_selector(char *str) { char *cp; for (cp = str; *str != '\0'; ++str, ++cp) { if (*str == '\\' && (*(str + 1) == ':' || *(str + 1) == ']' || *(str + 1) == '[')) ++str; *cp = *str; } *cp = '\0'; } int setconfquirk(const char *selector, const char *value, int flags) { char *str, *cp, *class; char *instance = NULL, *name = NULL; int retval, count = 0, ws = -1; uint32_t qrks; /* suppress unused warning since var is needed */ (void)flags; if (selector == NULL || strlen(selector) == 0) return (0); if ((str = strdup(selector)) == NULL) err(1, "setconfquirk: strdup"); /* Find non-escaped colon. */ class = cp = str; if (*cp == ':') { *cp = '\0'; ++count; } for (++cp; *cp != '\0'; ++cp) { if (*cp == ':' && *(cp - 1) != '\\') { *cp = '\0'; ++count; } } unescape_selector(class); if (count) { instance = class + strlen(class) + 1; unescape_selector(instance); } else { instance = ".*"; } if (count > 1) { name = instance + strlen(instance) + 1; unescape_selector(name); } else { name = ".*"; } DNPRINTF(SWM_D_CONF, "class: %s, instance: %s, name: %s\n", class, instance, name); if ((retval = parsequirks(value, &qrks, &ws)) == 0) setquirk(class, instance, name, qrks, ws); free(str); return (retval); } void setup_quirks(void) { setquirk("MPlayer", "xv", ".*", SWM_Q_FLOAT | SWM_Q_FULLSCREEN | SWM_Q_FOCUSPREV, -1); setquirk("OpenOffice.org 3.2", "VCLSalFrame", ".*", SWM_Q_FLOAT, -1); setquirk("Firefox-bin", "firefox-bin", ".*", SWM_Q_TRANSSZ, -1); setquirk("Firefox", "Dialog", ".*", SWM_Q_FLOAT, -1); setquirk("Gimp", "gimp", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1); setquirk("XTerm", "xterm", ".*", SWM_Q_XTERM_FONTADJ, -1); setquirk("xine", "Xine Window", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1); setquirk("Xitk", "Xitk Combo", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1); setquirk("xine", "xine Panel", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1); setquirk("Xitk", "Xine Window", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1); setquirk("xine", "xine Video Fullscreen Window", ".*", SWM_Q_FULLSCREEN | SWM_Q_FLOAT, -1); setquirk("pcb", "pcb", ".*", SWM_Q_FLOAT, -1); setquirk("SDL_App", "SDL_App", ".*", SWM_Q_FLOAT | SWM_Q_FULLSCREEN, -1); } /* conf file stuff */ #define SWM_CONF_FILE "spectrwm.conf" #define SWM_CONF_FILE_OLD "scrotwm.conf" enum { SWM_S_BAR_ACTION, SWM_S_BAR_AT_BOTTOM, SWM_S_BAR_BORDER_WIDTH, SWM_S_BAR_ENABLED, SWM_S_BAR_ENABLED_WS, SWM_S_BAR_FONT, SWM_S_BAR_FORMAT, SWM_S_BAR_JUSTIFY, SWM_S_BORDER_WIDTH, SWM_S_BOUNDARY_WIDTH, SWM_S_CLOCK_ENABLED, SWM_S_CLOCK_FORMAT, SWM_S_CYCLE_EMPTY, SWM_S_CYCLE_VISIBLE, SWM_S_DIALOG_RATIO, SWM_S_DISABLE_BORDER, SWM_S_FOCUS_CLOSE, SWM_S_FOCUS_CLOSE_WRAP, SWM_S_FOCUS_DEFAULT, SWM_S_FOCUS_MODE, SWM_S_ICONIC_ENABLED, SWM_S_MAXIMIZE_HIDE_BAR, SWM_S_REGION_PADDING, SWM_S_SPAWN_ORDER, SWM_S_SPAWN_TERM, SWM_S_STACK_ENABLED, SWM_S_TERM_WIDTH, SWM_S_TILE_GAP, SWM_S_URGENT_COLLAPSE, SWM_S_URGENT_ENABLED, SWM_S_VERBOSE_LAYOUT, SWM_S_WARP_FOCUS, SWM_S_WARP_POINTER, SWM_S_WINDOW_CLASS_ENABLED, SWM_S_WINDOW_INSTANCE_ENABLED, SWM_S_WINDOW_NAME_ENABLED, SWM_S_WORKSPACE_CLAMP, SWM_S_WORKSPACE_LIMIT, SWM_S_WORKSPACE_INDICATOR, SWM_S_WORKSPACE_NAME, }; int setconfvalue(const char *selector, const char *value, int flags) { struct workspace *ws; int i, ws_id, num_screens, n; char *b, *str, *sp; switch (flags) { case SWM_S_BAR_ACTION: free(bar_argv[0]); if ((bar_argv[0] = expand_tilde(value)) == NULL) err(1, "setconfvalue: bar_action"); break; case SWM_S_BAR_AT_BOTTOM: bar_at_bottom = (atoi(value) != 0); break; case SWM_S_BAR_BORDER_WIDTH: bar_border_width = atoi(value); if (bar_border_width < 0) bar_border_width = 0; break; case SWM_S_BAR_ENABLED: bar_enabled = (atoi(value) != 0); break; case SWM_S_BAR_ENABLED_WS: ws_id = atoi(selector) - 1; if (ws_id < 0 || ws_id >= workspace_limit) errx(1, "setconfvalue: bar_enabled_ws: invalid " "workspace %d.", ws_id + 1); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { ws = (struct workspace *)&screens[i].ws; ws[ws_id].bar_enabled = (atoi(value) != 0); } break; case SWM_S_BAR_FONT: b = bar_fonts; if (asprintf(&bar_fonts, "%s,%s", value, bar_fonts) == -1) err(1, "setconfvalue: asprintf: failed to allocate " "memory for bar_fonts."); free(b); /* If already in xft mode, then we are done. */ if (!bar_font_legacy) break; if ((sp = str = strdup(value)) == NULL) err(1, "setconfvalue: strdup"); /* If there are any non-XLFD entries, switch to Xft mode. */ while ((b = strsep(&sp, ",")) != NULL) { if (*b == '\0') continue; if (!isxlfd(b)) { bar_font_legacy = false; break; } } free(str); break; case SWM_S_BAR_FORMAT: free(bar_format); if ((bar_format = strdup(value)) == NULL) err(1, "setconfvalue: bar_format"); break; case SWM_S_BAR_JUSTIFY: if (strcmp(value, "left") == 0) bar_justify = SWM_BAR_JUSTIFY_LEFT; else if (strcmp(value, "center") == 0) bar_justify = SWM_BAR_JUSTIFY_CENTER; else if (strcmp(value, "right") == 0) bar_justify = SWM_BAR_JUSTIFY_RIGHT; else errx(1, "invalid bar_justify"); break; case SWM_S_BORDER_WIDTH: border_width = atoi(value); if (border_width < 0) border_width = 0; break; case SWM_S_BOUNDARY_WIDTH: boundary_width = atoi(value); if (boundary_width < 0) boundary_width = 0; break; case SWM_S_CLOCK_ENABLED: clock_enabled = (atoi(value) != 0); break; case SWM_S_CLOCK_FORMAT: #ifndef SWM_DENY_CLOCK_FORMAT free(clock_format); if ((clock_format = strdup(value)) == NULL) err(1, "setconfvalue: clock_format"); #endif break; case SWM_S_CYCLE_EMPTY: cycle_empty = (atoi(value) != 0); break; case SWM_S_CYCLE_VISIBLE: cycle_visible = (atoi(value) != 0); break; case SWM_S_DIALOG_RATIO: dialog_ratio = atof(value); if (dialog_ratio > 1.0 || dialog_ratio <= .3) dialog_ratio = .6; break; case SWM_S_DISABLE_BORDER: disable_border_always = (strcmp(value, "always") == 0); disable_border = (atoi(value) != 0) || disable_border_always; break; case SWM_S_FOCUS_CLOSE: if (strcmp(value, "first") == 0) focus_close = SWM_STACK_BOTTOM; else if (strcmp(value, "last") == 0) focus_close = SWM_STACK_TOP; else if (strcmp(value, "next") == 0) focus_close = SWM_STACK_ABOVE; else if (strcmp(value, "previous") == 0) focus_close = SWM_STACK_BELOW; else errx(1, "focus_close"); break; case SWM_S_FOCUS_CLOSE_WRAP: focus_close_wrap = (atoi(value) != 0); break; case SWM_S_FOCUS_DEFAULT: if (strcmp(value, "last") == 0) focus_default = SWM_STACK_TOP; else if (strcmp(value, "first") == 0) focus_default = SWM_STACK_BOTTOM; else errx(1, "focus_default"); break; case SWM_S_FOCUS_MODE: if (strcmp(value, "default") == 0) focus_mode = SWM_FOCUS_DEFAULT; else if (strcmp(value, "follow") == 0 || strcmp(value, "follow_cursor") == 0) focus_mode = SWM_FOCUS_FOLLOW; else if (strcmp(value, "manual") == 0) focus_mode = SWM_FOCUS_MANUAL; else errx(1, "focus_mode"); break; case SWM_S_ICONIC_ENABLED: iconic_enabled = (atoi(value) != 0); break; case SWM_S_MAXIMIZE_HIDE_BAR: maximize_hide_bar = atoi(value); break; case SWM_S_REGION_PADDING: region_padding = atoi(value); if (region_padding < 0) region_padding = 0; break; case SWM_S_SPAWN_ORDER: if (strcmp(value, "first") == 0) spawn_position = SWM_STACK_BOTTOM; else if (strcmp(value, "last") == 0) spawn_position = SWM_STACK_TOP; else if (strcmp(value, "next") == 0) spawn_position = SWM_STACK_ABOVE; else if (strcmp(value, "previous") == 0) spawn_position = SWM_STACK_BELOW; else errx(1, "spawn_position"); break; case SWM_S_SPAWN_TERM: setconfspawn("term", value, 0); setconfspawn("spawn_term", value, 0); break; case SWM_S_STACK_ENABLED: stack_enabled = (atoi(value) != 0); break; case SWM_S_TERM_WIDTH: term_width = atoi(value); if (term_width < 0) term_width = 0; break; case SWM_S_TILE_GAP: tile_gap = atoi(value); break; case SWM_S_URGENT_COLLAPSE: urgent_collapse = (atoi(value) != 0); break; case SWM_S_URGENT_ENABLED: urgent_enabled = (atoi(value) != 0); break; case SWM_S_VERBOSE_LAYOUT: verbose_layout = (atoi(value) != 0); for (i = 0; layouts[i].l_stack != NULL; i++) { if (verbose_layout) layouts[i].l_string = fancy_stacker; else layouts[i].l_string = plain_stacker; } break; case SWM_S_WARP_FOCUS: warp_focus = (atoi(value) != 0); break; case SWM_S_WARP_POINTER: warp_pointer = (atoi(value) != 0); break; case SWM_S_WINDOW_CLASS_ENABLED: window_class_enabled = (atoi(value) != 0); break; case SWM_S_WINDOW_INSTANCE_ENABLED: window_instance_enabled = (atoi(value) != 0); break; case SWM_S_WINDOW_NAME_ENABLED: window_name_enabled = (atoi(value) != 0); break; case SWM_S_WORKSPACE_CLAMP: workspace_clamp = (atoi(value) != 0); break; case SWM_S_WORKSPACE_LIMIT: workspace_limit = atoi(value); if (workspace_limit > SWM_WS_MAX) workspace_limit = SWM_WS_MAX; else if (workspace_limit < 1) workspace_limit = 1; ewmh_update_desktops(); break; case SWM_S_WORKSPACE_INDICATOR: if (parse_workspace_indicator(value, &workspace_indicator)) errx(1, "invalid workspace_indicator"); break; case SWM_S_WORKSPACE_NAME: if (getenv("SWM_STARTED") != NULL) return (0); n = 0; if (sscanf(value, "ws[%d]:%n", &ws_id, &n) != 1 || n == 0 || value[n] == '\0') errx(1, "invalid entry, should be 'ws[]:name'"); value += n; ws_id--; if (ws_id < 0 || ws_id >= workspace_limit) errx(1, "setconfvalue: workspace_name: invalid " "workspace %d.", ws_id + 1); num_screens = get_screen_count(); for (i = 0; i < num_screens; ++i) { ws = (struct workspace *)&screens[i].ws; free(ws[ws_id].name); if ((ws[ws_id].name = strdup(value)) == NULL) err(1, "setconfvalue: workspace_name."); ewmh_update_desktop_names(); ewmh_get_desktop_names(); } break; default: return (1); } return (0); } int setconfmodkey(const char *selector, const char *value, int flags) { /* suppress unused warnings since vars are needed */ (void)selector; (void)flags; if (strncasecmp(value, "Mod1", strlen("Mod1")) == 0) update_modkey(XCB_MOD_MASK_1); else if (strncasecmp(value, "Mod2", strlen("Mod2")) == 0) update_modkey(XCB_MOD_MASK_2); else if (strncasecmp(value, "Mod3", strlen("Mod3")) == 0) update_modkey(XCB_MOD_MASK_3); else if (strncasecmp(value, "Mod4", strlen("Mod4")) == 0) update_modkey(XCB_MOD_MASK_4); else if (strncasecmp(value, "Mod5", strlen("Mod5")) == 0) update_modkey(XCB_MOD_MASK_5); else return (1); return (0); } int setconfcolor(const char *selector, const char *value, int flags) { int first, last, i = 0, num_screens; num_screens = get_screen_count(); /* conf screen indices begin at 1; treat vals <= 0 as 'all screens.' */ if (selector == NULL || strlen(selector) == 0 || (last = atoi(selector) - 1) < 0) { first = 0; last = num_screens - 1; } else { first = last; } if (last >= num_screens) { add_startup_exception("invalid screen index: %d out of bounds " "(maximum %d)", last + 1, num_screens); return (1); } for (i = first; i <= last; ++i) { setscreencolor(value, i, flags); /* * Need to sync 'maximized' and 'selected' colors with their * respective colors if they haven't been customized. */ switch (flags) { case SWM_S_COLOR_FOCUS: if (!screens[i].c[SWM_S_COLOR_FOCUS_MAXIMIZED].manual) setscreencolor(value, i, SWM_S_COLOR_FOCUS_MAXIMIZED); break; case SWM_S_COLOR_UNFOCUS: if (!screens[i].c[SWM_S_COLOR_UNFOCUS_MAXIMIZED].manual) setscreencolor(value, i, SWM_S_COLOR_UNFOCUS_MAXIMIZED); break; case SWM_S_COLOR_BAR: if (!screens[i].c[SWM_S_COLOR_BAR_FONT_SELECTED].manual) setscreencolor(value, i, SWM_S_COLOR_BAR_FONT_SELECTED); break; case SWM_S_COLOR_BAR_BORDER: if (!screens[i].c[SWM_S_COLOR_BAR_SELECTED].manual) setscreencolor(value, i, SWM_S_COLOR_BAR_SELECTED); break; } screens[i].c[flags].manual = 1; } return (0); } int setconfregion(const char *selector, const char *value, int flags) { /* suppress unused warnings since vars are needed */ (void)selector; (void)flags; custom_region(value); return (0); } int setautorun(const char *selector, const char *value, int flags) { int ws_id; char *ap, *sp, *str; union arg a; int argc = 0, n; pid_t pid; struct pid_e *p; /* suppress unused warnings since vars are needed */ (void)selector; (void)flags; if (getenv("SWM_STARTED")) return (0); n = 0; if (sscanf(value, "ws[%d]:%n", &ws_id, &n) != 1 || n == 0 || value[n] == '\0') errx(1, "invalid autorun entry, should be 'ws[]:command'"); value += n; ws_id--; if (ws_id < 0 || ws_id >= workspace_limit) errx(1, "autorun: invalid workspace %d", ws_id + 1); sp = str = expand_tilde(value); /* * This is a little intricate * * If the pid already exists we simply reuse it because it means it was * used before AND not claimed by manage_window. We get away with * altering it in the parent after INSERT because this can not be a race */ a.argv = NULL; while ((ap = strsep(&sp, " \t")) != NULL) { if (*ap == '\0') continue; DNPRINTF(SWM_D_SPAWN, "arg [%s]\n", ap); argc++; if ((a.argv = realloc(a.argv, argc * sizeof(char *))) == NULL) err(1, "setautorun: realloc"); a.argv[argc - 1] = ap; } if ((a.argv = realloc(a.argv, (argc + 1) * sizeof(char *))) == NULL) err(1, "setautorun: realloc"); a.argv[argc] = NULL; if ((pid = fork()) == 0) { spawn(ws_id, &a, true); /* NOTREACHED */ _exit(1); } free(a.argv); free(str); /* parent */ p = find_pid(pid); if (p == NULL) { p = calloc(1, sizeof *p); if (p == NULL) return (1); TAILQ_INSERT_TAIL(&pidlist, p, entry); } p->pid = pid; p->ws = ws_id; return (0); } int setlayout(const char *selector, const char *value, int flags) { struct workspace *ws; int ws_id, i, x, mg, ma, si, ar, n; int st = SWM_V_STACK, num_screens; bool f = false; /* suppress unused warnings since vars are needed */ (void)selector; (void)flags; if (getenv("SWM_STARTED")) return (0); n = 0; if (sscanf(value, "ws[%d]:%d:%d:%d:%d:%n", &ws_id, &mg, &ma, &si, &ar, &n) != 5 || n == 0 || value[n] == '\0') errx(1, "invalid layout entry, should be 'ws[]:" "::::" "'"); value += n; ws_id--; if (ws_id < 0 || ws_id >= workspace_limit) errx(1, "layout: invalid workspace %d", ws_id + 1); if (strcasecmp(value, "vertical") == 0) st = SWM_V_STACK; else if (strcasecmp(value, "vertical_flip") == 0) { st = SWM_V_STACK; f = true; } else if (strcasecmp(value, "horizontal") == 0) st = SWM_H_STACK; else if (strcasecmp(value, "horizontal_flip") == 0) { st = SWM_H_STACK; f = true; } else if (strcasecmp(value, "max") == 0 || strcasecmp(value, "fullscreen") == 0) /* Keep "fullscreen" for backwards compatibility. */ st = SWM_MAX_STACK; else errx(1, "invalid layout entry, should be 'ws[]:" "::::" "'"); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { ws = (struct workspace *)&screens[i].ws; ws[ws_id].cur_layout = &layouts[st]; ws[ws_id].always_raise = (ar != 0); if (st == SWM_MAX_STACK) continue; /* master grow */ for (x = 0; x < abs(mg); x++) { ws[ws_id].cur_layout->l_config(&ws[ws_id], mg >= 0 ? SWM_ARG_ID_MASTERGROW : SWM_ARG_ID_MASTERSHRINK); } /* master add */ for (x = 0; x < abs(ma); x++) { ws[ws_id].cur_layout->l_config(&ws[ws_id], ma >= 0 ? SWM_ARG_ID_MASTERADD : SWM_ARG_ID_MASTERDEL); } /* stack inc */ for (x = 0; x < abs(si); x++) { ws[ws_id].cur_layout->l_config(&ws[ws_id], si >= 0 ? SWM_ARG_ID_STACKINC : SWM_ARG_ID_STACKDEC); } /* Apply flip */ if (f) { ws[ws_id].cur_layout->l_config(&ws[ws_id], SWM_ARG_ID_FLIPLAYOUT); } } return (0); } /* config options */ struct config_option { char *name; int (*func)(const char*, const char*, int); int flags; }; struct config_option configopt[] = { { "autorun", setautorun, 0 }, { "bar_action", setconfvalue, SWM_S_BAR_ACTION }, { "bar_at_bottom", setconfvalue, SWM_S_BAR_AT_BOTTOM }, { "bar_border", setconfcolor, SWM_S_COLOR_BAR_BORDER }, { "bar_border_unfocus", setconfcolor, SWM_S_COLOR_BAR_BORDER_UNFOCUS }, { "bar_border_width", setconfvalue, SWM_S_BAR_BORDER_WIDTH }, { "bar_color", setconfcolor, SWM_S_COLOR_BAR }, { "bar_color_selected", setconfcolor, SWM_S_COLOR_BAR_SELECTED }, { "bar_delay", NULL, 0 }, /* dummy */ { "bar_enabled", setconfvalue, SWM_S_BAR_ENABLED }, { "bar_enabled_ws", setconfvalue, SWM_S_BAR_ENABLED_WS }, { "bar_font", setconfvalue, SWM_S_BAR_FONT }, { "bar_font_color", setconfcolor, SWM_S_COLOR_BAR_FONT }, { "bar_font_color_selected", setconfcolor, SWM_S_COLOR_BAR_FONT_SELECTED }, { "bar_format", setconfvalue, SWM_S_BAR_FORMAT }, { "bar_justify", setconfvalue, SWM_S_BAR_JUSTIFY }, { "bind", setconfbinding, 0 }, { "border_width", setconfvalue, SWM_S_BORDER_WIDTH }, { "boundary_width", setconfvalue, SWM_S_BOUNDARY_WIDTH }, { "clock_enabled", setconfvalue, SWM_S_CLOCK_ENABLED }, { "clock_format", setconfvalue, SWM_S_CLOCK_FORMAT }, { "color_focus", setconfcolor, SWM_S_COLOR_FOCUS }, { "color_focus_maximized", setconfcolor, SWM_S_COLOR_FOCUS_MAXIMIZED }, { "color_unfocus", setconfcolor, SWM_S_COLOR_UNFOCUS }, { "color_unfocus_maximized", setconfcolor, SWM_S_COLOR_UNFOCUS_MAXIMIZED }, { "cycle_empty", setconfvalue, SWM_S_CYCLE_EMPTY }, { "cycle_visible", setconfvalue, SWM_S_CYCLE_VISIBLE }, { "dialog_ratio", setconfvalue, SWM_S_DIALOG_RATIO }, { "disable_border", setconfvalue, SWM_S_DISABLE_BORDER }, { "focus_close", setconfvalue, SWM_S_FOCUS_CLOSE }, { "focus_close_wrap", setconfvalue, SWM_S_FOCUS_CLOSE_WRAP }, { "focus_default", setconfvalue, SWM_S_FOCUS_DEFAULT }, { "focus_mode", setconfvalue, SWM_S_FOCUS_MODE }, { "iconic_enabled", setconfvalue, SWM_S_ICONIC_ENABLED }, { "java_workaround", NULL, 0 }, /* dummy */ { "keyboard_mapping", setkeymapping, 0 }, { "layout", setlayout, 0 }, { "maximize_hide_bar", setconfvalue, SWM_S_MAXIMIZE_HIDE_BAR }, { "modkey", setconfmodkey, 0 }, { "program", setconfspawn, 0 }, { "quirk", setconfquirk, 0 }, { "region", setconfregion, 0 }, { "region_padding", setconfvalue, SWM_S_REGION_PADDING }, { "screenshot_app", NULL, 0 }, /* dummy */ { "screenshot_enabled", NULL, 0 }, /* dummy */ { "spawn_position", setconfvalue, SWM_S_SPAWN_ORDER }, { "spawn_term", setconfvalue, SWM_S_SPAWN_TERM }, { "stack_enabled", setconfvalue, SWM_S_STACK_ENABLED }, { "term_width", setconfvalue, SWM_S_TERM_WIDTH }, { "tile_gap", setconfvalue, SWM_S_TILE_GAP }, { "title_class_enabled", setconfvalue, SWM_S_WINDOW_CLASS_ENABLED }, /* For backwards compat. */ { "title_name_enabled", setconfvalue, SWM_S_WINDOW_INSTANCE_ENABLED }, /* For backwards compat. */ { "urgent_collapse", setconfvalue, SWM_S_URGENT_COLLAPSE }, { "urgent_enabled", setconfvalue, SWM_S_URGENT_ENABLED }, { "verbose_layout", setconfvalue, SWM_S_VERBOSE_LAYOUT }, { "warp_focus", setconfvalue, SWM_S_WARP_FOCUS }, { "warp_pointer", setconfvalue, SWM_S_WARP_POINTER }, { "window_class_enabled", setconfvalue, SWM_S_WINDOW_CLASS_ENABLED }, { "window_instance_enabled", setconfvalue, SWM_S_WINDOW_INSTANCE_ENABLED }, { "window_name_enabled", setconfvalue, SWM_S_WINDOW_NAME_ENABLED }, { "workspace_clamp", setconfvalue, SWM_S_WORKSPACE_CLAMP }, { "workspace_limit", setconfvalue, SWM_S_WORKSPACE_LIMIT }, { "workspace_indicator", setconfvalue, SWM_S_WORKSPACE_INDICATOR }, { "name", setconfvalue, SWM_S_WORKSPACE_NAME }, }; void _add_startup_exception(const char *fmt, va_list ap) { if (vasprintf(&startup_exception, fmt, ap) == -1) warn("%s: asprintf", __func__); } void add_startup_exception(const char *fmt, ...) { va_list ap; nr_exceptions++; if (startup_exception) return; /* force bar to be enabled due to exception */ bar_enabled = true; va_start(ap, fmt); _add_startup_exception(fmt, ap); va_end(ap); } int conf_load(const char *filename, int keymapping) { FILE *config; char *line = NULL, *cp, *ce, *optsub, *optval = NULL; size_t linelen, lineno = 0; int wordlen, i, optidx, count; struct config_option *opt = NULL; DNPRINTF(SWM_D_CONF, "begin\n"); if (filename == NULL) { warnx("conf_load: no filename"); return (1); } DNPRINTF(SWM_D_CONF, "open %s\n", filename); if ((config = fopen(filename, "r")) == NULL) { warn("conf_load: fopen: %s", filename); return (1); } while (!feof(config)) { if (line) free(line); if ((line = fparseln(config, &linelen, &lineno, NULL, FPARSELN_UNESCCOMM | FPARSELN_UNESCCONT)) == NULL) { if (ferror(config)) err(1, "%s", filename); else continue; } cp = line; cp += strspn(cp, " \t\n"); /* eat whitespace */ if (cp[0] == '\0') { /* empty line */ continue; } /* get config option */ wordlen = strcspn(cp, "=[ \t\n"); if (wordlen == 0) { add_startup_exception("%s: line %zd: no option found", filename, lineno); continue; } optidx = -1; for (i = 0; i < LENGTH(configopt); i++) { opt = &configopt[i]; if (strncasecmp(cp, opt->name, wordlen) == 0 && (int)strlen(opt->name) == wordlen) { optidx = i; break; } } if (optidx == -1) { add_startup_exception("%s: line %zd: unknown option " "%.*s", filename, lineno, wordlen, cp); continue; } if (keymapping && opt && strcmp(opt->name, "bind")) { add_startup_exception("%s: line %zd: invalid option " "%.*s", filename, lineno, wordlen, cp); continue; } cp += wordlen; cp += strspn(cp, " \t\n"); /* eat whitespace */ /* get [selector] if any */ optsub = NULL; count = 0; if (*cp == '[') { ++count; /* Get length of selector. */ for (ce = ++cp; *ce != '\0'; ++ce) { /* Find matching (not escaped) bracket. */ if (*ce == ']' && *(ce - 1) != '\\') { --count; break; } } if (count > 0) { add_startup_exception("%s: line %zd: syntax " "error: unterminated selector", filename, lineno); continue; } /* ce points at ']'; terminate optsub. */ *ce = '\0'; optsub = cp; cp = ce + 1; } cp += strspn(cp, "= \t\n"); /* eat trailing */ /* get RHS value */ optval = cp; if (strlen(optval) == 0) { add_startup_exception("%s: line %zd: must supply value " "to %s", filename, lineno, opt->name); continue; } /* trim trailing spaces */ ce = optval + strlen(optval) - 1; while (ce > optval && isspace(*ce)) --ce; *(ce + 1) = '\0'; /* call function to deal with it all */ if (opt->func && opt->func(optsub, optval, opt->flags) != 0) { add_startup_exception("%s: line %zd: invalid data for " "%s", filename, lineno, opt->name); continue; } } if (line) free(line); fclose(config); DNPRINTF(SWM_D_CONF, "end\n"); return (0); } void set_child_transient(struct ws_win *win, xcb_window_t *trans) { struct ws_win *parent, *w; struct swm_region *r; struct workspace *ws; xcb_icccm_wm_hints_t wmh; parent = find_window(win->transient); if (parent) parent->focus_child = win; else { DNPRINTF(SWM_D_MISC, "parent doesn't exist for %#x trans %#x\n", win->id, win->transient); r = root_to_region(win->s->root, SWM_CK_ALL); ws = r->ws; /* parent doen't exist in our window list */ TAILQ_FOREACH(w, &ws->winlist, entry) { if (xcb_icccm_get_wm_hints_reply(conn, xcb_icccm_get_wm_hints(conn, w->id), &wmh, NULL) != 1) { warnx("can't get hints for %#x", w->id); continue; } if (win->hints.window_group != wmh.window_group) continue; w->focus_child = win; win->transient = w->id; *trans = w->id; DNPRINTF(SWM_D_MISC, "adjusting transient to %#x\n", win->transient); break; } } } pid_t window_get_pid(xcb_window_t win) { pid_t ret = 0; const char *errstr; xcb_atom_t apid; xcb_get_property_cookie_t pc; xcb_get_property_reply_t *pr; apid = get_atom_from_string("_NET_WM_PID"); if (apid == XCB_ATOM_NONE) goto tryharder; pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_CARDINAL, 0, 1); pr = xcb_get_property_reply(conn, pc, NULL); if (pr == NULL) goto tryharder; if (pr->type != XCB_ATOM_CARDINAL) { free(pr); goto tryharder; } if (pr->type == apid && pr->format == 32) ret = *((pid_t *)xcb_get_property_value(pr)); free(pr); return (ret); tryharder: apid = get_atom_from_string("_SWM_PID"); pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_STRING, 0, SWM_PROPLEN); pr = xcb_get_property_reply(conn, pc, NULL); if (pr == NULL) return (0); if (pr->type != apid) { free(pr); return (0); } ret = (pid_t)strtonum(xcb_get_property_value(pr), 0, INT_MAX, &errstr); free(pr); return (ret); } int get_swm_ws(xcb_window_t id) { int ws_idx = -1; char *prop = NULL; size_t proplen; const char *errstr; xcb_get_property_reply_t *gpr; gpr = xcb_get_property_reply(conn, xcb_get_property(conn, 0, id, a_swm_ws, XCB_ATOM_STRING, 0, SWM_PROPLEN), NULL); if (gpr == NULL) return (-1); if (gpr->type) { proplen = xcb_get_property_value_length(gpr); if (proplen > 0) { prop = malloc(proplen + 1); if (prop) { memcpy(prop, xcb_get_property_value(gpr), proplen); prop[proplen] = '\0'; } } } free(gpr); if (prop) { DNPRINTF(SWM_D_PROP, "_SWM_WS: %s\n", prop); ws_idx = (int)strtonum(prop, 0, workspace_limit - 1, &errstr); if (errstr) { DNPRINTF(SWM_D_PROP, "win #%s: %s", errstr, prop); } free(prop); } return (ws_idx); } int get_ws_idx(struct ws_win *win) { xcb_get_property_reply_t *gpr; int ws_idx = -1; if (win == NULL) return (-1); gpr = xcb_get_property_reply(conn, xcb_get_property(conn, 0, win->id, ewmh[_NET_WM_DESKTOP].atom, XCB_ATOM_CARDINAL, 0, 1), NULL); if (gpr) { if (gpr->type == XCB_ATOM_CARDINAL && gpr->format == 32) ws_idx = *((int *)xcb_get_property_value(gpr)); free(gpr); } if (ws_idx == -1 && !(win->quirks & SWM_Q_IGNORESPAWNWS)) ws_idx = get_swm_ws(win->id); if (ws_idx > workspace_limit - 1 || ws_idx < -1) ws_idx = -1; DNPRINTF(SWM_D_PROP, "win %#x, ws_idx: %d\n", win->id, ws_idx); return (ws_idx); } void reparent_window(struct ws_win *win) { xcb_void_cookie_t c; xcb_generic_error_t *error; uint32_t wa[3]; win->frame = xcb_generate_id(conn); DNPRINTF(SWM_D_MISC, "win %#x, frame: %#x\n", win->id, win->frame); struct xcb_screen_t *s; if ((s = get_screen(win->s->idx)) == NULL) errx(1, "ERROR: can't get screen %d.", win->s->idx); wa[0] = s->black_pixel; wa[1] = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_EXPOSURE; #ifdef SWM_DEBUG wa[1] |= XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_FOCUS_CHANGE; #endif wa[2] = win->s->colormap; xcb_create_window(conn, win->s->depth, win->frame, win->s->root, X(win), Y(win), WIDTH(win), HEIGHT(win), 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, win->s->visual, XCB_CW_BORDER_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_COLORMAP, wa); win->state = SWM_WIN_STATE_REPARENTING; c = xcb_reparent_window_checked(conn, win->id, win->frame, 0, 0); if ((error = xcb_request_check(conn, c))) { DNPRINTF(SWM_D_MISC, "error:\n"); event_error(error); free(error); /* Abort. */ xcb_destroy_window(conn, win->frame); win->frame = XCB_WINDOW_NONE; } else { xcb_change_save_set(conn, XCB_SET_MODE_INSERT, win->id); } DNPRINTF(SWM_D_MISC, "done\n"); } void unparent_window(struct ws_win *win) { xcb_change_save_set(conn, XCB_SET_MODE_DELETE, win->id); xcb_reparent_window(conn, win->id, win->s->root, X(win), Y(win)); xcb_destroy_window(conn, win->frame); win->frame = XCB_WINDOW_NONE; win->state = SWM_WIN_STATE_UNPARENTING; } struct ws_win * manage_window(xcb_window_t id, int spawn_pos, bool mapping) { struct ws_win *win = NULL, *ww; struct swm_region *r; struct pid_e *p; struct quirk *qp; xcb_get_geometry_reply_t *gr; xcb_get_window_attributes_reply_t *war = NULL; xcb_window_t trans = XCB_WINDOW_NONE; uint32_t i, wa[1], new_flags; int ws_idx, force_ws = -1; char *class, *instance, *name; if (find_bar(id)) { DNPRINTF(SWM_D_MISC, "skip; win %#x is region bar\n", id); goto out; } if (find_region(id)) { DNPRINTF(SWM_D_MISC, "skip; win %#x is region window\n", id); goto out; } if ((win = find_window(id)) != NULL) { DNPRINTF(SWM_D_MISC, "skip; win %#x (%#x) already managed\n", win->frame, win->id); goto out; } /* See if window is on the unmanaged list. */ if ((win = find_unmanaged_window(id)) != NULL) { DNPRINTF(SWM_D_MISC, "win %#x is on unmanaged list\n", id); TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry); if (TRANS(win)) set_child_transient(win, &trans); goto remanage; } else { DNPRINTF(SWM_D_MISC, "win %#x is new\n", id); } war = xcb_get_window_attributes_reply(conn, xcb_get_window_attributes(conn, id), NULL); if (war == NULL) { DNPRINTF(SWM_D_EVENT, "skip; window lost\n"); goto out; } if (war->override_redirect) { DNPRINTF(SWM_D_EVENT, "skip; override_redirect\n"); goto out; } if (!mapping && war->map_state == XCB_MAP_STATE_UNMAPPED && get_win_state(id) == XCB_ICCCM_WM_STATE_WITHDRAWN) { DNPRINTF(SWM_D_EVENT, "skip; window withdrawn\n"); goto out; } /* Try to get initial window geometry. */ gr = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, id), NULL); if (gr == NULL) { DNPRINTF(SWM_D_MISC, "get geometry failed\n"); goto out; } /* Create and initialize ws_win object. */ if ((win = calloc(1, sizeof(struct ws_win))) == NULL) err(1, "manage_window: calloc: failed to allocate memory for " "new window"); win->id = id; /* Figureout which region the window belongs to. */ r = root_to_region(gr->root, SWM_CK_ALL); /* Ignore window border if there is one. */ WIDTH(win) = gr->width; HEIGHT(win) = gr->height; X(win) = gr->x + gr->border_width; Y(win) = gr->y + gr->border_width; win->bordered = false; win->mapped = (war->map_state != XCB_MAP_STATE_UNMAPPED); win->s = r->s; /* this never changes */ free(gr); /* Select which X events to monitor and set border pixel color. */ wa[0] = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_STRUCTURE_NOTIFY; xcb_change_window_attributes(conn, win->id, XCB_CW_EVENT_MASK, wa); /* Get WM_SIZE_HINTS. */ xcb_icccm_get_wm_normal_hints_reply(conn, xcb_icccm_get_wm_normal_hints(conn, win->id), &win->sh, NULL); /* Get WM_HINTS. */ xcb_icccm_get_wm_hints_reply(conn, xcb_icccm_get_wm_hints(conn, win->id), &win->hints, NULL); /* Get WM_TRANSIENT_FOR; see if window is a transient. */ xcb_icccm_get_wm_transient_for_reply(conn, xcb_icccm_get_wm_transient_for(conn, win->id), &trans, NULL); if (trans) { win->transient = trans; set_child_transient(win, &win->transient); } /* Get WM_PROTOCOLS. */ get_wm_protocols(win); #ifdef SWM_DEBUG /* Must be after getting WM_HINTS and WM_PROTOCOLS. */ DNPRINTF(SWM_D_FOCUS, "input_model: %s\n", get_win_input_model(win)); #endif /* Set initial quirks based on EWMH. */ ewmh_autoquirk(win); /* Determine initial quirks. */ xcb_icccm_get_wm_class_reply(conn, xcb_icccm_get_wm_class(conn, win->id), &win->ch, NULL); class = win->ch.class_name ? win->ch.class_name : ""; instance = win->ch.instance_name ? win->ch.instance_name : ""; name = get_win_name(win->id); DNPRINTF(SWM_D_CLASS, "class: %s, instance: %s, name: %s\n", class, instance, name); /* java is retarded so treat it special */ if (strstr(instance, "sun-awt")) { DNPRINTF(SWM_D_CLASS, "java window detected.\n"); win->java = true; } TAILQ_FOREACH(qp, &quirks, entry) { if (regexec(&qp->regex_class, class, 0, NULL, 0) == 0 && regexec(&qp->regex_instance, instance, 0, NULL, 0) == 0 && regexec(&qp->regex_name, name, 0, NULL, 0) == 0) { DNPRINTF(SWM_D_CLASS, "matched quirk: %s:%s:%s " "mask: %#x, ws: %d\n", qp->class, qp->instance, qp->name, qp->quirk, qp->ws); win->quirks = qp->quirk; if (qp->ws >= 0 && qp->ws < workspace_limit) force_ws = qp->ws; } } free(name); /* Reset font sizes (the bruteforce way; no default keybinding). */ if (win->quirks & SWM_Q_XTERM_FONTADJ) { for (i = 0; i < SWM_MAX_FONT_STEPS; i++) fake_keypress(win, XK_KP_Subtract, XCB_MOD_MASK_SHIFT); for (i = 0; i < SWM_MAX_FONT_STEPS; i++) fake_keypress(win, XK_KP_Add, XCB_MOD_MASK_SHIFT); } /* Figure out which workspace the window belongs to. */ if (!(win->quirks & SWM_Q_IGNOREPID) && (p = find_pid(window_get_pid(win->id))) != NULL) { win->ws = &r->s->ws[p->ws]; TAILQ_REMOVE(&pidlist, p, entry); free(p); p = NULL; } else if ((ws_idx = get_ws_idx(win)) != -1 && !TRANS(win)) { /* _SWM_WS is set; use that. */ win->ws = &r->s->ws[ws_idx]; } else if (trans && (ww = find_window(trans)) != NULL) { /* Launch transients in the same ws as parent. */ win->ws = ww->ws; } else { win->ws = r->ws; } if (force_ws != -1) win->ws = &r->s->ws[force_ws]; /* Set the _NET_WM_DESKTOP atom. */ DNPRINTF(SWM_D_PROP, "set _NET_WM_DESKTOP: %d\n", win->ws->idx); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, ewmh[_NET_WM_DESKTOP].atom, XCB_ATOM_CARDINAL, 32, 1, &win->ws->idx); /* Remove any _SWM_WS now that we set _NET_WM_DESKTOP. */ xcb_delete_property(conn, win->id, a_swm_ws); /* WS must already be set for this to work. */ store_float_geom(win); /* Make sure window is positioned inside its region, if its active. */ if (win->ws->r) { region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_HARDBOUNDARY); update_window(win); } remanage: /* Figure out where to insert the window in the workspace list. */ if (trans && (ww = find_window(trans))) TAILQ_INSERT_AFTER(&win->ws->winlist, ww, win, entry); else if (win->ws->focus && spawn_pos == SWM_STACK_ABOVE) TAILQ_INSERT_AFTER(&win->ws->winlist, win->ws->focus, win, entry); else if (win->ws->focus && spawn_pos == SWM_STACK_BELOW) TAILQ_INSERT_BEFORE(win->ws->focus, win, entry); else switch (spawn_pos) { default: case SWM_STACK_TOP: case SWM_STACK_ABOVE: TAILQ_INSERT_TAIL(&win->ws->winlist, win, entry); break; case SWM_STACK_BOTTOM: case SWM_STACK_BELOW: TAILQ_INSERT_HEAD(&win->ws->winlist, win, entry); } ewmh_update_client_list(); TAILQ_INSERT_HEAD(&win->ws->stack, win, stack_entry); lower_window(win); /* Get/apply initial _NET_WM_STATE */ ewmh_get_wm_state(win); /* Apply quirks. */ new_flags = win->ewmh_flags; if (win->quirks & SWM_Q_FLOAT) new_flags |= EWMH_F_ABOVE; if (win->quirks & SWM_Q_ANYWHERE) new_flags |= SWM_F_MANUAL; ewmh_apply_flags(win, new_flags); ewmh_update_wm_state(win); /* Set initial _NET_WM_ALLOWED_ACTIONS */ ewmh_update_actions(win); reparent_window(win); DNPRINTF(SWM_D_MISC, "done. win %#x, (x,y) w x h: (%d,%d) %d x %d, " "ws: %d, iconic: %s, transient: %#x\n", win->id, X(win), Y(win), WIDTH(win), HEIGHT(win), win->ws->idx, YESNO(ICONIC(win)), win->transient); out: free(war); return (win); } void free_window(struct ws_win *win) { DNPRINTF(SWM_D_MISC, "win %#x\n", WINID(win)); if (win == NULL) return; xcb_icccm_get_wm_class_reply_wipe(&win->ch); /* paint memory */ memset(win, 0xff, sizeof *win); /* XXX kill later */ free(win); DNPRINTF(SWM_D_MISC, "done\n"); } void unmanage_window(struct ws_win *win) { DNPRINTF(SWM_D_MISC, "win %#x\n", WINID(win)); if (win == NULL) return; kill_refs(win); unparent_window(win); TAILQ_REMOVE(&win->ws->stack, win, stack_entry); TAILQ_REMOVE(&win->ws->winlist, win, entry); TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry); ewmh_update_client_list(); } void expose(xcb_expose_event_t *e) { struct ws_win *w; struct swm_bar *b; #ifdef SWM_DEBUG struct workspace *ws; #endif DNPRINTF(SWM_D_EVENT, "win %#x, count: %d\n", e->window, e->count); if (e->count > 0) return; if ((b = find_bar(e->window))) { bar_draw(b); xcb_flush(conn); } else if ((w = find_window(e->window)) && w->frame == e->window) { draw_frame(w); #ifdef SWM_DEBUG ws = w->ws; TAILQ_FOREACH(w, &ws->winlist, entry) debug_refresh(w); #endif xcb_flush(conn); } DNPRINTF(SWM_D_EVENT, "done\n"); } void focusin(xcb_focus_in_event_t *e) { struct ws_win *win; DNPRINTF(SWM_D_EVENT, "win %#x, mode: %s(%u), detail: %s(%u)\n", e->event, get_notify_mode_label(e->mode), e->mode, get_notify_detail_label(e->detail), e->detail); if ((win = find_window(e->event)) && win != win->ws->focus && win != win->ws->focus_pending && e->mode == XCB_NOTIFY_MODE_NORMAL) { win->ws->focus_prev = win->ws->focus; win->ws->focus = win; win->ws->focus_pending = NULL; if (win->ws->focus_prev) draw_frame(win->ws->focus_prev); draw_frame(win); raise_window(win); } } #ifdef SWM_DEBUG void focusout(xcb_focus_out_event_t *e) { DNPRINTF(SWM_D_EVENT, "win %#x, mode: %s(%u), detail: %s(%u)\n", e->event, get_notify_mode_label(e->mode), e->mode, get_notify_detail_label(e->detail), e->detail); } #endif void keypress(xcb_key_press_event_t *e) { struct action *ap; struct binding *bp; xcb_keysym_t keysym; bool replay = true; last_event_time = e->time; keysym = xcb_key_press_lookup_keysym(syms, e, 0); DNPRINTF(SWM_D_EVENT, "keysym: %u, win (x,y): %#x (%d,%d), detail: %u, " "time: %#x, root (x,y): %#x (%d,%d), child: %#x, state: %u, " "cleaned: %u, same_screen: %s\n", keysym, e->event, e->event_x, e->event_y, e->detail, e->time, e->root, e->root_x, e->root_y, e->child, e->state, CLEANMASK(e->state), YESNO(e->same_screen)); bp = binding_lookup(CLEANMASK(e->state), KEYBIND, keysym); if (bp == NULL) { /* Look for catch-all. */ if ((bp = binding_lookup(ANYMOD, KEYBIND, keysym)) == NULL) goto out; } replay = bp->flags & BINDING_F_REPLAY; if ((ap = &actions[bp->action]) == NULL) goto out; if (bp->action == FN_SPAWN_CUSTOM) spawn_custom(root_to_region(e->root, SWM_CK_ALL), &ap->args, bp->spawn_name); else if (ap->func) ap->func(bp, root_to_region(e->root, SWM_CK_ALL), &ap->args); replay = replay && !(ap->flags & FN_F_NOREPLAY); out: if (replay) { /* Replay event to event window */ DNPRINTF(SWM_D_EVENT, "replaying\n"); xcb_allow_events(conn, XCB_ALLOW_REPLAY_KEYBOARD, e->time); } else { /* Unfreeze grab events. */ DNPRINTF(SWM_D_EVENT, "unfreezing\n"); xcb_allow_events(conn, XCB_ALLOW_SYNC_KEYBOARD, e->time); } xcb_flush(conn); DNPRINTF(SWM_D_EVENT, "done\n"); } void keyrelease(xcb_key_release_event_t *e) { struct action *ap; struct binding *bp; xcb_keysym_t keysym; last_event_time = e->time; keysym = xcb_key_release_lookup_keysym(syms, e, 0); DNPRINTF(SWM_D_EVENT, "keysym: %u, win (x,y): %#x (%d,%d), detail: %u, " "time: %#x, root (x,y): %#x (%d,%d), child: %#x, state: %u, " "same_screen: %s\n", keysym, e->event, e->event_x, e->event_y, e->detail, e->time, e->root, e->root_x, e->root_y, e->child, e->state, YESNO(e->same_screen)); bp = binding_lookup(CLEANMASK(e->state), KEYBIND, keysym); if (bp == NULL) /* Look for catch-all. */ bp = binding_lookup(ANYMOD, KEYBIND, keysym); if (bp && (ap = &actions[bp->action]) && !(ap->flags & FN_F_NOREPLAY) && bp->flags & BINDING_F_REPLAY) { /* Replay event to event window */ DNPRINTF(SWM_D_EVENT, "replaying\n"); xcb_allow_events(conn, XCB_ALLOW_REPLAY_KEYBOARD, e->time); } else { /* Unfreeze grab events. */ DNPRINTF(SWM_D_EVENT, "unfreezing\n"); xcb_allow_events(conn, XCB_ALLOW_SYNC_KEYBOARD, e->time); } xcb_flush(conn); DNPRINTF(SWM_D_EVENT, "done\n"); } void buttonpress(xcb_button_press_event_t *e) { struct ws_win *win = NULL, *newf; struct swm_region *r, *old_r; struct action *ap; struct binding *bp; bool replay = true; last_event_time = e->time; DNPRINTF(SWM_D_EVENT, "win (x,y): %#x (%d,%d), detail: %u, time: %#x, " "root (x,y): %#x (%d,%d), child: %#x, state: %u, same_screen: %s\n", e->event, e->event_x, e->event_y, e->detail, e->time, e->root, e->root_x, e->root_y, e->child, e->state, YESNO(e->same_screen)); if (e->event == e->root) { if (e->child) { win = find_window(e->child); } else { /* Focus on empty region */ /* If no windows on region if its empty. */ r = root_to_region(e->root, SWM_CK_POINTER); if (r && TAILQ_EMPTY(&r->ws->winlist)) { old_r = root_to_region(e->root, SWM_CK_FOCUS); if (old_r && old_r != r) unfocus_win(old_r->ws->focus); DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, " "revert-to: parent, time: %#x\n", e->root, e->time); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, e->root, e->time); /* Clear bar since empty. */ bar_draw(r->bar); /* Don't replay root window events. */ replay = false; } } } else { win = find_window(e->event); } if (win) { newf = get_focus_magic(win); if (win->ws->focus == newf && newf != win) { if (win->focus_child == win) win->focus_child = NULL; newf = win; } focus_win(newf); } /* Handle any bound action. */ bp = binding_lookup(CLEANMASK(e->state), BTNBIND, e->detail); if (bp == NULL) { /* Look for catch-all. */ if ((bp = binding_lookup(ANYMOD, BTNBIND, e->detail)) == NULL) goto out; } replay = bp->flags & BINDING_F_REPLAY; if ((ap = &actions[bp->action]) == NULL) goto out; if (bp->action == FN_SPAWN_CUSTOM) spawn_custom(root_to_region(e->root, SWM_CK_ALL), &ap->args, bp->spawn_name); else if (ap->func) ap->func(bp, root_to_region(e->root, SWM_CK_ALL), &ap->args); replay = replay && !(ap->flags & FN_F_NOREPLAY); out: if (replay) { /* Replay event to event window */ DNPRINTF(SWM_D_EVENT, "replaying\n"); xcb_allow_events(conn, XCB_ALLOW_REPLAY_POINTER, e->time); } else { /* Unfreeze grab events. */ DNPRINTF(SWM_D_EVENT, "unfreezing\n"); xcb_allow_events(conn, XCB_ALLOW_SYNC_POINTER, e->time); } focus_flush(); } void buttonrelease(xcb_button_release_event_t *e) { struct action *ap; struct binding *bp; last_event_time = e->time; DNPRINTF(SWM_D_EVENT, "win (x,y): %#x (%d,%d), detail: %u, time: %#x, " "root (x,y): %#x (%d,%d), child: %#x, state: %u, same_screen: %s\n", e->event, e->event_x, e->event_y, e->detail, e->time, e->root, e->root_x, e->root_y, e->child, e->state, YESNO(e->same_screen)); bp = binding_lookup(CLEANMASK(e->state), BTNBIND, e->detail); if (bp == NULL) /* Look for catch-all. */ bp = binding_lookup(ANYMOD, BTNBIND, e->detail); if (bp && (ap = &actions[bp->action]) && !(ap->flags & FN_F_NOREPLAY) && bp->flags & BINDING_F_REPLAY) { /* Replay event to event window */ DNPRINTF(SWM_D_EVENT, "replaying\n"); xcb_allow_events(conn, XCB_ALLOW_REPLAY_POINTER, e->time); } else { /* Unfreeze grab events. */ DNPRINTF(SWM_D_EVENT, "unfreezing\n"); xcb_allow_events(conn, XCB_ALLOW_SYNC_POINTER, e->time); } xcb_flush(conn); } #ifdef SWM_DEBUG char * get_win_input_model(struct ws_win *win) { char *inputmodel; /* * Input Model Input Field WM_TAKE_FOCUS * No Input False Absent * Passive True Absent * Locally Active True Present * Globally Active False Present */ if (ACCEPTS_FOCUS(win)) inputmodel = (win->take_focus) ? "Locally Active" : "Passive"; else inputmodel = (win->take_focus) ? "Globally Active" : "No Input"; return (inputmodel); } void print_win_geom(xcb_window_t w) { xcb_get_geometry_reply_t *wa; wa = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, w), NULL); if (wa == NULL) { DNPRINTF(SWM_D_MISC, "win %#x not found\n", w); return; } DNPRINTF(SWM_D_MISC, "win %#x, root: %#x, depth: %u, (x,y) w x h: " "(%d,%d) %d x %d, border: %d\n", w, wa->root, wa->depth, wa->x, wa->y, wa->width, wa->height, wa->border_width); free(wa); } #endif #ifdef SWM_DEBUG char * get_stack_mode_name(uint8_t mode) { char *name; switch (mode) { case XCB_STACK_MODE_ABOVE: name = "Above"; break; case XCB_STACK_MODE_BELOW: name = "Below"; break; case XCB_STACK_MODE_TOP_IF: name = "TopIf"; break; case XCB_STACK_MODE_BOTTOM_IF: name = "BottomIf"; break; case XCB_STACK_MODE_OPPOSITE: name = "Opposite"; break; default: name = "Unknown"; } return (name); } #endif void configurerequest(xcb_configure_request_event_t *e) { struct ws_win *win; struct swm_region *r = NULL; int i = 0; uint32_t wc[7] = {0}; uint16_t mask = 0; bool new = false; if ((win = find_window(e->window)) == NULL) if ((win = find_unmanaged_window(e->window)) == NULL) new = true; #ifdef SWM_DEBUG if (swm_debug & SWM_D_EVENT) { print_win_geom(e->window); DNPRINTF(SWM_D_EVENT, "win %#x, parent: %#x, new: %s, " "value_mask: %u { ", e->window, e->parent, YESNO(new), e->value_mask); if (e->value_mask & XCB_CONFIG_WINDOW_X) DPRINTF("X: %d ", e->x); if (e->value_mask & XCB_CONFIG_WINDOW_Y) DPRINTF("Y: %d ", e->y); if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) DPRINTF("W: %u ", e->width); if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) DPRINTF("H: %u ", e->height); if (e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) DPRINTF("Border: %u ", e->border_width); if (e->value_mask & XCB_CONFIG_WINDOW_SIBLING) DPRINTF("Sibling: %#x ", e->sibling); if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) DPRINTF("StackMode: %s(%u) ", get_stack_mode_name(e->stack_mode), e->stack_mode); DPRINTF("}\n"); } #endif if (new) { if (e->value_mask & XCB_CONFIG_WINDOW_X) { mask |= XCB_CONFIG_WINDOW_X; wc[i++] = e->x; } if (e->value_mask & XCB_CONFIG_WINDOW_Y) { mask |= XCB_CONFIG_WINDOW_Y; wc[i++] = e->y; } if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) { mask |= XCB_CONFIG_WINDOW_WIDTH; wc[i++] = e->width; } if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) { mask |= XCB_CONFIG_WINDOW_HEIGHT; wc[i++] = e->height; } if (e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) { mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH; wc[i++] = e->border_width; } if (e->value_mask & XCB_CONFIG_WINDOW_SIBLING) { mask |= XCB_CONFIG_WINDOW_SIBLING; wc[i++] = e->sibling; } if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) { mask |= XCB_CONFIG_WINDOW_STACK_MODE; wc[i++] = e->stack_mode; } if (mask != 0) { xcb_configure_window(conn, e->window, mask, wc); xcb_flush(conn); } } else if ((!MANUAL(win) || win->quirks & SWM_Q_ANYWHERE) && !FULLSCREEN(win) && !MAXIMIZED(win)) { if (win->ws->r) r = win->ws->r; else if (win->ws->old_r) r = win->ws->old_r; /* windows are centered unless ANYWHERE quirk is set. */ if (win->quirks & SWM_Q_ANYWHERE) { if (e->value_mask & XCB_CONFIG_WINDOW_X) { win->g_float.x = e->x; if (r) win->g_float.x -= X(r); } if (e->value_mask & XCB_CONFIG_WINDOW_Y) { win->g_float.y = e->y; if (r) win->g_float.y -= Y(r); } } if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) win->g_float.w = e->width; if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) win->g_float.h = e->height; win->g_floatvalid = true; if (!MAXIMIZED(win) && !FULLSCREEN(win) && (TRANS(win) || (ABOVE(win) && win->ws->cur_layout != &layouts[SWM_MAX_STACK]))) { WIDTH(win) = win->g_float.w; HEIGHT(win) = win->g_float.h; if (r != NULL) { update_floater(win); focus_flush(); } else { config_win(win, e); xcb_flush(conn); } } else { config_win(win, e); xcb_flush(conn); } } else { config_win(win, e); xcb_flush(conn); } DNPRINTF(SWM_D_EVENT, "done\n"); } void configurenotify(xcb_configure_notify_event_t *e) { struct ws_win *win; DNPRINTF(SWM_D_EVENT, "win %#x, event win: %#x, (x,y) WxH: (%d,%d) " "%ux%u, border: %u, above_sibling: %#x, override_redirect: %s\n", e->window, e->event, e->x, e->y, e->width, e->height, e->border_width, e->above_sibling, YESNO(e->override_redirect)); win = find_window(e->window); if (win) { adjust_font(win); if (font_adjusted && win->ws->r) { stack(win->ws->r); xcb_flush(conn); } } } void destroynotify(xcb_destroy_notify_event_t *e) { struct ws_win *win; struct workspace *ws; DNPRINTF(SWM_D_EVENT, "win %#x\n", e->window); if ((win = find_window(e->window)) == NULL) { if ((win = find_unmanaged_window(e->window)) == NULL) goto out; /* Window is on unmanaged list. */ TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry); free_window(win); goto out; } ws = win->ws; if (win->frame == e->window) { DNPRINTF(SWM_D_EVENT, "frame for win %#x\n", win->id); win->frame = XCB_WINDOW_NONE; goto out; } if (focus_mode != SWM_FOCUS_FOLLOW) { /* If we were focused, make sure we focus on something else. */ if (win == ws->focus) { ws->focus_pending = get_focus_prev(win); if (ws->focus_pending == win) ws->focus_pending = NULL; } } unmanage_window(win); TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry); free_window(win); stack(ws->r); if (focus_mode != SWM_FOCUS_FOLLOW && WS_FOCUSED(ws)) { if (ws->focus_pending) { focus_win(ws->focus_pending); ws->focus_pending = NULL; } else if (ws->focus == NULL) { DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, " "revert-to: parent, time: 0\n", ws->r->id); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, ws->r->id, XCB_CURRENT_TIME); } focus_flush(); } out: DNPRINTF(SWM_D_EVENT, "done\n"); } #ifdef SWM_DEBUG char * get_notify_detail_label(uint8_t detail) { char *label; switch (detail) { case XCB_NOTIFY_DETAIL_ANCESTOR: label = "Ancestor"; break; case XCB_NOTIFY_DETAIL_VIRTUAL: label = "Virtual"; break; case XCB_NOTIFY_DETAIL_INFERIOR: label = "Inferior"; break; case XCB_NOTIFY_DETAIL_NONLINEAR: label = "Nonlinear"; break; case XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL: label = "NonlinearVirtual"; break; case XCB_NOTIFY_DETAIL_POINTER: label = "Pointer"; break; case XCB_NOTIFY_DETAIL_POINTER_ROOT: label = "PointerRoot"; break; case XCB_NOTIFY_DETAIL_NONE: label = "None"; break; default: label = "Unknown"; } return (label); } char * get_notify_mode_label(uint8_t mode) { char *label; switch (mode) { case XCB_NOTIFY_MODE_NORMAL: label = "Normal"; break; case XCB_NOTIFY_MODE_GRAB: label = "Grab"; break; case XCB_NOTIFY_MODE_UNGRAB: label = "Ungrab"; break; case XCB_NOTIFY_MODE_WHILE_GRABBED: label = "WhileGrabbed"; break; default: label = "Unknown"; } return (label); } char * get_state_mask_label(uint16_t state) { char *label; switch (state) { case XCB_KEY_BUT_MASK_SHIFT: label = "ShiftMask"; break; case XCB_KEY_BUT_MASK_LOCK: label = "LockMask"; break; case XCB_KEY_BUT_MASK_CONTROL: label = "ControlMask"; break; case XCB_KEY_BUT_MASK_MOD_1: label = "Mod1Mask"; break; case XCB_KEY_BUT_MASK_MOD_2: label = "Mod2Mask"; break; case XCB_KEY_BUT_MASK_MOD_3: label = "Mod3Mask"; break; case XCB_KEY_BUT_MASK_MOD_4: label = "Mod4Mask"; break; case XCB_KEY_BUT_MASK_MOD_5: label = "Mod5Mask"; break; case XCB_KEY_BUT_MASK_BUTTON_1: label = "Button1Mask"; break; case XCB_KEY_BUT_MASK_BUTTON_2: label = "Button2Mask"; break; case XCB_KEY_BUT_MASK_BUTTON_3: label = "Button3Mask"; break; case XCB_KEY_BUT_MASK_BUTTON_4: label = "Button4Mask"; break; case XCB_KEY_BUT_MASK_BUTTON_5: label = "Button5Mask"; break; case 0: label = "None"; break; default: label = "Unknown"; } return (label); } char * get_wm_state_label(uint8_t state) { char *label; switch (state) { case XCB_ICCCM_WM_STATE_WITHDRAWN: label = "Withdrawn"; break; case XCB_ICCCM_WM_STATE_NORMAL: label = "Normal"; break; case XCB_ICCCM_WM_STATE_ICONIC: label = "Iconic"; break; default: label = "Unknown"; } return (label); } #endif void enternotify(xcb_enter_notify_event_t *e) { struct ws_win *win; struct swm_region *r; last_event_time = e->time; DNPRINTF(SWM_D_FOCUS, "time: %#x, win (x,y): %#x (%d,%d), mode: %s(%d), " "detail: %s(%d), root (x,y): %#x (%d,%d), child: %#x, " "same_screen_focus: %s, state: %s(%d)\n", e->time, e->event, e->event_x, e->event_y, get_notify_mode_label(e->mode), e->mode, get_notify_detail_label(e->detail), e->detail, e->root, e->root_x, e->root_y, e->child, YESNO(e->same_screen_focus), get_state_mask_label(e->state), e->state); if (e->event == e->root && e->child == XCB_WINDOW_NONE && e->mode == XCB_NOTIFY_MODE_GRAB && e->detail == XCB_NOTIFY_DETAIL_INFERIOR) { DNPRINTF(SWM_D_EVENT, "ignore; grab inferior\n"); return; } if (focus_mode == SWM_FOCUS_MANUAL && e->mode == XCB_NOTIFY_MODE_NORMAL) { DNPRINTF(SWM_D_EVENT, "ignore; manual focus\n"); return; } if (focus_mode != SWM_FOCUS_FOLLOW && e->mode == XCB_NOTIFY_MODE_UNGRAB && e->detail != XCB_NOTIFY_DETAIL_ANCESTOR) { DNPRINTF(SWM_D_EVENT, "ignore; ungrab\n"); return; } if ((win = find_window(e->event)) == NULL) { if (e->event == e->root) { /* If no windows on pointer region, then focus root. */ r = root_to_region(e->root, SWM_CK_POINTER); if (r == NULL) { DNPRINTF(SWM_D_EVENT, "ignore; NULL region\n"); return; } focus_region(r); } else { DNPRINTF(SWM_D_EVENT, "ignore; window is NULL\n"); return; } } else { if (e->mode == XCB_NOTIFY_MODE_NORMAL && e->detail == XCB_NOTIFY_DETAIL_INFERIOR) { DNPRINTF(SWM_D_EVENT, "ignore; enter from inferior\n"); return; } focus_win(get_focus_magic(win)); } DNPRINTF(SWM_D_EVENT, "done\n"); xcb_flush(conn); } #ifdef SWM_DEBUG void leavenotify(xcb_leave_notify_event_t *e) { last_event_time = e->time; DNPRINTF(SWM_D_FOCUS, "time: %#x, win (x,y): %#x (%d,%d), mode: %s(%d)," " detail: %s(%d), root (x,y): %#x (%d,%d), child: %#x, " "same_screen_focus: %s, state: %s(%d)\n", e->time, e->event, e->event_x, e->event_y, get_notify_mode_label(e->mode), e->mode, get_notify_detail_label(e->detail), e->detail, e->root, e->root_x, e->root_y, e->child, YESNO(e->same_screen_focus), get_state_mask_label(e->state), e->state); } #endif void mapnotify(xcb_map_notify_event_t *e) { struct ws_win *win, *parent = NULL; struct workspace *ws; DNPRINTF(SWM_D_EVENT, "win %#x\n", e->window); if ((win = manage_window(e->window, spawn_position, false)) == NULL) goto out; ws = win->ws; if (win->state == SWM_WIN_STATE_REPARENTING) goto out; if (ws->r == NULL) { unmap_window(win); goto flush; } /* Need to know if win was mapped due to ws switch. */ if (ws->state == SWM_WS_STATE_MAPPED) { if (ws->focus_pending && TRANS(ws->focus_pending)) parent = find_window(win->transient); /* If window's parent is maximized, don't clear it. */ if ((parent == NULL) || !MAXIMIZED(parent)) if (clear_maximized(ws) > 0) stack(ws->r); } win->mapped = true; set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL); if (focus_mode != SWM_FOCUS_FOLLOW && WS_FOCUSED(win->ws)) { if (ws->focus_pending == win) { focus_win(win); ws->focus_pending = NULL; center_pointer(ws->r); focus_flush(); } } flush: xcb_flush(conn); out: DNPRINTF(SWM_D_EVENT, "done\n"); } void mappingnotify(xcb_mapping_notify_event_t *e) { if (e->request != XCB_MAPPING_POINTER) { xcb_refresh_keyboard_mapping(syms, e); grabkeys(); } grabbuttons(); } void maprequest(xcb_map_request_event_t *e) { struct ws_win *win, *w = NULL; DNPRINTF(SWM_D_EVENT, "win %#x\n", e->window); win = manage_window(e->window, spawn_position, true); if (win == NULL) goto out; /* The new window should get focus; prepare. */ if (focus_mode != SWM_FOCUS_FOLLOW && !(win->quirks & SWM_Q_NOFOCUSONMAP) && ACCEPTS_FOCUS(win)) { if (win->quirks & SWM_Q_FOCUSONMAP_SINGLE) { /* See if other wins of same type are already mapped. */ TAILQ_FOREACH(w, &win->ws->winlist, entry) { if (w == win || !w->mapped) continue; if (w->ch.class_name && win->ch.class_name && strcmp(w->ch.class_name, win->ch.class_name) == 0 && w->ch.instance_name && win->ch.instance_name && strcmp(w->ch.instance_name, win->ch.instance_name) == 0) break; } } if (w == NULL) win->ws->focus_pending = get_focus_magic(win); } /* All windows need to be mapped if they are in the current workspace.*/ stack(win->ws->r); /* Ignore EnterNotify to handle the mapnotify without interference. */ if (focus_mode == SWM_FOCUS_DEFAULT) event_drain(XCB_ENTER_NOTIFY); out: DNPRINTF(SWM_D_EVENT, "done\n"); } void motionnotify(xcb_motion_notify_event_t *e) { struct swm_region *r = NULL; int i, num_screens; last_event_time = e->time; DNPRINTF(SWM_D_FOCUS, "time: %#x, win (x,y): %#x (%d,%d), " "detail: %s(%d), root (x,y): %#x (%d,%d), child: %#x, " "same_screen_focus: %s, state: %d\n", e->time, e->event, e->event_x, e->event_y, get_notify_detail_label(e->detail), e->detail, e->root, e->root_x, e->root_y, e->child, YESNO(e->same_screen), e->state); if (focus_mode == SWM_FOCUS_MANUAL) return; num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) if (screens[i].root == e->root) break; TAILQ_FOREACH(r, &screens[i].rl, entry) if (X(r) <= e->root_x && e->root_x < MAX_X(r) && Y(r) <= e->root_y && e->root_y < MAX_Y(r)) break; focus_region(r); } #ifdef SWM_DEBUG char * get_atom_name(xcb_atom_t atom) { char *name = NULL; #ifdef SWM_DEBUG_ATOM_NAMES /* * This should be disabled during most debugging since * xcb_get_* causes an xcb_flush. */ size_t len; xcb_get_atom_name_reply_t *r; r = xcb_get_atom_name_reply(conn, xcb_get_atom_name(conn, atom), NULL); if (r) { len = xcb_get_atom_name_name_length(r); if (len > 0) { name = malloc(len + 1); if (name) { memcpy(name, xcb_get_atom_name_name(r), len); name[len] = '\0'; } } free(r); } #else (void)atom; #endif return (name); } #endif void propertynotify(xcb_property_notify_event_t *e) { struct ws_win *win; struct workspace *ws; #ifdef SWM_DEBUG char *name; name = get_atom_name(e->atom); DNPRINTF(SWM_D_EVENT, "win %#x, atom: %s(%u), time: %#x, state: %u\n", e->window, name, e->atom, e->time, e->state); free(name); #endif last_event_time = e->time; win = find_window(e->window); if (win == NULL) return; ws = win->ws; if (e->atom == a_state) { /* State just changed, make sure it gets focused if mapped. */ if (e->state == XCB_PROPERTY_NEW_VALUE) { if (focus_mode != SWM_FOCUS_FOLLOW && WS_FOCUSED(ws)) { if (win->mapped && win->state == SWM_WIN_STATE_REPARENTED && ws->focus_pending == win) { focus_win(ws->focus_pending); ws->focus_pending = NULL; } } } } else if (e->atom == XCB_ATOM_WM_CLASS || e->atom == XCB_ATOM_WM_NAME) { if (ws->r) bar_draw(ws->r->bar); } else if (e->atom == a_prot) { get_wm_protocols(win); } else if (e->atom == XCB_ATOM_WM_NORMAL_HINTS) { xcb_icccm_get_wm_normal_hints_reply(conn, xcb_icccm_get_wm_normal_hints(conn, win->id), &win->sh, NULL); } xcb_flush(conn); } void reparentnotify(xcb_reparent_notify_event_t *e) { struct ws_win *win; DNPRINTF(SWM_D_EVENT, "event: %#x, win %#x, parent: %#x, " "(x,y): (%u,%u), override_redirect: %u\n", e->event, e->window, e->parent, e->x, e->y, e->override_redirect); win = find_window(e->window); if (win) { if (win->state == SWM_WIN_STATE_REPARENTING) { win->state = SWM_WIN_STATE_REPARENTED; if (win->ws->r && !ICONIC(win)) map_window(win); else unmap_window(win); update_window(win); update_win_stacking(win); } else if (win->state == SWM_WIN_STATE_UNPARENTING) { win->state = SWM_WIN_STATE_UNPARENTED; } } } void unmapnotify(xcb_unmap_notify_event_t *e) { struct ws_win *win; struct workspace *ws; DNPRINTF(SWM_D_EVENT, "win %#x\n", e->window); /* If we aren't managing the window, then ignore. */ win = find_window(e->window); if (win == NULL || win->id != e->window) { DNPRINTF(SWM_D_EVENT, "ignore; unmanaged.\n"); return; } /* Do nothing if already withdrawn. */ if (!win->mapped && !ICONIC(win)) { DNPRINTF(SWM_D_EVENT, "ignore; withdrawn.\n"); return; } ws = win->ws; win->mapped = false; /* Ignore if reparenting-related. */ if (win->state != SWM_WIN_STATE_REPARENTED) { DNPRINTF(SWM_D_EVENT, "ignore; not reparented\n"); return; } /* If win was focused, make sure to focus on something else. */ if (win == ws->focus) { if (focus_mode != SWM_FOCUS_FOLLOW) { ws->focus_pending = get_focus_prev(win); DNPRINTF(SWM_D_EVENT, "focus_pending: %#x\n", WINID(ws->focus_pending)); } unfocus_win(win); } if (ICONIC(win)) { /* Iconify. */ DNPRINTF(SWM_D_EVENT, "iconify\n"); set_win_state(win, XCB_ICCCM_WM_STATE_ICONIC); } else { /* Withdraw. */ DNPRINTF(SWM_D_EVENT, "withdraw\n"); set_win_state(win, XCB_ICCCM_WM_STATE_WITHDRAWN); unmanage_window(win); } stack(ws->r); /* Update focus if ws is active. */ if (WS_FOCUSED(ws)) { if (focus_mode == SWM_FOCUS_FOLLOW) { focus_win(get_pointer_win(ws->r->s->root)); } else if (ws->focus_pending) { focus_win(ws->focus_pending); ws->focus_pending = NULL; } else if (ws->focus == NULL) { DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, " "revert-to: parent, time: 0\n", ws->r->id); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, ws->r->id, XCB_CURRENT_TIME); } } center_pointer(ws->r); focus_flush(); DNPRINTF(SWM_D_EVENT, "done\n"); } #ifdef SWM_DEBUG char * get_source_type_label(uint32_t type) { char *label; switch (type) { case EWMH_SOURCE_TYPE_NONE: label = "None"; break; case EWMH_SOURCE_TYPE_NORMAL: label = "Normal"; break; case EWMH_SOURCE_TYPE_OTHER: label = "Other"; break; default: label = "Invalid"; } return (label); } #endif void clientmessage(xcb_client_message_event_t *e) { struct ws_win *win; struct swm_region *r = NULL; union arg a; uint32_t vals[4]; int num_screens, i; xcb_map_request_event_t mre; #ifdef SWM_DEBUG char *name; name = get_atom_name(e->type); DNPRINTF(SWM_D_EVENT, "win %#x, atom: %s(%u)\n", e->window, name, e->type); free(name); #endif if (e->type == ewmh[_NET_CURRENT_DESKTOP].atom) { num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) if (screens[i].root == e->window) { r = screens[i].r_focus; break; } if (r && e->data.data32[0] < (uint32_t)workspace_limit) { a.id = e->data.data32[0]; switchws(NULL, r, &a); focus_flush(); } return; } else if (e->type == ewmh[_NET_REQUEST_FRAME_EXTENTS].atom) { DNPRINTF(SWM_D_EVENT,"set _NET_FRAME_EXTENTS on window\n"); vals[0] = vals[1] = vals[2] = vals[3] = border_width; xcb_change_property(conn, XCB_PROP_MODE_REPLACE, e->window, a_net_frame_extents, XCB_ATOM_CARDINAL, 32, 4, vals); xcb_flush(conn); return; } win = find_window(e->window); if (win == NULL) { if (e->type == ewmh[_NET_ACTIVE_WINDOW].atom) { /* Manage the window with maprequest. */ DNPRINTF(SWM_D_EVENT, "focus unmanaged; mapping.\n"); mre.window = e->window; maprequest(&mre); } return; } if (e->type == ewmh[_NET_ACTIVE_WINDOW].atom) { DNPRINTF(SWM_D_EVENT, "_NET_ACTIVE_WINDOW, " "source_type: " "%s(%d)\n", get_source_type_label(e->data.data32[0]), e->data.data32[0]); /* * Allow focus changes that are a result of direct user * action and from applications that use the old EWMH spec. */ if (e->data.data32[0] != EWMH_SOURCE_TYPE_NORMAL || win->quirks & SWM_Q_OBEYAPPFOCUSREQ) { if (WS_FOCUSED(win->ws)) focus_win(win); else win->ws->focus_pending = win; } } else if (e->type == ewmh[_NET_CLOSE_WINDOW].atom) { DNPRINTF(SWM_D_EVENT, "_NET_CLOSE_WINDOW\n"); if (win->can_delete) client_msg(win, a_delete, 0); else xcb_kill_client(conn, win->id); } else if (e->type == ewmh[_NET_MOVERESIZE_WINDOW].atom) { DNPRINTF(SWM_D_EVENT, "_NET_MOVERESIZE_WINDOW\n"); if (ABOVE(win)) { if (e->data.data32[0] & (1<<8)) /* x */ X(win) = e->data.data32[1]; if (e->data.data32[0] & (1<<9)) /* y */ Y(win) = e->data.data32[2]; if (e->data.data32[0] & (1<<10)) /* width */ WIDTH(win) = e->data.data32[3]; if (e->data.data32[0] & (1<<11)) /* height */ HEIGHT(win) = e->data.data32[4]; update_window(win); } else { /* Notify no change was made. */ config_win(win, NULL); /* TODO: Change stack sizes */ } } else if (e->type == ewmh[_NET_RESTACK_WINDOW].atom) { DNPRINTF(SWM_D_EVENT, "_NET_RESTACK_WINDOW\n"); vals[0] = e->data.data32[1]; /* Sibling window. */ vals[1] = e->data.data32[2]; /* Stack mode detail. */ if (win->frame != XCB_WINDOW_NONE) xcb_configure_window(conn, win->frame, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, vals); } else if (e->type == ewmh[_NET_WM_STATE].atom) { DNPRINTF(SWM_D_EVENT, "_NET_WM_STATE\n"); ewmh_change_wm_state(win, e->data.data32[1], e->data.data32[0]); if (e->data.data32[2]) ewmh_change_wm_state(win, e->data.data32[2], e->data.data32[0]); ewmh_update_wm_state(win); stack(win->ws->r); } else if (e->type == ewmh[_NET_WM_DESKTOP].atom) { DNPRINTF(SWM_D_EVENT, "_NET_WM_DESKTOP\n"); r = win->ws->r; win_to_ws(win, e->data.data32[0], true); /* Stack source and destination ws, if mapped. */ if (r != win->ws->r) { if (r) stack(r); if (win->ws->r) { if (FLOATING(win)) load_float_geom(win); stack(win->ws->r); } } } focus_flush(); } int enable_wm(void) { int num_screens, i; const uint32_t val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_OWNER_GRAB_BUTTON | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_PROPERTY_CHANGE; xcb_screen_t *sc; xcb_void_cookie_t wac; xcb_generic_error_t *error; /* this causes an error if some other window manager is running */ num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { if ((sc = get_screen(i)) == NULL) errx(1, "ERROR: can't get screen %d.", i); DNPRINTF(SWM_D_INIT, "screen %d, root: %#x\n", i, sc->root); wac = xcb_change_window_attributes_checked(conn, sc->root, XCB_CW_EVENT_MASK, &val); if ((error = xcb_request_check(conn, wac))) { DNPRINTF(SWM_D_INIT, "error_code: %u\n", error->error_code); free(error); return (1); } } return (0); } void new_region(struct swm_screen *s, int x, int y, int w, int h) { struct swm_region *r = NULL, *n; struct workspace *ws = NULL; int i; uint32_t wa[1]; DNPRINTF(SWM_D_MISC, "screen[%d]:%dx%d+%d+%d\n", s->idx, w, h, x, y); /* remove any conflicting regions */ n = TAILQ_FIRST(&s->rl); while (n) { r = n; n = TAILQ_NEXT(r, entry); if (X(r) < (x + w) && (X(r) + WIDTH(r)) > x && Y(r) < (y + h) && (Y(r) + HEIGHT(r)) > y) { if (r->ws->r != NULL) r->ws->old_r = r->ws->r; r->ws->r = NULL; bar_cleanup(r); xcb_destroy_window(conn, r->id); r->id = XCB_WINDOW_NONE; TAILQ_REMOVE(&s->rl, r, entry); TAILQ_INSERT_TAIL(&s->orl, r, entry); } } /* search old regions for one to reuse */ /* size + location match */ TAILQ_FOREACH(r, &s->orl, entry) if (X(r) == x && Y(r) == y && HEIGHT(r) == h && WIDTH(r) == w) break; /* size match */ TAILQ_FOREACH(r, &s->orl, entry) if (HEIGHT(r) == h && WIDTH(r) == w) break; if (r != NULL) { TAILQ_REMOVE(&s->orl, r, entry); /* try to use old region's workspace */ if (r->ws->r == NULL) ws = r->ws; } else if ((r = calloc(1, sizeof(struct swm_region))) == NULL) err(1, "new_region: calloc: failed to allocate memory " "for screen"); /* if we don't have a workspace already, find one */ if (ws == NULL) { for (i = 0; i < workspace_limit; i++) if (s->ws[i].r == NULL) { ws = &s->ws[i]; break; } } if (ws == NULL) errx(1, "new_region: no free workspaces"); if (ws->state == SWM_WS_STATE_HIDDEN) ws->state = SWM_WS_STATE_MAPPING; X(r) = x; Y(r) = y; WIDTH(r) = w; HEIGHT(r) = h; r->bar = NULL; r->s = s; r->ws = ws; r->ws_prior = NULL; ws->r = r; outputs++; TAILQ_INSERT_TAIL(&s->rl, r, entry); /* Invisible region window to detect pointer events on empty regions. */ r->id = xcb_generate_id(conn); wa[0] = XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_POINTER_MOTION_HINT; /* Depth of InputOnly always 0. */ xcb_create_window(conn, 0, r->id, r->s->root, X(r), Y(r), WIDTH(r), HEIGHT(r), 0, XCB_WINDOW_CLASS_INPUT_ONLY, r->s->visual, XCB_CW_EVENT_MASK, wa); /* Make sure region input is at the bottom. */ wa[0] = XCB_STACK_MODE_BELOW; xcb_configure_window(conn, r->id, XCB_CONFIG_WINDOW_STACK_MODE, wa); xcb_map_window(conn, r->id); } void scan_randr(int idx) { #ifdef SWM_XRR_HAS_CRTC int i, j; int ncrtc = 0, nmodes = 0; #endif /* SWM_XRR_HAS_CRTC */ struct swm_region *r; int num_screens; xcb_randr_get_screen_resources_current_cookie_t src; xcb_randr_get_screen_resources_current_reply_t *srr; xcb_randr_get_crtc_info_cookie_t cic; xcb_randr_get_crtc_info_reply_t *cir = NULL; xcb_randr_crtc_t *crtc; xcb_randr_mode_info_t *mode; xcb_screen_t *screen; int minrate, currate; DNPRINTF(SWM_D_MISC, "screen: %d\n", idx); if ((screen = get_screen(idx)) == NULL) errx(1, "ERROR: can't get screen %d.", idx); num_screens = get_screen_count(); if (idx >= num_screens) errx(1, "scan_randr: invalid screen"); /* remove any old regions */ while ((r = TAILQ_FIRST(&screens[idx].rl)) != NULL) { r->ws->old_r = r->ws->r = NULL; bar_cleanup(r); xcb_destroy_window(conn, r->id); r->id = XCB_WINDOW_NONE; TAILQ_REMOVE(&screens[idx].rl, r, entry); TAILQ_INSERT_TAIL(&screens[idx].orl, r, entry); } outputs = 0; /* map virtual screens onto physical screens */ #ifdef SWM_XRR_HAS_CRTC if (randr_support) { src = xcb_randr_get_screen_resources_current(conn, screens[idx].root); srr = xcb_randr_get_screen_resources_current_reply(conn, src, NULL); if (srr == NULL) { new_region(&screens[idx], 0, 0, screen->width_in_pixels, screen->height_in_pixels); goto out; } else { ncrtc = srr->num_crtcs; nmodes = srr->num_modes; } minrate = -1; mode = xcb_randr_get_screen_resources_current_modes(srr); crtc = xcb_randr_get_screen_resources_current_crtcs(srr); for (i = 0; i < ncrtc; i++) { currate = SWM_RATE_DEFAULT; cic = xcb_randr_get_crtc_info(conn, crtc[i], XCB_CURRENT_TIME); cir = xcb_randr_get_crtc_info_reply(conn, cic, NULL); if (cir == NULL) continue; if (cir->num_outputs == 0) { free(cir); continue; } if (cir->mode == 0) { new_region(&screens[idx], 0, 0, screen->width_in_pixels, screen->height_in_pixels); } else { new_region(&screens[idx], cir->x, cir->y, cir->width, cir->height); /* Determine the crtc refresh rate. */ for (j = 0; j < nmodes; j++) { if (mode[j].id == cir->mode) { if (mode[j].htotal && mode[j].vtotal) currate = mode[j].dot_clock / (mode[j].htotal * mode[j].vtotal); break; } } if (minrate == -1 || currate < minrate) minrate = currate; } free(cir); } free(srr); screens[idx].rate = (minrate > 0) ? minrate : SWM_RATE_DEFAULT; DNPRINTF(SWM_D_MISC, "Screen %d update rate: %d\n", idx, screens[idx].rate); } #endif /* SWM_XRR_HAS_CRTC */ /* If detection failed, create a single region that spans the screen. */ if (TAILQ_EMPTY(&screens[idx].rl)) new_region(&screens[idx], 0, 0, screen->width_in_pixels, screen->height_in_pixels); out: /* The screen shouldn't focus on unused regions. */ TAILQ_FOREACH(r, &screens[idx].orl, entry) { if (screens[idx].r_focus == r) screens[idx].r_focus = NULL; } DNPRINTF(SWM_D_MISC, "done.\n"); } void screenchange(xcb_randr_screen_change_notify_event_t *e) { struct swm_region *r; struct workspace *ws; struct ws_win *win; int i, j, num_screens; DNPRINTF(SWM_D_EVENT, "root: %#x\n", e->root); num_screens = get_screen_count(); /* silly event doesn't include the screen index */ for (i = 0; i < num_screens; i++) if (screens[i].root == e->root) break; if (i >= num_screens) errx(1, "screenchange: screen not found"); /* brute force for now, just re-enumerate the regions */ scan_randr(i); #ifdef SWM_DEBUG print_win_geom(e->root); #endif /* add bars to all regions */ TAILQ_FOREACH(r, &screens[i].rl, entry) bar_setup(r); /* Stack all regions. */ TAILQ_FOREACH(r, &screens[i].rl, entry) stack(r); /* Focus region. */ if (screens[i].r_focus) { /* Update bar colors for existing focus. */ r = screens[i].r_focus; screens[i].r_focus = NULL; set_region(r); } else { /* Focus on the first region. */ r = TAILQ_FIRST(&screens[i].rl); if (r) focus_region(r); } /* Cleanup unused previously visible workspaces. */ for (j = 0; j < workspace_limit; j++) { ws = &screens[i].ws[j]; if (ws->r == NULL && ws->state != SWM_WS_STATE_HIDDEN) { TAILQ_FOREACH(win, &ws->winlist, entry) unmap_window(win); ws->state = SWM_WS_STATE_HIDDEN; } } focus_flush(); /* Update workspace state and bar on all regions. */ TAILQ_FOREACH(r, &screens[i].rl, entry) { r->ws->state = SWM_WS_STATE_MAPPED; bar_draw(r->bar); } } void grab_windows(void) { struct swm_region *r = NULL; xcb_query_tree_cookie_t qtc; xcb_query_tree_reply_t *qtr; xcb_get_property_cookie_t pc; xcb_get_property_reply_t *pr; xcb_window_t *wins = NULL, trans, *cwins = NULL; int i, j, k, n, no, num_screens; DNPRINTF(SWM_D_INIT, "begin\n"); num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) { qtc = xcb_query_tree(conn, screens[i].root); qtr = xcb_query_tree_reply(conn, qtc, NULL); if (qtr == NULL) continue; wins = xcb_query_tree_children(qtr); no = xcb_query_tree_children_length(qtr); /* Try to sort windows according to _NET_CLIENT_LIST. */ pr = xcb_get_property_reply(conn, xcb_get_property(conn, 0, screens[i].root, ewmh[_NET_CLIENT_LIST].atom, XCB_ATOM_WINDOW, 0, UINT32_MAX), NULL); if (pr != NULL) { cwins = xcb_get_property_value(pr); n = xcb_get_property_value_length(pr) / sizeof(xcb_atom_t); for (j = 0; j < n; ++j) { for (k = j; k < no; ++k) { if (wins[k] == cwins[j]) { /* Swap wins j and k. */ wins[k] = wins[j]; wins[j] = cwins[j]; } } } free(pr); } /* Manage top-level windows first, then transients. */ /* TODO: allow transients to be managed before leader. */ DNPRINTF(SWM_D_INIT, "grab top-level windows.\n"); for (j = 0; j < no; j++) { TAILQ_FOREACH(r, &screens[i].rl, entry) { if (r->id == wins[j]) { DNPRINTF(SWM_D_INIT, "skip %#x; region " "input window.\n", wins[j]); break; } else if (r->bar->id == wins[j]) { DNPRINTF(SWM_D_INIT, "skip %#x; " "region bar.\n", wins[j]); break; } } if (r) continue; pc = xcb_icccm_get_wm_transient_for(conn, wins[j]); if (xcb_icccm_get_wm_transient_for_reply(conn, pc, &trans, NULL)) { DNPRINTF(SWM_D_INIT, "skip %#x; transient for " "%#x\n", wins[j], trans); continue; } manage_window(wins[j], SWM_STACK_TOP, false); } DNPRINTF(SWM_D_INIT, "grab transient windows\n"); for (j = 0; j < no; j++) { pc = xcb_icccm_get_wm_transient_for(conn, wins[j]); if (xcb_icccm_get_wm_transient_for_reply(conn, pc, &trans, NULL)) manage_window(wins[j], SWM_STACK_TOP, false); } free(qtr); } DNPRINTF(SWM_D_INIT, "done\n"); } void setup_screens(void) { struct workspace *ws; xcb_pixmap_t pxmap; xcb_depth_iterator_t diter; xcb_visualtype_iterator_t viter; xcb_void_cookie_t cmc; xcb_generic_error_t *error; XVisualInfo vtmpl, *vlist; int i, j, k, num_screens, vcount; uint32_t wa[1]; xcb_screen_t *screen; num_screens = get_screen_count(); if ((screens = calloc(num_screens, sizeof(struct swm_screen))) == NULL) err(1, "setup_screens: calloc: failed to allocate memory for " "screens"); wa[0] = cursors[XC_LEFT_PTR].cid; /* map physical screens */ for (i = 0; i < num_screens; i++) { DNPRINTF(SWM_D_WS, "init screen: %d\n", i); screens[i].idx = i; screens[i].r_focus = NULL; TAILQ_INIT(&screens[i].rl); TAILQ_INIT(&screens[i].orl); if ((screen = get_screen(i)) == NULL) errx(1, "ERROR: can't get screen %d.", i); screens[i].rate = SWM_RATE_DEFAULT; screens[i].root = screen->root; screens[i].depth = screen->root_depth; screens[i].visual = screen->root_visual; screens[i].colormap = screen->default_colormap; screens[i].xvisual = DefaultVisual(display, i); DNPRINTF(SWM_D_INIT, "root_depth: %d, screen_depth: %d\n", screen->root_depth, xcb_aux_get_depth(conn, screen)); /* Use the maximum supported screen depth. */ for (diter = xcb_screen_allowed_depths_iterator(screen); diter.rem; xcb_depth_next(&diter)) { if (diter.data->depth > screens[i].depth) { viter = xcb_depth_visuals_iterator(diter.data); if (viter.rem) { screens[i].depth = diter.data->depth; screens[i].visual = viter.data->visual_id; DNPRINTF(SWM_D_INIT, "Found visual %#x," " depth: %d.\n", screens[i].visual, screens[i].depth); } } } /* Create a new colormap if not using the root visual */ if (screens[i].visual != screen->root_visual) { /* Find the corresponding Xlib visual struct for Xft. */ vtmpl.visualid = screens[i].visual; vlist = XGetVisualInfo(display, VisualIDMask, &vtmpl, &vcount); if (vcount > 0) screens[i].xvisual = vlist[0].visual; DNPRINTF(SWM_D_INIT, "Creating new colormap.\n"); screens[i].colormap = xcb_generate_id(conn); cmc = xcb_create_colormap_checked(conn, XCB_COLORMAP_ALLOC_NONE, screens[i].colormap, screens[i].root, screens[i].visual); if ((error = xcb_request_check(conn, cmc))) { DNPRINTF(SWM_D_MISC, "error:\n"); event_error(error); free(error); } } DNPRINTF(SWM_D_INIT, "Using visual %#x, depth: %d.\n", screens[i].visual, xcb_aux_get_depth_of_visual(screen, screens[i].visual)); /* set default colors */ setscreencolor("red", i, SWM_S_COLOR_FOCUS); setscreencolor("red", i, SWM_S_COLOR_FOCUS_MAXIMIZED); setscreencolor("rgb:88/88/88", i, SWM_S_COLOR_UNFOCUS); setscreencolor("rgb:88/88/88", i, SWM_S_COLOR_UNFOCUS_MAXIMIZED); setscreencolor("rgb:00/80/80", i, SWM_S_COLOR_BAR_BORDER); setscreencolor("rgb:00/40/40", i, SWM_S_COLOR_BAR_BORDER_UNFOCUS); setscreencolor("black", i, SWM_S_COLOR_BAR); setscreencolor("rgb:00/80/80", i, SWM_S_COLOR_BAR_SELECTED); setscreencolor("rgb:a0/a0/a0", i, SWM_S_COLOR_BAR_FONT); setscreencolor("black", i, SWM_S_COLOR_BAR_FONT_SELECTED); /* set default cursor */ xcb_change_window_attributes(conn, screens[i].root, XCB_CW_CURSOR, wa); /* Create graphics context. */ /* xcb_create_gc determines root/depth from a drawable. */ pxmap = xcb_generate_id(conn); xcb_create_pixmap(conn, screens[i].depth, pxmap, screens[i].root, 10, 10); screens[i].gc = xcb_generate_id(conn); wa[0] = 0; xcb_create_gc(conn, screens[i].gc, pxmap, XCB_GC_GRAPHICS_EXPOSURES, wa); xcb_free_pixmap(conn, pxmap); /* init all workspaces */ /* XXX these should be dynamically allocated too */ for (j = 0; j < SWM_WS_MAX; j++) { ws = &screens[i].ws[j]; ws->idx = j; ws->name = NULL; ws->bar_enabled = true; ws->focus = NULL; ws->focus_prev = NULL; ws->focus_pending = NULL; ws->focus_raise = NULL; ws->r = NULL; ws->old_r = NULL; ws->state = SWM_WS_STATE_HIDDEN; TAILQ_INIT(&ws->stack); TAILQ_INIT(&ws->winlist); TAILQ_INIT(&ws->unmanagedlist); for (k = 0; layouts[k].l_stack != NULL; k++) if (layouts[k].l_config != NULL) layouts[k].l_config(ws, SWM_ARG_ID_STACKINIT); ws->cur_layout = &layouts[0]; ws->cur_layout->l_string(ws); } scan_randr(i); if (randr_support) xcb_randr_select_input(conn, screens[i].root, XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE); } } void setup_extensions(void) { const xcb_query_extension_reply_t *qep; xcb_randr_query_version_reply_t *rqvr; #ifdef SWM_XCB_HAS_XINPUT xcb_input_xi_query_version_reply_t *xiqvr; #endif randr_support = false; qep = xcb_get_extension_data(conn, &xcb_randr_id); if (qep->present) { rqvr = xcb_randr_query_version_reply(conn, xcb_randr_query_version(conn, 1, 1), NULL); if (rqvr) { if (rqvr->major_version >= 1) { randr_support = true; randr_eventbase = qep->first_event; } free(rqvr); } } #ifdef SWM_XCB_HAS_XINPUT xinput2_support = false; qep = xcb_get_extension_data(conn, &xcb_input_id); if (qep->present) { xiqvr = xcb_input_xi_query_version_reply(conn, xcb_input_xi_query_version(conn, 2, 0), NULL); if (xiqvr) { if (xiqvr->major_version >= 2) xinput2_support = true; free(xiqvr); } } #endif } void setup_globals(void) { if ((bar_fonts = strdup(SWM_BAR_FONTS)) == NULL) err(1, "setup_globals: strdup: failed to allocate memory."); if ((clock_format = strdup("%a %b %d %R %Z %Y")) == NULL) err(1, "setup_globals: strdup: failed to allocate memory."); if ((syms = xcb_key_symbols_alloc(conn)) == NULL) errx(1, "unable to allocate key symbols"); a_state = get_atom_from_string("WM_STATE"); a_prot = get_atom_from_string("WM_PROTOCOLS"); a_delete = get_atom_from_string("WM_DELETE_WINDOW"); a_net_frame_extents = get_atom_from_string("_NET_FRAME_EXTENTS"); a_net_supported = get_atom_from_string("_NET_SUPPORTED"); a_net_wm_check = get_atom_from_string("_NET_SUPPORTING_WM_CHECK"); a_takefocus = get_atom_from_string("WM_TAKE_FOCUS"); a_utf8_string = get_atom_from_string("UTF8_STRING"); a_swm_ws = get_atom_from_string("_SWM_WS"); } void shutdown_cleanup(void) { struct swm_region *r; struct ws_win *w; struct workspace *ws; int i, num_screens; /* disable alarm because the following code may not be interrupted */ alarm(0); if (signal(SIGALRM, SIG_IGN) == SIG_ERR) err(1, "can't disable alarm"); bar_extra_stop(); unmap_all(); cursors_cleanup(); clear_quirks(); clear_spawns(); clear_bindings(); teardown_ewmh(); num_screens = get_screen_count(); for (i = 0; i < num_screens; ++i) { int j; DNPRINTF(SWM_D_FOCUS, "set_input_focus: %#x, revert-to: root, " "time: 0\n", screens[i].root); xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, screens[i].root, XCB_CURRENT_TIME); if (screens[i].gc != XCB_NONE) xcb_free_gc(conn, screens[i].gc); if (!bar_font_legacy) { XftColorFree(display, screens[i].xvisual, screens[i].colormap, &bar_font_color); XftColorFree(display, screens[i].xvisual, screens[i].colormap, &search_font_color); } for (j = 0; j < SWM_S_COLOR_MAX; ++j) { free(screens[i].c[j].name); } /* Free window memory. */ for (j = 0; j < SWM_WS_MAX; ++j) { ws = &screens[i].ws[j]; free(ws->name); while ((w = TAILQ_FIRST(&ws->winlist)) != NULL) { TAILQ_REMOVE(&ws->winlist, w, entry); free_window(w); } while ((w = TAILQ_FIRST(&ws->unmanagedlist)) != NULL) { TAILQ_REMOVE(&ws->unmanagedlist, w, entry); free_window(w); } } /* Free region memory. */ while ((r = TAILQ_FIRST(&screens[i].rl)) != NULL) { TAILQ_REMOVE(&screens[i].rl, r, entry); free(r->bar); free(r); } while ((r = TAILQ_FIRST(&screens[i].orl)) != NULL) { TAILQ_REMOVE(&screens[i].rl, r, entry); free(r->bar); free(r); } } free(screens); free(bar_format); free(bar_fonts); free(clock_format); free(startup_exception); if (bar_fs) XFreeFontSet(display, bar_fs); if (bar_font) XftFontClose(display, bar_font); xcb_key_symbols_free(syms); xcb_flush(conn); xcb_aux_sync(conn); xcb_disconnect(conn); } void event_error(xcb_generic_error_t *e) { (void)e; DNPRINTF(SWM_D_EVENT, "%s(%u) from %s(%u), sequence: %u, " "resource_id: %u, minor_code: %u\n", xcb_event_get_error_label(e->error_code), e->error_code, xcb_event_get_request_label(e->major_code), e->major_code, e->sequence, e->resource_id, e->minor_code); } void event_handle(xcb_generic_event_t *evt) { uint8_t type = XCB_EVENT_RESPONSE_TYPE(evt); DNPRINTF(SWM_D_EVENT, "%s(%d), seq %u\n", xcb_event_get_label(XCB_EVENT_RESPONSE_TYPE(evt)), XCB_EVENT_RESPONSE_TYPE(evt), evt->sequence); switch (type) { #define EVENT(type, callback) case type: callback((void *)evt); return EVENT(0, event_error); EVENT(XCB_BUTTON_PRESS, buttonpress); EVENT(XCB_BUTTON_RELEASE, buttonrelease); /*EVENT(XCB_CIRCULATE_NOTIFY, );*/ /*EVENT(XCB_CIRCULATE_REQUEST, );*/ EVENT(XCB_CLIENT_MESSAGE, clientmessage); /*EVENT(XCB_COLORMAP_NOTIFY, );*/ EVENT(XCB_CONFIGURE_NOTIFY, configurenotify); EVENT(XCB_CONFIGURE_REQUEST, configurerequest); /*EVENT(XCB_CREATE_NOTIFY, );*/ EVENT(XCB_DESTROY_NOTIFY, destroynotify); EVENT(XCB_ENTER_NOTIFY, enternotify); EVENT(XCB_EXPOSE, expose); EVENT(XCB_FOCUS_IN, focusin); #ifdef SWM_DEBUG EVENT(XCB_FOCUS_OUT, focusout); #endif /*EVENT(XCB_GRAPHICS_EXPOSURE, );*/ /*EVENT(XCB_GRAVITY_NOTIFY, );*/ EVENT(XCB_KEY_PRESS, keypress); EVENT(XCB_KEY_RELEASE, keyrelease); /*EVENT(XCB_KEYMAP_NOTIFY, );*/ #ifdef SWM_DEBUG EVENT(XCB_LEAVE_NOTIFY, leavenotify); #endif EVENT(XCB_MAP_NOTIFY, mapnotify); EVENT(XCB_MAP_REQUEST, maprequest); EVENT(XCB_MAPPING_NOTIFY, mappingnotify); EVENT(XCB_MOTION_NOTIFY, motionnotify); /*EVENT(XCB_NO_EXPOSURE, );*/ EVENT(XCB_PROPERTY_NOTIFY, propertynotify); EVENT(XCB_REPARENT_NOTIFY, reparentnotify); /*EVENT(XCB_RESIZE_REQUEST, );*/ /*EVENT(XCB_SELECTION_CLEAR, );*/ /*EVENT(XCB_SELECTION_NOTIFY, );*/ /*EVENT(XCB_SELECTION_REQUEST, );*/ EVENT(XCB_UNMAP_NOTIFY, unmapnotify); /*EVENT(XCB_VISIBILITY_NOTIFY, );*/ #undef EVENT } if (randr_support && (type - randr_eventbase) == XCB_RANDR_SCREEN_CHANGE_NOTIFY) screenchange((void *)evt); } int main(int argc, char *argv[]) { struct pollfd pfd[2]; struct sigaction sact; struct stat sb; struct passwd *pwd; struct swm_region *r; xcb_generic_event_t *evt; xcb_mapping_notify_event_t *mne; int xfd, i, num_screens, num_readable; char conf[PATH_MAX], *cfile = NULL; bool stdin_ready = false, startup = true; /* suppress unused warning since var is needed */ (void)argc; #ifdef SWM_DEBUG time_started = time(NULL); #endif start_argv = argv; warnx("Welcome to spectrwm V%s Build: %s", SPECTRWM_VERSION, buildstr); if (setlocale(LC_CTYPE, "") == NULL || setlocale(LC_TIME, "") == NULL) warnx("no locale support"); if (pledge("stdio proc exec cpath rpath wpath fattr getpw dns inet " "unix", NULL) == -1) err(1, "pledge"); /* handle some signals */ bzero(&sact, sizeof(sact)); sigemptyset(&sact.sa_mask); sact.sa_flags = 0; sact.sa_handler = sighdlr; sigaction(SIGINT, &sact, NULL); sigaction(SIGQUIT, &sact, NULL); sigaction(SIGTERM, &sact, NULL); sigaction(SIGHUP, &sact, NULL); sact.sa_handler = sighdlr; sact.sa_flags = SA_NOCLDSTOP; sigaction(SIGCHLD, &sact, NULL); if ((display = XOpenDisplay(0)) == NULL) errx(1, "can not open display"); if (pledge("stdio proc exec cpath rpath wpath fattr getpw", NULL) == -1) err(1, "pledge"); conn = XGetXCBConnection(display); if (xcb_connection_has_error(conn)) errx(1, "can not get XCB connection"); XSetEventQueueOwner(display, XCBOwnsEventQueue); xcb_prefetch_extension_data(conn, &xcb_randr_id); xfd = xcb_get_file_descriptor(conn); /* look for local and global conf file */ pwd = getpwuid(getuid()); if (pwd == NULL) errx(1, "invalid user: %d", getuid()); xcb_grab_server(conn); xcb_aux_sync(conn); /* Flush the event queue. */ while ((evt = get_next_event(false))) { switch (XCB_EVENT_RESPONSE_TYPE(evt)) { case XCB_MAPPING_NOTIFY: /* Need to handle mapping changes during startup. */ mne = (xcb_mapping_notify_event_t *)evt; if (mne->request == XCB_MAPPING_KEYBOARD) xcb_refresh_keyboard_mapping(syms, mne); break; #ifdef SWM_DEBUG case 0: /* Display errors. */ event_handle(evt); break; #endif } free(evt); } if (enable_wm()) errx(1, "another window manager is currently running"); /* Load Xcursors and/or cursorfont glyph cursors. */ cursors_load(); xcb_aux_sync(conn); setup_globals(); setup_extensions(); setup_screens(); setup_ewmh(); setup_keybindings(); setup_btnbindings(); setup_quirks(); setup_spawn(); /* load config */ for (i = 0; ; i++) { conf[0] = '\0'; switch (i) { case 0: /* ~ */ snprintf(conf, sizeof conf, "%s/.%s", pwd->pw_dir, SWM_CONF_FILE); break; case 1: /* global */ snprintf(conf, sizeof conf, "/etc/%s", SWM_CONF_FILE); break; case 2: /* ~ compat */ snprintf(conf, sizeof conf, "%s/.%s", pwd->pw_dir, SWM_CONF_FILE_OLD); break; case 3: /* global compat */ snprintf(conf, sizeof conf, "/etc/%s", SWM_CONF_FILE_OLD); break; default: goto noconfig; } if (strlen(conf) && stat(conf, &sb) != -1) if (S_ISREG(sb.st_mode)) { cfile = conf; break; } } noconfig: /* load conf (if any) */ if (cfile) conf_load(cfile, SWM_CONF_DEFAULT); if (pledge("stdio proc exec cpath rpath wpath fattr", NULL) == -1) err(1, "pledge"); validate_spawns(); if (getenv("SWM_STARTED") == NULL) setenv("SWM_STARTED", "YES", 1); /* setup all bars */ num_screens = get_screen_count(); for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) bar_setup(r); if (pledge("stdio proc exec", NULL) == -1) err(1, "pledge"); /* Manage existing windows. */ grab_windows(); grabkeys(); grabbuttons(); /* Stack all regions to trigger mapping. */ for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) stack(r); xcb_ungrab_server(conn); xcb_flush(conn); /* Update state and bar of each newly mapped workspace. */ for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) { r->ws->state = SWM_WS_STATE_MAPPED; bar_draw(r->bar); } memset(&pfd, 0, sizeof(pfd)); pfd[0].fd = xfd; pfd[0].events = POLLIN; pfd[1].fd = STDIN_FILENO; pfd[1].events = POLLIN; while (running) { while ((evt = get_next_event(false))) { if (!running) goto done; event_handle(evt); free(evt); } /* If just (re)started, set default focus if needed. */ if (startup) { startup = false; if (focus_mode == SWM_FOCUS_FOLLOW) r = root_to_region(screens[0].root, SWM_CK_POINTER); else r = TAILQ_FIRST(&screens[0].rl); if (r) { focus_region(r); focus_flush(); continue; } } if (search_resp) search_do_resp(); num_readable = poll(pfd, bar_extra ? 2 : 1, 1000); if (num_readable == -1) { DNPRINTF(SWM_D_MISC, "poll failed: %s", strerror(errno)); } else if (num_readable > 0 && bar_extra && pfd[1].revents & POLLIN) { stdin_ready = true; } if (restart_wm) restart(NULL, NULL, NULL); if (!running) goto done; if (stdin_ready) { stdin_ready = false; bar_extra_update(); } /* Need to ensure the bar(s) are always updated. */ for (i = 0; i < num_screens; i++) TAILQ_FOREACH(r, &screens[i].rl, entry) bar_draw(r->bar); xcb_flush(conn); } done: if (pledge("stdio proc", NULL) == -1) err(1, "pledge"); shutdown_cleanup(); return (0); }