#include <stdio.h>
#include <stdlib.h>
#include <err.h>
+#include <errno.h>
#include <locale.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <util.h>
#include <pwd.h>
+#include <ctype.h>
#include <sys/types.h>
+#include <sys/time.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/queue.h>
#include <sys/param.h>
+#include <sys/select.h>
#include <X11/cursorfont.h>
#include <X11/keysym.h>
/* dialog windows */
double dialog_ratio = .6;
/* status bar */
+#define SWM_BAR_MAX (128)
+sig_atomic_t bar_alarm = 0;
int bar_enabled = 1;
+int bar_verbose = 1;
int bar_height = 0;
GC bar_gc;
XGCValues bar_gcv;
XFontStruct *bar_fs;
-char bar_text[128];
char *bar_fonts[] = {
"-*-terminus-*-*-*-*-*-*-*-*-*-*-*-*",
"-*-times-medium-r-*-*-*-*-*-*-*-*-*-*",
/* layout handlers */
void stack(void);
-void vertical_init(struct workspace *);
-void vertical_resize(struct workspace *, int);
+void vertical_config(struct workspace *, int);
void vertical_stack(struct workspace *, struct swm_geometry *);
-void horizontal_init(struct workspace *);
-void horizontal_resize(struct workspace *, int);
+void horizontal_config(struct workspace *, int);
void horizontal_stack(struct workspace *, struct swm_geometry *);
-void max_init(struct workspace *);
void max_stack(struct workspace *, struct swm_geometry *);
struct layout {
- void (*l_init)(struct workspace *); /* init/reset */
void (*l_stack)(struct workspace *, struct swm_geometry *);
- void (*l_resize)(struct workspace *, int);
+ void (*l_config)(struct workspace *, int);
} layouts[] = {
- /* init stack, resize */
- { vertical_init, vertical_stack, vertical_resize},
- { horizontal_init, horizontal_stack, horizontal_resize},
- { NULL, max_stack, NULL},
- { NULL, NULL, NULL},
+ /* stack, configure */
+ { vertical_stack, vertical_config},
+ { horizontal_stack, horizontal_config},
+ { max_stack, NULL},
+ { NULL, NULL},
};
#define SWM_H_SLICE (32)
#define SWM_V_SLICE (32)
-
/* define work spaces */
struct workspace {
int idx; /* workspace index */
/* stacker state */
struct {
int horizontal_msize;
+ int horizontal_mwin;
int vertical_msize;
+ int vertical_mwin;
} l_state;
};
#define SWM_ARG_ID_SWAPMAIN (5)
#define SWM_ARG_ID_MASTERSHRINK (6)
#define SWM_ARG_ID_MASTERGROW (7)
+#define SWM_ARG_ID_MASTERADD (8)
+#define SWM_ARG_ID_MASTERDEL (9)
+#define SWM_ARG_ID_STACKRESET (10)
+#define SWM_ARG_ID_STACKINIT (11)
char **argv;
};
return (result);
}
+int
+varmatch(char *var, char *name, int *index)
+{
+ char *p, buf[5];
+ int i;
+
+ i = strncmp(var, name, 255);
+ if (index == NULL)
+ return (i);
+
+ *index = -1;
+ if (i <= 0)
+ return (i);
+ p = var + strlen(name);
+ if (*p++ != '[')
+ return (i);
+ bzero(buf, sizeof buf);
+ i = 0;
+ while (isdigit(*p) && i < sizeof buf)
+ buf[i++] = *p++;
+ if (i == 0 || i >= sizeof buf || *p != ']')
+ return (1);
+ *index = strtonum(buf, 0, 99, NULL);
+ return (0);
+}
+
/* conf file stuff */
#define SWM_CONF_WS "\n= \t"
#define SWM_CONF_FILE "scrotwm.conf"
FILE *config;
char *line, *cp, *var, *val;
size_t len, lineno = 0;
- int i;
+ int i, sc;
DNPRINTF(SWM_D_MISC, "conf_load: filename %s\n", filename);
if ((config = fopen(filename, "r")) == NULL)
return (1);
- for (;;) {
+ for (sc = ScreenCount(display);;) {
if ((line = fparseln(config, &len, &lineno, NULL, 0)) == NULL)
if (feof(config))
break;
case 'b':
if (!strncmp(var, "bar_enabled", strlen("bar_enabled")))
bar_enabled = atoi(val);
- else if (!strncmp(var, "bar_border",
- strlen("bar_border")))
- for (i = 0; i < ScreenCount(display); i++)
- screens[i].bar_border = name_to_color(val);
- else if (!strncmp(var, "bar_color",
- strlen("bar_color")))
- for (i = 0; i < ScreenCount(display); i++)
- screens[i].bar_color = name_to_color(val);
- else if (!strncmp(var, "bar_font_color",
- strlen("bar_font_color")))
- for (i = 0; i < ScreenCount(display); i++)
- screens[i].bar_font_color = name_to_color(val);
+ else if (!varmatch(var, "bar_border", &i))
+ if (i > 0 && i <= sc)
+ screens[i - 1].bar_border =
+ name_to_color(val);
+ else if (i == -1)
+ for (i = 0; i < sc; i++)
+ screens[i].bar_border =
+ name_to_color(val);
+ else
+ goto badidx;
+ else if (!varmatch(var, "bar_color", &i))
+ if (i > 0 && i <= sc)
+ screens[i - 1].bar_color =
+ name_to_color(val);
+ else if (i == -1)
+ for (i = 0; i < sc; i++)
+ screens[i].bar_color =
+ name_to_color(val);
+ else
+ goto badidx;
+ else if (!varmatch(var, "bar_font_color", &i))
+ if (i > 0 && i <= sc)
+ screens[i - 1].bar_font_color =
+ name_to_color(val);
+ else if (i == -1)
+ for (i = 0; i < sc; i++)
+ screens[i].bar_font_color =
+ name_to_color(val);
+ else
+ goto badidx;
+
else if (!strncmp(var, "bar_font", strlen("bar_font")))
asprintf(&bar_fonts[0], "%s", val);
else
break;
case 'c':
- if (!strncmp(var, "color_focus", strlen("color_focus")))
- for (i = 0; i < ScreenCount(display); i++)
- screens[i].color_focus = name_to_color(val);
- else if (!strncmp(var, "color_unfocus",
- strlen("color_unfocus")))
- for (i = 0; i < ScreenCount(display); i++)
- screens[i].color_unfocus = name_to_color(val);
+ if (!varmatch(var, "color_focus", &i))
+ if (i > 0 && i <= sc)
+ screens[i - 1].color_focus =
+ name_to_color(val);
+ else if (i == -1)
+ for (i = 0; i < sc; i++)
+ screens[i].color_focus =
+ name_to_color(val);
+ else
+ goto badidx;
+ else if (!varmatch(var, "color_unfocus", &i))
+ if (i > 0 && i <= sc)
+ screens[i - 1].color_unfocus =
+ name_to_color(val);
+ else if (i == -1)
+ for (i = 0; i < sc; i++)
+ screens[i].color_unfocus =
+ name_to_color(val);
+ else
+ goto badidx;
else
goto bad;
break;
return (0);
bad:
errx(1, "invalid conf file entry: %s=%s", var, val);
+badidx:
+ errx(1, "invalid screen index: %s out of bounds", var);
+}
+
+void
+bar_print(struct swm_region *r, char *s)
+{
+ XClearWindow(display, r->bar_window);
+ XSetForeground(display, bar_gc, r->s->bar_font_color);
+ XDrawString(display, r->bar_window, bar_gc, 4, bar_fs->ascent, s,
+ strlen(s));
}
void
-bar_print(struct swm_region *r)
+bar_update(void)
{
time_t tmt;
struct tm tm;
-
+ struct swm_region *r;
+ int i, x;
+ char s[SWM_BAR_MAX];
+ char e[SWM_BAR_MAX];
+
if (bar_enabled == 0)
return;
- /* clear old text */
- XSetForeground(display, bar_gc, r->s->bar_color);
- XDrawString(display, r->bar_window,
- bar_gc, 4, bar_fs->ascent, bar_text, strlen(bar_text));
-
- /* draw new text */
time(&tmt);
localtime_r(&tmt, &tm);
- strftime(bar_text, sizeof bar_text, "%a %b %d %R %Z %Y", &tm);
- XSetForeground(display, bar_gc, r->s->bar_font_color);
- XDrawString(display, r->bar_window, bar_gc, 4,
- bar_fs->ascent, bar_text, strlen(bar_text));
+ strftime(s, sizeof s, "%a %b %d %R %Z %Y", &tm);
+ for (i = 0; i < ScreenCount(display); i++) {
+ x = 1;
+ TAILQ_FOREACH(r, &screens[i].rl, entry) {
+ snprintf(e, sizeof e, "%s %d:%d",
+ s, x++, r->ws->idx + 1);
+ bar_print(r, e);
+ }
+ }
XSync(display, False);
-
alarm(60);
}
void
bar_signal(int sig)
{
- /* XXX yeah yeah byte me */
- if (cur_focus)
- bar_print(cur_focus->ws->r);
+ bar_alarm = 1;
}
void
bar_toggle(struct swm_region *r, union arg *args)
{
- struct swm_region *tmpr;
- int i, j;
+ struct swm_region *tmpr;
+ int i, j, sc = ScreenCount(display);
DNPRINTF(SWM_D_MISC, "bar_toggle\n");
if (bar_enabled) {
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < sc; i++)
TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
XUnmapWindow(display, tmpr->bar_window);
} else {
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < sc; i++)
TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
XMapRaised(display, tmpr->bar_window);
}
bar_enabled = !bar_enabled;
XSync(display, False);
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < sc; i++)
for (j = 0; j < SWM_WS_MAX; j++)
screens[i].ws[j].restack = 1;
stack();
/* must be after stack */
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < sc; i++)
TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
- bar_print(tmpr);
+ bar_update();
}
void
bar_height = bar_fs->ascent + bar_fs->descent + 3;
r->bar_window = XCreateSimpleWindow(display,
- r->s->root, X(r), Y(r), WIDTH(r), bar_height - 2,
+ r->s->root, X(r), Y(r), WIDTH(r) - 2, bar_height - 2,
1, r->s->bar_border, r->s->bar_color);
bar_gc = XCreateGC(display, r->bar_window, 0, &bar_gcv);
XSetFont(display, bar_gc, bar_fs->fid);
if (signal(SIGALRM, bar_signal) == SIG_ERR)
err(1, "could not install bar_signal");
- bar_print(r);
+ bar_update();
+}
+
+void
+bar_refresh(void)
+{
+ XSetWindowAttributes wa;
+ struct swm_region *r;
+ int i;
+
+ bzero(&wa, sizeof wa);
+ for (i = 0; i < ScreenCount(display); i++)
+ TAILQ_FOREACH(r, &screens[i].rl, entry) {
+ wa.border_pixel = screens[i].bar_border;
+ wa.background_pixel = screens[i].bar_color;
+ XChangeWindowAttributes(display, r->bar_window,
+ CWBackPixel | CWBorderPixel, &wa);
+ }
+ bar_update();
}
void
{
DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]);
+ /* disable alarm because the following code may not be interrupted */
+ alarm(0);
+ if (signal(SIGALRM, SIG_IGN) == SIG_ERR)
+ errx(1, "can't disable alarm");
+
XCloseDisplay(display);
execvp(start_argv[0], start_argv);
fprintf(stderr, "execvp failed\n");
return;
other_r = new_ws->r;
- fprintf(stderr, "switchws: other_r %p\n", other_r);
if (!other_r) {
/* if the other workspace is hidden, switch windows */
-
/* map new window first to prevent ugly blinking */
TAILQ_FOREACH(win, &new_ws->winlist, entry)
XMapRaised(display, win->id);
if (new_ws->focus)
focus_win(new_ws->focus);
stack();
+ bar_update();
}
void
}
void
-resize_master(struct swm_region *r, union arg *args)
+stack_config(struct swm_region *r, union arg *args)
{
struct workspace *ws = r->ws;
- DNPRINTF(SWM_D_STACK, "resize_master for workspace %d (id %d\n",
+ DNPRINTF(SWM_D_STACK, "stack_config for workspace %d (id %d\n",
args->id, ws->idx);
- if (ws->cur_layout->l_resize != NULL)
- ws->cur_layout->l_resize(ws, args->id);
-}
-
-void
-stack_reset(struct swm_region *r, union arg *args)
-{
- struct workspace *ws = r->ws;
-
- DNPRINTF(SWM_D_STACK, "stack_reset: ws %d\n", ws->idx);
+ if (ws->cur_layout->l_config != NULL)
+ ws->cur_layout->l_config(ws, args->id);
- if (ws->cur_layout->l_init != NULL) {
- ws->cur_layout->l_init(ws);
+ if (args->id != SWM_ARG_ID_STACKINIT);
stack();
- }
}
void
XConfigureWindow(display, win->id, mask, &wc);
}
-int vertical_msize[SWM_WS_MAX];
-
-void
-vertical_init(struct workspace *ws)
-{
- DNPRINTF(SWM_D_MISC, "vertical_init: workspace: %d\n", ws->idx);
-
- ws->l_state.vertical_msize = SWM_V_SLICE / 2;
-}
void
-vertical_resize(struct workspace *ws, int id)
+vertical_config(struct workspace *ws, int id)
{
DNPRINTF(SWM_D_STACK, "vertical_resize: workspace: %d\n", ws->idx);
switch (id) {
+ case SWM_ARG_ID_STACKRESET:
+ case SWM_ARG_ID_STACKINIT:
+ ws->l_state.vertical_msize = SWM_V_SLICE / 2;
+ ws->l_state.vertical_mwin = 1;
+ break;
case SWM_ARG_ID_MASTERSHRINK:
- ws->l_state.vertical_msize--;
- if (ws->l_state.vertical_msize < 1)
- ws->l_state.vertical_msize = 1;
+ if (ws->l_state.vertical_msize > 1)
+ ws->l_state.vertical_msize--;
break;
case SWM_ARG_ID_MASTERGROW:
- ws->l_state.vertical_msize++;
- if (ws->l_state.vertical_msize > SWM_V_SLICE - 1)
- ws->l_state.vertical_msize = SWM_V_SLICE - 1;
+ if (ws->l_state.vertical_msize < SWM_V_SLICE - 1)
+ ws->l_state.vertical_msize++;
+ break;
+ case SWM_ARG_ID_MASTERADD:
+ ws->l_state.vertical_mwin++;
+ break;
+ case SWM_ARG_ID_MASTERDEL:
+ if (ws->l_state.vertical_mwin > 0)
+ ws->l_state.vertical_mwin--;
break;
default:
return;
}
- stack();
}
void
XWindowChanges wc;
struct swm_geometry gg = *g;
struct ws_win *win, *winfocus;
- int i, hrh, winno, main_width;
+ int i, j, split, colno, hrh, winno, main_width;
unsigned int mask;
DNPRINTF(SWM_D_STACK, "vertical_stack: workspace: %d\n", ws->idx);
ws->focus = TAILQ_FIRST(&ws->winlist);
winfocus = cur_focus ? cur_focus : ws->focus;
- if (winno > 1) {
+ if (ws->l_state.vertical_mwin &&
+ winno > ws->l_state.vertical_mwin) {
+ split = ws->l_state.vertical_mwin;
+ colno = split;
main_width = (g->w / SWM_V_SLICE) *
ws->l_state.vertical_msize;
gg.w = main_width;
+ } else {
+ colno = winno;
+ split = 0;
}
+ hrh = g->h / colno;
+ gg.h = hrh - 2;
- if (winno > 2)
- hrh = g->h / (winno - 1);
- else
- hrh = 0;
-
- i = 0;
+ i = j = 0;
TAILQ_FOREACH(win, &ws->winlist, entry) {
- if (i == 1) {
+ if (split && i == split) {
+ colno = winno - split;
+ hrh = (g->h / colno);
gg.x += main_width + 2;
gg.w = g->w - (main_width + 2);
+ gg.h = hrh - 2;
+ j = 0;
}
- if (i != 0 && hrh != 0) {
- /* correct the last window for lost pixels */
- if (win == TAILQ_LAST(&ws->winlist, ws_win_list)) {
- gg.h = hrh + (g->h - (i * hrh));
- gg.y += hrh;
- } else {
- gg.h = hrh - 2;
- /* leave first right hand window at y = 0 */
- if (i > 1)
- gg.y += gg.h + 2;
- }
- }
+ if (j == colno - 1)
+ gg.h = (hrh + (g->h - (colno * hrh)));
+
+ if (j == 0)
+ gg.y = g->y;
+ else
+ gg.y += hrh;
+
if (win->transient != 0 || win->floating != 0)
stack_floater(win, ws->r);
XMapRaised(display, win->id);
i++;
+ j++;
}
if (winfocus)
void
-horizontal_init(struct workspace *ws)
-{
- DNPRINTF(SWM_D_STACK, "horizontal_init: workspace: %d\n", ws->idx);
-
- ws->l_state.horizontal_msize = SWM_H_SLICE / 2;
-}
-
-void
-horizontal_resize(struct workspace *ws, int id)
+horizontal_config(struct workspace *ws, int id)
{
- DNPRINTF(SWM_D_STACK, "horizontal_resize: workspace: %d\n", ws->idx);
+ DNPRINTF(SWM_D_STACK, "horizontal_config: workspace: %d\n", ws->idx);
switch (id) {
+ case SWM_ARG_ID_STACKRESET:
+ case SWM_ARG_ID_STACKINIT:
+ ws->l_state.horizontal_mwin = 1;
+ ws->l_state.horizontal_msize = SWM_H_SLICE / 2;
+ break;
case SWM_ARG_ID_MASTERSHRINK:
- ws->l_state.horizontal_msize--;
- if (ws->l_state.horizontal_msize < 1)
- ws->l_state.horizontal_msize = 1;
+ if (ws->l_state.horizontal_msize > 1)
+ ws->l_state.horizontal_msize--;
break;
case SWM_ARG_ID_MASTERGROW:
- ws->l_state.horizontal_msize++;
- if (ws->l_state.horizontal_msize > SWM_H_SLICE - 1)
- ws->l_state.horizontal_msize = SWM_H_SLICE - 1;
+ if (ws->l_state.horizontal_msize < SWM_H_SLICE - 1)
+ ws->l_state.horizontal_msize++;
+ break;
+ case SWM_ARG_ID_MASTERADD:
+ ws->l_state.horizontal_mwin++;
+ break;
+ case SWM_ARG_ID_MASTERDEL:
+ if (ws->l_state.horizontal_mwin > 0)
+ ws->l_state.horizontal_mwin--;
break;
default:
return;
}
- stack();
}
void
XWindowChanges wc;
struct swm_geometry gg = *g;
struct ws_win *win, *winfocus;
- int i, hrw, winno, main_height;
+ int i, j, split, rowno, hrw, winno, main_height;
unsigned int mask;
DNPRINTF(SWM_D_STACK, "horizontal_stack: workspace: %d\n", ws->idx);
ws->focus = TAILQ_FIRST(&ws->winlist);
winfocus = cur_focus ? cur_focus : ws->focus;
- if (winno > 1) {
- main_height = (g->h / SWM_H_SLICE) *
- ws->l_state.horizontal_msize;
+ if (ws->l_state.horizontal_mwin &&
+ winno > ws->l_state.horizontal_mwin) {
+ split = ws->l_state.horizontal_mwin;
+ rowno = split;
+ main_height = (g->h / SWM_V_SLICE) *
+ ws->l_state.horizontal_msize;
gg.h = main_height;
+ } else {
+ rowno = winno;
+ split = 0;
}
+ hrw = g->w / rowno;
+ gg.w = hrw - 2;
- if (winno > 2)
- hrw = g->w / (winno - 1);
- else
- hrw = 0;
-
- i = 0;
+ i = j = 0;
TAILQ_FOREACH(win, &ws->winlist, entry) {
- if (i == 1) {
+ if (split && i == split) {
+ rowno = winno - split;
+ hrw = (g->w / rowno);
gg.y += main_height + 2;
gg.h = g->h - (main_height + 2);
+ gg.w = hrw - 2;
+ j = 0;
}
- if (i != 0 && hrw != 0) {
- /* correct the last window for lost pixels */
- if (win == TAILQ_LAST(&ws->winlist, ws_win_list)) {
- gg.w = hrw + (g->w - (i * hrw));
- gg.x += hrw;
- } else {
- gg.w = hrw - 2;
- /* leave first bottom window at x = 0 */
- if (i > 1)
- gg.x += gg.w + 2;
- }
- }
+ if (j == rowno - 1)
+ gg.w = (hrw + (g->w - (rowno * hrw)));
+
+ if (j == 0)
+ gg.x = g->x;
+ else
+ gg.x += hrw;
if (win->transient != 0 || win->floating != 0)
stack_floater(win, ws->r);
}
XMapRaised(display, win->id);
+ j++;
i++;
}
} keys[] = {
/* modifier key function argument */
{ MODKEY, XK_space, cycle_layout, {0} },
- { MODKEY | ShiftMask, XK_space, stack_reset, {0} },
- { MODKEY, XK_h, resize_master, {.id = SWM_ARG_ID_MASTERSHRINK} },
- { MODKEY, XK_l, resize_master, {.id = SWM_ARG_ID_MASTERGROW} },
+ { MODKEY | ShiftMask, XK_space, stack_config, {.id = SWM_ARG_ID_STACKRESET} },
+ { MODKEY, XK_h, stack_config, {.id = SWM_ARG_ID_MASTERSHRINK} },
+ { MODKEY, XK_l, stack_config, {.id = SWM_ARG_ID_MASTERGROW} },
+ { MODKEY, XK_comma, stack_config, {.id = SWM_ARG_ID_MASTERADD} },
+ { MODKEY, XK_period, stack_config, {.id = SWM_ARG_ID_MASTERDEL} },
{ MODKEY, XK_Return, swapwin, {.id = SWM_ARG_ID_SWAPMAIN} },
{ MODKEY, XK_j, focus, {.id = SWM_ARG_ID_FOCUSNEXT} },
{ MODKEY, XK_k, focus, {.id = SWM_ARG_ID_FOCUSPREV} },
if (TAILQ_EMPTY(&screens[k].rl))
continue;
XUngrabKey(display, AnyKey, AnyModifier, screens[k].root);
- for(i = 0; i < LENGTH(keys); i++) {
- if((code = XKeysymToKeycode(display, keys[i].keysym)))
- for(j = 0; j < LENGTH(modifiers); j++)
+ for (i = 0; i < LENGTH(keys); i++) {
+ if ((code = XKeysymToKeycode(display, keys[i].keysym)))
+ for (j = 0; j < LENGTH(modifiers); j++)
XGrabKey(display, code,
keys[i].mod | modifiers[j],
screens[k].root, True,
set_win_state(win, WithdrawnState);
free(win);
}
-
stack();
}
DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window);
- if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) &&
+ if ((ev->mode != NotifyNormal || ev->detail == NotifyInferior) &&
ev->window != ev->root)
return;
if (ignore_enter) {
for (i = 0; i < ScreenCount(display); i++)
TAILQ_FOREACH(r, &screens[i].rl, entry)
if (e->xvisibility.window == r->bar_window)
- bar_print(r);
+ bar_update();
}
void (*handler[LASTEvent])(XEvent *) = {
TAILQ_INIT(&ws->winlist);
for (k = 0; layouts[k].l_stack != NULL; k++)
- if (layouts[k].l_init != NULL)
- layouts[k].l_init(ws);
+ if (layouts[k].l_config != NULL)
+ layouts[k].l_config(ws,
+ SWM_ARG_ID_STACKINIT);
ws->cur_layout = &layouts[0];
}
char conf[PATH_MAX], *cfile = NULL;
struct stat sb;
XEvent e;
+ int xfd;
+ fd_set rd;
start_argv = argv;
fprintf(stderr, "Welcome to scrotwm V%s\n", SWM_VERSION);
if (pwd == NULL)
errx(1, "invalid user %d", getuid());
+ setup_screens();
+
snprintf(conf, sizeof conf, "%s/.%s", pwd->pw_dir, SWM_CONF_FILE);
if (stat(conf, &sb) != -1) {
if (S_ISREG(sb.st_mode))
}
if (cfile)
conf_load(cfile);
-
- setup_screens();
+ bar_refresh();
/* ws[0].focus = TAILQ_FIRST(&ws[0].winlist); */
grabkeys();
stack();
+ xfd = ConnectionNumber(display);
while (running) {
- XNextEvent(display, &e);
- if (handler[e.type])
- handler[e.type](&e);
+ FD_SET(xfd, &rd);
+ if (select(xfd + 1, &rd, NULL, NULL, NULL) == -1)
+ if (errno != EINTR)
+ errx(1, "select failed");
+ if (bar_alarm) {
+ bar_alarm = 0;
+ bar_update();
+ }
+ while(XPending(display)) {
+ XNextEvent(display, &e);
+ if (handler[e.type])
+ handler[e.type](&e);
+ }
}
XCloseDisplay(display);
Got questions, comments, patches, etc.? Contact Jason Woofenden