#define XCB_ICCCM_SIZE_HINT_P_MIN_SIZE XCB_SIZE_HINT_P_MIN_SIZE
#define XCB_ICCCM_SIZE_HINT_P_MAX_SIZE XCB_SIZE_HINT_P_MAX_SIZE
#define XCB_ICCCM_SIZE_HINT_P_RESIZE_INC XCB_SIZE_HINT_P_RESIZE_INC
+#define XCB_ICCCM_WM_HINT_INPUT XCB_WM_HINT_INPUT
#define XCB_ICCCM_WM_HINT_X_URGENCY XCB_WM_HINT_X_URGENCY
#define XCB_ICCCM_WM_STATE_ICONIC XCB_WM_STATE_ICONIC
#define XCB_ICCCM_WM_STATE_WITHDRAWN XCB_WM_STATE_WITHDRAWN
#define 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)
xcb_atom_t a_swm_ws;
volatile sig_atomic_t running = 1;
volatile sig_atomic_t restart_wm = 0;
+xcb_timestamp_t last_event_time = 0;
int outputs = 0;
-/*int last_focus_event = FocusOut;*/
int other_wm;
int ss_enabled = 0;
int xrandr_support;
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)
void configurerequest(xcb_configure_request_event_t *);
void constrain_window(struct ws_win *, struct swm_region *, int);
void destroynotify(xcb_destroy_notify_event_t *);
-void do_sync(void);
void enternotify(xcb_enter_notify_event_t *);
void event_drain(uint8_t);
void event_error(xcb_generic_error_t *);
struct ws_win *find_window(xcb_window_t);
int floating_toggle_win(struct ws_win *);
void focus(struct swm_region *, union arg *);
-struct ws_win *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
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 grabbuttons(struct ws_win *, int);
+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 *);
-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 *);*/
}
void
-do_sync(void)
+focus_flush(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)
-{
- 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
}
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;
-
pr = xcb_get_property_reply(conn,
xcb_get_property(conn, 0, win->id, a_swm_iconic,
XCB_ATOM_INTEGER, 0, 1), 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;
/* must be after stack */
bar_update();
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ focus_flush();
}
void
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),
{
uint16_t data[2] = { state, XCB_ATOM_NONE };
- DNPRINTF(SWM_D_EVENT, "set_win_state: window: 0x%x\n", win->id);
+ DNPRINTF(SWM_D_EVENT, "set_win_state: window: 0x%x, state: %u\n",
+ win->id, state);
if (win == NULL)
return;
}
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
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;
}
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].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) {
- /* 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; /* XXX this gets hit with thunderbird, needs fixing */
+ 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);
-
- 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 (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->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 ws_win *
-focus_magic(struct ws_win *win)
+get_focus_magic(struct ws_win *win)
{
struct ws_win *parent = NULL;
- DNPRINTF(SWM_D_FOCUS, "focus_magic: window: 0x%x\n", WINID(win));
+ DNPRINTF(SWM_D_FOCUS, "get_focus_magic: window: 0x%x\n", WINID(win));
if (win == NULL)
return win;
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);
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ 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();
+ }
- DNPRINTF(SWM_D_WS, "switchws: done\n");
+ focus_flush();
+
+ 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
struct ws_win *cur_focus;
struct ws_win_list *wl;
-
DNPRINTF(SWM_D_WS, "swapwin: 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);
stack();
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- 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;
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 */
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) {
}
kill_refs(win);
- focus_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;
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(focus_magic(winfocus));
- return;
- }
-
if ((cur_focus = r->ws->focus) == NULL)
return;
ws = r->ws;
return;
}
- focus_win(focus_magic(winfocus));
+ focus_win(get_focus_magic(winfocus));
xcb_flush(conn);
}
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));
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ focus_flush();
}
void
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(focus_magic(wintrans));
+ ws->focus = get_focus_magic(wintrans);
}
}
stack();
bar_update();
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ focus_flush();
}
void
if (r->ws->always_raise == 0)
stack();
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- 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);
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ 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);
}
-
int
floating_toggle_win(struct ws_win *win)
{
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);
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ focus_flush();
}
void
stack();
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ focus_flush();
switch (args->id) {
case SWM_ARG_ID_WIDTHSHRINK:
/* 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:
free(evt);
}
if (timestamp) {
- do_sync();
update_window(win);
+ xcb_flush(conn);
}
store_float_geom(win,r);
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
stack();
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ focus_flush();
move_step = 0;
switch (args->id) {
/* 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:
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
move(win, args);
}
-
/* user/key callable function IDs */
enum keyfuncid {
KF_BAR_TOGGLE,
} 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_SHIFT, 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
};
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,
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)
{
int i;
- 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)
- xcb_grab_button(conn, 0, 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, 0, 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[] = {
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;
}
}
- if (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ focus_flush();
return (0);
}
{ "layout", setlayout, 0 },
};
-
int
conf_load(char *filename, int keymapping)
{
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. */
/* 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,
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;
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);
-
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);
{
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);
if ((win = find_window(e->event)) == NULL)
return;
- focus_win(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);
}
stack_floater(win, win->ws->r);
- if (focus_mode == SWM_FOCUS_DEFAULT) {
- event_drain(XCB_ENTER_NOTIFY);
- } else {
- xcb_flush(conn);
- }
+ focus_flush();
} else {
config_win(win, e);
xcb_flush(conn);
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 (focus_mode == SWM_FOCUS_DEFAULT)
- event_drain(XCB_ENTER_NOTIFY);
- else
- xcb_flush(conn);
+ if (win->ws->focus_pending) {
+ focus_win(win->ws->focus_pending);
+ win->ws->focus_pending = NULL;
+ }
+
+ free_window(win);
+
+ focus_flush();
}
#ifdef SWM_DEBUG
enternotify(xcb_enter_notify_event_t *e)
{
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);
-
- switch (focus_mode) {
- case SWM_FOCUS_DEFAULT:
- break;
- case SWM_FOCUS_FOLLOW:
- break;
- case SWM_FOCUS_SYNERGY:
- break;
+
+ 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_win(focus_magic(win));
+ 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);
}
void
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 = 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);
- 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) {
+ win->ws->focus_pending = get_focus_prev(win);
+ unfocus_win(win);
+ unmap_window(win);
+
+ if (win->ws->r) {
+ stack();
+ focus_win(win->ws->focus_pending);
+ win->ws->focus_pending = NULL;
+ 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);
+
+ win->mapped = 0;
+ set_win_state(win, XCB_ICCCM_WM_STATE_ICONIC);
+
unmanage_window(win);
stack();
- /* resend unmap because we ated it */
- xcb_unmap_window(conn, e->window);
- xcb_flush(conn);
+ 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;
}