#define XCB_ICCCM_SIZE_HINT_P_MIN_SIZE XCB_SIZE_HINT_P_MIN_SIZE
#define XCB_ICCCM_SIZE_HINT_P_MAX_SIZE XCB_SIZE_HINT_P_MAX_SIZE
#define XCB_ICCCM_SIZE_HINT_P_RESIZE_INC XCB_SIZE_HINT_P_RESIZE_INC
+#define XCB_ICCCM_WM_HINT_INPUT XCB_WM_HINT_INPUT
#define XCB_ICCCM_WM_HINT_X_URGENCY XCB_WM_HINT_X_URGENCY
#define XCB_ICCCM_WM_STATE_ICONIC XCB_WM_STATE_ICONIC
#define XCB_ICCCM_WM_STATE_WITHDRAWN XCB_WM_STATE_WITHDRAWN
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;
int floatmaxed; /* whether maxed by max_stack */
int floating;
int manual;
+ int32_t mapped;
int32_t iconic;
int bordered;
unsigned int ewmh_flags;
struct layout *cur_layout; /* current layout handlers */
struct ws_win *focus; /* may be NULL */
struct ws_win *focus_prev; /* may be NULL */
+ struct ws_win *focus_pending; /* may be NULL */
struct swm_region *r; /* may be NULL */
struct swm_region *old_r; /* may be NULL */
struct ws_win_list winlist; /* list of windows in ws */
#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)
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);
uint32_t getstate(xcb_window_t);
void leavenotify(xcb_leave_notify_event_t *);
#endif
void load_float_geom(struct ws_win *, struct swm_region *);
-void map_window_raised(xcb_window_t);
+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 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 *);*/
xcb_flush(conn);
}
-void
-map_window_raised(xcb_window_t win)
-{
- uint32_t val = XCB_STACK_MODE_ABOVE;
-
- xcb_configure_window(conn, win,
- XCB_CONFIG_WINDOW_STACK_MODE, &val);
-
- xcb_map_window(conn, win);
-}
-
xcb_atom_t
get_atom_from_string(const char *str)
{
}
int32_t
-get_iconic(struct ws_win *win)
+get_swm_iconic(struct ws_win *win)
{
int32_t v = 0;
xcb_get_property_reply_t *pr = NULL;
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;
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),
}
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;
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, 0, win->id,
XCB_EVENT_MASK_NO_EVENT, (const char *)&ev);
}
void
-unmap_window(struct ws_win *win)
+map_window(struct ws_win *win)
{
- DNPRINTF(SWM_D_EVENT, "unmap_window: window: 0x%x\n", win->id);
+ 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].pixel);
+ set_win_state(win, XCB_ICCCM_WM_STATE_ICONIC);
+ win->mapped = 0;
}
void
xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL,
&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);
DNPRINTF(SWM_D_FOCUS, "unfocus_win: done.\n");
}
-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);
-}
-
void
focus_win(struct ws_win *win)
{
- struct ws_win *cfw = NULL;
+ struct ws_win *cfw = NULL;
xcb_get_input_focus_reply_t *r;
DNPRINTF(SWM_D_FOCUS, "focus_win: window: 0x%x\n", WINID(win));
- if (win == NULL) {
- /* Clear the status-bar. */
- bar_update();
- return;
- }
+ if (win == NULL)
+ goto out;
if (win->ws == NULL)
- return;
+ goto out;
if (validate_ws(win->ws))
- 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 (win->ws->focus != win) {
- if (win->ws->focus != cfw)
+ if (win->ws->focus && win->ws->focus != cfw)
unfocus_win(win->ws->focus);
win->ws->focus = win;
}
- /* Tell app it can set focus. */
- if (win->take_focus) {
- /* java is special; always tell parent */
- if (win->transient && win->java)
- client_msg(find_window(win->transient), a_takefocus);
- else
- client_msg(win, a_takefocus);
- }
-
if (cfw != win && win->ws->r != NULL) {
- if (win->java == 0)
+ /* 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);
+ 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");
}
/* If a child window should have focus instead, return it. */
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;
if (new_ws == old_ws)
return;
+ unfocus_win(old_ws->focus);
+
other_r = new_ws->r;
if (other_r == NULL) {
/* the other workspace is hidden, hide this one */
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);
/* unmap old windows */
if (unmap_old)
TAILQ_FOREACH(win, &old_ws->winlist, entry)
unmap_window(win);
+ new_ws->focus_pending = get_region_focus(new_ws->r);
+
+ if (new_ws->focus_pending) {
+ /* if workspaces were swapped, then don't wait to set focus */
+ if (old_ws->r)
+ focus_win(new_ws->focus);
+ } else {
+ /* make sure bar gets updated if ws is empty */
+ bar_update();
+ }
+
focus_flush();
- DNPRINTF(SWM_D_WS, "switchws: done\n");
+ DNPRINTF(SWM_D_WS, "switchws: done.\n");
}
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));
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 */
xcb_warp_pointer(conn, XCB_WINDOW_NONE, rr->s[i].root, 0, 0, 0,
0, x, y);
}
+
+ focus_flush();
}
void
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;
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_win(get_focus_magic(winfocus));
- xcb_flush(conn);
- return;
- }
-
if ((cur_focus = r->ws->focus) == NULL)
return;
ws = r->ws;
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;
stack();
bar_update();
- a.id = SWM_ARG_ID_FOCUSCUR;
- focus(r, &a);
+ focus_win(get_region_focus(r));
focus_flush();
}
if (args->id != SWM_ARG_ID_STACKINIT)
stack();
bar_update();
+
+ focus_flush();
}
void
int w_inc = 1, h_inc, w_base = 1, h_base;
int hrh, extra = 0, h_slice, last_h = 0;
int split, colno, winno, mwin, msize, mscale;
- int remain, missing, v_slice, reconfigure;
+ int remain, missing, v_slice, reconfigure = 0;
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));
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++;
}
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);
}
}
/* put the last transient on top */
if (wintrans) {
if (parent)
- map_window_raised(parent->id);
+ map_window(parent);
stack_floater(wintrans, ws->r);
- focus_win(get_focus_magic(wintrans));
+ ws->focus = get_focus_magic(wintrans);
}
}
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);
- focus_flush();
+ xcb_flush(conn);
}
char *
}
fclose(lfile);
-
- xcb_flush(conn);
}
void
XCB_COPY_FROM_PARENT, XCB_CW_BACK_PIXEL |
XCB_CW_BORDER_PIXEL, wa);
- map_window_raised(w);
+ xcb_map_window(conn, w);
sw->indicator = w;
TAILQ_INSERT_TAIL(&search_wl, sw, entry);
if (strncmp(s, resp, len) == 0) {
/* XXX this should be a callback to generalize */
update_iconic(win, 0);
+ xcb_flush(conn);
free(s);
break;
}
search_resp_action = SWM_SEARCH_NONE;
close(select_resp_pipe[0]);
free(resp);
+
+ xcb_flush(conn);
}
void
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);
}
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;
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);
focus_flush();
}
xcb_free_cursor(conn, cursor);
xcb_close_font(conn, cursor_font);
free(xpr);
- DNPRINTF(SWM_D_EVENT, "resize: done\n");
+ DNPRINTF(SWM_D_EVENT, "resize: done.\n");
}
void
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
setspawn(selector, args);
free(args);
- DNPRINTF(SWM_D_SPAWN, "setconfspawn: done\n");
+ DNPRINTF(SWM_D_SPAWN, "setconfspawn: done.\n");
return (0);
}
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, 1,
screens[k].root,
*code, XCB_GRAB_MODE_SYNC,
XCB_GRAB_MODE_ASYNC);
free(code);
+ }
}
}
}
char *line, *cp, *optsub, *optval;
size_t linelen, lineno = 0;
int wordlen, i, optidx;
- struct config_option *opt;
+ struct config_option *opt = NULL;
DNPRINTF(SWM_D_CONF, "conf_load: begin\n");
filename, lineno, wordlen, cp);
goto out;
}
- if (keymapping && strcmp(opt->optname, "bind")) {
+ if (keymapping && opt && strcmp(opt->optname, "bind")) {
warnx("%s: line %zd: invalid option %.*s",
filename, lineno, wordlen, cp);
goto out;
}
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 ws_win *win, *ww;
- int ws_idx, border_me = 0;
+ int ws_idx;
char ws_idx_str[SWM_PROPLEN];
struct swm_region *r;
struct pid_e *p;
struct quirk *qp;
- uint32_t event_mask, i;
+ uint32_t i, wa[2];
xcb_icccm_get_wm_protocols_reply_t wpr;
if ((win = find_window(id)) != NULL) {
/* 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;
+ X(win) = win->wa->x + win->wa->border_width - border_width;
+ Y(win) = win->wa->y + win->wa->border_width - border_width;
+ win->bordered = 1;
+ win->mapped = mapped;
win->floatmaxed = 0;
win->ewmh_flags = 0;
win->s = r->s; /* this never changes */
xcb_icccm_get_wm_protocols_reply_wipe(&wpr);
}
- win->iconic = get_iconic(win);
+ win->iconic = get_swm_iconic(win);
/* Figure out which workspace the window belongs to. */
if ((p = find_pid(window_get_pid(win->id))) != NULL) {
} else if (trans && (ww = find_window(trans)) != NULL) {
/* Launch transients in the same ws as parent. */
win->ws = ww->ws;
- border_me = 1;
} else {
win->ws = r->ws;
}
DNPRINTF(SWM_D_CLASS, "manage_window: java window "
"detected.\n");
win->java = 1;
- border_me = 1;
}
TAILQ_FOREACH(qp, &quirks, entry) {
!strcmp(win->ch.instance_name, qp->name)) {
DNPRINTF(SWM_D_CLASS, "manage_window: on quirks"
"list; mask: 0x%lx\n", qp->quirk);
- if (qp->quirk & SWM_Q_FLOAT) {
+ if (qp->quirk & SWM_Q_FLOAT)
win->floating = 1;
- border_me = 1;
- }
win->quirks = qp->quirk;
}
}
}
/* Alter window position if quirky */
- if (win->quirks & SWM_Q_ANYWHERE) {
+ if (win->quirks & SWM_Q_ANYWHERE)
win->manual = 1;
- border_me = 1;
- }
/* Reset font sizes (the bruteforce way; no default keybinding). */
if (win->quirks & SWM_Q_XTERM_FONTADJ) {
fake_keypress(win, XK_KP_Add, XCB_MOD_MASK_SHIFT);
}
- if (border_me) {
- win->bordered = 1;
- X(win) -= border_width;
- Y(win) -= border_width;
- }
-
/* Make sure window is positioned inside its region, if its active. */
- if (win->ws->r)
+ 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;
+
+ /* Select which X events to monitor and set border pixel color. */
+ wa[0] = win->s->c[SWM_S_COLOR_UNFOCUS].pixel;
+ wa[1] = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_PROPERTY_CHANGE |
+ XCB_EVENT_MASK_STRUCTURE_NOTIFY;
#ifdef SWM_DEBUG
- event_mask |= XCB_EVENT_MASK_LEAVE_WINDOW;
+ wa[1] |= XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_FOCUS_CHANGE;
#endif
- xcb_change_window_attributes(conn, win->id, XCB_CW_EVENT_MASK,
- &event_mask);
+ xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL |
+ XCB_CW_EVENT_MASK, wa);
out:
/* Figure out where to stack the window in the workspace. */
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
parent->focus_child = NULL;
}
- focus_win(get_focus_prev(win));
-
TAILQ_REMOVE(&win->ws->winlist, win, entry);
TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry);
}
"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
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);
if ((win = find_window(e->event)) == NULL)
return;
+ last_event_time = e->time;
+
focus_win(get_focus_magic(win));
for (i = 0; i < LENGTH(buttons); i++)
return;
}
- /* make sure we focus on something */
- win->floating = 0;
+ /* If we were focused, make sure we focus on something else. */
+ if (win == win->ws->focus)
+ win->ws->focus_pending = get_focus_prev(win);
unmanage_window(win);
- free_window(win);
-
stack();
+ if (win->ws->focus_pending) {
+ focus_win(win->ws->focus_pending);
+ win->ws->focus_pending = NULL;
+ }
+
+ free_window(win);
+
focus_flush();
}
{
struct ws_win *win;
- DNPRINTF(SWM_D_FOCUS, "enternotify: window: 0x%x, mode: %s(%d), "
- "detail: %s(%d), root: 0x%x, subwindow: 0x%x, same_screen_focus: "
- "%s, state: %d\n", e->event, get_notify_mode_label(e->mode),
- e->mode, get_notify_detail_label(e->detail), e->detail, e->root,
- e->child, YESNO(e->same_screen_focus), e->state);
+ 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) {
return;
}
+ last_event_time = e->time;
+
focus_win(get_focus_magic(win));
xcb_flush(conn);
void
leavenotify(xcb_leave_notify_event_t *e)
{
- DNPRINTF(SWM_D_FOCUS, "leavenotify: window: 0x%x, mode: %s(%d), "
- "detail: %s(%d), root: 0x%x, subwindow: 0x%x, same_screen_focus: "
- "%s, state: %d\n", e->event, get_notify_mode_label(e->mode),
- e->mode, get_notify_detail_label(e->detail), e->detail, e->root,
- e->child, YESNO(e->same_screen_focus), e->state);
+ 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
DNPRINTF(SWM_D_EVENT, "mapnotify: window: 0x%x\n", e->window);
if ((win = find_window(e->window)) == NULL)
- win = manage_window(e->window);
+ win = manage_window(e->window, 1);
+ win->mapped = 1;
set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL);
- /* Focus on window if it is selected. */
- if (win->ws->focus == win)
+ if (win->ws->focus_pending == win) {
focus_win(win);
+ win->ws->focus_pending = NULL;
+ }
xcb_flush(conn);
}
goto out;
}
- win = manage_window(e->window);
+ win = manage_window(e->window,
+ (war->map_state == XCB_MAP_STATE_VIEWABLE));
/* 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);
+ win->ws->focus_pending = get_focus_magic(win);
/* Ignore EnterNotify to handle the mapnotify without interference. */
if (focus_mode == SWM_FOCUS_DEFAULT)
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
- xcb_flush(conn);
-
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);
- xcb_flush(conn);
- 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. */
+ win->ws->focus_pending = get_focus_magic(win);
+ stack();
+
+ /* Flush EnterNotify for mapnotify, if needed. */
+ focus_flush();
+ return;
+ } else if (e->state == XCB_PROPERTY_NEW_VALUE) {
+ 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) {
+ /* State just changed, make sure it gets focused if mapped. */
+ if (win->mapped && win->ws->focus_pending == win) {
+ win->ws->focus_pending = NULL;
+ focus_win(win);
+ }
}
switch (e->atom) {
default:
break;
}
+
+ xcb_flush(conn);
}
void
return;
if (getstate(e->window) == XCB_ICCCM_WM_STATE_NORMAL) {
+ /* If we were focused, make sure we focus on something else. */
+ if (win == win->ws->focus)
+ win->ws->focus_pending = get_focus_prev(win);
+
unmanage_window(win);
stack();
+
+ if (win->ws->focus_pending) {
+ focus_win(win->ws->focus_pending);
+ win->ws->focus_pending = NULL;
+ }
+
focus_flush();
}
}
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);
}
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;
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 */
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");
+ DNPRINTF(SWM_D_INIT, "grab_windows: done.\n");
}
void
ws->idx = j;
ws->name = NULL;
ws->focus = NULL;
+ ws->focus_prev = NULL;
+ ws->focus_pending = NULL;
ws->r = NULL;
ws->old_r = NULL;
TAILQ_INIT(&ws->winlist);
{
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
EVENT(XCB_EXPOSE, expose);
#ifdef SWM_DEBUG
EVENT(XCB_FOCUS_IN, focusin);
+ EVENT(XCB_FOCUS_OUT, focusout);
#endif
- /*EVENT(XCB_FOCUS_OUT, );*/
/*EVENT(XCB_GRAPHICS_EXPOSURE, );*/
/*EVENT(XCB_GRAVITY_NOTIFY, );*/
EVENT(XCB_KEY_PRESS, keypress);
{
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;
bar_setup(r);
}
- //unfocus_all();
-
grabkeys();
stack();
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;
}