X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=spectrwm.c;h=06b73c0b9a1ef2b9f6e5a3a6d35c215a62b6a09c;hb=4c59fde083056c15e80b6b9e9ceb89e09598293d;hp=cd629162ddc6f3ba210d05e9829b9ae4b7577594;hpb=78294264814075f867420d88e406593dab73dc75;p=spectrwm.git diff --git a/spectrwm.c b/spectrwm.c index cd62916..06b73c0 100644 --- a/spectrwm.c +++ b/spectrwm.c @@ -8,6 +8,7 @@ * Copyright (c) 2011-2012 Reginald Kennedy * Copyright (c) 2011-2012 Lawrence Teo * Copyright (c) 2011-2012 Tiago Cunha + * Copyright (c) 2012 David Hill * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -111,17 +112,19 @@ static const char *buildstr = SPECTRWM_BUILDSTR; static const char *buildstr = SPECTRWM_VERSION; #endif -#if RANDR_MAJOR < 1 -# error XRandR versions less than 1.0 are not supported +#if !defined(__CYGWIN__) /* cygwin chokes on xrandr stuff */ +# if RANDR_MAJOR < 1 +# error XRandR versions less than 1.0 are not supported #endif -#if RANDR_MAJOR >= 1 -#if RANDR_MINOR >= 2 -#define SWM_XRR_HAS_CRTC -#endif -#endif +# if RANDR_MAJOR >= 1 +# if RANDR_MINOR >= 2 +# define SWM_XRR_HAS_CRTC +# endif +# endif +#endif /* __CYGWIN__ */ -#if defined(__OpenBSD__) +#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 @@ -150,7 +153,7 @@ static const char *buildstr = SPECTRWM_VERSION; #define xcb_icccm_wm_hints_t xcb_wm_hints_t #endif -#define SWM_DEBUG +/*#define SWM_DEBUG*/ #ifdef SWM_DEBUG #define DPRINTF(x...) do { \ if (swm_debug) \ @@ -202,11 +205,21 @@ u_int32_t swm_debug = 0 #define DNPRINTF(n,x...) #endif -#define LENGTH(x) (int)(sizeof x / sizeof x[0]) -#define MODKEY Mod1Mask -#define CLEANMASK(mask) (mask & ~(numlockmask | LockMask)) -#define BUTTONMASK (ButtonPressMask|ButtonReleaseMask) -#define MOUSEMASK (BUTTONMASK|PointerMotionMask) +/* 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 CLEANMASK(mask) ((mask) & ~(numlockmask | XCB_MOD_MASK_LOCK)) +#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_KEYS_LEN (255) @@ -215,7 +228,7 @@ u_int32_t swm_debug = 0 #define Y(r) (r)->g.y #define WIDTH(r) (r)->g.w #define HEIGHT(r) (r)->g.h -#define BORDER(w) (w->bordered ? border_width : 0) +#define BORDER(w) ((w)->bordered ? border_width : 0) #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 @@ -232,8 +245,8 @@ u_int32_t swm_debug = 0 #define YESNO(x) ((x) ? "yes" : "no") #define SWM_FOCUS_DEFAULT (0) -#define SWM_FOCUS_SYNERGY (1) -#define SWM_FOCUS_FOLLOW (2) +#define SWM_FOCUS_FOLLOW (1) +#define SWM_FOCUS_MANUAL (2) #define SWM_CONF_DEFAULT (0) #define SWM_CONF_KEYMAPPING (1) @@ -252,6 +265,7 @@ xcb_atom_t a_netwmname; xcb_atom_t a_utf8_string; xcb_atom_t a_string; xcb_atom_t a_swm_iconic; +xcb_atom_t a_swm_ws; volatile sig_atomic_t running = 1; volatile sig_atomic_t restart_wm = 0; int outputs = 0; @@ -265,6 +279,7 @@ unsigned int numlockmask = 0; Display *display; xcb_connection_t *conn; xcb_key_symbols_t *syms; +xcb_timestamp_t last_event_time; int cycle_empty = 0; int cycle_visible = 0; @@ -312,48 +327,58 @@ double dialog_ratio = 0.6; #define SWM_BAR_JUSTIFY_CENTER (1) #define SWM_BAR_JUSTIFY_RIGHT (2) #define SWM_BAR_OFFSET (4) -#define SWM_BAR_FONTS "-*-terminus-medium-*-*-*-*-*-*-*-*-*-*-*," \ - "-*-profont-*-*-*-*-*-*-*-*-*-*-*-*," \ - "-*-times-medium-r-*-*-*-*-*-*-*-*-*-*," \ - "-misc-fixed-medium-r-*-*-*-*-*-*-*-*-*-*," \ - "-*-*-*-r-*--*-*-*-*-*-*-*-*" - -char *bar_argv[] = { NULL, NULL }; -int bar_pipe[2]; -unsigned char bar_ext[SWM_BAR_MAX]; -char bar_vertext[SWM_BAR_MAX]; -int bar_version = 0; -sig_atomic_t bar_alarm = 0; -int bar_delay = 30; -int bar_enabled = 1; -int bar_border_width = 1; -int bar_at_bottom = 0; -int bar_extra = 1; -int bar_extra_running = 0; -int bar_verbose = 1; -int bar_height = 0; -int bar_justify = SWM_BAR_JUSTIFY_LEFT; -char *bar_format = NULL; -int stack_enabled = 1; -int clock_enabled = 1; -int urgent_enabled = 0; -char *clock_format = NULL; -int title_name_enabled = 0; -int title_class_enabled = 0; -int window_name_enabled = 0; -int focus_mode = SWM_FOCUS_DEFAULT; -int focus_close = SWM_STACK_BELOW; -int focus_close_wrap = 1; -int focus_default = SWM_STACK_TOP; -int spawn_position = SWM_STACK_TOP; -int disable_border = 0; -int border_width = 1; -int verbose_layout = 0; -time_t time_started; -pid_t bar_pid; -XftFont *bar_font; -char *bar_fonts; -struct passwd *pwd; +#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]; +unsigned char bar_ext[SWM_BAR_MAX]; +char bar_vertext[SWM_BAR_MAX]; +int bar_version = 0; +sig_atomic_t bar_alarm = 0; +int bar_delay = 30; +int bar_enabled = 1; +int bar_border_width = 1; +int bar_at_bottom = 0; +int bar_extra = 1; +int bar_extra_running = 0; +int bar_verbose = 1; +int bar_height = 0; +int bar_justify = SWM_BAR_JUSTIFY_LEFT; +char *bar_format = NULL; +int stack_enabled = 1; +int clock_enabled = 1; +int urgent_enabled = 0; +char *clock_format = NULL; +int title_name_enabled = 0; +int title_class_enabled = 0; +int window_name_enabled = 0; +int focus_mode = SWM_FOCUS_DEFAULT; +int focus_close = SWM_STACK_BELOW; +int focus_close_wrap = 1; +int focus_default = SWM_STACK_TOP; +int spawn_position = SWM_STACK_TOP; +int disable_border = 0; +int border_width = 1; +int verbose_layout = 0; +time_t time_started; +pid_t bar_pid; +XFontSet bar_fs; +XFontSetExtents *bar_fs_extents; +XftFont *bar_font; +int bar_font_legacy = 1; +char *bar_fonts; +XftColor bar_font_color; +struct passwd *pwd; /* layout manager data */ struct swm_geometry { @@ -387,13 +412,14 @@ struct ws_win { TAILQ_ENTRY(ws_win) entry; xcb_window_t id; xcb_window_t transient; - struct ws_win *child_trans; /* transient child window */ + struct ws_win *focus_child; /* focus on child transient */ struct swm_geometry g; /* current geometry */ struct swm_geometry g_float; /* region coordinates */ int g_floatvalid; /* g_float geometry validity */ int floatmaxed; /* whether maxed by max_stack */ int floating; int manual; + int32_t mapped; int32_t iconic; int bordered; unsigned int ewmh_flags; @@ -505,11 +531,12 @@ struct swm_screen { /* colors */ struct { - uint32_t color; + uint32_t pixel; char *name; } c[SWM_S_COLOR_MAX]; xcb_gcontext_t bar_gc; + GC bar_gc_legacy; }; struct swm_screen *screens; @@ -519,7 +546,6 @@ union arg { #define SWM_ARG_ID_FOCUSNEXT (0) #define SWM_ARG_ID_FOCUSPREV (1) #define SWM_ARG_ID_FOCUSMAIN (2) -#define SWM_ARG_ID_FOCUSCUR (4) #define SWM_ARG_ID_SWAPNEXT (10) #define SWM_ARG_ID_SWAPPREV (11) #define SWM_ARG_ID_SWAPMAIN (12) @@ -580,11 +606,13 @@ enum { _NET_ACTIVE_WINDOW, _NET_CLOSE_WINDOW, _NET_MOVERESIZE_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_NAME, _NET_WM_STATE, _NET_WM_STATE_ABOVE, _NET_WM_STATE_FULLSCREEN, @@ -612,11 +640,13 @@ struct ewmh_hint { {"_NET_ACTIVE_WINDOW", XCB_ATOM_NONE}, {"_NET_CLOSE_WINDOW", XCB_ATOM_NONE}, {"_NET_MOVERESIZE_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_NAME", XCB_ATOM_NONE}, {"_NET_WM_STATE", XCB_ATOM_NONE}, {"_NET_WM_STATE_ABOVE", XCB_ATOM_NONE}, {"_NET_WM_STATE_FULLSCREEN", XCB_ATOM_NONE}, @@ -636,46 +666,105 @@ struct ewmh_hint { }; /* function prototypes */ -xcb_char2b_t *char2b(const char *); +void buttonpress(xcb_button_press_event_t *); +void check_conn(void); +void clientmessage(xcb_client_message_event_t *); int conf_load(char *, int); +void configurenotify(xcb_configure_notify_event_t *); +void configurerequest(xcb_configure_request_event_t *); void constrain_window(struct ws_win *, struct swm_region *, int); -void do_sync(void); +void destroynotify(xcb_destroy_notify_event_t *); +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 *); +char *expand_tilde(char *); +void expose(xcb_expose_event_t *); struct ws_win *find_window(xcb_window_t); int floating_toggle_win(struct ws_win *); void focus(struct swm_region *, union arg *); -void focus_magic(struct ws_win *); +void focus_flush(void); +struct ws_win *get_focus_magic(struct ws_win *); +struct ws_win *get_focus_prev(struct ws_win *); +void focus_win(struct ws_win *); +#ifdef SWM_DEBUG +void focusin(xcb_focus_in_event_t *); +#endif xcb_atom_t get_atom_from_string(const char *); +#ifdef SWM_DEBUG +char *get_atom_name(xcb_atom_t); +char *get_notify_detail_label(uint8_t); +char *get_notify_mode_label(uint8_t); +#endif +struct ws_win *get_region_focus(struct swm_region *); xcb_screen_t *get_screen(int); char *get_win_name(xcb_window_t); -uint16_t getstate(xcb_window_t); -void grabbuttons(struct ws_win *, int); -void map_window_raised(xcb_window_t); +uint32_t getstate(xcb_window_t); +void grabbuttons(struct ws_win *); +void keypress(xcb_key_press_event_t *); +#ifdef SWM_DEBUG +void leavenotify(xcb_leave_notify_event_t *); +#endif +void load_float_geom(struct ws_win *, struct swm_region *); +struct ws_win *manage_window(xcb_window_t, uint16_t); +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 new_region(struct swm_screen *, int, int, int, int); int parse_rgb(const char *, uint16_t *, uint16_t *, uint16_t *); +void propertynotify(xcb_property_notify_event_t *); void spawn_select(struct swm_region *, union arg *, char *, int *); +void screenchange(xcb_randr_screen_change_notify_event_t *); +void shutdown_cleanup(void); void store_float_geom(struct ws_win *, struct swm_region *); void unmanage_window(struct ws_win *); +void unmapnotify(xcb_unmap_notify_event_t *); +void unfocus_win(struct ws_win *); void update_window(struct ws_win *); +/*void visibilitynotify(xcb_visibility_notify_event_t *);*/ -/* function definitions */ -xcb_char2b_t * -char2b(const char *str) +char * +expand_tilde(char *s) { - xcb_char2b_t *s; - size_t i, len; + struct passwd *ppwd; + int i, max; + char *user; + const char *sc = s; + char *result; - len = strlen(str); - s = malloc(len * sizeof(xcb_char2b_t)); - if (!s) - return (NULL); + if (s == NULL) + errx(1, "expand_tilde: NULL string."); + + if (s[0] != '~') { + result = strdup(sc); + goto out; + } - for (i = 0; i < len; i++) { - s[i].byte1 = '\0'; - s[i].byte2 = str[i]; - } + ++s; - return (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); + 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 @@ -686,9 +775,9 @@ parse_rgb(const char *rgb, uint16_t *rr, uint16_t *gg, uint16_t *bb) if (sscanf(rgb, "rgb:%x/%x/%x", &tmpr, &tmpg, &tmpb) != 3) return (-1); - *rr = tmpr << 8; - *gg = tmpg << 8; - *bb = tmpb << 8; + *rr = RGB_8_TO_16(tmpr); + *gg = RGB_8_TO_16(tmpg); + *bb = RGB_8_TO_16(tmpb); return (0); } @@ -696,39 +785,29 @@ parse_rgb(const char *rgb, uint16_t *rr, uint16_t *gg, uint16_t *bb) xcb_screen_t * get_screen(int screen) { - xcb_screen_iterator_t i; + const xcb_setup_t *r; + xcb_screen_iterator_t iter; + + if ((r = xcb_get_setup(conn)) == NULL) { + DNPRINTF(SWM_D_MISC, "get_screen: xcb_get_setup\n"); + check_conn(); + } - i = xcb_setup_roots_iterator(xcb_get_setup(conn)); - for (; i.rem; --screen, xcb_screen_next(&i)) + iter = xcb_setup_roots_iterator(r); + for (; iter.rem; --screen, xcb_screen_next(&iter)) if (screen == 0) - return (i.data); + return (iter.data); return (NULL); } void -do_sync(void) -{ - xcb_get_input_focus_cookie_t c; - xcb_get_input_focus_reply_t *r; - - /* mimic XSync() */ - c = xcb_get_input_focus(conn); - xcb_flush(conn); - r = xcb_get_input_focus_reply(conn, c, NULL); - if (r) - free(r); -} - -void -map_window_raised(xcb_window_t win) +focus_flush(void) { - uint32_t val = XCB_STACK_MODE_ABOVE; - - xcb_configure_window(conn, win, - XCB_CONFIG_WINDOW_STACK_MODE, &val); - - xcb_map_window(conn, win); + if (focus_mode == SWM_FOCUS_DEFAULT) + event_drain(XCB_ENTER_NOTIFY); + else + xcb_flush(conn); } xcb_atom_t @@ -738,7 +817,7 @@ get_atom_from_string(const char *str) xcb_intern_atom_reply_t *r; xcb_atom_t atom; - c = xcb_intern_atom(conn, False, strlen(str), str); + c = xcb_intern_atom(conn, 0, strlen(str), str); r = xcb_intern_atom_reply(conn, c, NULL); if (r) { atom = r->atom; @@ -754,35 +833,26 @@ void update_iconic(struct ws_win *win, int newv) { int32_t v = newv; - xcb_atom_t iprop; win->iconic = newv; - iprop = get_atom_from_string("_SWM_ICONIC"); - if (iprop == XCB_ATOM_NONE) - return; - if (newv) xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, - iprop, XCB_ATOM_INTEGER, 32, 1, &v); + a_swm_iconic, XCB_ATOM_INTEGER, 32, 1, &v); else - xcb_delete_property(conn, win->id, iprop); + xcb_delete_property(conn, win->id, a_swm_iconic); } int32_t -get_iconic(struct ws_win *win) +get_swm_iconic(struct ws_win *win) { int32_t v = 0; - xcb_atom_t iprop; xcb_get_property_reply_t *pr = NULL; - iprop = get_atom_from_string("_SWM_ICONIC"); - if (iprop == XCB_ATOM_NONE) - goto out; pr = xcb_get_property_reply(conn, - xcb_get_property(conn, False, win->id, iprop, XCB_ATOM_INTEGER, - 0, 1), NULL); + xcb_get_property(conn, 0, win->id, a_swm_iconic, + XCB_ATOM_INTEGER, 0, 1), NULL); if (!pr) goto out; if (pr->type != XCB_ATOM_INTEGER || pr->format != 32) @@ -833,18 +903,19 @@ teardown_ewmh(void) for (i = 0; i < num_screens; i++) { /* Get the support check window and destroy it */ - pc = xcb_get_property(conn, False, screens[i].root, sup_check, + pc = xcb_get_property(conn, 0, screens[i].root, sup_check, XCB_ATOM_WINDOW, 0, 1); pr = xcb_get_property_reply(conn, pc, NULL); - if (pr) { + if (!pr) + continue; + if (pr->format == sup_check) { id = *((xcb_window_t *)xcb_get_property_value(pr)); xcb_destroy_window(conn, id); xcb_delete_property(conn, screens[i].root, sup_check); xcb_delete_property(conn, screens[i].root, sup_list); - - free(pr); } + free(pr); } } @@ -856,7 +927,7 @@ ewmh_autoquirk(struct ws_win *win) xcb_get_property_cookie_t c; xcb_get_property_reply_t *r; - c = xcb_get_property(conn, False, win->id, + 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) @@ -912,12 +983,7 @@ ewmh_set_win_fullscreen(struct ws_win *win, int fs) win->g = win->ws->r->g; win->bordered = 0; } else { - if (win->g_floatvalid) { - /* refloat at last floating relative position */ - win->g = win->g_float; - X(win) += X(win->ws->r); - Y(win) += Y(win->ws->r); - } + load_float_geom(win, win->ws->r); } return (1); @@ -937,6 +1003,7 @@ ewmh_update_actions(struct ws_win *win) if (win->floating) { 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, @@ -948,7 +1015,7 @@ ewmh_update_actions(struct ws_win *win) #define _NET_WM_STATE_TOGGLE 2 /* toggle property */ void -ewmh_update_win_state(struct ws_win *win, long state, long action) +ewmh_update_win_state(struct ws_win *win, xcb_atom_t state, long action) { unsigned int mask = 0; unsigned int changed = 0; @@ -957,18 +1024,20 @@ ewmh_update_win_state(struct ws_win *win, long state, long action) if (win == NULL) return; + DNPRINTF(SWM_D_PROP, "ewmh_update_win_state: window: 0x%x, state: %ld, " + "action: %ld\n", win->id, (unsigned long)state, action); + if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom) mask = EWMH_F_FULLSCREEN; - if (state == ewmh[_NET_WM_STATE_ABOVE].atom) + else if (state == ewmh[_NET_WM_STATE_ABOVE].atom) mask = EWMH_F_ABOVE; - if (state == ewmh[_SWM_WM_STATE_MANUAL].atom) + else if (state == ewmh[_SWM_WM_STATE_MANUAL].atom) mask = SWM_F_MANUAL; - if (state == ewmh[_NET_WM_STATE_SKIP_PAGER].atom) + else if (state == ewmh[_NET_WM_STATE_SKIP_PAGER].atom) mask = EWMH_F_SKIP_PAGER; - if (state == ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom) + else if (state == ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom) mask = EWMH_F_SKIP_TASKBAR; - orig_flags = win->ewmh_flags; switch (action) { @@ -985,18 +1054,17 @@ ewmh_update_win_state(struct ws_win *win, long state, long action) changed = (win->ewmh_flags & mask) ^ (orig_flags & mask) ? 1 : 0; - if (state == ewmh[_NET_WM_STATE_ABOVE].atom) - if (changed) - if (!floating_toggle_win(win)) + if (state == ewmh[_NET_WM_STATE_ABOVE].atom) { + if (changed && !floating_toggle_win(win)) win->ewmh_flags = orig_flags; /* revert */ - if (state == ewmh[_SWM_WM_STATE_MANUAL].atom) + } else if (state == ewmh[_SWM_WM_STATE_MANUAL].atom) { if (changed) win->manual = (win->ewmh_flags & SWM_F_MANUAL) != 0; - if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom) - if (changed) - if (!ewmh_set_win_fullscreen(win, + } else if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom) { + if (changed && !ewmh_set_win_fullscreen(win, win->ewmh_flags & EWMH_F_FULLSCREEN)) win->ewmh_flags = orig_flags; /* revert */ + } xcb_delete_property(conn, win->id, ewmh[_NET_WM_STATE].atom); @@ -1004,19 +1072,19 @@ ewmh_update_win_state(struct ws_win *win, long state, long action) xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id, ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1, &ewmh[_NET_WM_STATE_FULLSCREEN].atom); - if (win->ewmh_flags & EWMH_F_SKIP_PAGER) + else if (win->ewmh_flags & EWMH_F_SKIP_PAGER) xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id, ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1, &ewmh[_NET_WM_STATE_SKIP_PAGER].atom); - if (win->ewmh_flags & EWMH_F_SKIP_TASKBAR) + else if (win->ewmh_flags & EWMH_F_SKIP_TASKBAR) xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id, ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1, &ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom); - if (win->ewmh_flags & EWMH_F_ABOVE) + else if (win->ewmh_flags & EWMH_F_ABOVE) xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id, ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1, &ewmh[_NET_WM_STATE_ABOVE].atom); - if (win->ewmh_flags & SWM_F_MANUAL) + else if (win->ewmh_flags & SWM_F_MANUAL) xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id, ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1, &ewmh[_SWM_WM_STATE_MANUAL].atom); @@ -1039,7 +1107,7 @@ ewmh_get_win_state(struct ws_win *win) if (win->manual) win->ewmh_flags |= SWM_F_MANUAL; - c = xcb_get_property(conn, False, win->id, ewmh[_NET_WM_STATE].atom, + 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) @@ -1060,10 +1128,13 @@ void dumpwins(struct swm_region *r, union arg *args) { struct ws_win *win; - uint16_t state; + 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)args; + if (r->ws == NULL) { warnx("dumpwins: invalid workspace"); return; @@ -1103,28 +1174,13 @@ dumpwins(struct swm_region *r, union arg *args) } #else void -dumpwins(struct swm_region *r, union arg *args) +dumpwins(struct swm_region *r, union arg *s) { + (void)r; + (void)s; } #endif /* SWM_DEBUG */ -void event_error(xcb_generic_error_t *); -void expose(xcb_expose_event_t *); -void keypress(xcb_key_press_event_t *); -void buttonpress(xcb_button_press_event_t *); -void configurerequest(xcb_configure_request_event_t *); -void configurenotify(xcb_configure_notify_event_t *); -void destroynotify(xcb_destroy_notify_event_t *); -void enternotify(xcb_enter_notify_event_t *); -void mapnotify(xcb_map_notify_event_t *); -void mappingnotify(xcb_mapping_notify_event_t *); -void maprequest(xcb_map_request_event_t *); -void propertynotify(xcb_property_notify_event_t *); -void unmapnotify(xcb_unmap_notify_event_t *); -/*void visibilitynotify(xcb_visibility_notify_event_t *);*/ -void clientmessage(xcb_client_message_event_t *); -void screenchange(xcb_randr_screen_change_notify_event_t *); - void sighdlr(int sig) { @@ -1192,7 +1248,7 @@ find_pid(pid_t pid) } uint32_t -name_to_color(const char *colorname) +name_to_pixel(const char *colorname) { uint32_t result = 0; char cname[32] = "#"; @@ -1246,13 +1302,13 @@ setscreencolor(char *val, int i, int c) num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); if (i > 0 && i <= num_screens) { - screens[i - 1].c[c].color = name_to_color(val); + screens[i - 1].c[c].pixel = name_to_pixel(val); free(screens[i - 1].c[c].name); if ((screens[i - 1].c[c].name = strdup(val)) == NULL) err(1, "strdup"); } else if (i == -1) { for (i = 0; i < num_screens; i++) { - screens[i].c[c].color = name_to_color(val); + screens[i].c[c].pixel = name_to_pixel(val); free(screens[i].c[c].name); if ((screens[i].c[c].name = strdup(val)) == NULL) err(1, "strdup"); @@ -1304,7 +1360,9 @@ custom_region(char *val) sidx, num_screens); sidx--; - screen = get_screen(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); @@ -1334,13 +1392,67 @@ socket_setnonblock(int fd) } 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; + + rect.x = 0; + rect.y = 0; + rect.width = WIDTH(r->bar); + rect.height = HEIGHT(r->bar); + + /* clear back buffer */ + gcv[0] = r->s->c[SWM_S_COLOR_BAR].pixel; + xcb_change_gc(conn, r->s->bar_gc, XCB_GC_FOREGROUND, gcv); + xcb_poly_fill_rectangle(conn, r->bar->buffer, r->s->bar_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->bar_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; + int32_t x = 0; XGlyphInfo info; + XftDraw *draw; len = strlen(s); @@ -1367,19 +1479,20 @@ bar_print(struct swm_region *r, const char *s) rect.height = HEIGHT(r->bar); /* clear back buffer */ - gcv[0] = r->s->c[SWM_S_COLOR_BAR].color; + gcv[0] = r->s->c[SWM_S_COLOR_BAR].pixel; xcb_change_gc(conn, r->s->bar_gc, XCB_GC_FOREGROUND, gcv); - xcb_poly_fill_rectangle(conn, r->bar->buffer, r->s->bar_gc, - sizeof(rect), &rect); + xcb_poly_fill_rectangle(conn, r->bar->buffer, r->s->bar_gc, 1, &rect); /* draw back buffer */ - gcv[0] = r->s->c[SWM_S_COLOR_BAR].color; - xcb_change_gc(conn, r->s->bar_gc, XCB_GC_BACKGROUND, gcv); - gcv[0] = r->s->c[SWM_S_COLOR_BAR_FONT].color; - xcb_change_gc(conn, r->s->bar_gc, XCB_GC_FOREGROUND, gcv); + draw = XftDrawCreate(display, r->bar->buffer, + DefaultVisual(display, r->s->idx), + DefaultColormap(display, r->s->idx)); - xcb_image_text_8(conn, len, r->bar->buffer, r->s->bar_gc, x, - bar_font->height, s); + 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->bar_gc, 0, 0, @@ -1722,7 +1835,10 @@ bar_fmt_print(void) continue; bar_fmt(fmtexp, fmtnew, r, sizeof fmtnew); bar_replace(fmtnew, fmtrep, r, sizeof fmtrep); - bar_print(r, fmtrep); + if (bar_font_legacy) + bar_print_legacy(r, fmtrep); + else + bar_print(r, fmtrep); } } } @@ -1756,6 +1872,9 @@ bar_update(void) void bar_signal(int sig) { + /* suppress unused warning since var is needed */ + (void)sig; + bar_alarm = 1; } @@ -1765,6 +1884,10 @@ bar_toggle(struct swm_region *r, union arg *args) struct swm_region *tmpr; int i, num_screens; + /* suppress unused warnings since vars are needed */ + (void)r; + (void)args; + DNPRINTF(SWM_D_BAR, "bar_toggle\n"); num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); @@ -1777,16 +1900,17 @@ bar_toggle(struct swm_region *r, union arg *args) for (i = 0; i < num_screens; i++) TAILQ_FOREACH(tmpr, &screens[i].rl, entry) if (tmpr->bar) - map_window_raised(tmpr->bar->id); + xcb_map_window(conn, tmpr->bar->id); } bar_enabled = !bar_enabled; stack(); + /* must be after stack */ bar_update(); - xcb_flush(conn); + focus_flush(); } void @@ -1830,50 +1954,145 @@ bar_refresh(void) TAILQ_FOREACH(r, &screens[i].rl, entry) { if (r->bar == NULL) continue; - wa[0] = screens[i].c[SWM_S_COLOR_BAR].color; - wa[1] = screens[i].c[SWM_S_COLOR_BAR_BORDER].color; + wa[0] = screens[i].c[SWM_S_COLOR_BAR].pixel; + wa[1] = screens[i].c[SWM_S_COLOR_BAR_BORDER].pixel; xcb_change_window_attributes(conn, r->bar->id, XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa); } bar_update(); } +int +isxlfd(char *s) +{ + int count = 0; + + while ((s = index(s, '-'))) { + ++count; + ++s; + } + + return (count == 14); +} + void -bar_setup(struct swm_region *r) +fontset_init() { - char *font; - xcb_screen_t *screen = get_screen(r->s->idx); - uint32_t wa[3]; + char *default_string; + char **missing_charsets; + int num_missing_charsets = 0; + int i; - if (bar_font) { - XftFontClose(display, bar_font); - bar_font = NULL; + if (bar_fs) { + XFreeFontSet(display, bar_fs); + bar_fs = NULL; } - if ((r->bar = calloc(1, sizeof(struct swm_bar))) == NULL) - err(1, "bar_setup: calloc: failed to allocate memory."); + DNPRINTF(SWM_D_INIT, "fontset_init: loading bar_fonts: %s\n", bar_fonts); - while ((font = strsep(&bar_fonts, " ,")) != NULL) { - if (*font == '\0') - continue; + bar_fs = XCreateFontSet(display, bar_fonts, &missing_charsets, + &num_missing_charsets, &default_string); - DNPRINTF(SWM_D_INIT, "bar_setup: try font %s\n", font); - bar_font = XftFontOpenName(display, DefaultScreen(display), - font); - if (!bar_font) { - warnx("unable to load font %s", font); - continue; - } else { - DNPRINTF(SWM_D_INIT, "successfully opened font %s\n", - font); - break; + 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 (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, *d, *search; + XRenderColor color; + + if (bar_font == NULL) { + if ((d = strdup(bar_fonts)) == NULL) + errx(1, "insufficient memory."); + search = d; + while ((font = strsep(&search, ",")) != NULL) { + if (*font == '\0') + continue; + + DNPRINTF(SWM_D_INIT, "xft_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) { + warnx("unable to load font %s", font); + continue; + } else { + DNPRINTF(SWM_D_INIT, "successfully opened " + "font %s\n", font); + break; + } } + free(d); } - bar_height = bar_font->height + 4 * bar_border_width; + 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, DefaultVisual(display, r->s->idx), + DefaultColormap(display, r->s->idx), &color, &bar_font_color)) + warn("unable to allocate Xft 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[3]; + + DNPRINTF(SWM_D_BAR, "bar_setup: 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); X(r->bar) = X(r); Y(r->bar) = bar_at_bottom ? (Y(r) + HEIGHT(r) - bar_height) : Y(r); @@ -1881,11 +2100,10 @@ bar_setup(struct swm_region *r) HEIGHT(r->bar) = bar_height - 2 * bar_border_width; r->bar->id = xcb_generate_id(conn); - wa[0] = r->s->c[SWM_S_COLOR_BAR].color; - wa[1] = r->s->c[SWM_S_COLOR_BAR_BORDER].color; + wa[0] = r->s->c[SWM_S_COLOR_BAR].pixel; + wa[1] = r->s->c[SWM_S_COLOR_BAR_BORDER].pixel; wa[2] = XCB_EVENT_MASK_EXPOSURE; - DNPRINTF(SWM_D_BAR, "bar_setup: create_window: (x,y) w x h: (%d,%d) " - "%d x %d\n", X(r->bar), Y(r->bar), WIDTH(r->bar), HEIGHT(r->bar)); + xcb_create_window(conn, XCB_COPY_FROM_PARENT, 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, @@ -1896,11 +2114,12 @@ bar_setup(struct swm_region *r) xcb_create_pixmap(conn, screen->root_depth, r->bar->buffer, r->bar->id, WIDTH(r->bar), HEIGHT(r->bar)); - xcb_randr_select_input(conn, r->bar->id, - XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE); + if (xrandr_support) + xcb_randr_select_input(conn, r->bar->id, + XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE); if (bar_enabled) - map_window_raised(r->bar->id); + xcb_map_window(conn, r->bar->id); DNPRINTF(SWM_D_BAR, "bar_setup: window: 0x%x, (x,y) w x h: (%d,%d) " "%d x %d\n", WINID(r->bar), X(r->bar), Y(r->bar), WIDTH(r->bar), @@ -1936,18 +2155,19 @@ set_win_state(struct ws_win *win, uint16_t state) a_state, 32, 2, data); } -uint16_t +uint32_t getstate(xcb_window_t w) { - uint16_t result = 0; + uint32_t result = 0; xcb_get_property_cookie_t c; xcb_get_property_reply_t *r; - c = xcb_get_property(conn, False, w, a_state, a_state, 0L, 2L); + c = xcb_get_property(conn, 0, w, a_state, a_state, 0L, 2L); r = xcb_get_property_reply(conn, c, NULL); if (r) { - result = *((uint16_t *)xcb_get_property_value(r)); + if (r->type == a_state && r->format == 32 && r->length == 2) + result = *((uint32_t *)xcb_get_property_value(r)); free(r); } @@ -1959,6 +2179,10 @@ getstate(xcb_window_t w) void version(struct swm_region *r, union arg *args) { + /* suppress unused warnings since vars are needed */ + (void)r; + (void)args; + bar_version = !bar_version; if (bar_version) snprintf(bar_vertext, sizeof bar_vertext, @@ -1971,12 +2195,22 @@ version(struct swm_region *r, union arg *args) } void -client_msg(struct ws_win *win, xcb_atom_t a) +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, "client_msg: window: 0x%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; @@ -1984,9 +2218,9 @@ client_msg(struct ws_win *win, xcb_atom_t a) ev.type = a_prot; ev.format = 32; ev.data.data32[0] = a; - ev.data.data32[1] = XCB_CURRENT_TIME; + ev.data.data32[1] = t; - xcb_send_event(conn, False, win->id, + xcb_send_event(conn, 0, win->id, XCB_EVENT_MASK_NO_EVENT, (const char *)&ev); } @@ -2006,7 +2240,7 @@ config_win(struct ws_win *win, xcb_configure_request_event_t *ev) ce.y = Y(win); ce.width = WIDTH(win); ce.height = HEIGHT(win); - ce.override_redirect = False; + ce.override_redirect = 0; if (ev == NULL) { /* EWMH */ @@ -2020,12 +2254,13 @@ config_win(struct ws_win *win, xcb_configure_request_event_t *ev) ce.window = ev->window; /* make response appear more WM_SIZE_HINTS-compliant */ - if (win->sh.flags) + if (win->sh.flags) { DNPRINTF(SWM_D_MISC, "config_win: hints: window: 0x%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)) { @@ -2066,8 +2301,8 @@ config_win(struct ws_win *win, xcb_configure_request_event_t *ev) "(%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, False, win->id, XCB_EVENT_MASK_STRUCTURE_NOTIFY, - (char *)&ce); + xcb_send_event(conn, 0, win->id, XCB_EVENT_MASK_STRUCTURE_NOTIFY, + (char *)&ce); } int @@ -2093,25 +2328,51 @@ count_win(struct workspace *ws, int count_transient) void quit(struct swm_region *r, union arg *args) { + /* suppress unused warnings since vars are needed */ + (void)r; + (void)args; + DNPRINTF(SWM_D_MISC, "quit\n"); running = 0; } void -unmap_window(struct ws_win *win) +map_window(struct ws_win *win) { + uint32_t val = XCB_STACK_MODE_ABOVE; + if (win == NULL) return; - /* don't unmap again */ - if (getstate(win->id) == XCB_ICCCM_WM_STATE_ICONIC) + DNPRINTF(SWM_D_EVENT, "map_window: win 0x%x, mapped: %s\n", win->id, + YESNO(win->mapped)); + + xcb_configure_window(conn, win->id, + XCB_CONFIG_WINDOW_STACK_MODE, &val); + + if (win->mapped) return; - set_win_state(win, XCB_ICCCM_WM_STATE_ICONIC); + xcb_map_window(conn, win->id); + set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL); + win->mapped = 1; +} + +void +unmap_window(struct ws_win *win) +{ + if (win == NULL) + return; + + DNPRINTF(SWM_D_EVENT, "unmap_window: win 0x%x, mapped: %s\n", win->id, + YESNO(win->mapped)); + + if (!win->mapped) + return; xcb_unmap_window(conn, win->id); - xcb_change_window_attributes(conn, win->id, - XCB_CW_BORDER_PIXEL, &win->s->c[SWM_S_COLOR_UNFOCUS].color); + set_win_state(win, XCB_ICCCM_WM_STATE_ICONIC); + win->mapped = 0; } void @@ -2150,36 +2411,31 @@ fake_keypress(struct ws_win *win, xcb_keysym_t keysym, uint16_t modifiers) event.event_y = Y(win); event.root_x = 1; event.root_y = 1; - event.same_screen = True; + event.same_screen = 1; event.detail = *keycode; event.state = modifiers; event.response_type = XCB_KEY_PRESS; - xcb_send_event(conn, True, win->id, + 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, True, win->id, + xcb_send_event(conn, 1, win->id, XCB_EVENT_MASK_KEY_RELEASE, (const char *)&event); + + free(keycode); } void restart(struct swm_region *r, union arg *args) { - DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]); - - /* 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"); + /* suppress unused warning since var is needed */ + (void)r; + (void)args; - bar_extra_stop(); - bar_extra = 1; - unmap_all(); + DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]); - xcb_key_symbols_free(syms); - xcb_flush(conn); - xcb_disconnect(conn); + shutdown_cleanup(); execvp(start_argv[0], start_argv); warn("execvp failed"); @@ -2255,8 +2511,10 @@ find_window(xcb_window_t id) return (NULL); /* if we were looking for the parent return that window instead */ - if (r->parent == 0 || r->root == r->parent) + if (r->parent == 0 || r->root == r->parent) { + free(r); return (NULL); + } /* look for parent */ for (i = 0; i < num_screens; i++) @@ -2399,16 +2657,23 @@ unfocus_win(struct ws_win *win) if (win == NULL) return; - if (win->ws == NULL) + if (win->ws == NULL) { + DNPRINTF(SWM_D_FOCUS, "unfocus_win: NULL ws.\n"); return; + } - if (validate_ws(win->ws)) - return; /* XXX this gets hit with thunderbird, needs fixing */ + if (validate_ws(win->ws)) { + DNPRINTF(SWM_D_FOCUS, "unfocus_win: invalid ws.\n"); + return; + } - if (win->ws->r == NULL) + if (win->ws->r == NULL) { + DNPRINTF(SWM_D_FOCUS, "unfocus_win: NULL region.\n"); return; + } if (validate_win(win)) { + DNPRINTF(SWM_D_FOCUS, "unfocus_win: invalid win.\n"); kill_refs(win); return; } @@ -2427,106 +2692,134 @@ unfocus_win(struct ws_win *win) win->ws->focus_prev = NULL; } - grabbuttons(win, 0); xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL, - &win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color); + &win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].pixel); + xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root, ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1, &none); -} - -void -unfocus_all(void) -{ - struct ws_win *win; - int i, j, num_screens; - DNPRINTF(SWM_D_FOCUS, "unfocus_all\n"); - - num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); - for (i = 0; i < num_screens; i++) - for (j = 0; j < workspace_limit; j++) - TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) - unfocus_win(win); + DNPRINTF(SWM_D_FOCUS, "unfocus_win: done.\n"); } void focus_win(struct ws_win *win) { - struct ws_win *cfw = NULL; + struct ws_win *cfw = NULL; xcb_get_input_focus_reply_t *r; - xcb_window_t cur_focus = XCB_WINDOW_NONE; DNPRINTF(SWM_D_FOCUS, "focus_win: window: 0x%x\n", WINID(win)); if (win == NULL) - return; + goto out; + if (win->ws == NULL) - return; + goto out; if (validate_ws(win->ws)) - return; /* XXX this gets hit with thunderbird, needs fixing */ - - if (validate_win(win)) { - kill_refs(win); - return; - } + goto out; if (validate_win(win)) { kill_refs(win); - return; + goto out; } r = xcb_get_input_focus_reply(conn, xcb_get_input_focus(conn), NULL); if (r) { - cur_focus = r->focus; + cfw = find_window(r->focus); + if (cfw != win) + unfocus_win(cfw); free(r); } - if ((cfw = find_window(cur_focus)) != NULL) - unfocus_win(cfw); - else { - /* use larger hammer since the window was killed somehow */ - /* TAILQ_FOREACH(cfw, &win->ws->winlist, entry) - if (cfw->ws && cfw->ws->r && cfw->ws->r->s) - xcb_change_window_attributes(conn, cfw->id, - XCB_CW_BORDER_PIXEL, - &cfw->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);*/ - } - win->ws->focus = win; + if (win->ws->focus != win) { + if (win->ws->focus && win->ws->focus != cfw) + unfocus_win(win->ws->focus); + win->ws->focus = win; + } - if (win->ws->r != NULL) { - if (win->java == 0) + if (cfw != win && win->ws->r != NULL) { + /* Set input focus if no input hint, or indicated by hint. */ + if (!(win->hints.flags & XCB_ICCCM_WM_HINT_INPUT) || + (win->hints.flags & XCB_ICCCM_WM_HINT_INPUT && + win->hints.input)) xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT, - win->id, XCB_CURRENT_TIME); - grabbuttons(win, 1); - xcb_change_window_attributes(conn, win->id, - XCB_CW_BORDER_PIXEL, - &win->ws->r->s->c[SWM_S_COLOR_FOCUS].color); + win->id, last_event_time); + + /* Tell app it can adjust focus to a specific window. */ + if (win->take_focus) { + /* java is special; always tell parent */ + if (win->transient && win->java) + client_msg(find_window(win->transient), + a_takefocus, last_event_time); + else + client_msg(win, a_takefocus, last_event_time); + } + + xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL, + &win->ws->r->s->c[SWM_S_COLOR_FOCUS].pixel); + if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS || win->ws->always_raise) - map_window_raised(win->id); + map_window(win); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root, ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1, &win->id); } +out: bar_update(); + + DNPRINTF(SWM_D_FOCUS, "focus_win: done.\n"); } -void -event_drain(uint8_t rt) +/* If a child window should have focus instead, return it. */ +struct ws_win * +get_focus_magic(struct ws_win *win) { - xcb_generic_event_t *evt; - - xcb_flush(conn); - while ((evt = xcb_poll_for_event(conn))) { - if (XCB_EVENT_RESPONSE_TYPE(evt) != rt) - event_handle(evt); + struct ws_win *parent = NULL; - free(evt); - } -} + DNPRINTF(SWM_D_FOCUS, "get_focus_magic: window: 0x%x\n", WINID(win)); + if (win == NULL) + return win; + + if (win->transient) { + parent = find_window(win->transient); + + /* If parent prefers focus elsewhere, then do so. */ + if (parent && parent->focus_child) { + if (validate_win(parent->focus_child) == 0) + win = parent->focus_child; + else + parent->focus_child = NULL; + } + } + + /* If this window prefers focus elsewhere, then do so. */ + if (win->focus_child) { + if (validate_win(win->focus_child) == 0) + win = win->focus_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 = xcb_poll_for_event(conn))) { + if (XCB_EVENT_RESPONSE_TYPE(evt) != rt) + event_handle(evt); + + free(evt); + } +} void switchws(struct swm_region *r, union arg *args) @@ -2535,7 +2828,6 @@ switchws(struct swm_region *r, union arg *args) struct swm_region *this_r, *other_r; struct ws_win *win; struct workspace *new_ws, *old_ws; - union arg a; if (!(r && r->s)) return; @@ -2570,22 +2862,22 @@ switchws(struct swm_region *r, union arg *args) this_r->ws = new_ws; new_ws->r = this_r; - /* this is needed so that we can click on a window after a restart */ - unfocus_all(); - stack(); - a.id = SWM_ARG_ID_FOCUSCUR; - focus(new_ws->r, &a); + + new_ws->focus = get_region_focus(new_ws->r); /* unmap old windows */ if (unmap_old) TAILQ_FOREACH(win, &old_ws->winlist, entry) unmap_window(win); - if (focus_mode == SWM_FOCUS_DEFAULT) - event_drain(XCB_ENTER_NOTIFY); - else - xcb_flush(conn); + /* make sure bar gets updated if ws is empty */ + if (!new_ws->focus) + bar_update(); + + focus_flush(); + + DNPRINTF(SWM_D_WS, "switchws: done.\n"); } void @@ -2638,6 +2930,8 @@ priorws(struct swm_region *r, union arg *args) { union arg a; + (void)args; + DNPRINTF(SWM_D_WS, "priorws: 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); @@ -2652,7 +2946,6 @@ void cyclescr(struct swm_region *r, union arg *args) { struct swm_region *rr = NULL; - union arg a; int i, x, y, num_screens; num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); @@ -2684,8 +2977,7 @@ cyclescr(struct swm_region *r, union arg *args) xcb_warp_pointer(conn, XCB_WINDOW_NONE, rr->s[i].root, 0, 0, 0, 0, x, y); - a.id = SWM_ARG_ID_FOCUSCUR; - focus(rr, &a); + rr->ws->focus = get_region_focus(rr); if (rr->ws->focus) { /* move to focus window */ @@ -2694,6 +2986,8 @@ cyclescr(struct swm_region *r, union arg *args) xcb_warp_pointer(conn, XCB_WINDOW_NONE, rr->s[i].root, 0, 0, 0, 0, x, y); } + + focus_flush(); } void @@ -2791,11 +3085,11 @@ swapwin(struct swm_region *r, union arg *args) stack(); - xcb_flush(conn); + focus_flush(); } -void -focus_prev(struct ws_win *win) +struct ws_win * +get_focus_prev(struct ws_win *win) { struct ws_win *winfocus = NULL; struct ws_win *cur_focus = NULL; @@ -2803,13 +3097,13 @@ focus_prev(struct ws_win *win) struct workspace *ws = NULL; if (!(win && win->ws)) - return; + return NULL; ws = win->ws; wl = &ws->winlist; cur_focus = ws->focus; - DNPRINTF(SWM_D_FOCUS, "focus_prev: window: 0x%x, cur_focus: 0x%x\n", + DNPRINTF(SWM_D_FOCUS, "get_focus_prev: window: 0x%x, cur_focus: 0x%x\n", WINID(win), WINID(cur_focus)); /* pickle, just focus on whatever */ @@ -2838,7 +3132,7 @@ focus_prev(struct ws_win *win) goto done; } - DNPRINTF(SWM_D_FOCUS, "focus_prev: focus_close: %d\n", focus_close); + DNPRINTF(SWM_D_FOCUS, "get_focus_prev: focus_close: %d\n", focus_close); if (winfocus == NULL || winfocus == win) { switch (focus_close) { @@ -2877,14 +3171,34 @@ done: } kill_refs(win); - focus_magic(winfocus); + + 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 && !r->ws->focus->iconic) + winfocus = r->ws->focus; + else if (r->ws->focus_prev && !r->ws->focus_prev->iconic) + winfocus = r->ws->focus_prev; + else + TAILQ_FOREACH(winfocus, &r->ws->winlist, entry) + if (!winfocus->iconic) + break; + + return get_focus_magic(winfocus); } void focus(struct swm_region *r, union arg *args) { - struct ws_win *winfocus = NULL, *head; - struct ws_win *cur_focus = NULL; + struct ws_win *head, *cur_focus = NULL, *winfocus = NULL; struct ws_win_list *wl = NULL; struct workspace *ws = NULL; int all_iconics; @@ -2894,21 +3208,6 @@ focus(struct swm_region *r, union arg *args) DNPRINTF(SWM_D_FOCUS, "focus: id: %d\n", args->id); - /* treat FOCUS_CUR special */ - if (args->id == SWM_ARG_ID_FOCUSCUR) { - if (r->ws->focus && r->ws->focus->iconic == 0) - winfocus = r->ws->focus; - else if (r->ws->focus_prev && r->ws->focus_prev->iconic == 0) - winfocus = r->ws->focus_prev; - else - TAILQ_FOREACH(winfocus, &r->ws->winlist, entry) - if (winfocus->iconic == 0) - break; - - focus_magic(winfocus); - return; - } - if ((cur_focus = r->ws->focus) == NULL) return; ws = r->ws; @@ -2979,7 +3278,7 @@ focus(struct swm_region *r, union arg *args) return; } - focus_magic(winfocus); + focus_win(get_focus_magic(winfocus)); xcb_flush(conn); } @@ -2988,7 +3287,9 @@ void cycle_layout(struct swm_region *r, union arg *args) { struct workspace *ws = r->ws; - union arg a; + + /* suppress unused warning since var is needed */ + (void)args; DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx); @@ -2999,11 +3300,9 @@ cycle_layout(struct swm_region *r, union arg *args) stack(); bar_update(); - if (focus_mode == SWM_FOCUS_DEFAULT) - event_drain(XCB_ENTER_NOTIFY); + focus_win(get_region_focus(r)); - a.id = SWM_ARG_ID_FOCUSCUR; - focus(r, &a); + focus_flush(); } void @@ -3020,6 +3319,8 @@ stack_config(struct swm_region *r, union arg *args) if (args->id != SWM_ARG_ID_STACKINIT) stack(); bar_update(); + + focus_flush(); } void @@ -3060,15 +3361,15 @@ stack(void) { if (font_adjusted) font_adjusted--; - if (focus_mode == SWM_FOCUS_DEFAULT) - event_drain(XCB_ENTER_NOTIFY); - DNPRINTF(SWM_D_STACK, "stack: end\n"); } void store_float_geom(struct ws_win *win, struct swm_region *r) { + if (win == NULL || r == NULL) + return; + /* retain window geom and region geom */ win->g_float = win->g; win->g_float.x -= X(r); @@ -3081,6 +3382,25 @@ store_float_geom(struct ws_win *win, struct swm_region *r) } void +load_float_geom(struct ws_win *win, struct swm_region *r) +{ + if (win == NULL || r == NULL) + return; + + if (win->g_floatvalid) { + win->g = win->g_float; + X(win) += X(r); + Y(win) += Y(r); + DNPRINTF(SWM_D_MISC, "load_float_geom: window: 0x%x, g: (%d,%d)" + "%d x %d\n", win->id, X(win), Y(win), WIDTH(win), + HEIGHT(win)); + } else { + DNPRINTF(SWM_D_MISC, "load_float_geom: window: 0x%x, g_float " + "is not set.\n", win->id); + } +} + +void stack_floater(struct ws_win *win, struct swm_region *r) { if (win == NULL) @@ -3092,12 +3412,10 @@ stack_floater(struct ws_win *win, struct swm_region *r) * to allow windows to change their size (e.g. mplayer fs) only retrieve * geom on ws switches or return from max mode */ - if (win->g_floatvalid && (win->floatmaxed || (r != r->ws->old_r && - !(win->ewmh_flags & EWMH_F_FULLSCREEN)))) { - /* refloat at last floating relative position */ - win->g = win->g_float; - X(win) += X(r); - Y(win) += Y(r); + if (win->floatmaxed || (r != r->ws->old_r && + !(win->ewmh_flags & EWMH_F_FULLSCREEN))) { + /* update geometry for the new region */ + load_float_geom(win, r); } win->floatmaxed = 0; @@ -3109,7 +3427,7 @@ stack_floater(struct ws_win *win, struct swm_region *r) if (!win->g_floatvalid) store_float_geom(win, win->ws->r); - win->g = win->ws->r->g; + win->g = r->g; } /* @@ -3135,13 +3453,16 @@ stack_floater(struct ws_win *win, struct swm_region *r) HEIGHT(win) = (double)HEIGHT(r) * dialog_ratio; } - if (!win->manual) { + if (!win->manual && !(win->ewmh_flags & EWMH_F_FULLSCREEN) && + !(win->quirks & SWM_Q_ANYWHERE)) { /* - * floaters and transients are auto-centred unless moved - * or resized + * floaters and transients are auto-centred unless moved, + * resized or ANYWHERE quirk is set. */ X(win) = X(r) + (WIDTH(r) - WIDTH(win)) / 2 - BORDER(win); Y(win) = Y(r) + (HEIGHT(r) - HEIGHT(win)) / 2 - BORDER(win); + + store_float_geom(win, r); } /* keep window within region bounds */ @@ -3169,13 +3490,13 @@ adjust_font(struct ws_win *win) win->font_steps++; font_adjusted++; win->last_inc = win->sh.width_inc; - fake_keypress(win, XK_KP_Subtract, ShiftMask); + 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, ShiftMask); + fake_keypress(win, XK_KP_Add, XCB_MOD_MASK_SHIFT); } } @@ -3195,7 +3516,6 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) int split, colno, winno, mwin, msize, mscale; int remain, missing, v_slice, reconfigure; int bordered = 1; - xcb_get_window_attributes_reply_t *war; DNPRINTF(SWM_D_STACK, "stack_master: workspace: %d, rot: %s, " "flip: %s\n", ws->idx, YESNO(rot), YESNO(flip)); @@ -3358,14 +3678,7 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) update_window(win); } - war = xcb_get_window_attributes_reply(conn, - xcb_get_window_attributes(conn, win->id), - NULL); - if (war) { - if (war->map_state == XCB_MAP_STATE_UNMAPPED) - map_window_raised(win->id); - free(war); - } + map_window(win); last_h = win_g.h; i++; @@ -3385,12 +3698,12 @@ notiles: } stack_floater(win, ws->r); - map_window_raised(win->id); + map_window(win); } if (fs_win) { stack_floater(fs_win, ws->r); - map_window_raised(fs_win->id); + map_window(fs_win); } } @@ -3552,9 +3865,9 @@ max_stack(struct workspace *ws, struct swm_geometry *g) /* put the last transient on top */ if (wintrans) { if (parent) - map_window_raised(parent->id); + map_window(parent); stack_floater(wintrans, ws->r); - focus_magic(wintrans); + ws->focus = get_focus_magic(wintrans); } } @@ -3564,7 +3877,6 @@ send_to_ws(struct swm_region *r, union arg *args) int wsid = args->id; struct ws_win *win = NULL, *parent; struct workspace *ws, *nws; - xcb_atom_t ws_idx_atom = XCB_ATOM_NONE; char ws_idx_str[SWM_PROPLEN]; union arg a; @@ -3604,26 +3916,26 @@ send_to_ws(struct swm_region *r, union arg *args) win->ws = nws; /* Try to update the window's workspace property */ - ws_idx_atom = get_atom_from_string("_SWM_WS"); - if (ws_idx_atom && - snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < - SWM_PROPLEN) { + if (snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < SWM_PROPLEN) { DNPRINTF(SWM_D_PROP, "send_to_ws: set property: _SWM_WS: %s\n", ws_idx_str); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, - ws_idx_atom, XCB_ATOM_STRING, 8, strlen(ws_idx_str), + a_swm_ws, XCB_ATOM_STRING, 8, strlen(ws_idx_str), ws_idx_str); } stack(); bar_update(); - xcb_flush(conn); + focus_flush(); } void pressbutton(struct swm_region *r, union arg *args) { + /* suppress unused warning since var is needed */ + (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, @@ -3633,6 +3945,9 @@ pressbutton(struct swm_region *r, union arg *args) void raise_toggle(struct swm_region *r, union arg *args) { + /* suppress unused warning since var is needed */ + (void)args; + if (r == NULL || r->ws == NULL) return; @@ -3642,23 +3957,19 @@ raise_toggle(struct swm_region *r, union arg *args) if (r->ws->always_raise == 0) stack(); - xcb_flush(conn); + focus_flush(); } void iconify(struct swm_region *r, union arg *args) { - union arg a; + /* suppress unused warning since var is needed */ + (void)args; if (r->ws->focus == NULL) return; - unmap_window(r->ws->focus); - update_iconic(r->ws->focus, 1); - stack(); - r->ws->focus = NULL; - a.id = SWM_ARG_ID_FOCUSCUR; - focus(r, &a); + update_iconic(r->ws->focus, 1); xcb_flush(conn); } @@ -3668,23 +3979,32 @@ get_win_name(xcb_window_t win) { char *name = NULL; xcb_get_property_cookie_t c; - xcb_icccm_get_text_property_reply_t r; - - c = xcb_icccm_get_wm_name(conn, win); - if (xcb_icccm_get_wm_name_reply(conn, c, &r, NULL)) { - if (r.name_len > 0) { - name = malloc(r.name_len + 1); - if (!name) { - xcb_icccm_get_text_property_reply_wipe(&r); - return (NULL); - } - memcpy(name, r.name, r.name_len); - name[r.name_len] = '\0'; + xcb_get_property_reply_t *r; + + /* First try _NET_WM_NAME for UTF-8. */ + c = xcb_get_property(conn, 0, win, a_netwmname, + 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) { + free(r); + return NULL; } - xcb_icccm_get_text_property_reply_wipe(&r); } - return (name); + if (r->length > 0) + name = strndup(xcb_get_property_value(r), + xcb_get_property_value_length(r)); + + free(r); + return name; } void @@ -3733,8 +4053,6 @@ uniconify(struct swm_region *r, union arg *args) } fclose(lfile); - - xcb_flush(conn); } void @@ -3797,7 +4115,6 @@ search_win_cleanup(void) while ((sw = TAILQ_FIRST(&search_wl)) != NULL) { xcb_destroy_window(conn, sw->indicator); - xcb_free_gc(conn, sw->gc); TAILQ_REMOVE(&search_wl, sw, entry); free(sw); } @@ -3809,12 +4126,16 @@ search_win(struct swm_region *r, union arg *args) struct ws_win *win = NULL; struct search_window *sw = NULL; xcb_window_t w; - uint32_t gcv[3], wa[2]; - int i; + uint32_t wa[2]; + int i, width, height; char s[8]; FILE *lfile; size_t len; + XftDraw *draw; XGlyphInfo info; + GC l_draw; + XGCValues l_gcv; + XRectangle l_ibox, l_lbox; DNPRINTF(SWM_D_MISC, "search_win\n"); @@ -3846,28 +4167,55 @@ search_win(struct swm_region *r, union arg *args) snprintf(s, sizeof s, "%d", i); len = strlen(s); - XftTextExtentsUtf8(display, bar_font, (FcChar8 *)s, len, &info); - w = xcb_generate_id(conn); - wa[0] = r->s->c[SWM_S_COLOR_FOCUS].color; - wa[1] = r->s->c[SWM_S_COLOR_UNFOCUS].color; + wa[0] = r->s->c[SWM_S_COLOR_FOCUS].pixel; + wa[1] = r->s->c[SWM_S_COLOR_UNFOCUS].pixel; + + 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, XCB_COPY_FROM_PARENT, w, win->id, 0, 0, - info.width + 4, bar_font->height + 4, - 1, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, - XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa); + width, height, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT, + XCB_COPY_FROM_PARENT, XCB_CW_BACK_PIXEL | + XCB_CW_BORDER_PIXEL, wa); + + xcb_map_window(conn, w); sw->indicator = w; TAILQ_INSERT_TAIL(&search_wl, sw, entry); - sw->gc = xcb_generate_id(conn); - gcv[0] = r->s->c[SWM_S_COLOR_BAR].color; - gcv[1] = r->s->c[SWM_S_COLOR_FOCUS].color; - gcv[2] = 0; - xcb_create_gc(conn, sw->gc, w, XCB_GC_FOREGROUND | - XCB_GC_BACKGROUND | XCB_GC_GRAPHICS_EXPOSURES, gcv); - map_window_raised(w); + 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, + DefaultVisual(display, r->s->idx), + DefaultColormap(display, r->s->idx)); + + XftDrawStringUtf8(draw, &bar_font_color, bar_font, 2, + (HEIGHT(r->bar) + bar_font->height) / 2 - + bar_font->descent, (FcChar8 *)s, len); - xcb_image_text_8(conn, len, w, sw->gc, 2, bar_font->height, s); + XftDrawDestroy(draw); + } DNPRINTF(SWM_D_MISC, "search_win: mapped window: 0x%x\n", w); @@ -3903,6 +4251,7 @@ search_resp_uniconify(char *resp, unsigned long len) if (strncmp(s, resp, len) == 0) { /* XXX this should be a callback to generalize */ update_iconic(win, 0); + xcb_flush(conn); free(s); break; } @@ -3937,7 +4286,7 @@ search_resp_name_workspace(char *resp, unsigned long len) } void -search_resp_search_workspace(char *resp, unsigned long len) +search_resp_search_workspace(char *resp) { char *p, *q; int ws_idx; @@ -3968,7 +4317,7 @@ search_resp_search_workspace(char *resp, unsigned long len) } void -search_resp_search_window(char *resp, unsigned long len) +search_resp_search_window(char *resp) { char *s; int idx; @@ -4041,10 +4390,10 @@ search_do_resp(void) search_resp_name_workspace(resp, len); break; case SWM_SEARCH_SEARCH_WORKSPACE: - search_resp_search_workspace(resp, len); + search_resp_search_workspace(resp); break; case SWM_SEARCH_SEARCH_WINDOW: - search_resp_search_window(resp, len); + search_resp_search_window(resp); break; } @@ -4055,6 +4404,8 @@ done: search_resp_action = SWM_SEARCH_NONE; close(select_resp_pipe[0]); free(resp); + + xcb_flush(conn); } void @@ -4069,7 +4420,7 @@ wkill(struct swm_region *r, union arg *args) xcb_kill_client(conn, r->ws->focus->id); else if (r->ws->focus->can_delete) - client_msg(r->ws->focus, a_delete); + client_msg(r->ws->focus, a_delete, 0); xcb_flush(conn); } @@ -4099,13 +4450,7 @@ floating_toggle_win(struct ws_win *win) } win->floating = 0; } else { - if (win->g_floatvalid) { - /* refloat at last floating relative position */ - X(win) = win->g_float.x + X(r); - Y(win) = win->g_float.y + Y(r); - WIDTH(win) = win->g_float.w; - HEIGHT(win) = win->g_float.h; - } + load_float_geom(win, r); win->floating = 1; } @@ -4118,23 +4463,25 @@ void floating_toggle(struct swm_region *r, union arg *args) { struct ws_win *win = r->ws->focus; - union arg a; + + /* suppress unused warning since var is needed */ + (void)args; if (win == NULL) return; + if (win->ewmh_flags & EWMH_F_FULLSCREEN) + return; + ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom, _NET_WM_STATE_TOGGLE); stack(); - if (win == win->ws->focus) { - a.id = SWM_ARG_ID_FOCUSCUR; - focus(win->ws->r, &a); - } + if (win == win->ws->focus) + focus_win(win); - xcb_flush(conn); - event_drain(XCB_ENTER_NOTIFY); + focus_flush(); } void @@ -4183,8 +4530,8 @@ update_window(struct ws_win *win) uint32_t wc[5]; mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | - XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT | - XCB_CONFIG_WINDOW_BORDER_WIDTH; + XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT | + XCB_CONFIG_WINDOW_BORDER_WIDTH; wc[0] = X(win); wc[1] = Y(win); wc[2] = WIDTH(win); @@ -4212,8 +4559,6 @@ resize(struct ws_win *win, union arg *args) unsigned int shape; /* cursor style */ xcb_cursor_t cursor; xcb_font_t cursor_font; - xcb_grab_pointer_cookie_t gpc; - xcb_grab_pointer_reply_t *gpr; xcb_query_pointer_reply_t *xpr; xcb_generic_event_t *evt; xcb_motion_notify_event_t *mne; @@ -4242,6 +4587,8 @@ resize(struct ws_win *win, union arg *args) stack(); + focus_flush(); + switch (args->id) { case SWM_ARG_ID_WIDTHSHRINK: WIDTH(win) -= SWM_RESIZE_STEPS; @@ -4297,16 +4644,9 @@ resize(struct ws_win *win, union arg *args) xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font, shape, shape + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff); - gpc = xcb_grab_pointer(conn, False, win->id, MOUSEMASK, + xcb_grab_pointer(conn, 0, win->id, MOUSEMASK, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, cursor, XCB_CURRENT_TIME), - gpr = xcb_grab_pointer_reply(conn, gpc, NULL); - if (!gpr) { - xcb_free_cursor(conn, cursor); - xcb_close_font(conn, cursor_font); - free(xpr); - return; - } xcb_flush(conn); resizing = 1; @@ -4367,8 +4707,8 @@ resize(struct ws_win *win, union arg *args) /* not free, don't sync more than 120 times / second */ if ((mne->time - timestamp) > (1000 / 120) ) { timestamp = mne->time; - do_sync(); update_window(win); + xcb_flush(conn); } break; default: @@ -4378,17 +4718,16 @@ resize(struct ws_win *win, union arg *args) free(evt); } if (timestamp) { - do_sync(); update_window(win); + xcb_flush(conn); } store_float_geom(win,r); xcb_ungrab_pointer(conn, XCB_CURRENT_TIME); xcb_free_cursor(conn, cursor); xcb_close_font(conn, cursor_font); - free(gpr); free(xpr); - DNPRINTF(SWM_D_EVENT, "resize: done\n"); + DNPRINTF(SWM_D_EVENT, "resize: done.\n"); } void @@ -4414,8 +4753,6 @@ move(struct ws_win *win, union arg *args) struct swm_region *r = NULL; xcb_font_t cursor_font; xcb_cursor_t cursor; - xcb_grab_pointer_cookie_t gpc; - xcb_grab_pointer_reply_t *gpr; xcb_query_pointer_reply_t *qpr; xcb_generic_event_t *evt; xcb_motion_notify_event_t *mne; @@ -4445,6 +4782,8 @@ move(struct ws_win *win, union arg *args) stack(); + focus_flush(); + move_step = 0; switch (args->id) { case SWM_ARG_ID_MOVELEFT: @@ -4480,15 +4819,9 @@ move(struct ws_win *win, union arg *args) xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font, XC_fleur, XC_fleur + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff); - gpc = xcb_grab_pointer(conn, False, win->id, MOUSEMASK, + xcb_grab_pointer(conn, 0, win->id, MOUSEMASK, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, cursor, XCB_CURRENT_TIME); - gpr = xcb_grab_pointer_reply(conn, gpc, NULL); - if (!gpr) { - xcb_free_cursor(conn, cursor); - xcb_close_font(conn, cursor_font); - return; - } /* get cursor offset from window root */ qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id), @@ -4518,8 +4851,8 @@ move(struct ws_win *win, union arg *args) /* not free, don't sync more than 120 times / second */ if ((mne->time - timestamp) > (1000 / 120) ) { timestamp = mne->time; - do_sync(); update_window(win); + xcb_flush(conn); } break; default: @@ -4529,15 +4862,15 @@ move(struct ws_win *win, union arg *args) free(evt); } if (timestamp) { - do_sync(); update_window(win); + xcb_flush(conn); } store_float_geom(win, r); free(qpr); xcb_free_cursor(conn, cursor); xcb_close_font(conn, cursor_font); xcb_ungrab_pointer(conn, XCB_CURRENT_TIME); - DNPRINTF(SWM_D_EVENT, "move: done\n"); + DNPRINTF(SWM_D_EVENT, "move: done.\n"); } void @@ -4788,10 +5121,12 @@ struct button { void (*func)(struct ws_win *, union arg *); union arg args; } buttons[] = { +#define MODKEY_SHIFT MODKEY | XCB_MOD_MASK_SHIFT /* action key mouse button func args */ - { client_click, MODKEY, Button3, resize, {.id = SWM_ARG_ID_DONTCENTER} }, - { client_click, MODKEY | ShiftMask, Button3, resize, {.id = SWM_ARG_ID_CENTER} }, - { client_click, MODKEY, Button1, move, {0} }, + { client_click, MODKEY, XCB_BUTTON_INDEX_3, resize, {.id = SWM_ARG_ID_DONTCENTER} }, + { client_click, MODKEY_SHIFT, XCB_BUTTON_INDEX_3, resize, {.id = SWM_ARG_ID_CENTER} }, + { client_click, MODKEY, XCB_BUTTON_INDEX_1, move, {0} }, +#undef MODKEY_SHIFT }; void @@ -4802,14 +5137,14 @@ update_modkey(unsigned int mod) mod_key = mod; RB_FOREACH(kp, key_tree, &keys) - if (kp->mod & ShiftMask) - kp->mod = mod | ShiftMask; + if (kp->mod & XCB_MOD_MASK_SHIFT) + kp->mod = mod | XCB_MOD_MASK_SHIFT; else kp->mod = mod; for (i = 0; i < LENGTH(buttons); i++) - if (buttons[i].mask & ShiftMask) - buttons[i].mask = mod | ShiftMask; + if (buttons[i].mask & XCB_MOD_MASK_SHIFT) + buttons[i].mask = mod | XCB_MOD_MASK_SHIFT; else buttons[i].mask = mod; } @@ -4832,6 +5167,9 @@ spawn_expand(struct swm_region *r, union arg *args, char *spawn_name, int i; char *ap, **real_args; + /* suppress unused warning since var is needed */ + (void)args; + DNPRINTF(SWM_D_SPAWN, "spawn_expand: %s\n", spawn_name); /* find program */ @@ -5054,11 +5392,19 @@ setspawn(char *name, char *args) int setconfspawn(char *selector, char *value, int flags) { - DNPRINTF(SWM_D_SPAWN, "setconfspawn: [%s] [%s]\n", selector, value); + char *args; - setspawn(selector, value); + /* suppress unused warning since var is needed */ + (void)flags; - DNPRINTF(SWM_D_SPAWN, "setconfspawn: done\n"); + args = expand_tilde(value); + + DNPRINTF(SWM_D_SPAWN, "setconfspawn: [%s] [%s]\n", selector, args); + + setspawn(selector, args); + free(args); + + DNPRINTF(SWM_D_SPAWN, "setconfspawn: done.\n"); return (0); } @@ -5120,17 +5466,17 @@ parsekeys(char *keystr, unsigned int currmod, unsigned int *mod, KeySym *ks) if (strncasecmp(name, "MOD", SWM_MODNAME_SIZE) == 0) *mod |= currmod; else if (!strncasecmp(name, "Mod1", SWM_MODNAME_SIZE)) - *mod |= Mod1Mask; + *mod |= XCB_MOD_MASK_1; else if (!strncasecmp(name, "Mod2", SWM_MODNAME_SIZE)) - *mod += Mod2Mask; + *mod += XCB_MOD_MASK_2; else if (!strncmp(name, "Mod3", SWM_MODNAME_SIZE)) - *mod |= Mod3Mask; + *mod |= XCB_MOD_MASK_3; else if (!strncmp(name, "Mod4", SWM_MODNAME_SIZE)) - *mod |= Mod4Mask; + *mod |= XCB_MOD_MASK_4; else if (strncasecmp(name, "SHIFT", SWM_MODNAME_SIZE) == 0) - *mod |= ShiftMask; + *mod |= XCB_MOD_MASK_SHIFT; else if (strncasecmp(name, "CONTROL", SWM_MODNAME_SIZE) == 0) - *mod |= ControlMask; + *mod |= XCB_MOD_MASK_CONTROL; else { *ks = XStringToKeysym(name); XConvertCase(*ks, ks, &uks); @@ -5245,6 +5591,10 @@ setconfbinding(char *selector, char *value, int flags) unsigned int mod; KeySym ks; struct spawn_prog *sp; + + /* suppress unused warning since var is needed */ + (void)flags; + DNPRINTF(SWM_D_KEY, "setconfbinding: enter\n"); if (selector == NULL) { DNPRINTF(SWM_D_KEY, "setconfbinding: unbind %s\n", value); @@ -5288,23 +5638,24 @@ setconfbinding(char *selector, char *value, int flags) void setup_keys(void) { +#define MODKEY_SHIFT MODKEY | XCB_MOD_MASK_SHIFT setkeybinding(MODKEY, XK_space, KF_CYCLE_LAYOUT,NULL); - setkeybinding(MODKEY|ShiftMask, XK_backslash, KF_FLIP_LAYOUT, NULL); - setkeybinding(MODKEY|ShiftMask, XK_space, KF_STACK_RESET, NULL); + setkeybinding(MODKEY_SHIFT, XK_backslash, KF_FLIP_LAYOUT, NULL); + setkeybinding(MODKEY_SHIFT, XK_space, KF_STACK_RESET, NULL); setkeybinding(MODKEY, XK_h, KF_MASTER_SHRINK, NULL); setkeybinding(MODKEY, XK_l, KF_MASTER_GROW, NULL); setkeybinding(MODKEY, XK_comma, KF_MASTER_ADD, NULL); setkeybinding(MODKEY, XK_period, KF_MASTER_DEL, NULL); - setkeybinding(MODKEY|ShiftMask, XK_comma, KF_STACK_INC, NULL); - setkeybinding(MODKEY|ShiftMask, XK_period, KF_STACK_DEC, NULL); + setkeybinding(MODKEY_SHIFT, XK_comma, KF_STACK_INC, NULL); + setkeybinding(MODKEY_SHIFT, XK_period, KF_STACK_DEC, NULL); setkeybinding(MODKEY, XK_Return, KF_SWAP_MAIN, NULL); setkeybinding(MODKEY, XK_j, KF_FOCUS_NEXT, NULL); setkeybinding(MODKEY, XK_k, KF_FOCUS_PREV, NULL); - setkeybinding(MODKEY|ShiftMask, XK_j, KF_SWAP_NEXT, NULL); - setkeybinding(MODKEY|ShiftMask, XK_k, KF_SWAP_PREV, NULL); - setkeybinding(MODKEY|ShiftMask, XK_Return, KF_SPAWN_CUSTOM,"term"); + setkeybinding(MODKEY_SHIFT, XK_j, KF_SWAP_NEXT, NULL); + setkeybinding(MODKEY_SHIFT, XK_k, KF_SWAP_PREV, NULL); + setkeybinding(MODKEY_SHIFT, XK_Return, KF_SPAWN_CUSTOM,"term"); setkeybinding(MODKEY, XK_p, KF_SPAWN_CUSTOM,"menu"); - setkeybinding(MODKEY|ShiftMask, XK_q, KF_QUIT, NULL); + setkeybinding(MODKEY_SHIFT, XK_q, KF_QUIT, NULL); setkeybinding(MODKEY, XK_q, KF_RESTART, NULL); setkeybinding(MODKEY, XK_m, KF_FOCUS_MAIN, NULL); setkeybinding(MODKEY, XK_1, KF_WS_1, NULL); @@ -5334,59 +5685,60 @@ setup_keys(void) setkeybinding(MODKEY, XK_Up, KF_WS_NEXT_ALL, NULL); setkeybinding(MODKEY, XK_Down, KF_WS_PREV_ALL, NULL); setkeybinding(MODKEY, XK_a, KF_WS_PRIOR, NULL); - setkeybinding(MODKEY|ShiftMask, XK_Right, KF_SCREEN_NEXT, NULL); - setkeybinding(MODKEY|ShiftMask, XK_Left, KF_SCREEN_PREV, NULL); - setkeybinding(MODKEY|ShiftMask, XK_1, KF_MVWS_1, NULL); - setkeybinding(MODKEY|ShiftMask, XK_2, KF_MVWS_2, NULL); - setkeybinding(MODKEY|ShiftMask, XK_3, KF_MVWS_3, NULL); - setkeybinding(MODKEY|ShiftMask, XK_4, KF_MVWS_4, NULL); - setkeybinding(MODKEY|ShiftMask, XK_5, KF_MVWS_5, NULL); - setkeybinding(MODKEY|ShiftMask, XK_6, KF_MVWS_6, NULL); - setkeybinding(MODKEY|ShiftMask, XK_7, KF_MVWS_7, NULL); - setkeybinding(MODKEY|ShiftMask, XK_8, KF_MVWS_8, NULL); - setkeybinding(MODKEY|ShiftMask, XK_9, KF_MVWS_9, NULL); - setkeybinding(MODKEY|ShiftMask, XK_0, KF_MVWS_10, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F1, KF_MVWS_11, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F2, KF_MVWS_12, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F3, KF_MVWS_13, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F4, KF_MVWS_14, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F5, KF_MVWS_15, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F6, KF_MVWS_16, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F7, KF_MVWS_17, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F8, KF_MVWS_18, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F9, KF_MVWS_19, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F10, KF_MVWS_20, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F11, KF_MVWS_21, NULL); - setkeybinding(MODKEY|ShiftMask, XK_F12, KF_MVWS_22, NULL); + setkeybinding(MODKEY_SHIFT, XK_Right, KF_SCREEN_NEXT, NULL); + setkeybinding(MODKEY_SHIFT, XK_Left, KF_SCREEN_PREV, NULL); + setkeybinding(MODKEY_SHIFT, XK_1, KF_MVWS_1, NULL); + setkeybinding(MODKEY_SHIFT, XK_2, KF_MVWS_2, NULL); + setkeybinding(MODKEY_SHIFT, XK_3, KF_MVWS_3, NULL); + setkeybinding(MODKEY_SHIFT, XK_4, KF_MVWS_4, NULL); + setkeybinding(MODKEY_SHIFT, XK_5, KF_MVWS_5, NULL); + setkeybinding(MODKEY_SHIFT, XK_6, KF_MVWS_6, NULL); + setkeybinding(MODKEY_SHIFT, XK_7, KF_MVWS_7, NULL); + setkeybinding(MODKEY_SHIFT, XK_8, KF_MVWS_8, NULL); + setkeybinding(MODKEY_SHIFT, XK_9, KF_MVWS_9, NULL); + setkeybinding(MODKEY_SHIFT, XK_0, KF_MVWS_10, NULL); + setkeybinding(MODKEY_SHIFT, XK_F1, KF_MVWS_11, NULL); + setkeybinding(MODKEY_SHIFT, XK_F2, KF_MVWS_12, NULL); + setkeybinding(MODKEY_SHIFT, XK_F3, KF_MVWS_13, NULL); + setkeybinding(MODKEY_SHIFT, XK_F4, KF_MVWS_14, NULL); + setkeybinding(MODKEY_SHIFT, XK_F5, KF_MVWS_15, NULL); + setkeybinding(MODKEY_SHIFT, XK_F6, KF_MVWS_16, NULL); + setkeybinding(MODKEY_SHIFT, XK_F7, KF_MVWS_17, NULL); + setkeybinding(MODKEY_SHIFT, XK_F8, KF_MVWS_18, NULL); + setkeybinding(MODKEY_SHIFT, XK_F9, KF_MVWS_19, NULL); + setkeybinding(MODKEY_SHIFT, XK_F10, KF_MVWS_20, NULL); + setkeybinding(MODKEY_SHIFT, XK_F11, KF_MVWS_21, NULL); + setkeybinding(MODKEY_SHIFT, XK_F12, KF_MVWS_22, NULL); setkeybinding(MODKEY, XK_b, KF_BAR_TOGGLE, NULL); setkeybinding(MODKEY, XK_Tab, KF_FOCUS_NEXT, NULL); - setkeybinding(MODKEY|ShiftMask, XK_Tab, KF_FOCUS_PREV, NULL); - setkeybinding(MODKEY|ShiftMask, XK_x, KF_WIND_KILL, NULL); + setkeybinding(MODKEY_SHIFT, XK_Tab, KF_FOCUS_PREV, NULL); + setkeybinding(MODKEY_SHIFT, XK_x, KF_WIND_KILL, NULL); setkeybinding(MODKEY, XK_x, KF_WIND_DEL, NULL); setkeybinding(MODKEY, XK_s, KF_SPAWN_CUSTOM,"screenshot_all"); - setkeybinding(MODKEY|ShiftMask, XK_s, KF_SPAWN_CUSTOM,"screenshot_wind"); + setkeybinding(MODKEY_SHIFT, XK_s, KF_SPAWN_CUSTOM,"screenshot_wind"); setkeybinding(MODKEY, XK_t, KF_FLOAT_TOGGLE,NULL); - setkeybinding(MODKEY|ShiftMask, XK_v, KF_VERSION, NULL); - setkeybinding(MODKEY|ShiftMask, XK_Delete, KF_SPAWN_CUSTOM,"lock"); - setkeybinding(MODKEY|ShiftMask, XK_i, KF_SPAWN_CUSTOM,"initscr"); + setkeybinding(MODKEY_SHIFT, XK_v, KF_VERSION, NULL); + setkeybinding(MODKEY_SHIFT, XK_Delete, KF_SPAWN_CUSTOM,"lock"); + setkeybinding(MODKEY_SHIFT, XK_i, KF_SPAWN_CUSTOM,"initscr"); setkeybinding(MODKEY, XK_w, KF_ICONIFY, NULL); - setkeybinding(MODKEY|ShiftMask, XK_w, KF_UNICONIFY, NULL); - setkeybinding(MODKEY|ShiftMask, XK_r, KF_RAISE_TOGGLE,NULL); + setkeybinding(MODKEY_SHIFT, XK_w, KF_UNICONIFY, NULL); + setkeybinding(MODKEY_SHIFT, XK_r, KF_RAISE_TOGGLE,NULL); setkeybinding(MODKEY, XK_v, KF_BUTTON2, NULL); setkeybinding(MODKEY, XK_equal, KF_WIDTH_GROW, NULL); setkeybinding(MODKEY, XK_minus, KF_WIDTH_SHRINK,NULL); - setkeybinding(MODKEY|ShiftMask, XK_equal, KF_HEIGHT_GROW,NULL); - setkeybinding(MODKEY|ShiftMask, XK_minus, KF_HEIGHT_SHRINK,NULL); + setkeybinding(MODKEY_SHIFT, XK_equal, KF_HEIGHT_GROW,NULL); + setkeybinding(MODKEY_SHIFT, XK_minus, KF_HEIGHT_SHRINK,NULL); setkeybinding(MODKEY, XK_bracketleft, KF_MOVE_LEFT,NULL); setkeybinding(MODKEY, XK_bracketright,KF_MOVE_RIGHT,NULL); - setkeybinding(MODKEY|ShiftMask, XK_bracketleft, KF_MOVE_UP, NULL); - setkeybinding(MODKEY|ShiftMask, XK_bracketright,KF_MOVE_DOWN,NULL); - setkeybinding(MODKEY|ShiftMask, XK_slash, KF_NAME_WORKSPACE,NULL); + setkeybinding(MODKEY_SHIFT, XK_bracketleft, KF_MOVE_UP, NULL); + setkeybinding(MODKEY_SHIFT, XK_bracketright,KF_MOVE_DOWN,NULL); + setkeybinding(MODKEY_SHIFT, XK_slash, KF_NAME_WORKSPACE,NULL); setkeybinding(MODKEY, XK_slash, KF_SEARCH_WORKSPACE,NULL); setkeybinding(MODKEY, XK_f, KF_SEARCH_WIN, NULL); #ifdef SWM_DEBUG - setkeybinding(MODKEY|ShiftMask, XK_d, KF_DUMPWINS, NULL); + setkeybinding(MODKEY_SHIFT, XK_d, KF_DUMPWINS, NULL); #endif +#undef MODKEY_SHIFT } void @@ -5404,6 +5756,11 @@ int setkeymapping(char *selector, char *value, int flags) { char keymapping_file[PATH_MAX]; + + /* suppress unused warnings since vars are needed */ + (void)selector; + (void)flags; + DNPRINTF(SWM_D_KEY, "setkeymapping: enter\n"); if (value[0] == '~') snprintf(keymapping_file, sizeof keymapping_file, "%s/%s", @@ -5425,9 +5782,8 @@ updatenumlockmask(void) { unsigned int i, j; xcb_get_modifier_mapping_reply_t *modmap_r; - xcb_keycode_t *modmap, kc; + xcb_keycode_t *modmap, kc, *keycode; - DNPRINTF(SWM_D_MISC, "updatenumlockmask\n"); numlockmask = 0; modmap_r = xcb_get_modifier_mapping_reply(conn, @@ -5439,29 +5795,33 @@ updatenumlockmask(void) for (j = 0; j < modmap_r->keycodes_per_modifier; j++) { kc = modmap[i * modmap_r->keycodes_per_modifier + j]; - - if (kc == *((xcb_keycode_t *)xcb_key_symbols_get_keycode(syms, - XK_Num_Lock))) + keycode = xcb_key_symbols_get_keycode(syms, + XK_Num_Lock); + if (kc == *keycode) numlockmask = (1 << i); + free(keycode); } } free(modmap_r); } + DNPRINTF(SWM_D_MISC, "updatenumlockmask: %d\n", numlockmask); } void grabkeys(void) { - int num_screens, k; - unsigned int j; - xcb_keycode_t *code; - unsigned int modifiers[] = - { 0, LockMask, numlockmask, numlockmask | LockMask }; struct key *kp; + int num_screens, k, j; + unsigned int modifiers[3]; + xcb_keycode_t *code; DNPRINTF(SWM_D_MISC, "grabkeys\n"); updatenumlockmask(); + modifiers[0] = 0; + modifiers[1] = numlockmask; + modifiers[2] = numlockmask | XCB_MOD_MASK_LOCK; + num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); for (k = 0; k < num_screens; k++) { if (TAILQ_EMPTY(&screens[k].rl)) @@ -5470,43 +5830,37 @@ grabkeys(void) XCB_MOD_MASK_ANY); RB_FOREACH(kp, key_tree, &keys) { if ((code = xcb_key_symbols_get_keycode(syms, - kp->keysym))) + kp->keysym))) { for (j = 0; j < LENGTH(modifiers); j++) - xcb_grab_key(conn, True, + xcb_grab_key(conn, 1, screens[k].root, kp->mod | modifiers[j], - *code, XCB_GRAB_MODE_ASYNC, + *code, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC); + free(code); + } } } } void -grabbuttons(struct ws_win *win, int focused) +grabbuttons(struct ws_win *win) { - unsigned int i, j; - unsigned int modifiers[] = - { 0, LockMask, numlockmask, numlockmask|LockMask }; + int i; - updatenumlockmask(); - xcb_ungrab_button(conn, XCB_BUTTON_INDEX_ANY, win->id, - XCB_BUTTON_MASK_ANY); - if (focused) { - for (i = 0; i < LENGTH(buttons); i++) - if (buttons[i].action == client_click) - for (j = 0; j < LENGTH(modifiers); j++) - xcb_grab_button(conn, False, win->id, - BUTTONMASK, - XCB_GRAB_MODE_ASYNC, - XCB_GRAB_MODE_SYNC, - XCB_WINDOW_NONE, - XCB_CURSOR_NONE, - buttons[i].button, - buttons[i].mask); - } else - xcb_grab_button(conn, False, win->id, BUTTONMASK, - XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_SYNC, XCB_WINDOW_NONE, - XCB_CURSOR_NONE, XCB_BUTTON_INDEX_ANY, XCB_BUTTON_MASK_ANY); + DNPRINTF(SWM_D_MOUSE, "grabbuttons: win 0x%x\n", win->id); + + for (i = 0; i < LENGTH(buttons); i++) + if (buttons[i].action == client_click) + xcb_grab_button(conn, 0, win->id, BUTTONMASK, + XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, + XCB_WINDOW_NONE, XCB_CURSOR_NONE, + buttons[i].button, buttons[i].mask); + + /* click to focus */ + xcb_grab_button(conn, 0, win->id, BUTTONMASK, XCB_GRAB_MODE_SYNC, + XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, XCB_CURSOR_NONE, + XCB_BUTTON_INDEX_1, XCB_BUTTON_MASK_ANY); } const char *quirkname[] = { @@ -5636,7 +5990,11 @@ setconfquirk(char *selector, char *value, int flags) { char *cp, *class, *name; int retval; - unsigned long quirks; + unsigned long qrks; + + /* suppress unused warning since var is needed */ + (void)flags; + if (selector == NULL) return (0); if ((cp = strchr(selector, ':')) == NULL) @@ -5644,8 +6002,8 @@ setconfquirk(char *selector, char *value, int flags) *cp = '\0'; class = selector; name = cp + 1; - if ((retval = parsequirks(value, &quirks)) == 0) - setquirk(class, name, quirks); + if ((retval = parsequirks(value, &qrks)) == 0) + setquirk(class, name, qrks); return (retval); } @@ -5711,10 +6069,13 @@ setconfvalue(char *selector, char *value, int flags) int i; char *b; + /* suppress unused warning since var is needed */ + (void)selector; + switch (flags) { case SWM_S_BAR_ACTION: free(bar_argv[0]); - if ((bar_argv[0] = strdup(value)) == NULL) + if ((bar_argv[0] = expand_tilde(value)) == NULL) err(1, "setconfvalue: bar_action"); break; case SWM_S_BAR_AT_BOTTOM: @@ -5737,6 +6098,20 @@ setconfvalue(char *selector, char *value, int flags) 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 there are any non-XLFD entries, switch to Xft mode. */ + while ((b = strsep(&value, ",")) != NULL) { + if (*b == '\0') + continue; + if (!isxlfd(b)) { + bar_font_legacy = 0; + break; + } + } break; case SWM_S_BAR_FORMAT: free(bar_format); @@ -5810,8 +6185,8 @@ setconfvalue(char *selector, char *value, int flags) focus_mode = SWM_FOCUS_DEFAULT; else if (!strcmp(value, "follow_cursor")) focus_mode = SWM_FOCUS_FOLLOW; - else if (!strcmp(value, "synergy")) - focus_mode = SWM_FOCUS_SYNERGY; + else if (!strcmp(value, "manual")) + focus_mode = SWM_FOCUS_MANUAL; else errx(1, "focus_mode"); break; @@ -5881,14 +6256,18 @@ setconfvalue(char *selector, char *value, int flags) int setconfmodkey(char *selector, char *value, int flags) { + /* suppress unused warnings since vars are needed */ + (void)selector; + (void)flags; + if (!strncasecmp(value, "Mod1", strlen("Mod1"))) - update_modkey(Mod1Mask); + update_modkey(XCB_MOD_MASK_1); else if (!strncasecmp(value, "Mod2", strlen("Mod2"))) - update_modkey(Mod2Mask); + update_modkey(XCB_MOD_MASK_2); else if (!strncasecmp(value, "Mod3", strlen("Mod3"))) - update_modkey(Mod3Mask); + update_modkey(XCB_MOD_MASK_3); else if (!strncasecmp(value, "Mod4", strlen("Mod4"))) - update_modkey(Mod4Mask); + update_modkey(XCB_MOD_MASK_4); else return (1); return (0); @@ -5904,6 +6283,10 @@ setconfcolor(char *selector, char *value, int flags) int setconfregion(char *selector, char *value, int flags) { + /* suppress unused warnings since vars are needed */ + (void)selector; + (void)flags; + custom_region(value); return (0); } @@ -5919,6 +6302,10 @@ setautorun(char *selector, char *value, int flags) pid_t pid; struct pid_e *p; + /* suppress unused warnings since vars are needed */ + (void)selector; + (void)flags; + if (getenv("SWM_STARTED")) return (0); @@ -5976,17 +6363,21 @@ setautorun(char *selector, char *value, int flags) int setlayout(char *selector, char *value, int flags) { - int ws_id, i, x, mg, ma, si, raise, f = 0; + int ws_id, i, x, mg, ma, si, ar, f = 0; int st = SWM_V_STACK, num_screens; char s[1024]; struct workspace *ws; + /* suppress unused warnings since vars are needed */ + (void)selector; + (void)flags; + if (getenv("SWM_STARTED")) return (0); bzero(s, sizeof s); if (sscanf(value, "ws[%d]:%d:%d:%d:%d:%1023c", - &ws_id, &mg, &ma, &si, &raise, s) != 6) + &ws_id, &mg, &ma, &si, &ar, s) != 6) errx(1, "invalid layout entry, should be 'ws[]:" "::::" "'"); @@ -6016,7 +6407,7 @@ setlayout(char *selector, char *value, int flags) ws = (struct workspace *)&screens[i].ws; ws[ws_id].cur_layout = &layouts[st]; - ws[ws_id].always_raise = raise; + ws[ws_id].always_raise = ar; if (st == SWM_MAX_STACK) continue; @@ -6049,6 +6440,8 @@ setlayout(char *selector, char *value, int flags) } } + focus_flush(); + return (0); } @@ -6112,7 +6505,7 @@ conf_load(char *filename, int keymapping) FILE *config; char *line, *cp, *optsub, *optval; size_t linelen, lineno = 0; - int wordlen, i, optind; + int wordlen, i, optidx; struct config_option *opt; DNPRINTF(SWM_D_CONF, "conf_load: begin\n"); @@ -6148,16 +6541,16 @@ conf_load(char *filename, int keymapping) filename, lineno); goto out; } - optind = -1; + optidx = -1; for (i = 0; i < LENGTH(configopt); i++) { opt = &configopt[i]; if (!strncasecmp(cp, opt->optname, wordlen) && (int)strlen(opt->optname) == wordlen) { - optind = i; + optidx = i; break; } } - if (optind == -1) { + if (optidx == -1) { warnx("%s: line %zd: unknown option %.*s", filename, lineno, wordlen, cp); goto out; @@ -6196,10 +6589,10 @@ conf_load(char *filename, int keymapping) /* get RHS value */ optval = strdup(cp); /* call function to deal with it all */ - if (configopt[optind].func(optsub, optval, - configopt[optind].funcflags) != 0) + if (configopt[optidx].func(optsub, optval, + configopt[optidx].funcflags) != 0) errx(1, "%s: line %zd: invalid data for %s", - filename, lineno, configopt[optind].optname); + filename, lineno, configopt[optidx].optname); free(optval); free(optsub); free(line); @@ -6228,7 +6621,7 @@ set_child_transient(struct ws_win *win, xcb_window_t *trans) parent = find_window(win->transient); if (parent) - parent->child_trans = win; + parent->focus_child = win; else { DNPRINTF(SWM_D_MISC, "set_child_transient: parent doesn't exist" " for 0x%x trans 0x%x\n", win->id, win->transient); @@ -6247,7 +6640,7 @@ set_child_transient(struct ws_win *win, xcb_window_t *trans) if (win->hints.window_group != wmh.window_group) continue; - w->child_trans = win; + w->focus_child = win; win->transient = w->id; *trans = w->id; DNPRINTF(SWM_D_MISC, "set_child_transient: adjusting " @@ -6270,7 +6663,7 @@ window_get_pid(xcb_window_t win) if (apid == XCB_ATOM_NONE) goto tryharder; - pc = xcb_get_property(conn, False, win, apid, XCB_ATOM_CARDINAL, 0, 1); + pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_CARDINAL, 0, 1); pr = xcb_get_property_reply(conn, pc, NULL); if (!pr) goto tryharder; @@ -6279,19 +6672,20 @@ window_get_pid(xcb_window_t win) goto tryharder; } - ret = *((pid_t *)xcb_get_property_value(pr)); + 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, False, win, apid, XCB_ATOM_STRING, + pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_STRING, 0, SWM_PROPLEN); pr = xcb_get_property_reply(conn, pc, NULL); if (!pr) return (0); - if (pr->type != XCB_ATOM_STRING) { + if (pr->type != apid) { free(pr); return (0); } @@ -6302,114 +6696,131 @@ tryharder: return (ret); } +int +get_ws_idx(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) + 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, "get_ws_idx: _SWM_WS: %s\n", prop); + ws_idx = (int)strtonum(prop, 0, workspace_limit - 1, &errstr); + if (errstr) { + DNPRINTF(SWM_D_PROP, "get_ws_idx: window: #%s: %s", + errstr, prop); + } + free(prop); + } + + return ws_idx; +} + struct ws_win * -manage_window(xcb_window_t id) +manage_window(xcb_window_t id, uint16_t mapped) { xcb_window_t trans = XCB_WINDOW_NONE; - struct workspace *ws; struct ws_win *win, *ww; int ws_idx, border_me = 0; - xcb_atom_t ws_idx_atom = XCB_ATOM_NONE; - char ws_idx_str[SWM_PROPLEN], *prop = NULL; - size_t proplen; + char ws_idx_str[SWM_PROPLEN]; struct swm_region *r; - const char *errstr; struct pid_e *p; struct quirk *qp; uint32_t event_mask, i; - xcb_atom_t prot; - xcb_get_property_reply_t *gpr; xcb_icccm_get_wm_protocols_reply_t wpr; - if ((win = find_window(id)) != NULL) - return (win); /* already being managed */ + if ((win = find_window(id)) != NULL) { + DNPRINTF(SWM_D_MISC, "manage_window: win 0x%x already " + "managed; skipping.)\n", id); + return (win); /* Already managed. */ + } - /* see if we are on the unmanaged list */ + /* See if window is on the unmanaged list. */ if ((win = find_unmanaged_window(id)) != NULL) { - DNPRINTF(SWM_D_MISC, "manage_window: previously unmanaged " - "window: 0x%x\n", win->id); + DNPRINTF(SWM_D_MISC, "manage_window: win 0x%x found on " + "unmanaged list.\n", id); TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry); + if (win->transient) set_child_transient(win, &trans); - if (trans && (ww = find_window(trans))) - TAILQ_INSERT_AFTER(&win->ws->winlist, ww, win, entry); - else if ((ww = win->ws->focus) && - spawn_position == SWM_STACK_ABOVE) - TAILQ_INSERT_AFTER(&win->ws->winlist, win->ws->focus, - win, entry); - else if (ww && spawn_position == SWM_STACK_BELOW) - TAILQ_INSERT_BEFORE(win->ws->focus, win, entry); - else switch (spawn_position) { - 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_actions(win); - return (win); + goto out; + } else { + DNPRINTF(SWM_D_MISC, "manage_window: win 0x%x is new.\n", id); } + /* 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; - win->bordered = 0; - /* see if we need to override the workspace */ - p = find_pid(window_get_pid(id)); - - /* Get all the window data in one shot */ - ws_idx_atom = get_atom_from_string("_SWM_WS"); - if (ws_idx_atom) { - gpr = xcb_get_property_reply(conn, - xcb_get_property(conn, False, id, ws_idx_atom, - XCB_ATOM_STRING, 0, SWM_PROPLEN), - NULL); - if (gpr) { - 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); - } - } + /* Get window geometry. */ win->wa = xcb_get_geometry_reply(conn, - xcb_get_geometry(conn, id), + xcb_get_geometry(conn, win->id), NULL); + + /* Figure out which region the window belongs to. */ + r = root_to_region(win->wa->root); + + /* Ignore window border if there is one. */ + WIDTH(win) = win->wa->width; + HEIGHT(win) = win->wa->height; + X(win) = win->wa->x + win->wa->border_width; + Y(win) = win->wa->y + win->wa->border_width; + win->bordered = 0; + win->mapped = mapped; + win->floatmaxed = 0; + win->ewmh_flags = 0; + win->s = r->s; /* this never changes */ + + store_float_geom(win, r); + + /* Get WM_SIZE_HINTS. */ xcb_icccm_get_wm_normal_hints_reply(conn, - xcb_icccm_get_wm_normal_hints(conn, id), + 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, id), + 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, id), + xcb_icccm_get_wm_transient_for(conn, win->id), &trans, NULL); if (trans) { win->transient = trans; - set_child_transient(win, &trans); - DNPRINTF(SWM_D_MISC, "manage_window: window: 0x%x, " - "transient: 0x%x\n", win->id, win->transient); + set_child_transient(win, &win->transient); } - prot = get_atom_from_string("WM_PROTOCOLS"); - - /* get supported protocols */ + /* Get supported protocols. */ if (xcb_icccm_get_wm_protocols_reply(conn, - xcb_icccm_get_wm_protocols(conn, id, prot), + xcb_icccm_get_wm_protocols(conn, win->id, a_prot), &wpr, NULL)) { for (i = 0; i < wpr.atoms_len; i++) { if (wpr.atoms[i] == a_takefocus) @@ -6420,97 +6831,40 @@ manage_window(xcb_window_t id) xcb_icccm_get_wm_protocols_reply_wipe(&wpr); } - win->iconic = get_iconic(win); + win->iconic = get_swm_iconic(win); - /* - * Figure out where to put the window. If it was previously assigned to - * a workspace (either by spawn() or manually moving), and isn't - * transient, * put it in the same workspace - */ - r = root_to_region(win->wa->root); - if (p) { - ws = &r->s->ws[p->ws]; + /* Figure out which workspace the window belongs to. */ + if ((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 (prop && win->transient == 0) { - DNPRINTF(SWM_D_PROP, "manage_window: get _SWM_WS: %s\n", prop); - ws_idx = (int)strtonum(prop, 0, workspace_limit - 1, - &errstr); - if (errstr) { - DNPRINTF(SWM_D_EVENT, "manage_window: window: #%s: %s", - errstr, prop); - } - ws = &r->s->ws[ws_idx]; + } else if ((ws_idx = get_ws_idx(win->id)) != -1 && + win->transient == 0) { + /* _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; + border_me = 1; } else { - ws = r->ws; - /* this should launch transients in the same ws as parent */ - if (id && trans) - if ((ww = find_window(trans)) != NULL) - if (ws->r) { - ws = ww->ws; - if (ww->ws->r) - r = ww->ws->r; - else - warnx("manage_window: fix this " - "bug mcbride"); - border_me = 1; - } - } - - /* set up the window layout */ - win->id = id; - win->ws = ws; - win->s = r->s; /* this never changes */ - if (trans && (ww = find_window(trans))) - TAILQ_INSERT_AFTER(&ws->winlist, ww, win, entry); - else if (win->ws->focus && spawn_position == SWM_STACK_ABOVE) - TAILQ_INSERT_AFTER(&win->ws->winlist, win->ws->focus, win, - entry); - else if (win->ws->focus && spawn_position == SWM_STACK_BELOW) - TAILQ_INSERT_BEFORE(win->ws->focus, win, entry); - else switch (spawn_position) { - 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); + win->ws = r->ws; } - /* ignore window border if there is one. */ - WIDTH(win) = win->wa->width; - HEIGHT(win) = win->wa->height; - X(win) = win->wa->x + win->wa->border_width; - Y(win) = win->wa->y + win->wa->border_width; - win->bordered = 0; - win->g_floatvalid = 0; - win->floatmaxed = 0; - win->ewmh_flags = 0; - - DNPRINTF(SWM_D_MISC, "manage_window: window: 0x%x, (x,y) w x h: " - "(%d,%d) %d x %d, ws: %d\n", win->id, X(win), Y(win), WIDTH(win), - HEIGHT(win), ws->idx); - - constrain_window(win, r, 0); - - /* Set window properties so we can remember this after reincarnation */ - if (ws_idx_atom && prop == NULL && - snprintf(ws_idx_str, SWM_PROPLEN, "%d", ws->idx) < - SWM_PROPLEN) { + /* Set the _SWM_WS atom so we can remember this after reincarnation. */ + if (snprintf(ws_idx_str, SWM_PROPLEN, "%d", win->ws->idx) < + SWM_PROPLEN) { DNPRINTF(SWM_D_PROP, "manage_window: set _SWM_WS: %s\n", ws_idx_str); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, - ws_idx_atom, XCB_ATOM_STRING, 8, strlen(ws_idx_str), + a_swm_ws, XCB_ATOM_STRING, 8, strlen(ws_idx_str), ws_idx_str); } - if (prop) - free(prop); + /* Handle EWMH */ ewmh_autoquirk(win); + /* Determine initial quirks. */ if (xcb_icccm_get_wm_class_reply(conn, xcb_icccm_get_wm_class(conn, win->id), &win->ch, NULL)) { @@ -6519,6 +6873,8 @@ manage_window(xcb_window_t id) /* java is retarded so treat it special */ if (strstr(win->ch.instance_name, "sun-awt")) { + DNPRINTF(SWM_D_CLASS, "manage_window: java window " + "detected.\n"); win->java = 1; border_me = 1; } @@ -6526,9 +6882,8 @@ manage_window(xcb_window_t id) TAILQ_FOREACH(qp, &quirks, entry) { if (!strcmp(win->ch.class_name, qp->class) && !strcmp(win->ch.instance_name, qp->name)) { - DNPRINTF(SWM_D_CLASS, "manage_window: found: " - "class: %s, name: %s\n", win->ch.class_name, - win->ch.instance_name); + DNPRINTF(SWM_D_CLASS, "manage_window: on quirks" + "list; mask: 0x%lx\n", qp->quirk); if (qp->quirk & SWM_Q_FLOAT) { win->floating = 1; border_me = 1; @@ -6538,44 +6893,74 @@ manage_window(xcb_window_t id) } } - /* alter window position if quirky */ + /* Alter window position if quirky */ if (win->quirks & SWM_Q_ANYWHERE) { - win->manual = 1; /* don't center the quirky windows */ - if (bar_enabled && Y(win) < bar_height) - Y(win) = bar_height; - if (WIDTH(win) + X(win) > WIDTH(r)) - X(win) = WIDTH(r) - WIDTH(win) - 2; + win->manual = 1; border_me = 1; } /* 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, ShiftMask); + 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, ShiftMask); + fake_keypress(win, XK_KP_Add, XCB_MOD_MASK_SHIFT); } - ewmh_get_win_state(win); - ewmh_update_actions(win); - ewmh_update_win_state(win, None, _NET_WM_STATE_REMOVE); - - /* border me */ if (border_me) { win->bordered = 1; X(win) -= border_width; Y(win) -= border_width; - update_window(win); } + /* Make sure window is positioned inside its region, if its active. */ + if (win->ws->r) + constrain_window(win, win->ws->r, 0); + + if (win->ws->r || border_me) + update_window(win); + + /* Select which X events to monitor. */ event_mask = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_FOCUS_CHANGE | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_STRUCTURE_NOTIFY; +#ifdef SWM_DEBUG + event_mask |= XCB_EVENT_MASK_LEAVE_WINDOW; +#endif - xcb_change_window_attributes(conn, id, XCB_CW_EVENT_MASK, &event_mask); + xcb_change_window_attributes(conn, win->id, XCB_CW_EVENT_MASK, + &event_mask); - /* floaters need to be mapped if they are in the current workspace */ - if ((win->floating || win->transient) && (ws->idx == r->ws->idx)) - map_window_raised(win->id); +out: + /* Figure out where to stack the window in the workspace. */ + if (trans && (ww = find_window(trans))) + TAILQ_INSERT_AFTER(&win->ws->winlist, ww, win, entry); + else if (win->ws->focus && spawn_position == SWM_STACK_ABOVE) + TAILQ_INSERT_AFTER(&win->ws->winlist, win->ws->focus, win, + entry); + else if (win->ws->focus && spawn_position == SWM_STACK_BELOW) + TAILQ_INSERT_BEFORE(win->ws->focus, win, entry); + else switch (spawn_position) { + 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); + } + + /* Get initial _NET_WM_STATE */ + ewmh_get_win_state(win); + /* Set initial _NET_WM_ALLOWED_ACTIONS */ + ewmh_update_actions(win); + + grabbuttons(win); + + DNPRINTF(SWM_D_MISC, "manage_window: done. window: 0x%x, (x,y) w x h: " + "(%d,%d) %d x %d, ws: %d, iconic: %s, transient: 0x%x\n", win->id, + X(win), Y(win), WIDTH(win), HEIGHT(win), win->ws->idx, + YESNO(win->iconic), win->transient); return (win); } @@ -6601,14 +6986,13 @@ free_window(struct ws_win *win) memset(win, 0xff, sizeof *win); /* XXX kill later */ free(win); - DNPRINTF(SWM_D_MISC, "free_window: done\n"); + DNPRINTF(SWM_D_MISC, "free_window: done.\n"); } void unmanage_window(struct ws_win *win) { struct ws_win *parent; - xcb_screen_t *screen; if (win == NULL) return; @@ -6618,60 +7002,16 @@ unmanage_window(struct ws_win *win) if (win->transient) { parent = find_window(win->transient); if (parent) - parent->child_trans = NULL; + parent->focus_child = NULL; } - /* focus on root just in case */ - screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data; - xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, - screen->root, XCB_CURRENT_TIME); - - focus_prev(win); + focus_win(get_focus_prev(win)); TAILQ_REMOVE(&win->ws->winlist, win, entry); TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry); } void -focus_magic(struct ws_win *win) -{ - DNPRINTF(SWM_D_FOCUS, "focus_magic: window: 0x%x\n", WINID(win)); - - if (win == NULL) { - /* if there are no windows clear the status-bar */ - bar_update(); - return; - } - - if (win->child_trans) { - /* win = parent & has a transient so focus on that */ - if (win->java) { - focus_win(win->child_trans); - if (win->child_trans->take_focus) - client_msg(win, a_takefocus); - } else { - /* make sure transient hasn't disappeared */ - if (validate_win(win->child_trans) == 0) { - focus_win(win->child_trans); - if (win->child_trans->take_focus) - client_msg(win->child_trans, - a_takefocus); - } else { - win->child_trans = NULL; - focus_win(win); - if (win->take_focus) - client_msg(win, a_takefocus); - } - } - } else { - /* regular focus */ - focus_win(win); - if (win->take_focus) - client_msg(win, a_takefocus); - } -} - -void expose(xcb_expose_event_t *e) { int i, num_screens; @@ -6688,6 +7028,24 @@ expose(xcb_expose_event_t *e) xcb_flush(conn); } +#ifdef SWM_DEBUG +void +focusin(xcb_focus_in_event_t *e) +{ + DNPRINTF(SWM_D_EVENT, "focusin: window: 0x%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); +} + +void +focusout(xcb_focus_out_event_t *e) +{ + DNPRINTF(SWM_D_EVENT, "focusout: window: 0x%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) { @@ -6701,6 +7059,8 @@ keypress(xcb_key_press_event_t *e) if ((kp = key_lookup(CLEANMASK(e->state), keysym)) == NULL) return; + last_event_time = e->time; + if (kp->funcid == KF_SPAWN_CUSTOM) spawn_custom(root_to_region(e->root), &(keyfuncs[kp->funcid].args), kp->spawn_name); @@ -6714,7 +7074,7 @@ buttonpress(xcb_button_press_event_t *e) { struct ws_win *win; int i; - unsigned int action; + int handled = 0; DNPRINTF(SWM_D_EVENT, "buttonpress: window 0x%x, detail: %u\n", e->event, e->detail); @@ -6722,14 +7082,24 @@ buttonpress(xcb_button_press_event_t *e) if ((win = find_window(e->event)) == NULL) return; - focus_magic(win); - action = client_click; + last_event_time = e->time; + + focus_win(get_focus_magic(win)); for (i = 0; i < LENGTH(buttons); i++) - if (action == buttons[i].action && buttons[i].func && + if (client_click == buttons[i].action && buttons[i].func && buttons[i].button == e->detail && - CLEANMASK(buttons[i].mask) == CLEANMASK(e->state)) + CLEANMASK(buttons[i].mask) == CLEANMASK(e->state)) { buttons[i].func(win, &buttons[i].args); + handled = 1; + } + + if (!handled) { + DNPRINTF(SWM_D_EVENT, "buttonpress: passing to window.\n"); + xcb_allow_events(conn, XCB_ALLOW_REPLAY_POINTER, e->time); + } else { + DNPRINTF(SWM_D_EVENT, "buttonpress: handled.\n"); + } xcb_flush(conn); } @@ -6740,9 +7110,14 @@ 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) { + DNPRINTF(SWM_D_MISC, "print_win_geom: window not found: 0x%x\n", + w); + return; + } + DNPRINTF(SWM_D_MISC, "print_win_geom: window: 0x%x, root: 0x%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, @@ -6752,10 +7127,41 @@ print_win_geom(xcb_window_t w) } #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 new = 0, i = 0; uint16_t mask = 0; uint32_t wc[7] = {0}; @@ -6763,73 +7169,110 @@ configurerequest(xcb_configure_request_event_t *e) if ((win = find_window(e->window)) == NULL) if ((win = find_unmanaged_window(e->window)) == NULL) new = 1; + #ifdef SWM_DEBUG - print_win_geom(e->window); + if (swm_debug & SWM_D_EVENT) { + print_win_geom(e->window); + + DNPRINTF(SWM_D_EVENT, "configurerequest: window: 0x%x, " + "parent: 0x%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: 0x%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) { - DNPRINTF(SWM_D_EVENT, "configurerequest: new window: 0x%x, " - "value_mask: 0x%x", e->window, e->value_mask); if (e->value_mask & XCB_CONFIG_WINDOW_X) { mask |= XCB_CONFIG_WINDOW_X; wc[i++] = e->x; - DPRINTF(", X: %d", e->x); } if (e->value_mask & XCB_CONFIG_WINDOW_Y) { mask |= XCB_CONFIG_WINDOW_Y; wc[i++] = e->y; - DPRINTF(", Y: %d", e->y); } if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) { mask |= XCB_CONFIG_WINDOW_WIDTH; wc[i++] = e->width; - DPRINTF(", W: %u", e->width); } if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) { mask |= XCB_CONFIG_WINDOW_HEIGHT; wc[i++] = e->height; - DPRINTF(", H: %u", e->height); } if (e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) { mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH; wc[i++] = e->border_width; - DPRINTF(", Border: %u", e->border_width); } if (e->value_mask & XCB_CONFIG_WINDOW_SIBLING) { mask |= XCB_CONFIG_WINDOW_SIBLING; wc[i++] = e->sibling; - DPRINTF(", Sibling: 0x%x", e->sibling); } if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) { mask |= XCB_CONFIG_WINDOW_STACK_MODE; wc[i++] = e->stack_mode; - DPRINTF(", StackMode: %u", e->stack_mode); } if (mask != 0) xcb_configure_window(conn, e->window, mask, wc); - - DPRINTF(", Sent: %s\n", YESNO((mask != 0))); } else if ((!win->manual || win->quirks & SWM_Q_ANYWHERE) && !(win->ewmh_flags & EWMH_F_FULLSCREEN)) { - win->g_float.x = e->x - X(win->ws->r); - win->g_float.y = e->y - Y(win->ws->r); - win->g_float.w = e->width; - win->g_float.h = e->height; + 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 = 1; - if (win->floating) { - win->g = win->g_float; - win->g.x += X(win->ws->r); - win->g.y += Y(win->ws->r); - update_window(win); + if (win->floating && r) { + WIDTH(win) = win->g_float.w; + HEIGHT(win) = win->g_float.h; + + stack_floater(win, win->ws->r); + + focus_flush(); } else { config_win(win, e); + xcb_flush(conn); } } else { config_win(win, e); + xcb_flush(conn); } - - xcb_flush(conn); } void @@ -6846,8 +7289,10 @@ configurenotify(xcb_configure_notify_event_t *e) xcb_icccm_get_wm_normal_hints(conn, win->id), &win->sh, NULL); adjust_font(win); - if (font_adjusted) + if (font_adjusted) { stack(); + xcb_flush(conn); + } } } @@ -6869,44 +7314,124 @@ destroynotify(xcb_destroy_notify_event_t *e) win->floating = 0; unmanage_window(win); - stack(); free_window(win); + + stack(); + + focus_flush(); } -void -enternotify(xcb_enter_notify_event_t *e) +#ifdef SWM_DEBUG +char * +get_notify_detail_label(uint8_t detail) { - struct ws_win *win; - DNPRINTF(SWM_D_FOCUS, "enternotify: window: 0x%x, mode: %d, detail: " - "%d, root: 0x%x, subwindow: 0x%x, same_screen_focus: %s, " - "state: %d\n", e->event, e->mode, e->detail, e->root, - e->child, YESNO(e->same_screen_focus), e->state); - - if (e->mode != XCB_NOTIFY_MODE_NORMAL) { - DNPRINTF(SWM_D_EVENT, "skip enternotify: generated by " - "cursor grab.\n"); - return; + 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"; } - switch (focus_mode) { - case SWM_FOCUS_DEFAULT: + 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 SWM_FOCUS_FOLLOW: + case XCB_NOTIFY_MODE_UNGRAB: + label = "Ungrab"; break; - case SWM_FOCUS_SYNERGY: + case XCB_NOTIFY_MODE_WHILE_GRABBED: + label = "WhileGrabbed"; break; + default: + label = "Unknown"; + } + + return label; +} +#endif + +void +enternotify(xcb_enter_notify_event_t *e) +{ + struct ws_win *win; + + DNPRINTF(SWM_D_FOCUS, "enternotify: time: %u, win (x,y): 0x%x " + "(%d,%d), mode: %s(%d), detail: %s(%d), root (x,y): 0x%x (%d,%d), " + "child: 0x%x, same_screen_focus: %s, state: %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), e->state); + + if (focus_mode == SWM_FOCUS_MANUAL && + e->mode == XCB_NOTIFY_MODE_NORMAL) { + DNPRINTF(SWM_D_EVENT, "enternotify: manual focus; ignoring.\n"); + return; } if ((win = find_window(e->event)) == NULL) { - DNPRINTF(SWM_D_EVENT, "skip enternotify: window is NULL\n"); + DNPRINTF(SWM_D_EVENT, "enternotify: window is NULL; ignoring\n"); return; } - focus_magic(win); + last_event_time = e->time; + + focus_win(get_focus_magic(win)); xcb_flush(conn); } +#ifdef SWM_DEBUG +void +leavenotify(xcb_leave_notify_event_t *e) +{ + DNPRINTF(SWM_D_FOCUS, "leavenotify: time: %u, win (x,y): 0x%x " + "(%d,%d), mode: %s(%d), detail: %s(%d), root (x,y): 0x%x (%d,%d), " + "child: 0x%x, same_screen_focus: %s, state: %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), e->state); +} +#endif + /* lets us use one switch statement for arbitrary mode/detail combinations */ #define MERGE_MEMBERS(a,b) (((a & 0xffff) << 16) | (b & 0xffff)) @@ -6917,16 +7442,17 @@ mapnotify(xcb_map_notify_event_t *e) DNPRINTF(SWM_D_EVENT, "mapnotify: window: 0x%x\n", e->window); - win = manage_window(e->window); - if (win) - set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL); + if ((win = find_window(e->window)) == NULL) + win = manage_window(e->window, 1); - /* - * focus_win can only set input focus on a mapped window. - * make sure the window really has focus since it is just being mapped. - */ + win->mapped = 1; + set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL); + + /* Focus on window if it is selected. */ if (win->ws->focus == win) focus_win(win); + + xcb_flush(conn); } void @@ -6942,44 +7468,55 @@ void maprequest(xcb_map_request_event_t *e) { struct ws_win *win; - struct swm_region *r; xcb_get_window_attributes_reply_t *war; - DNPRINTF(SWM_D_EVENT, "maprequest: window: 0x%x\n", + DNPRINTF(SWM_D_EVENT, "maprequest: win 0x%x\n", e->window); war = xcb_get_window_attributes_reply(conn, xcb_get_window_attributes(conn, e->window), NULL); - if (!war) - return; - if (war->override_redirect) { - free(war); - return; + if (war == NULL) { + DNPRINTF(SWM_D_EVENT, "maprequest: window lost.\n"); + goto out; } - free(war); - win = manage_window(e->window); - if (win == NULL) { - return; /* can't happen */ + if (war->override_redirect) { + DNPRINTF(SWM_D_EVENT, "maprequest: override_redirect; " + "skipping.\n"); + goto out; } - stack(); + win = manage_window(e->window, + (war->map_state == XCB_MAP_STATE_VIEWABLE)); - /* make new win focused */ - r = root_to_region(win->wa->root); - if (win->ws == r->ws) - focus_magic(win); + /* All windows need to be mapped if they are in the current workspace.*/ + if (win->ws->r) + stack(); + + /* The new window should get focus. */ + win->ws->focus = get_focus_magic(win); + + /* Ignore EnterNotify to handle the mapnotify without interference. */ + if (focus_mode == SWM_FOCUS_DEFAULT) + event_drain(XCB_ENTER_NOTIFY); +out: + free(war); + DNPRINTF(SWM_D_EVENT, "maprequest: done.\n"); } #ifdef SWM_DEBUG char * get_atom_name(xcb_atom_t atom) { - char *name; + char *name = NULL; +#if 0 + /* + * This should be disabled during most debugging since + * xcb_get_* causes an xcb_flush. + */ size_t len; xcb_get_atom_name_reply_t *r; - xcb_map_request_event_t mre; r = xcb_get_atom_name_reply(conn, xcb_get_atom_name(conn, atom), @@ -6991,14 +7528,14 @@ get_atom_name(xcb_atom_t atom) if (name) { memcpy(name, xcb_get_atom_name_name(r), len); name[len] = '\0'; - - return name; } } free(r); } - - return NULL; +#else + (void)atom; +#endif + return (name); } #endif @@ -7010,21 +7547,43 @@ propertynotify(xcb_property_notify_event_t *e) char *name; name = get_atom_name(e->atom); - DNPRINTF(SWM_D_EVENT, "propertynotify: window: 0x%x, atom: %s(%u)\n", - e->window, name, e->atom); + DNPRINTF(SWM_D_EVENT, "propertynotify: window: 0x%x, atom: %s(%u), " + "time: %#x\n", e->window, name, e->atom, e->time); free(name); #endif - win = find_window(e->window); if (win == NULL) return; - if (e->state == XCB_PROPERTY_DELETE && e->atom == a_swm_iconic) { - update_iconic(win, 0); - map_window_raised(win->id); - stack(); - focus_win(win); - return; + last_event_time = e->time; + + if (e->atom == a_swm_iconic) { + if (e->state == XCB_PROPERTY_DELETE) { + /* The window is no longer iconic, restack ws. */ + stack(); + + /* The window should get focus. */ + win->ws->focus = get_focus_magic(win); + + /* Flush EnterNotify for mapnotify, if needed. */ + focus_flush(); + return; + } else if (e->state == XCB_PROPERTY_NEW_VALUE) { + win->ws->focus = NULL; + + unfocus_win(win); + unmap_window(win); + + if (win->ws->r) { + focus_win(get_focus_prev(win)); + stack(); + focus_flush(); + } + } + } else if (e->atom == a_state && e->state == XCB_PROPERTY_NEW_VALUE) { + /* Focus on window if it is selected. */ + if (win->ws->focus == win) + focus_win(win); } switch (e->atom) { @@ -7035,6 +7594,8 @@ propertynotify(xcb_property_notify_event_t *e) default: break; } + + xcb_flush(conn); } void @@ -7052,19 +7613,18 @@ unmapnotify(xcb_unmap_notify_event_t *e) if (getstate(e->window) == XCB_ICCCM_WM_STATE_NORMAL) { unmanage_window(win); stack(); - - /* resend unmap because we ated it */ - xcb_unmap_window(conn, e->window); - xcb_flush(conn); + focus_flush(); } } -/*void +#if 0 +void visibilitynotify(xcb_visibility_notify_event_t *e) { DNPRINTF(SWM_D_EVENT, "visibilitynotify: window: 0x%x\n", e->window); -}*/ +} +#endif void clientmessage(xcb_client_message_event_t *e) @@ -7098,7 +7658,7 @@ clientmessage(xcb_client_message_event_t *e) if (e->type == ewmh[_NET_CLOSE_WINDOW].atom) { DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_CLOSE_WINDOW\n"); if (win->can_delete) - client_msg(win, a_delete); + client_msg(win, a_delete, 0); else xcb_kill_client(conn, win->id); } @@ -7136,6 +7696,39 @@ clientmessage(xcb_client_message_event_t *e) xcb_flush(conn); } +void +check_conn(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 +} + int enable_wm(void) { @@ -7148,11 +7741,12 @@ enable_wm(void) /* this causes an error if some other window manager is running */ num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); for (i = 0; i < num_screens; i++) { - sc = get_screen(i); + if ((sc = get_screen(i)) == NULL) + errx(1, "ERROR: can't get screen %d.", i); DNPRINTF(SWM_D_INIT, "enable_wm: screen %d, root: 0x%x\n", i, sc->root); wac = xcb_change_window_attributes_checked(conn, sc->root, - XCB_CW_EVENT_MASK, &val); + XCB_CW_EVENT_MASK, &val); if ((error = xcb_request_check(conn, wac))) { DNPRINTF(SWM_D_INIT, "enable_wm: error_code: %u\n", error->error_code); @@ -7253,7 +7847,10 @@ scan_xrandr(int i) xcb_randr_get_crtc_info_cookie_t cic; xcb_randr_get_crtc_info_reply_t *cir = NULL; xcb_randr_crtc_t *crtc; - xcb_screen_t *screen = get_screen(i); + xcb_screen_t *screen; + + if ((screen = get_screen(i)) == NULL) + errx(1, "ERROR: can't get screen %d.", i); num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); if (i >= num_screens) @@ -7282,8 +7879,9 @@ scan_xrandr(int i) return; } else ncrtc = srr->num_crtcs; + + crtc = xcb_randr_get_screen_resources_current_crtcs(srr); for (c = 0; c < ncrtc; c++) { - crtc = xcb_randr_get_screen_resources_current_crtcs(srr); cic = xcb_randr_get_crtc_info(conn, crtc[c], XCB_CURRENT_TIME); cir = xcb_randr_get_crtc_info_reply(conn, cic, NULL); @@ -7347,7 +7945,7 @@ grab_windows(void) xcb_window_t *wins = NULL; int no; int i, j, num_screens; - uint16_t state, manage; + uint16_t state, manage, mapped; xcb_query_tree_cookie_t qtc; xcb_query_tree_reply_t *qtr; @@ -7355,6 +7953,7 @@ grab_windows(void) xcb_get_window_attributes_reply_t *r; xcb_get_property_cookie_t pc; + DNPRINTF(SWM_D_INIT, "grab_windows: begin\n"); num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); for (i = 0; i < num_screens; i++) { qtc = xcb_query_tree(conn, screens[i].root); @@ -7384,8 +7983,9 @@ grab_windows(void) state = getstate(wins[j]); manage = state == XCB_ICCCM_WM_STATE_ICONIC; - if (r->map_state == XCB_MAP_STATE_VIEWABLE || manage) - manage_window(wins[j]); + mapped = r->map_state != XCB_MAP_STATE_UNMAPPED; + if (mapped || manage) + manage_window(wins[j], mapped); free(r); } /* transient windows */ @@ -7402,13 +8002,15 @@ grab_windows(void) state = getstate(wins[j]); manage = state == XCB_ICCCM_WM_STATE_ICONIC; + mapped = r->map_state != XCB_MAP_STATE_UNMAPPED; pc = xcb_icccm_get_wm_transient_for(conn, wins[j]); if (xcb_icccm_get_wm_transient_for_reply(conn, pc, &wins[j], NULL) && manage) - manage_window(wins[j]); + manage_window(wins[j], mapped); } free(qtr); } + DNPRINTF(SWM_D_INIT, "grab_windows: done.\n"); } void @@ -7418,6 +8020,7 @@ setup_screens(void) struct workspace *ws; uint32_t gcv[1], wa[1]; const xcb_query_extension_reply_t *qep; + xcb_screen_t *screen; xcb_cursor_t cursor; xcb_font_t cursor_font; xcb_randr_query_version_cookie_t c; @@ -7430,23 +8033,26 @@ setup_screens(void) "screens"); /* initial Xrandr setup */ - xrandr_support = False; - c = xcb_randr_query_version(conn, True, True); - r = xcb_randr_query_version_reply(conn, c, NULL); - if (r) { - if (r->major_version >= 1) - xrandr_support = True; - free(r); - } + xrandr_support = 0; qep = xcb_get_extension_data(conn, &xcb_randr_id); - xrandr_eventbase = qep->first_event; + if (qep->present) { + c = xcb_randr_query_version(conn, 1, 1); + r = xcb_randr_query_version_reply(conn, c, NULL); + if (r) { + if (r->major_version >= 1) { + xrandr_support = 1; + xrandr_eventbase = qep->first_event; + } + free(r); + } + } cursor_font = xcb_generate_id(conn); xcb_open_font(conn, cursor_font, strlen("cursor"), "cursor"); cursor = xcb_generate_id(conn); xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font, - XC_left_ptr, XC_left_ptr + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff); + XC_left_ptr, XC_left_ptr + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff); wa[0] = cursor; /* map physical screens */ @@ -7455,7 +8061,9 @@ setup_screens(void) screens[i].idx = i; TAILQ_INIT(&screens[i].rl); TAILQ_INIT(&screens[i].orl); - screens[i].root = get_screen(i)->root; + if ((screen = get_screen(i)) == NULL) + errx(1, "ERROR: can't get screen %d.", i); + screens[i].root = screen->root; /* set default colors */ setscreencolor("red", i + 1, SWM_S_COLOR_FOCUS); @@ -7525,44 +8133,78 @@ setup_globals(void) a_utf8_string = get_atom_from_string("UTF8_STRING"); a_string = get_atom_from_string("STRING"); a_swm_iconic = get_atom_from_string("_SWM_ICONIC"); + a_swm_ws = get_atom_from_string("_SWM_WS"); } void workaround(void) { int i, num_screens; - xcb_atom_t netwmcheck, netwmname, utf8_string; + xcb_atom_t netwmcheck; xcb_window_t root, win; - uint32_t wa[2]; /* work around sun jdk bugs, code from wmname */ netwmcheck = get_atom_from_string("_NET_SUPPORTING_WM_CHECK"); - netwmname = get_atom_from_string("_NET_WM_NAME"); - utf8_string = get_atom_from_string("UTF8_STRING"); num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); for (i = 0; i < num_screens; i++) { root = screens[i].root; win = xcb_generate_id(conn); - wa[0] = screens[i].c[SWM_S_COLOR_UNFOCUS].color; - wa[1] = screens[i].c[SWM_S_COLOR_UNFOCUS].color; - xcb_create_window(conn, XCB_COPY_FROM_PARENT, win, 0, 0, 0, 1, - 1, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, - XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa); + 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, netwmcheck, XCB_ATOM_WINDOW, 32, 1, &win); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, netwmcheck, XCB_ATOM_WINDOW, 32, 1, &win); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, - netwmname, utf8_string, 8, strlen("LG3D"), "LG3D"); + a_netwmname, a_utf8_string, 8, strlen("LG3D"), "LG3D"); + } +} + +void +shutdown_cleanup(void) +{ + 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(); + bar_extra = 1; + unmap_all(); + + teardown_ewmh(); + + num_screens = xcb_setup_roots_length(xcb_get_setup(conn)); + for (i = 0; i < num_screens; ++i) { + if (screens[i].bar_gc != 0) + xcb_free_gc(conn, screens[i].bar_gc); + if (!bar_font_legacy) + XftColorFree(display, DefaultVisual(display, i), + DefaultColormap(display, i), &bar_font_color); + } + + if (bar_font_legacy) + XFreeFontSet(display, bar_fs); + else { + XftFontClose(display, bar_font); } + + xcb_key_symbols_free(syms); + xcb_flush(conn); + xcb_disconnect(conn); } void event_error(xcb_generic_error_t *e) { + (void)e; + DNPRINTF(SWM_D_EVENT, "event_error: %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, @@ -7575,9 +8217,9 @@ event_handle(xcb_generic_event_t *evt) { uint8_t type = XCB_EVENT_RESPONSE_TYPE(evt); - DNPRINTF(SWM_D_EVENT, "XCB Event: %s(%d)\n", + DNPRINTF(SWM_D_EVENT, "XCB Event: %s(%d), seq %u\n", xcb_event_get_label(XCB_EVENT_RESPONSE_TYPE(evt)), - XCB_EVENT_RESPONSE_TYPE(evt)); + XCB_EVENT_RESPONSE_TYPE(evt), evt->sequence); switch (type) { #define EVENT(type, callback) case type: callback((void *)evt); return @@ -7594,14 +8236,18 @@ event_handle(xcb_generic_event_t *evt) EVENT(XCB_DESTROY_NOTIFY, destroynotify); EVENT(XCB_ENTER_NOTIFY, enternotify); EVENT(XCB_EXPOSE, expose); - /*EVENT(XCB_FOCUS_IN, );*/ - /*EVENT(XCB_FOCUS_OUT, );*/ +#ifdef SWM_DEBUG + EVENT(XCB_FOCUS_IN, focusin); + EVENT(XCB_FOCUS_OUT, focusout); +#endif /*EVENT(XCB_GRAPHICS_EXPOSURE, );*/ /*EVENT(XCB_GRAVITY_NOTIFY, );*/ EVENT(XCB_KEY_PRESS, keypress); /*EVENT(XCB_KEY_RELEASE, keypress);*/ /*EVENT(XCB_KEYMAP_NOTIFY, );*/ - /*EVENT(XCB_LEAVE_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); @@ -7626,7 +8272,6 @@ main(int argc, char *argv[]) { struct swm_region *r, *rr; struct ws_win *winfocus = NULL; - union arg a; char conf[PATH_MAX], *cfile = NULL; struct stat sb; int xfd, i, num_screens; @@ -7635,6 +8280,9 @@ main(int argc, char *argv[]) struct timeval tv; fd_set rd; + /* suppress unused warning since var is needed */ + (void)argc; + time_started = time(NULL); start_argv = argv; @@ -7752,8 +8400,6 @@ noconfig: bar_setup(r); } - //unfocus_all(); - grabkeys(); stack(); @@ -7782,8 +8428,8 @@ noconfig: rr->s[0].root, 0, 0, 0, 0, X(rr), Y(rr) + (bar_enabled ? bar_height : 0)); - a.id = SWM_ARG_ID_FOCUSCUR; - focus(rr, &a); + focus_win(get_region_focus(rr)); + focus_flush(); winfocus = NULL; continue; } @@ -7793,8 +8439,9 @@ noconfig: tv.tv_sec = 1; tv.tv_usec = 0; if (select(xfd + 1, &rd, NULL, NULL, &tv) == -1) - if (errno != EINTR) + if (errno != EINTR) { DNPRINTF(SWM_D_MISC, "select failed"); + } if (restart_wm == 1) restart(NULL, NULL); if (search_resp == 1) @@ -7807,18 +8454,7 @@ noconfig: } } done: - teardown_ewmh(); - bar_extra_stop(); - - for (i = 0; i < num_screens; ++i) - if (screens[i].bar_gc != 0) - xcb_free_gc(conn, screens[i].bar_gc); -#if 0 - XFreeFontSet(display, bar_font); -#endif - xcb_key_symbols_free(syms); - xcb_flush(conn); - xcb_disconnect(conn); + shutdown_cleanup(); return (0); }