* Copyright (c) 2009 Pierre-Yves Ritschard <pyr@spootnik.org>
* Copyright (c) 2010 Tuukka Kataja <stuge@xor.fi>
* Copyright (c) 2011 Jason L. Wright <jason@thought.net>
- * Copyright (c) 2011-2012 Reginald Kennedy <rk@rejii.com>
+ * Copyright (c) 2011-2013 Reginald Kennedy <rk@rejii.com>
* Copyright (c) 2011-2012 Lawrence Teo <lteo@lteo.net>
* Copyright (c) 2011-2012 Tiago Cunha <tcunha@gmx.com>
- * Copyright (c) 2012 David Hill <dhill@mindcry.org>
+ * Copyright (c) 2012-2013 David Hill <dhill@mindcry.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
#define SWM_ARG_ID_CYCLERG_DOWN (43)
#define SWM_ARG_ID_CYCLEWS_UP_ALL (44)
#define SWM_ARG_ID_CYCLEWS_DOWN_ALL (45)
+#define SWM_ARG_ID_CYCLEWS_MOVE_UP (46)
+#define SWM_ARG_ID_CYCLEWS_MOVE_DOWN (47)
#define SWM_ARG_ID_STACKINC (50)
#define SWM_ARG_ID_STACKDEC (51)
#define SWM_ARG_ID_SS_ALL (60)
KF_WS_22,
KF_WS_NEXT,
KF_WS_NEXT_ALL,
+ KF_WS_NEXT_MOVE,
KF_WS_PREV,
KF_WS_PREV_ALL,
+ KF_WS_PREV_MOVE,
KF_WS_PRIOR,
KF_DUMPWINS, /* MUST BE LAST */
KF_INVALID
void screenchange(xcb_randr_screen_change_notify_event_t *);
void scan_xrandr(int);
void search_do_resp(void);
-void search_resp_name_workspace(const char *, unsigned long);
+void search_resp_name_workspace(const char *, size_t);
void search_resp_search_window(const char *);
void search_resp_search_workspace(const char *);
-void search_resp_uniconify(const char *, unsigned long);
+void search_resp_uniconify(const char *, size_t);
void search_win(struct swm_region *, union arg *);
void search_win_cleanup(void);
void search_workspace(struct swm_region *, union arg *);
if (r == NULL && check & SWM_CK_FALLBACK)
r = TAILQ_FIRST(&screens[i].rl);
+ DNPRINTF(SWM_D_MISC, "root_to_region: idx: %d\n", get_region_index(r));
+
return (r);
}
if (old_r)
unfocus_win(old_r->ws->focus);
- xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT, r->s->root,
+ xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT, r->id,
XCB_CURRENT_TIME);
/* Clear bar since empty. */
if (old_ws->r && focus_mode != SWM_FOCUS_FOLLOW) {
if (new_ws->focus_pending) {
focus_win(new_ws->focus_pending);
- } else {
- /* Empty region, focus on root. */
- xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
- new_ws->r->s[new_ws->r->s->idx].root,
- XCB_CURRENT_TIME);
+ new_ws->focus_pending = NULL;
}
}
- /* Clear bar if new ws is empty. */
- if (new_ws->focus_pending == NULL)
+ /* Clear bar and set focus on region input win if new ws is empty. */
+ if (new_ws->focus_pending == NULL && new_ws->focus == NULL) {
+ xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT, r->id,
+ XCB_CURRENT_TIME);
bar_draw();
+ }
focus_flush();
union arg a;
struct swm_screen *s = r->s;
int cycle_all = 0;
+ int move = 0;
DNPRINTF(SWM_D_WS, "cyclews: id: %d, screen[%d]:%dx%d+%d+%d, ws: %d\n",
args->id, r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx);
a.id = r->ws->idx;
+
do {
switch (args->id) {
+ case SWM_ARG_ID_CYCLEWS_MOVE_UP:
+ move = 1;
+ /* FALLTHROUGH */
case SWM_ARG_ID_CYCLEWS_UP_ALL:
cycle_all = 1;
/* FALLTHROUGH */
case SWM_ARG_ID_CYCLEWS_UP:
- if (a.id < workspace_limit - 1)
- a.id++;
- else
- a.id = 0;
+ a.id = (a.id < workspace_limit - 1) ? a.id + 1 : 0;
break;
+ case SWM_ARG_ID_CYCLEWS_MOVE_DOWN:
+ move = 1;
+ /* FALLTHROUGH */
case SWM_ARG_ID_CYCLEWS_DOWN_ALL:
cycle_all = 1;
/* FALLTHROUGH */
case SWM_ARG_ID_CYCLEWS_DOWN:
- if (a.id > 0)
- a.id--;
- else
- a.id = workspace_limit - 1;
+ a.id = (a.id > 0) ? a.id - 1 : workspace_limit - 1;
break;
default:
return;
if (!cycle_visible && s->ws[a.id].r != NULL)
continue;
+ if (move)
+ send_to_ws(r, &a);
+
switchws(r, &a);
} while (a.id != r->ws->idx);
}
win = ws->focus_pending;
else if (ws->focus)
win = ws->focus;
+ else if (ws->focus_prev)
+ win = ws->focus_prev;
else
win = TAILQ_FIRST(&ws->winlist);
unfocus_win(parent);
- if (focus_mode != SWM_FOCUS_FOLLOW)
+ if (focus_mode != SWM_FOCUS_FOLLOW) {
pws->focus = pws->focus_pending;
-
- if (focus_mode != SWM_FOCUS_FOLLOW)
pws->focus_pending = NULL;
+ }
}
/* Don't unmap parent if new ws is visible */
stack();
if (focus_mode != SWM_FOCUS_FOLLOW) {
- focus_win(ws->focus_pending);
- ws->focus_pending = NULL;
+ if (ws->focus_pending) {
+ focus_win(ws->focus_pending);
+ ws->focus_pending = NULL;
+ } else {
+ xcb_set_input_focus(conn,
+ XCB_INPUT_FOCUS_PARENT, r->id,
+ XCB_CURRENT_TIME);
+ }
}
focus_flush();
}
void
-search_resp_uniconify(const char *resp, unsigned long len)
+search_resp_uniconify(const char *resp, size_t len)
{
char *name;
struct ws_win *win;
}
void
-search_resp_name_workspace(const char *resp, unsigned long len)
+search_resp_name_workspace(const char *resp, size_t len)
{
struct workspace *ws;
{
ssize_t rbytes;
char *resp;
- unsigned long len;
+ size_t len;
DNPRINTF(SWM_D_MISC, "search_do_resp:\n");
int top = 0, left = 0, resizing;
int dx, dy;
xcb_cursor_t cursor;
- xcb_query_pointer_reply_t *xpr;
+ xcb_query_pointer_reply_t *xpr = NULL;
xcb_generic_event_t *evt;
xcb_motion_notify_event_t *mne;
xcb_timestamp_t timestamp = 0;
int move_stp = 0, moving;
struct swm_region *r = NULL;
- xcb_query_pointer_reply_t *qpr;
+ xcb_query_pointer_reply_t *qpr = NULL;
xcb_generic_event_t *evt;
xcb_motion_notify_event_t *mne;
{ "ws_22", switchws, {.id = 21} },
{ "ws_next", cyclews, {.id = SWM_ARG_ID_CYCLEWS_UP} },
{ "ws_next_all", cyclews, {.id = SWM_ARG_ID_CYCLEWS_UP_ALL} },
+ { "ws_next_move", cyclews, {.id = SWM_ARG_ID_CYCLEWS_MOVE_UP} },
{ "ws_prev", cyclews, {.id = SWM_ARG_ID_CYCLEWS_DOWN} },
{ "ws_prev_all", cyclews, {.id = SWM_ARG_ID_CYCLEWS_DOWN_ALL} },
+ { "ws_prev_move", cyclews, {.id = SWM_ARG_ID_CYCLEWS_MOVE_DOWN} },
{ "ws_prior", priorws, {0} },
{ "dumpwins", dumpwins, {0} }, /* MUST BE LAST */
{ "invalid key func", NULL, {0} },
setkeybinding(MODKEY, XK_Left, KF_WS_PREV, NULL);
setkeybinding(MODKEY, XK_Up, KF_WS_NEXT_ALL, NULL);
setkeybinding(MODKEY, XK_Down, KF_WS_PREV_ALL, NULL);
+ setkeybinding(MODKEY_SHIFT, XK_Up, KF_WS_NEXT_MOVE,NULL);
+ setkeybinding(MODKEY_SHIFT, XK_Down, KF_WS_PREV_MOVE,NULL);
setkeybinding(MODKEY, XK_a, KF_WS_PRIOR, NULL);
#ifdef SWM_DEBUG
setkeybinding(MODKEY_SHIFT, XK_d, KF_DUMPWINS, NULL);
xcb_ungrab_key(conn, XCB_GRAB_ANY, screens[k].root,
XCB_MOD_MASK_ANY);
RB_FOREACH(kp, key_tree, &keys) {
+ /* Skip unused ws binds. */
+ if ((int)kp->funcid > KF_WS_1 + workspace_limit - 1 &&
+ kp->funcid <= KF_WS_22)
+ continue;
+
+ /* Skip unused mvws binds. */
+ if ((int)kp->funcid > KF_MVWS_1 + workspace_limit - 1 &&
+ kp->funcid <= KF_MVWS_22)
+ continue;
+
if ((code = xcb_key_symbols_get_keycode(syms,
kp->keysym))) {
for (j = 0; j < LENGTH(modifiers); j++)
if (win->ws->focus_pending) {
focus_win(win->ws->focus_pending);
win->ws->focus_pending = NULL;
+ } else if (win == win->ws->focus && win->ws->r) {
+ xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
+ win->ws->r->id, XCB_CURRENT_TIME);
}
}
last_event_time = e->time;
+ if (focus_mode == SWM_FOCUS_MANUAL)
+ return;
+
num_screens = get_screen_count();
for (i = 0; i < num_screens; i++)
if (screens[i].root == e->root)
propertynotify(xcb_property_notify_event_t *e)
{
struct ws_win *win;
+ struct workspace *ws;
#ifdef SWM_DEBUG
char *name;
if (win == NULL)
return;
+ ws = win->ws;
+
last_event_time = e->time;
if (e->atom == a_swm_iconic) {
if (e->state == XCB_PROPERTY_NEW_VALUE) {
if (focus_mode != SWM_FOCUS_FOLLOW)
- win->ws->focus_pending = get_focus_prev(win);
+ ws->focus_pending = get_focus_prev(win);
unfocus_win(win);
unmap_window(win);
- if (win->ws->r) {
+ if (ws->r) {
stack();
+
if (focus_mode != SWM_FOCUS_FOLLOW) {
- focus_win(win->ws->focus_pending);
- win->ws->focus_pending = NULL;
+ if (ws->focus_pending) {
+ focus_win(ws->focus_pending);
+ ws->focus_pending = NULL;
+ } else {
+ xcb_set_input_focus(conn,
+ XCB_INPUT_FOCUS_PARENT,
+ ws->r->id,
+ XCB_CURRENT_TIME);
+ }
}
+
focus_flush();
}
} else if (e->state == XCB_PROPERTY_DELETE) {
/* The window is no longer iconic, restack ws. */
if (focus_mode != SWM_FOCUS_FOLLOW)
- win->ws->focus_pending = get_focus_magic(win);
+ ws->focus_pending = get_focus_magic(win);
stack();
if (e->state == XCB_PROPERTY_NEW_VALUE) {
if (focus_mode != SWM_FOCUS_FOLLOW) {
if (win->mapped &&
- win->ws->focus_pending == win) {
- focus_win(win->ws->focus_pending);
- win->ws->focus_pending = NULL;
+ ws->focus_pending == win) {
+ focus_win(ws->focus_pending);
+ ws->focus_pending = NULL;
}
}
}
if (focus_mode == SWM_FOCUS_FOLLOW) {
if (ws->r)
focus_win(get_pointer_win(ws->r->s->root));
- } else {
- if (ws->focus_pending) {
- focus_win(ws->focus_pending);
- ws->focus_pending = NULL;
- }
+ } else if (ws->focus_pending) {
+ focus_win(ws->focus_pending);
+ ws->focus_pending = NULL;
+ } else if (ws->focus == NULL && ws->r) {
+ xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
+ ws->r->id, XCB_CURRENT_TIME);
}
}
Got questions, comments, patches, etc.? Contact Jason Woofenden