xcb_timestamp_t last_event_time = 0;
int outputs = 0;
int other_wm;
-int ss_enabled = 0;
int xrandr_support;
int xrandr_eventbase;
unsigned int numlockmask = 0;
char *bar_argv[] = { NULL, NULL };
int bar_pipe[2];
char bar_ext[SWM_BAR_MAX];
+char bar_ext_buf[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 idx; /* workspace index */
char *name; /* workspace name */
int always_raise; /* raise windows on focus */
+ int bar_enabled; /* bar visibility */
struct layout *cur_layout; /* current layout handlers */
struct ws_win *focus; /* may be NULL */
struct ws_win *focus_prev; /* may be NULL */
#define SWM_ARG_ID_MOVEDOWN (101)
#define SWM_ARG_ID_MOVELEFT (102)
#define SWM_ARG_ID_MOVERIGHT (103)
+#define SWM_ARG_ID_BAR_TOGGLE (110)
+#define SWM_ARG_ID_BAR_TOGGLE_WS (111)
char **argv;
};
/* user/key callable function IDs */
enum keyfuncid {
KF_BAR_TOGGLE,
+ KF_BAR_TOGGLE_WS,
KF_BUTTON2,
KF_CYCLE_LAYOUT,
KF_FLIP_LAYOUT,
void bar_class_name(char *, size_t, struct swm_region *);
void bar_class_title_name(char *, size_t, struct swm_region *);
void bar_cleanup(struct swm_region *);
+void bar_extra_setup(void);
void bar_extra_stop(void);
+void bar_extra_update(void);
void bar_fmt(const char *, char *, struct swm_region *, size_t);
void bar_fmt_expand(char *, size_t);
-void bar_fmt_print(void);
+void bar_draw(void);
void bar_print(struct swm_region *, const char *);
void bar_print_legacy(struct swm_region *, const char *);
-void bar_refresh(void);
void bar_replace(char *, char *, struct swm_region *, size_t);
void bar_replace_pad(char *, int *, size_t);
char * bar_replace_seq(char *, char *, struct swm_region *, size_t *,
size_t);
void bar_setup(struct swm_region *);
-void bar_signal(int);
void bar_title_name(char *, size_t, struct swm_region *);
void bar_toggle(struct swm_region *, union arg *);
-void bar_update(void);
void bar_urgent(char *, size_t);
void bar_window_float(char *, size_t, struct swm_region *);
void bar_window_name(char *, size_t, struct swm_region *);
#endif
}
+/* Redraws the bar; need to follow with xcb_flush() or focus_flush(). */
void
-bar_fmt_print(void)
+bar_draw(void)
{
char fmtexp[SWM_BAR_MAX], fmtnew[SWM_BAR_MAX];
char fmtrep[SWM_BAR_MAX];
TAILQ_FOREACH(r, &screens[i].rl, entry) {
if (r->bar == NULL)
continue;
+
+ if (r->ws->bar_enabled)
+ xcb_map_window(conn, r->bar->id);
+ else {
+ xcb_unmap_window(conn, r->bar->id);
+ continue;
+ }
+
bar_fmt(fmtexp, fmtnew, r, sizeof fmtnew);
bar_replace(fmtnew, fmtrep, r, sizeof fmtrep);
if (bar_font_legacy)
}
}
+/* Reads external script output; call when stdin is readable. */
void
-bar_update(void)
+bar_extra_update(void)
{
- size_t len;
- char *b;
+ size_t len;
+ char b[SWM_BAR_MAX];
+ int redraw = 0;
- if (!bar_enabled)
- return;
- if (bar_extra && bar_extra_running) {
- /* ignore short reads; it'll correct itself */
- while ((b = fgetln(stdin, &len)) != NULL)
- if (b && b[len - 1] == '\n') {
- b[len - 1] = '\0';
- strlcpy(bar_ext, b, sizeof bar_ext);
+ if (bar_enabled && bar_extra && bar_extra_running) {
+ while (fgets(b, sizeof(b), stdin) != NULL) {
+ len = strlen(b);
+ if (b[len - 1] == '\n') {
+ /* Remove newline. */
+ b[--len] = '\0';
+
+ /* "Clear" bar_ext. */
+ bar_ext[0] = '\0';
+
+ /* Flush buffered output. */
+ strlcpy(bar_ext, bar_ext_buf, sizeof(bar_ext));
+ bar_ext_buf[0] = '\0';
+
+ /* Append new output to bar. */
+ strlcat(bar_ext, b, sizeof(bar_ext));
+
+ redraw = 1;
+ } else {
+ /* Buffer output. */
+ strlcat(bar_ext_buf, b, sizeof(bar_ext_buf));
}
- if (b == NULL && errno != EAGAIN) {
- warn("bar_update: bar_extra failed");
+ }
+
+ if (errno != EAGAIN) {
+ warn("bar_action failed");
bar_extra_stop();
}
- } else
- strlcpy(bar_ext, "", sizeof bar_ext);
+ } else {
+ /*
+ * Attempt to drain stdin, so it doesn't cause the main loop to
+ * call us as fast as it can.
+ */
+ while (fgets(b, sizeof(b), stdin) != NULL);
- bar_fmt_print();
- alarm(bar_delay);
-}
+ if (!bar_enabled)
+ return;
-void
-bar_signal(int sig)
-{
- /* suppress unused warning since var is needed */
- (void)sig;
+ /* Clear bar script output if bar script is not running. */
+ if (bar_ext[0] != '\0') {
+ bar_ext[0] = '\0';
+ redraw = 1;
+ }
+ }
- bar_alarm = 1;
+ if (redraw) {
+ bar_draw();
+ xcb_flush(conn);
+ }
}
void
DNPRINTF(SWM_D_BAR, "bar_toggle\n");
- num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
- if (bar_enabled) {
- for (i = 0; i < num_screens; i++)
- TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
- if (tmpr->bar)
- xcb_unmap_window(conn, tmpr->bar->id);
- } else {
- for (i = 0; i < num_screens; i++)
- TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
- if (tmpr->bar)
- xcb_map_window(conn, tmpr->bar->id);
+ switch (args->id) {
+ case SWM_ARG_ID_BAR_TOGGLE_WS:
+ /* Only change if master switch is enabled. */
+ if (bar_enabled)
+ r->ws->bar_enabled = !r->ws->bar_enabled;
+ else
+ bar_enabled = r->ws->bar_enabled = 1;
+ break;
+ case SWM_ARG_ID_BAR_TOGGLE:
+ bar_enabled = !bar_enabled;
+ break;
}
- bar_enabled = !bar_enabled;
+ /* update bars as necessary */
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
+ TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
+ if (tmpr->bar) {
+ if (bar_enabled && tmpr->ws->bar_enabled)
+ xcb_map_window(conn, tmpr->bar->id);
+ else
+ xcb_unmap_window(conn, tmpr->bar->id);
+ }
stack();
/* must be after stack */
- bar_update();
+ bar_draw();
focus_flush();
}
void
-bar_refresh(void)
+bar_extra_setup(void)
{
struct swm_region *r;
uint32_t wa[2];
err(1, "pipe error");
socket_setnonblock(bar_pipe[0]);
socket_setnonblock(bar_pipe[1]); /* XXX hmmm, really? */
+
+ /* Set stdin to read from the pipe. */
if (dup2(bar_pipe[0], 0) == -1)
err(1, "dup2");
+
+ /* Set stdout to write to the pipe. */
if (dup2(bar_pipe[1], 1) == -1)
err(1, "dup2");
+
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
err(1, "could not disable SIGPIPE");
switch (bar_pid = fork()) {
xcb_change_window_attributes(conn, r->bar->id,
XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa);
}
- bar_update();
+
+ bar_draw();
+ xcb_flush(conn);
}
int
"%d x %d\n", WINID(r->bar), X(r->bar), Y(r->bar), WIDTH(r->bar),
HEIGHT(r->bar));
- if (signal(SIGALRM, bar_signal) == SIG_ERR)
- err(1, "could not install bar_signal");
- bar_refresh();
+ bar_extra_setup();
}
void
"Version: %s Build: %s", SPECTRWM_VERSION, buildstr);
else
strlcpy(bar_vertext, "", sizeof bar_vertext);
- bar_update();
+ bar_draw();
xcb_flush(conn);
}
kill_refs(win->ws->focus);
win->ws->focus = NULL;
}
+
if (validate_win(win->ws->focus_prev)) {
kill_refs(win->ws->focus_prev);
win->ws->focus_prev = NULL;
}
out:
- bar_update();
+ bar_draw();
DNPRINTF(SWM_D_FOCUS, "focus_win: done.\n");
}
/* Clear bar if new ws is empty. */
if (new_ws->focus_pending == NULL)
- bar_update();
+ bar_draw();
focus_flush();
rr->s[i].root, XCB_CURRENT_TIME);
/* Clear bar since empty. */
- bar_update();
+ bar_draw();
}
focus_flush();
ws->cur_layout = &layouts[0];
stack();
- bar_update();
+ bar_draw();
focus_win(get_region_focus(r));
if (args->id != SWM_ARG_ID_STACKINIT)
stack();
- bar_update();
+ bar_draw();
focus_flush();
}
g = r->g;
g.w -= 2 * border_width;
g.h -= 2 * border_width;
- if (bar_enabled) {
+ if (bar_enabled && r->ws->bar_enabled) {
if (!bar_at_bottom)
g.y += bar_height;
g.h -= bar_height;
else
win_g.y += last_h + 2 * border_width;
- if (disable_border && !bar_enabled && winno == 1){
+ if (disable_border && !(bar_enabled && ws->bar_enabled) &&
+ winno == 1){
bordered = 0;
win_g.w += 2 * border_width;
win_g.h += 2 * border_width;
if (X(w) != gg.x || Y(w) != gg.y || WIDTH(w) != gg.w ||
HEIGHT(w) != gg.h) {
w->g = gg;
- if (bar_enabled){
+ if (bar_enabled && ws->bar_enabled){
w->bordered = 1;
} else {
w->bordered = 0;
}
/* Unmap unwanted windows if not multi-screen. */
- if (!(num_screens > 1 || outputs > 1) && (w != win ||
- w != parent || w->transient != win->id))
+ if (num_screens <= 1 && outputs <= 1 && w != win &&
+ w != parent && w->transient != win->id)
unmap_window(w);
}
union arg args;
} keyfuncs[KF_INVALID + 1] = {
/* name function argument */
- { "bar_toggle", bar_toggle, {0} },
+ { "bar_toggle", bar_toggle, {.id = SWM_ARG_ID_BAR_TOGGLE} },
+ { "bar_toggle_ws", bar_toggle, {.id = SWM_ARG_ID_BAR_TOGGLE_WS} },
{ "button2", pressbutton, {2} },
{ "cycle_layout", cycle_layout, {0} },
{ "flip_layout", stack_config, {.id = SWM_ARG_ID_FLIPLAYOUT} },
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_SHIFT, XK_b, KF_BAR_TOGGLE_WS,NULL);
setkeybinding(MODKEY, XK_Tab, KF_FOCUS_NEXT, NULL);
setkeybinding(MODKEY_SHIFT, XK_Tab, KF_FOCUS_PREV, NULL);
setkeybinding(MODKEY_SHIFT, XK_x, KF_WIND_KILL, NULL);
{
struct key *kp;
int num_screens, k, j;
- unsigned int modifiers[3];
+ unsigned int modifiers[4];
xcb_keycode_t *code;
DNPRINTF(SWM_D_MISC, "grabkeys\n");
modifiers[0] = 0;
modifiers[1] = numlockmask;
- modifiers[2] = numlockmask | XCB_MOD_MASK_LOCK;
+ modifiers[2] = XCB_MOD_MASK_LOCK;
+ modifiers[3] = numlockmask | XCB_MOD_MASK_LOCK;
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
for (k = 0; k < num_screens; k++) {
void
grabbuttons(struct ws_win *win)
{
- int i;
+ unsigned int modifiers[4];
+ int i, j;
DNPRINTF(SWM_D_MOUSE, "grabbuttons: win 0x%x\n", win->id);
+ updatenumlockmask();
+
+ modifiers[0] = 0;
+ modifiers[1] = numlockmask;
+ modifiers[2] = XCB_MOD_MASK_LOCK;
+ modifiers[3] = numlockmask | XCB_MOD_MASK_LOCK;
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);
+ for (j = 0; j < LENGTH(modifiers); ++j)
+ 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 |
+ modifiers[j]);
}
const char *quirkname[] = {
SWM_S_BAR_BORDER_WIDTH,
SWM_S_BAR_DELAY,
SWM_S_BAR_ENABLED,
+ SWM_S_BAR_ENABLED_WS,
SWM_S_BAR_FONT,
SWM_S_BAR_FORMAT,
SWM_S_BAR_JUSTIFY,
int
setconfvalue(char *selector, char *value, int flags)
{
- int i;
- char *b;
+ struct workspace *ws;
+ int i, ws_id, num_screens;
+ char *b;
/* suppress unused warning since var is needed */
(void)selector;
bar_border_width = 0;
break;
case SWM_S_BAR_DELAY:
- bar_delay = atoi(value);
+ /* No longer needed; leave to not break old conf files. */
break;
case SWM_S_BAR_ENABLED:
bar_enabled = atoi(value);
break;
+ case SWM_S_BAR_ENABLED_WS:
+ ws_id = atoi(selector) - 1;
+ if (ws_id < 0 || ws_id >= workspace_limit)
+ errx(1, "setconfvalue: bar_enabled_ws: invalid "
+ "workspace %d.", ws_id + 1);
+
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++) {
+ ws = (struct workspace *)&screens[i].ws;
+ ws[ws_id].bar_enabled = atoi(value);
+ }
+ break;
case SWM_S_BAR_FONT:
b = bar_fonts;
if (asprintf(&bar_fonts, "%s,%s", value, bar_fonts) == -1)
setconfspawn("spawn_term", value, 0);
break;
case SWM_S_SS_APP:
+ /* No longer needed; leave to not break old conf files. */
break;
case SWM_S_SS_ENABLED:
- ss_enabled = atoi(value);
+ /* No longer needed; leave to not break old conf files. */
break;
case SWM_S_STACK_ENABLED:
stack_enabled = atoi(value);
};
struct config_option configopt[] = {
{ "bar_enabled", setconfvalue, SWM_S_BAR_ENABLED },
+ { "bar_enabled_ws", setconfvalue, SWM_S_BAR_ENABLED_WS },
{ "bar_at_bottom", setconfvalue, SWM_S_BAR_AT_BOTTOM },
{ "bar_border", setconfcolor, SWM_S_COLOR_BAR_BORDER },
{ "bar_border_width", setconfvalue, SWM_S_BAR_BORDER_WIDTH },
for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry)
if (e->window == WINID(r->bar))
- bar_update();
+ bar_draw();
xcb_flush(conn);
}
XCB_INPUT_FOCUS_PARENT, e->root, e->time);
/* Clear bar since empty. */
- bar_update();
+ bar_draw();
handled = 1;
goto out;
}
if (win == NULL)
- return;
+ goto out;
last_event_time = e->time;
XCB_INPUT_FOCUS_PARENT, e->root, e->time);
/* Clear bar since empty. */
- bar_update();
+ bar_draw();
focus_flush();
}
}
} else if (e->atom == XCB_ATOM_WM_CLASS ||
e->atom == XCB_ATOM_WM_NAME) {
- bar_update();
+ bar_draw();
}
xcb_flush(conn);
ws = &screens[i].ws[j];
ws->idx = j;
ws->name = NULL;
+ ws->bar_enabled = 1;
ws->focus = NULL;
ws->focus_prev = NULL;
ws->focus_pending = NULL;
xcb_generic_event_t *evt;
struct timeval tv;
fd_set rd;
+ int rd_max;
+ int stdin_ready = 0;
+ int num_readable;
/* suppress unused warning since var is needed */
(void)argc;
xcb_ungrab_server(conn);
xcb_flush(conn);
+ rd_max = xfd > STDIN_FILENO ? xfd : STDIN_FILENO;
+
while (running) {
while ((evt = xcb_poll_for_event(conn))) {
if (!running)
}
FD_ZERO(&rd);
+ FD_SET(STDIN_FILENO, &rd);
FD_SET(xfd, &rd);
tv.tv_sec = 1;
tv.tv_usec = 0;
- if (select(xfd + 1, &rd, NULL, NULL, &tv) == -1)
- if (errno != EINTR) {
- DNPRINTF(SWM_D_MISC, "select failed");
- }
+ num_readable = select(rd_max + 1, &rd, NULL, NULL, &tv);
+ if (num_readable == -1 && errno != EINTR) {
+ DNPRINTF(SWM_D_MISC, "select failed");
+ } else if (num_readable > 0 && FD_ISSET(STDIN_FILENO, &rd)) {
+ stdin_ready = 1;
+ }
+
if (restart_wm)
restart(NULL, NULL);
+
if (search_resp)
search_do_resp();
+
if (!running)
goto done;
- if (bar_alarm) {
- bar_alarm = 0;
- bar_update();
+
+ if (stdin_ready) {
+ stdin_ready = 0;
+ bar_extra_update();
}
}
done:
Got questions, comments, patches, etc.? Contact Jason Woofenden