int horizontal_msize;
int horizontal_mwin;
int horizontal_stacks;
+ int horizontal_flip;
int vertical_msize;
int vertical_mwin;
int vertical_stacks;
+ int vertical_flip;
} l_state;
};
#define SWM_ARG_ID_MASTERGROW (21)
#define SWM_ARG_ID_MASTERADD (22)
#define SWM_ARG_ID_MASTERDEL (23)
+#define SWM_ARG_ID_FLIPLAYOUT (24)
#define SWM_ARG_ID_STACKRESET (30)
#define SWM_ARG_ID_STACKINIT (31)
#define SWM_ARG_ID_CYCLEWS_UP (40)
{
strlcpy(ws->stacker, "[ ]", sizeof ws->stacker);
if (ws->cur_layout->l_stack == vertical_stack)
- snprintf(ws->stacker, sizeof ws->stacker, "[%d|%d]",
+ snprintf(ws->stacker, sizeof ws->stacker,
+ ws->l_state.vertical_flip ? "[%d>%d]" : "[%d|%d]",
ws->l_state.vertical_mwin, ws->l_state.vertical_stacks);
if (ws->cur_layout->l_stack == horizontal_stack)
- snprintf(ws->stacker, sizeof ws->stacker, "[%d-%d]",
+ snprintf(ws->stacker, sizeof ws->stacker,
+ ws->l_state.horizontal_flip ? "[%dv%d]" : "[%d-%d]",
ws->l_state.horizontal_mwin, ws->l_state.horizontal_stacks);
}
{
strlcpy(ws->stacker, "[ ]", sizeof ws->stacker);
if (ws->cur_layout->l_stack == vertical_stack)
- strlcpy(ws->stacker, "[|]", sizeof ws->stacker);
+ strlcpy(ws->stacker, ws->l_state.vertical_flip ? "[>]" : "[|]",
+ sizeof ws->stacker);
if (ws->cur_layout->l_stack == horizontal_stack)
- strlcpy(ws->stacker, "[-]", sizeof ws->stacker);
+ strlcpy(ws->stacker, ws->l_state.horizontal_flip ? "[v]" : "[-]",
+ sizeof ws->stacker);
}
void
}
void
+bar_check_opts(void)
+{
+ if (title_class_enabled || title_name_enabled || window_name_enabled)
+ bar_update();
+}
+
+void
bar_signal(int sig)
{
bar_alarm = 1;
PropModeReplace, (unsigned char *)&win->id,1);
}
- if (window_name_enabled || title_class_enabled || title_name_enabled)
- bar_update();
+ bar_check_opts();
}
void
winfocus = TAILQ_LAST(wl, ws_win_list);
if (winfocus == NULL || winfocus == win)
winfocus = TAILQ_NEXT(cur_focus, entry);
-done:
- if (winfocus == winlostfocus || winfocus == NULL) {
- /* update the bar so that title/class/name will be cleared. */
- if (window_name_enabled || title_name_enabled ||
- title_class_enabled)
- bar_update();
- return;
- }
+done:
focus_magic(winfocus);
}
default:
return;
}
- if (winfocus == winlostfocus || winfocus == NULL) {
- /* update the bar so that title/class/name will be cleared. */
- if (window_name_enabled || title_name_enabled ||
- title_class_enabled)
- bar_update();
-
- return;
- }
focus_magic(winfocus);
}
if (ws->l_state.vertical_stacks > 1)
ws->l_state.vertical_stacks--;
break;
+ case SWM_ARG_ID_FLIPLAYOUT:
+ ws->l_state.vertical_flip = !ws->l_state.vertical_flip;
+ break;
default:
return;
}
{
DNPRINTF(SWM_D_STACK, "vertical_stack: workspace: %d\n", ws->idx);
- stack_master(ws, g, 0, 0);
+ stack_master(ws, g, 0, ws->l_state.vertical_flip);
}
void
if (ws->l_state.horizontal_stacks > 1)
ws->l_state.horizontal_stacks--;
break;
+ case SWM_ARG_ID_FLIPLAYOUT:
+ ws->l_state.horizontal_flip = !ws->l_state.horizontal_flip;
+ break;
default:
return;
}
{
DNPRINTF(SWM_D_STACK, "horizontal_stack: workspace: %d\n", ws->idx);
- stack_master(ws, g, 1, 0);
+ stack_master(ws, g, 1, ws->l_state.horizontal_flip);
}
/* fullscreen view */
/* user/key callable function IDs */
enum keyfuncid {
kf_cycle_layout,
+ kf_flip_layout,
kf_stack_reset,
kf_master_shrink,
kf_master_grow,
} keyfuncs[kf_invalid + 1] = {
/* name function argument */
{ "cycle_layout", cycle_layout, {0} },
+ { "flip_layout", stack_config, {.id = SWM_ARG_ID_FLIPLAYOUT} },
{ "stack_reset", stack_config, {.id = SWM_ARG_ID_STACKRESET} },
{ "master_shrink", stack_config, {.id = SWM_ARG_ID_MASTERSHRINK} },
{ "master_grow", stack_config, {.id = SWM_ARG_ID_MASTERGROW} },
/* spawn */
struct spawn_prog {
+ TAILQ_ENTRY(spawn_prog) entry;
char *name;
int argc;
char **argv;
};
-
-int spawns_size = 0, spawns_length = 0;
-struct spawn_prog *spawns = NULL;
+TAILQ_HEAD(spawn_list, spawn_prog);
+struct spawn_list spawns = TAILQ_HEAD_INITIALIZER(spawns);
int
spawn_expand(struct swm_region *r, union arg *args, char *spawn_name,
DNPRINTF(SWM_D_SPAWN, "spawn_expand: %s\n", spawn_name);
/* find program */
- for (i = 0; i < spawns_length; i++) {
- if (!strcasecmp(spawn_name, spawns[i].name))
- prog = &spawns[i];
+ TAILQ_FOREACH(prog, &spawns, entry) {
+ if (!strcasecmp(spawn_name, prog->name))
+ break;
}
if (prog == NULL) {
warnx("spawn_custom: program %s not found", spawn_name);
}
void
-setspawn(struct spawn_prog *prog)
+spawn_insert(char *name, char *args)
{
- int i, j;
+ char *arg, *cp, *ptr;
+ struct spawn_prog *sp;
- if (prog == NULL || prog->name == NULL)
- return;
+ DNPRINTF(SWM_D_SPAWN, "spawn_insert: %s\n", name);
- /* find existing */
- for (i = 0; i < spawns_length; i++) {
- if (!strcmp(spawns[i].name, prog->name)) {
- /* found */
- if (prog->argv == NULL) {
- /* delete */
- DNPRINTF(SWM_D_SPAWN,
- "setspawn: delete #%d: %s\n",
- i, spawns[i].name);
- free(spawns[i].name);
- for (j = 0; j < spawns[i].argc; j++)
- free(spawns[i].argv[j]);
- free(spawns[i].argv);
- j = spawns_length - 1;
- if (i < j)
- spawns[i] = spawns[j];
- spawns_length--;
- free(prog->name);
- } else {
- /* replace */
- DNPRINTF(SWM_D_SPAWN,
- "setspawn: replace #%d: %s\n",
- i, spawns[i].name);
- free(spawns[i].name);
- for (j = 0; j < spawns[i].argc; j++)
- free(spawns[i].argv[j]);
- free(spawns[i].argv);
- spawns[i] = *prog;
- }
- /* found case handled */
- free(prog);
- return;
- }
+ if ((sp = calloc(1, sizeof *sp)) == NULL)
+ err(1, "spawn_insert: malloc");
+ if ((sp->name = strdup(name)) == NULL)
+ err(1, "spawn_insert: strdup");
+
+ /* convert the arguments to an argument list */
+ if ((ptr = cp = strdup(args)) == NULL)
+ err(1, "spawn_insert: strdup");
+ while ((arg = strsep(&ptr, " \t")) != NULL) {
+ /* empty field; skip it */
+ if (*arg == '\0')
+ continue;
+
+ sp->argc++;
+ if ((sp->argv = realloc(sp->argv, sp->argc *
+ sizeof *sp->argv)) == NULL)
+ err(1, "spawn_insert: realloc");
+ if ((sp->argv[sp->argc - 1] = strdup(arg)) == NULL)
+ err(1, "spawn_insert: strdup");
}
+ free(cp);
+
+ TAILQ_INSERT_TAIL(&spawns, sp, entry);
+ DNPRINTF(SWM_D_SPAWN, "spawn_insert: leave\n");
+}
+
+void
+spawn_remove(struct spawn_prog *sp)
+{
+ int i;
+
+ DNPRINTF(SWM_D_SPAWN, "spawn_remove: %s\n", sp->name);
+
+ TAILQ_REMOVE(&spawns, sp, entry);
+ for (i = 0; i < sp->argc; i++)
+ free(sp->argv[i]);
+ free(sp->argv);
+ free(sp->name);
+ free(sp);
+
+ DNPRINTF(SWM_D_SPAWN, "spawn_remove: leave\n");
+}
+
+void
+spawn_replace(struct spawn_prog *sp, char *name, char *args)
+{
+ DNPRINTF(SWM_D_SPAWN, "spawn_replace: %s [%s]\n", sp->name, name);
+
+ spawn_remove(sp);
+ spawn_insert(name, args);
+
+ DNPRINTF(SWM_D_SPAWN, "spawn_replace: leave\n");
+}
+
+void
+setspawn(char *name, char *args)
+{
+ struct spawn_prog *sp;
+
+ DNPRINTF(SWM_D_SPAWN, "setspawn: %s\n", name);
- if (prog->argv == NULL) {
- warnx("error: setspawn: cannot find program: %s", prog->name);
- free(prog);
+ if (name == NULL)
return;
- }
- /* not found: add */
- if (spawns_size == 0 || spawns == NULL) {
- spawns_size = 4;
- DNPRINTF(SWM_D_SPAWN, "setspawn: init list %d\n", spawns_size);
- spawns = malloc((size_t)spawns_size *
- sizeof(struct spawn_prog));
- if (spawns == NULL) {
- warn("setspawn: malloc failed");
- quit(NULL, NULL);
- }
- } else if (spawns_length == spawns_size) {
- spawns_size *= 2;
- DNPRINTF(SWM_D_SPAWN, "setspawn: grow list %d\n", spawns_size);
- spawns = realloc(spawns, (size_t)spawns_size *
- sizeof(struct spawn_prog));
- if (spawns == NULL) {
- warn("setspawn: realloc failed");
- quit(NULL, NULL);
+ TAILQ_FOREACH(sp, &spawns, entry) {
+ if (!strcmp(sp->name, name)) {
+ if (*args == '\0')
+ spawn_remove(sp);
+ else
+ spawn_replace(sp, name, args);
+ DNPRINTF(SWM_D_SPAWN, "setspawn: leave\n");
+ return;
}
}
-
- if (spawns_length < spawns_size) {
- DNPRINTF(SWM_D_SPAWN, "setspawn: add #%d %s\n",
- spawns_length, prog->name);
- i = spawns_length++;
- spawns[i] = *prog;
- } else {
- warnx("spawns array problem?");
- if (spawns == NULL) {
- warnx("spawns array is NULL!");
- quit(NULL, NULL);
- }
+ if (*args == '\0') {
+ warnx("error: setspawn: cannot find program: %s", name);
+ return;
}
- free(prog);
+
+ spawn_insert(name, args);
+ DNPRINTF(SWM_D_SPAWN, "setspawn: leave\n");
}
int
setconfspawn(char *selector, char *value, int flags)
{
- struct spawn_prog *prog;
- char *vp, *cp, *word;
-
DNPRINTF(SWM_D_SPAWN, "setconfspawn: [%s] [%s]\n", selector, value);
- if ((prog = calloc(1, sizeof *prog)) == NULL)
- err(1, "setconfspawn: calloc prog");
- prog->name = strdup(selector);
- if (prog->name == NULL)
- err(1, "setconfspawn prog->name");
- if ((cp = vp = strdup(value)) == NULL)
- err(1, "setconfspawn: strdup(value) ");
- while ((word = strsep(&cp, " \t")) != NULL) {
- DNPRINTF(SWM_D_SPAWN, "setconfspawn: arg [%s]\n", word);
- if (cp)
- cp += (long)strspn(cp, " \t");
- if (strlen(word) > 0) {
- prog->argc++;
- if ((prog->argv = realloc(prog->argv,
- prog->argc * sizeof(char *))) == NULL)
- err(1, "setconfspawn: realloc");
- if ((prog->argv[prog->argc - 1] = strdup(word)) == NULL)
- err(1, "setconfspawn: strdup");
- }
- }
- free(vp);
- setspawn(prog);
+ setspawn(selector, value);
DNPRINTF(SWM_D_SPAWN, "setconfspawn: done\n");
return (0);
enum keyfuncid kfid;
unsigned int mod;
KeySym ks;
- int i;
+ struct spawn_prog *sp;
DNPRINTF(SWM_D_KEY, "setconfbinding: enter\n");
if (selector == NULL) {
DNPRINTF(SWM_D_KEY, "setconfbinding: unbind %s\n", value);
}
}
/* search by custom spawn name */
- for (i = 0; i < spawns_length; i++) {
- if (strcasecmp(selector, spawns[i].name) == 0) {
+ TAILQ_FOREACH(sp, &spawns, entry) {
+ if (strcasecmp(selector, sp->name) == 0) {
DNPRINTF(SWM_D_KEY, "setconfbinding: %s: match\n",
selector);
if (parsekeys(value, mod_key, &mod, &ks) == 0) {
setkeybinding(mod, ks, kf_spawn_custom,
- spawns[i].name);
+ sp->name);
return (0);
} else
return (1);
setup_keys(void)
{
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, XK_h, kf_master_shrink,NULL);
setkeybinding(MODKEY, XK_l, kf_master_grow, NULL);
{
DNPRINTF(SWM_D_FOCUS, "focus_magic: window: 0x%lx\n", WINID(win));
- if (win == NULL)
+ if (win == NULL) {
+ /* if there are no windows clear the status-bar */
+ bar_check_opts();
return;
+ }
if (win->child_trans) {
/* win = parent & has a transient so focus on that */
if (win->child_trans->take_focus)
client_msg(win, takefocus);
} else {
- /* make sure transient hasn't dissapeared */
+ /* make sure transient hasn't disappeared */
if (validate_win(win->child_trans) == 0) {
focus_win(win->child_trans);
if (win->child_trans->take_focus)