X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=92145c4facb165fb449364fa211b718779c9881a;hb=4a043e85195b7337a6087d38d0c6c5c6817f187f;hp=02b3baeaf1a40d501dfcd734adbcaef024a2db85;hpb=3b7ccf394f6e224677b807701f99e1cdb5f10a19;p=spectrwm.git diff --git a/scrotwm.c b/scrotwm.c index 02b3bae..92145c4 100644 --- a/scrotwm.c +++ b/scrotwm.c @@ -1,9 +1,11 @@ -/* $scrotwm$ */ /* - * Copyright (c) 2009-2010 Marco Peereboom - * Copyright (c) 2009 Ryan McBride + * Copyright (c) 2009-2012 Marco Peereboom + * Copyright (c) 2009-2011 Ryan McBride * Copyright (c) 2009 Darrin Chandler * Copyright (c) 2009 Pierre-Yves Ritschard + * Copyright (c) 2010 Tuukka Kataja + * Copyright (c) 2011 Jason L. Wright + * Copyright (c) 2011-2012 Reginald Kennedy * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -50,10 +52,6 @@ * DEALINGS IN THE SOFTWARE. */ -static const char *cvstag = "$scrotwm$"; - -#define SWM_VERSION "0.9.27" - #include #include #include @@ -84,11 +82,20 @@ static const char *cvstag = "$scrotwm$"; #include #include #include +#include #ifdef __OSX__ #include #endif +#include "version.h" + +#ifdef SCROTWM_BUILDSTR +static const char *buildstr = SCROTWM_BUILDSTR; +#else +static const char *buildstr = SCROTWM_VERSION; +#endif + #if RANDR_MAJOR < 1 # error XRandR versions less than 1.0 are not supported #endif @@ -99,7 +106,7 @@ static const char *cvstag = "$scrotwm$"; #endif #endif -/* #define SWM_DEBUG */ +/*#define SWM_DEBUG*/ #ifdef SWM_DEBUG #define DPRINTF(x...) do { if (swm_debug) fprintf(stderr, x); } while (0) #define DNPRINTF(n,x...) do { if (swm_debug & n) fprintf(stderr, x); } while (0) @@ -159,6 +166,9 @@ u_int32_t swm_debug = 0 #define SWM_FOCUS_SYNERGY (1) #define SWM_FOCUS_FOLLOW (2) +#define SWM_CONF_DEFAULT (0) +#define SWM_CONF_KEYMAPPING (1) + #ifndef SWM_LIB #define SWM_LIB "/usr/local/lib/libswmhack.so" #endif @@ -168,6 +178,11 @@ Atom astate; Atom aprot; Atom adelete; Atom takefocus; +Atom a_wmname; +Atom a_netwmname; +Atom a_utf8_string; +Atom a_string; +Atom a_swm_iconic; volatile sig_atomic_t running = 1; volatile sig_atomic_t restart_wm = 0; int outputs = 0; @@ -186,10 +201,41 @@ int term_width = 0; int font_adjusted = 0; unsigned int mod_key = MODKEY; +/* dmenu search */ +struct swm_region *search_r; +int select_list_pipe[2]; +int select_resp_pipe[2]; +pid_t searchpid; +volatile sig_atomic_t search_resp; +int search_resp_action; + +struct search_window { + TAILQ_ENTRY(search_window) entry; + int idx; + struct ws_win *win; + Window indicator; +}; +TAILQ_HEAD(search_winlist, search_window); + +struct search_winlist search_wl; + +/* search actions */ +enum { + SWM_SEARCH_NONE, + SWM_SEARCH_UNICONIFY, + SWM_SEARCH_NAME_WORKSPACE, + SWM_SEARCH_SEARCH_WORKSPACE, + SWM_SEARCH_SEARCH_WINDOW +}; + /* dialog windows */ double dialog_ratio = .6; /* status bar */ -#define SWM_BAR_MAX (256) +#define SWM_BAR_MAX (256) +#define SWM_BAR_JUSTIFY_LEFT (0) +#define SWM_BAR_JUSTIFY_CENTER (1) +#define SWM_BAR_JUSTIFY_RIGHT (2) +#define SWM_BAR_OFFSET (4) char *bar_argv[] = { NULL, NULL }; int bar_pipe[2]; char bar_ext[SWM_BAR_MAX]; @@ -198,19 +244,24 @@ 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 bar_extra = 1; int bar_extra_running = 0; int bar_verbose = 1; int bar_height = 0; +int bar_justify = SWM_BAR_JUSTIFY_LEFT; int stack_enabled = 1; int clock_enabled = 1; +int urgent_enabled = 0; char *clock_format = NULL; int title_name_enabled = 0; int title_class_enabled = 0; int window_name_enabled = 0; int focus_mode = SWM_FOCUS_DEFAULT; int disable_border = 0; +int border_width = 1; +int verbose_layout = 0; pid_t bar_pid; GC bar_gc; XGCValues bar_gcv; @@ -218,6 +269,7 @@ int bar_fidx = 0; XFontStruct *bar_fs; char *bar_fonts[] = { NULL, NULL, NULL, NULL };/* XXX Make fully dynamic */ char *spawn_term[] = { NULL, NULL }; /* XXX Make fully dynamic */ +struct passwd *pwd; #define SWM_MENU_FN (2) #define SWM_MENU_NB (4) @@ -259,6 +311,7 @@ struct ws_win { int floatmaxed; /* flag: floater was maxed in max_stack */ int floating; int manual; + int iconic; unsigned int ewmh_flags; int font_size_boundary[SWM_MAX_FONT_STEPS]; int font_steps; @@ -272,9 +325,19 @@ struct ws_win { XWindowAttributes wa; XSizeHints sh; XClassHint ch; + XWMHints *hints; }; TAILQ_HEAD(ws_win_list, ws_win); +/* pid goo */ +struct pid_e { + TAILQ_ENTRY(pid_e) entry; + long pid; + int ws; +}; +TAILQ_HEAD(pid_list, pid_e); +struct pid_list pidlist = TAILQ_HEAD_INITIALIZER(pidlist); + /* layout handlers */ void stack(void); void vertical_config(struct workspace *, int); @@ -282,6 +345,8 @@ void vertical_stack(struct workspace *, struct swm_geometry *); void horizontal_config(struct workspace *, int); void horizontal_stack(struct workspace *, struct swm_geometry *); void max_stack(struct workspace *, struct swm_geometry *); +void plain_stacker(struct workspace *); +void fancy_stacker(struct workspace *); struct ws_win *find_window(Window); @@ -290,24 +355,28 @@ void new_region(struct swm_screen *, int, int, int, int); void unmanage_window(struct ws_win *); long getstate(Window); +int conf_load(char *, int); + struct layout { void (*l_stack)(struct workspace *, struct swm_geometry *); void (*l_config)(struct workspace *, int); u_int32_t flags; #define SWM_L_FOCUSPREV (1<<0) #define SWM_L_MAPONFOCUS (1<<1) - char *name; + void (*l_string)(struct workspace *); } layouts[] = { /* stack, configure */ - { vertical_stack, vertical_config, 0, "[|]" }, - { horizontal_stack, horizontal_config, 0, "[-]" }, + { vertical_stack, vertical_config, 0, plain_stacker }, + { horizontal_stack, horizontal_config, 0, plain_stacker }, { max_stack, NULL, - SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV, "[ ]"}, - { NULL, NULL, 0, NULL }, + SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV, plain_stacker }, + { NULL, NULL, 0, NULL }, }; -/* position of max_stack mode in the layouts array */ -#define SWM_MAX_STACK 2 +/* position of max_stack mode in the layouts array, index into layouts! */ +#define SWM_V_STACK (0) +#define SWM_H_STACK (1) +#define SWM_MAX_STACK (2) #define SWM_H_SLICE (32) #define SWM_V_SLICE (32) @@ -315,6 +384,8 @@ struct layout { /* define work spaces */ struct workspace { int idx; /* workspace index */ + char *name; /* workspace name */ + int always_raise; /* raise windows on focus */ struct layout *cur_layout; /* current layout handlers */ struct ws_win *focus; /* may be NULL */ struct ws_win *focus_prev; /* may be NULL */ @@ -322,6 +393,7 @@ struct workspace { struct swm_region *old_r; /* may be NULL */ struct ws_win_list winlist; /* list of windows in ws */ struct ws_win_list unmanagedlist; /* list of dead windows in ws */ + char stacker[10]; /* display stacker and layout */ /* stacker state */ struct { @@ -376,6 +448,8 @@ union arg { #define SWM_ARG_ID_CYCLEWS_DOWN (41) #define SWM_ARG_ID_CYCLESC_UP (42) #define SWM_ARG_ID_CYCLESC_DOWN (43) +#define SWM_ARG_ID_CYCLEWS_UP_ALL (44) +#define SWM_ARG_ID_CYCLEWS_DOWN_ALL (45) #define SWM_ARG_ID_STACKINC (50) #define SWM_ARG_ID_STACKDEC (51) #define SWM_ARG_ID_SS_ALL (60) @@ -384,13 +458,20 @@ union arg { #define SWM_ARG_ID_CENTER (71) #define SWM_ARG_ID_KILLWINDOW (80) #define SWM_ARG_ID_DELETEWINDOW (81) +#define SWM_ARG_ID_WIDTHGROW (90) +#define SWM_ARG_ID_WIDTHSHRINK (91) +#define SWM_ARG_ID_HEIGHTGROW (92) +#define SWM_ARG_ID_HEIGHTSHRINK (93) +#define SWM_ARG_ID_MOVEUP (100) +#define SWM_ARG_ID_MOVEDOWN (101) +#define SWM_ARG_ID_MOVELEFT (102) +#define SWM_ARG_ID_MOVERIGHT (103) char **argv; }; void focus(struct swm_region *, union arg *); -void focus_magic(struct ws_win *, int); -#define SWM_F_GENERIC (0) -#define SWM_F_TRANSIENT (1) +void focus_magic(struct ws_win *); + /* quirks */ struct quirk { char *class; @@ -401,6 +482,7 @@ struct quirk { #define SWM_Q_ANYWHERE (1<<2) /* don't position this window */ #define SWM_Q_XTERM_FONTADJ (1<<3) /* adjust xterm fonts when resizing */ #define SWM_Q_FULLSCREEN (1<<4) /* remove border */ +#define SWM_Q_FOCUSPREV (1<<5) /* focus on caller */ }; int quirks_size = 0, quirks_length = 0; struct quirk *quirks = NULL; @@ -454,6 +536,7 @@ struct ewmh_hint { void store_float_geom(struct ws_win *win, struct swm_region *r); int floating_toggle_win(struct ws_win *win); +void spawn_select(struct swm_region *, union arg *, char *, int *); int get_property(Window id, Atom atom, long count, Atom type, @@ -477,6 +560,52 @@ get_property(Window id, Atom atom, long count, Atom type, } void +update_iconic(struct ws_win *win, int newv) +{ + int32_t v = newv; + Atom iprop; + + win->iconic = newv; + + iprop = XInternAtom(display, "_SWM_ICONIC", False); + if (!iprop) + return; + if (newv) + XChangeProperty(display, win->id, iprop, XA_INTEGER, 32, + PropModeReplace, (unsigned char *)&v, 1); + else + XDeleteProperty(display, win->id, iprop); +} + +int +get_iconic(struct ws_win *win) +{ + int32_t v = 0; + int retfmt, status; + Atom iprop, rettype; + unsigned long nitems, extra; + unsigned char *prop = NULL; + + iprop = XInternAtom(display, "_SWM_ICONIC", False); + if (!iprop) + goto out; + status = XGetWindowProperty(display, win->id, iprop, 0L, 1L, + False, XA_INTEGER, &rettype, &retfmt, &nitems, &extra, &prop); + if (status != Success) + goto out; + if (rettype != XA_INTEGER || retfmt != 32) + goto out; + if (nitems != 1) + goto out; + v = *((int32_t *)prop); + +out: + if (prop != NULL) + XFree(prop); + return (v); +} + +void setup_ewmh(void) { int i,j; @@ -493,7 +622,8 @@ setup_ewmh(void) /* Report supported atoms */ XDeleteProperty(display, screens[i].root, sup_list); for (j = 0; j < LENGTH(ewmh); j++) - XChangeProperty(display, screens[i].root, sup_list, XA_ATOM, 32, + XChangeProperty(display, screens[i].root, + sup_list, XA_ATOM, 32, PropModeAppend, (unsigned char *)&ewmh[j].atom,1); } } @@ -530,12 +660,11 @@ void ewmh_autoquirk(struct ws_win *win) { int success, i; - unsigned long *data = NULL; - unsigned long n; + unsigned long *data = NULL, n; Atom type; success = get_property(win->id, ewmh[_NET_WM_WINDOW_TYPE].atom, (~0L), - XA_ATOM, &n, (unsigned char **)&data); + XA_ATOM, &n, (void *)&data); if (!success) { XFree(data); @@ -595,7 +724,7 @@ ewmh_set_win_fullscreen(struct ws_win *win, int fs) win->g.y = rg.y; win->g.w = rg.w; win->g.h = rg.h; - } else { + } else { if (win->g_floatvalid) { /* refloat at last floating relative position */ win->g.x = win->g_float.x - win->rg_float.x + rg.x; @@ -679,7 +808,8 @@ ewmh_update_win_state(struct ws_win *win, long state, long action) win->manual = (win->ewmh_flags & SWM_F_MANUAL) != 0; if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom) if (changed) - if (!ewmh_set_win_fullscreen(win, win->ewmh_flags & EWMH_F_FULLSCREEN)) + if (!ewmh_set_win_fullscreen(win, + win->ewmh_flags & EWMH_F_FULLSCREEN)) win->ewmh_flags = orig_flags; /* revert */ XDeleteProperty(display, win->id, ewmh[_NET_WM_STATE].atom); @@ -722,8 +852,8 @@ ewmh_get_win_state(struct ws_win *win) if (win->manual) win->ewmh_flags |= SWM_F_MANUAL; - success = get_property(win->id, ewmh[_NET_WM_STATE].atom, (~0L), XA_ATOM, - &n, (unsigned char **)&states); + success = get_property(win->id, ewmh[_NET_WM_STATE].atom, + (~0L), XA_ATOM, &n, (void *)&states); if (!success) return; @@ -872,8 +1002,9 @@ dumpwins(struct swm_region *r, union arg *args) if (!XGetWindowAttributes(display, win->id, &wa)) fprintf(stderr, "window: %lu failed " "XGetWindowAttributes\n", win->id); - fprintf(stderr, "window: %lu map_state: %d state: %d\n", - win->id, wa.map_state, state); + fprintf(stderr, "window: %lu map_state: %d state: %d " + "transient: %lu\n", + win->id, wa.map_state, state, win->transient); } fprintf(stderr, "===== unmanaged window list =====\n"); @@ -882,8 +1013,9 @@ dumpwins(struct swm_region *r, union arg *args) if (!XGetWindowAttributes(display, win->id, &wa)) fprintf(stderr, "window: %lu failed " "XGetWindowAttributes\n", win->id); - fprintf(stderr, "window: %lu map_state: %d state: %d\n", - win->id, wa.map_state, state); + fprintf(stderr, "window: %lu map_state: %d state: %d " + "transient: %lu\n", + win->id, wa.map_state, state, win->transient); } fprintf(stderr, "=================================\n"); @@ -951,6 +1083,8 @@ sighdlr(int sig) #endif /* SWM_DEBUG */ break; } + if (pid == searchpid) + search_resp = 1; #ifdef SWM_DEBUG if (WIFEXITED(status)) { @@ -977,6 +1111,24 @@ sighdlr(int sig) errno = saved_errno; } +struct pid_e * +find_pid(long pid) +{ + struct pid_e *p = NULL; + + DNPRINTF(SWM_D_MISC, "find_pid: %lu\n", pid); + + if (pid == 0) + return (NULL); + + TAILQ_FOREACH(p, &pidlist, entry) { + if (p->pid == pid) + return (p); + } + + return (NULL); +} + unsigned long name_to_color(char *colorname) { @@ -1009,40 +1161,63 @@ setscreencolor(char *val, int i, int c) screens[i - 1].c[c].color = name_to_color(val); free(screens[i - 1].c[c].name); if ((screens[i - 1].c[c].name = strdup(val)) == NULL) - errx(1, "strdup"); + err(1, "strdup"); } else if (i == -1) { for (i = 0; i < ScreenCount(display); i++) { screens[i].c[c].color = name_to_color(val); free(screens[i].c[c].name); if ((screens[i].c[c].name = strdup(val)) == NULL) - errx(1, "strdup"); + err(1, "strdup"); } } else - errx(1, "invalid screen index: %d out of bounds (maximum %d)\n", + errx(1, "invalid screen index: %d out of bounds (maximum %d)", i, ScreenCount(display)); } void +fancy_stacker(struct workspace *ws) +{ + strlcpy(ws->stacker, "[ ]", sizeof ws->stacker); + if (ws->cur_layout->l_stack == vertical_stack) + snprintf(ws->stacker, sizeof ws->stacker, "[%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]", + ws->l_state.horizontal_mwin, ws->l_state.horizontal_stacks); +} + +void +plain_stacker(struct workspace *ws) +{ + strlcpy(ws->stacker, "[ ]", sizeof ws->stacker); + if (ws->cur_layout->l_stack == vertical_stack) + strlcpy(ws->stacker, "[|]", sizeof ws->stacker); + if (ws->cur_layout->l_stack == horizontal_stack) + strlcpy(ws->stacker, "[-]", sizeof ws->stacker); +} + +void custom_region(char *val) { unsigned int sidx, x, y, w, h; if (sscanf(val, "screen[%u]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5) errx(1, "invalid custom region, " - "should be 'screen[]:x++\n"); + "should be 'screen[]:x++"); if (sidx < 1 || sidx > ScreenCount(display)) - errx(1, "invalid screen index: %d out of bounds (maximum %d)\n", + errx(1, "invalid screen index: %d out of bounds (maximum %d)", sidx, ScreenCount(display)); sidx--; if (w < 1 || h < 1) - errx(1, "region %ux%u+%u+%u too small\n", w, h, x, y); + errx(1, "region %ux%u+%u+%u too small", w, h, x, y); - if (x < 0 || x > DisplayWidth(display, sidx) || - y < 0 || y > DisplayHeight(display, sidx) || + if (x > DisplayWidth(display, sidx) || + y > DisplayHeight(display, sidx) || w + x > DisplayWidth(display, sidx) || h + y > DisplayHeight(display, sidx)) { - fprintf(stderr, "ignoring region %ux%u+%u+%u - not within screen boundaries " + fprintf(stderr, "ignoring region %ux%u+%u+%u " + "- not within screen boundaries " "(%ux%u)\n", w, h, x, y, DisplayWidth(display, sidx), DisplayHeight(display, sidx)); return; @@ -1066,10 +1241,31 @@ socket_setnonblock(int fd) void bar_print(struct swm_region *r, char *s) { + int textwidth, x = 0; + size_t len; + XClearWindow(display, r->bar_window); XSetForeground(display, bar_gc, r->s->c[SWM_S_COLOR_BAR_FONT].color); - XDrawString(display, r->bar_window, bar_gc, 4, bar_fs->ascent, s, - strlen(s)); + + len = strlen(s); + textwidth = XTextWidth(bar_fs, s, len); + + switch (bar_justify) { + case SWM_BAR_JUSTIFY_LEFT: + x = SWM_BAR_OFFSET; + break; + case SWM_BAR_JUSTIFY_CENTER: + x = (WIDTH(r) - textwidth) / 2; + break; + case SWM_BAR_JUSTIFY_RIGHT: + x = WIDTH(r) - textwidth - SWM_BAR_OFFSET; + break; + } + + if (x < SWM_BAR_OFFSET) + x = SWM_BAR_OFFSET; + + XDrawString(display, r->bar_window, bar_gc, x, bar_fs->ascent, s, len); } void @@ -1133,6 +1329,44 @@ bar_window_name(char *s, ssize_t sz, struct ws_win *cur_focus) } } +int urgent[SWM_WS_MAX]; +void +bar_urgent(char *s, ssize_t sz) +{ + XWMHints *wmh = NULL; + struct ws_win *win; + int i, j; + char b[8]; + + if (urgent_enabled == 0) + return; + + for (i = 0; i < SWM_WS_MAX; i++) + urgent[i] = 0; + + for (i = 0; i < ScreenCount(display); i++) + for (j = 0; j < SWM_WS_MAX; j++) + TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) { + wmh = XGetWMHints(display, win->id); + if (wmh == NULL) + continue; + + if (wmh->flags & XUrgencyHint) + urgent[j] = 1; + XFree(wmh); + } + + strlcat(s, "* ", sz); + for (i = 0; i < SWM_WS_MAX; i++) { + if (urgent[i]) + snprintf(b, sizeof b, "%d ", i + 1); + else + snprintf(b, sizeof b, "- "); + strlcat(s, b, sz); + } + strlcat(s, "* ", sz); +} + void bar_update(void) { @@ -1141,11 +1375,11 @@ bar_update(void) struct swm_region *r; int i, x; size_t len; + char ws[SWM_BAR_MAX]; char s[SWM_BAR_MAX]; char cn[SWM_BAR_MAX]; char loc[SWM_BAR_MAX]; - char *b; - char *stack = ""; + char *b, *stack = ""; if (bar_enabled == 0) return; @@ -1177,16 +1411,19 @@ bar_update(void) x = 1; TAILQ_FOREACH(r, &screens[i].rl, entry) { strlcpy(cn, "", sizeof cn); + strlcpy(ws, "", sizeof ws); if (r && r->ws) { + bar_urgent(cn, sizeof cn); bar_class_name(cn, sizeof cn, r->ws->focus); bar_window_name(cn, sizeof cn, r->ws->focus); + if (r->ws->name) + snprintf(ws, sizeof ws, "<%s>", r->ws->name); } - if (stack_enabled) - stack = r->ws->cur_layout->name; + stack = r->ws->stacker; - snprintf(loc, sizeof loc, "%d:%d %s %s%s %s %s", - x++, r->ws->idx + 1, stack, s, cn, bar_ext, + snprintf(loc, sizeof loc, "%d:%d %s %s %s%s %s %s", + x++, r->ws->idx + 1, stack, ws, s, cn, bar_ext, bar_vertext); bar_print(r, loc); } @@ -1240,9 +1477,9 @@ bar_refresh(void) socket_setnonblock(bar_pipe[0]); socket_setnonblock(bar_pipe[1]); /* XXX hmmm, really? */ if (dup2(bar_pipe[0], 0) == -1) - errx(1, "dup2"); + err(1, "dup2"); if (dup2(bar_pipe[1], 1) == -1) - errx(1, "dup2"); + err(1, "dup2"); if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) err(1, "could not disable SIGPIPE"); switch (bar_pid = fork()) { @@ -1291,17 +1528,19 @@ bar_setup(struct swm_region *r) } } if (bar_fonts[i] == NULL) - errx(1, "couldn't load font"); + errx(1, "couldn't load font"); if (bar_fs == NULL) errx(1, "couldn't create font structure"); - bar_height = bar_fs->ascent + bar_fs->descent + 3; + bar_height = bar_fs->ascent + bar_fs->descent + 1 + + 2 * bar_border_width; x = X(r); y = bar_at_bottom ? (Y(r) + HEIGHT(r) - bar_height) : Y(r); r->bar_window = XCreateSimpleWindow(display, - r->s->root, x, y, WIDTH(r) - 2, bar_height - 2, - 1, r->s->c[SWM_S_COLOR_BAR_BORDER].color, + r->s->root, x, y, WIDTH(r) - 2 * bar_border_width, + bar_height - 2 * bar_border_width, + bar_border_width, r->s->c[SWM_S_COLOR_BAR_BORDER].color, r->s->c[SWM_S_COLOR_BAR].color); bar_gc = XCreateGC(display, r->bar_window, 0, &bar_gcv); XSetFont(display, bar_gc, bar_fs->fid); @@ -1316,6 +1555,18 @@ bar_setup(struct swm_region *r) } void +drain_enter_notify(void) +{ + int i = 0; + XEvent cne; + + while (XCheckMaskEvent(display, EnterWindowMask, &cne)) + i++; + + DNPRINTF(SWM_D_MISC, "drain_enter_notify: drained %d\n", i); +} + +void set_win_state(struct ws_win *win, long state) { long data[] = {state, None}; @@ -1349,8 +1600,8 @@ version(struct swm_region *r, union arg *args) { bar_version = !bar_version; if (bar_version) - snprintf(bar_vertext, sizeof bar_vertext, "Version: %s CVS: %s", - SWM_VERSION, cvstag); + snprintf(bar_vertext, sizeof bar_vertext, "Version: %s Build: %s", + SCROTWM_VERSION, buildstr); else strlcpy(bar_vertext, "", sizeof bar_vertext); bar_update(); @@ -1375,49 +1626,46 @@ client_msg(struct ws_win *win, Atom a) } void -configreq_win(struct ws_win *win) -{ - XConfigureRequestEvent cr; - - if (win == NULL) - return; - - bzero(&cr, sizeof cr); - cr.type = ConfigureRequest; - cr.display = display; - cr.parent = win->id; - cr.window = win->id; - cr.x = win->g.x; - cr.y = win->g.y; - cr.width = win->g.w; - cr.height = win->g.h; - cr.border_width = 1; - - XSendEvent(display, win->id, False, StructureNotifyMask, (XEvent *)&cr); -} - -void -config_win(struct ws_win *win) +config_win(struct ws_win *win, XConfigureRequestEvent *ev) { XConfigureEvent ce; - DNPRINTF(SWM_D_MISC, "config_win: win %lu x %d y %d w %d h %d\n", - win->id, win->g.x, win->g.y, win->g.w, win->g.h); - if (win == NULL) return; - ce.type = ConfigureNotify; - ce.display = display; - ce.event = win->id; - ce.window = win->id; - ce.x = win->g.x; - ce.y = win->g.y; - ce.width = win->g.w; - ce.height = win->g.h; - ce.border_width = 1; /* XXX store this! */ - ce.above = None; - ce.override_redirect = False; + if (ev == NULL) { + DNPRINTF(SWM_D_MISC, + "config_win: win %lu x %d y %d w %d h %d\n", + win->id, win->g.x, win->g.y, win->g.w, win->g.h); + + ce.type = ConfigureNotify; + ce.display = display; + ce.event = win->id; + ce.window = win->id; + ce.x = win->g.x; + ce.y = win->g.y; + ce.width = win->g.w; + ce.height = win->g.h; + ce.border_width = border_width; + ce.above = None; + ce.override_redirect = False; + } else { + DNPRINTF(SWM_D_MISC, + "config_win: ev win %lu x %d y %d w %d h %d\n", + ev->window, ev->x, ev->y, ev->width, ev->height); + ce.type = ConfigureNotify; + ce.display = ev->display; + ce.event = ev->window; + ce.window = ev->window; + ce.x = ev->x; + ce.y = ev->y; + ce.width = ev->width; + ce.height = ev->height; + ce.border_width = ev->border_width; + ce.above = ev->above; + ce.override_redirect = False; + } + XSendEvent(display, win->id, False, StructureNotifyMask, (XEvent *)&ce); } @@ -1432,6 +1680,8 @@ count_win(struct workspace *ws, int count_transient) continue; if (count_transient == 0 && win->transient) continue; + if (win->iconic) + continue; count++; } DNPRINTF(SWM_D_MISC, "count_win: %d\n", count); @@ -1514,7 +1764,7 @@ restart(struct swm_region *r, union arg *args) /* 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"); + err(1, "can't disable alarm"); bar_extra_stop(); bar_extra = 1; @@ -1603,40 +1853,40 @@ find_window(Window id) } void -spawn(struct swm_region *r, union arg *args) +spawn(int ws_idx, union arg *args, int close_fd) { int fd; char *ret = NULL; DNPRINTF(SWM_D_MISC, "spawn: %s\n", args->argv[0]); - if (fork() == 0) { - if (display) - close(ConnectionNumber(display)); + if (display) + close(ConnectionNumber(display)); - setenv("LD_PRELOAD", SWM_LIB, 1); + setenv("LD_PRELOAD", SWM_LIB, 1); - if (asprintf(&ret, "%d", r->ws->idx) == -1) { - perror("_SWM_WS"); - _exit(1); - } - setenv("_SWM_WS", ret, 1); - free(ret); - ret = NULL; + if (asprintf(&ret, "%d", ws_idx) == -1) { + perror("_SWM_WS"); + _exit(1); + } + setenv("_SWM_WS", ret, 1); + free(ret); + ret = NULL; - if (asprintf(&ret, "%d", getpid()) == -1) { - perror("_SWM_PID"); - _exit(1); - } - setenv("_SWM_PID", ret, 1); - free(ret); - ret = NULL; + if (asprintf(&ret, "%d", getpid()) == -1) { + perror("_SWM_PID"); + _exit(1); + } + setenv("_SWM_PID", ret, 1); + free(ret); + ret = NULL; - if (setsid() == -1) { - perror("setsid"); - _exit(1); - } + if (setsid() == -1) { + perror("setsid"); + _exit(1); + } + if (close_fd) { /* * close stdin and stdout to prevent interaction between apps * and the baraction script @@ -1650,12 +1900,12 @@ spawn(struct swm_region *r, union arg *args) dup2(fd, STDOUT_FILENO); if (fd > 2) close(fd); + } - execvp(args->argv[0], args->argv); + execvp(args->argv[0], args->argv); - perror("execvp"); - _exit(1); - } + perror("execvp"); + _exit(1); } void @@ -1663,9 +1913,11 @@ spawnterm(struct swm_region *r, union arg *args) { DNPRINTF(SWM_D_MISC, "spawnterm\n"); - if (term_width) - setenv("_SWM_XTERM_FONTADJ", "", 1); - spawn(r, args); + if (fork() == 0) { + if (term_width) + setenv("_SWM_XTERM_FONTADJ", "", 1); + spawn(r->ws->idx, args, 1); + } } void @@ -1695,12 +1947,12 @@ validate_win(struct ws_win *testwin) struct ws_win *win; struct workspace *ws; struct swm_region *r; - int i, x, foundit = 0; + int i, x; if (testwin == NULL) - return(0); + return (0); - for (i = 0, foundit = 0; i < ScreenCount(display); i++) + for (i = 0; i < ScreenCount(display); i++) TAILQ_FOREACH(r, &screens[i].rl, entry) for (x = 0; x < SWM_WS_MAX; x++) { ws = &r->s->ws[x]; @@ -1716,10 +1968,10 @@ validate_ws(struct workspace *testws) { struct swm_region *r; struct workspace *ws; - int foundit, i, x; + int i, x; /* validate all ws */ - for (i = 0, foundit = 0; i < ScreenCount(display); i++) + for (i = 0; i < ScreenCount(display); i++) TAILQ_FOREACH(r, &screens[i].rl, entry) for (x = 0; x < SWM_WS_MAX; x++) { ws = &r->s->ws[x]; @@ -1826,6 +2078,13 @@ focus_win(struct ws_win *win) XGetInputFocus(display, &cur_focus, &rr); if ((cfw = find_window(cur_focus)) != NULL) unfocus_win(cfw); + else { + /* use larger hammer since the window was killed somehow */ + TAILQ_FOREACH(cfw, &win->ws->winlist, entry) + if (cfw->ws && cfw->ws->r && cfw->ws->r->s) + XSetWindowBorder(display, cfw->id, + cfw->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color); + } win->ws->focus = win; @@ -1840,7 +2099,8 @@ focus_win(struct ws_win *win) grabbuttons(win, 1); XSetWindowBorder(display, win->id, win->ws->r->s->c[SWM_S_COLOR_FOCUS].color); - if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS) + if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS || + win->ws->always_raise) XMapRaised(display, win->id); XChangeProperty(display, win->s->root, @@ -1892,15 +2152,22 @@ switchws(struct swm_region *r, union arg *args) 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); + bar_update(); /* unmap old windows */ if (unmap_old) TAILQ_FOREACH(win, &old_ws->winlist, entry) unmap_window(win); + + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); } void @@ -1908,6 +2175,7 @@ cyclews(struct swm_region *r, union arg *args) { union arg a; struct swm_screen *s = r->s; + int cycle_all = 0; DNPRINTF(SWM_D_WS, "cyclews id %d " "in screen[%d]:%dx%d+%d+%d ws %d\n", args->id, @@ -1916,12 +2184,18 @@ cyclews(struct swm_region *r, union arg *args) a.id = r->ws->idx; do { switch (args->id) { + case SWM_ARG_ID_CYCLEWS_UP_ALL: + cycle_all = 1; + /* FALLTHROUGH */ case SWM_ARG_ID_CYCLEWS_UP: if (a.id < SWM_WS_MAX - 1) a.id++; else a.id = 0; break; + case SWM_ARG_ID_CYCLEWS_DOWN_ALL: + cycle_all = 1; + /* FALLTHROUGH */ case SWM_ARG_ID_CYCLEWS_DOWN: if (a.id > 0) a.id--; @@ -1932,7 +2206,8 @@ cyclews(struct swm_region *r, union arg *args) return; }; - if (cycle_empty == 0 && TAILQ_EMPTY(&s->ws[a.id].winlist)) + if (!cycle_all && + (cycle_empty == 0 && TAILQ_EMPTY(&s->ws[a.id].winlist))) continue; if (cycle_visible == 0 && s->ws[a.id].r != NULL) continue; @@ -2003,6 +2278,29 @@ cyclescr(struct swm_region *r, union arg *args) } void +sort_windows(struct ws_win_list *wl) +{ + struct ws_win *win, *parent, *nxt; + + if (wl == NULL) + return; + + for (win = TAILQ_FIRST(wl); win != TAILQ_END(wl); win = nxt) { + nxt = TAILQ_NEXT(win, entry); + if (win->transient) { + parent = find_window(win->transient); + if (parent == NULL) { + fprintf(stderr, "not possible bug\n"); + continue; + } + TAILQ_REMOVE(wl, win, entry); + TAILQ_INSERT_AFTER(wl, parent, win, entry); + } + } + +} + +void swapwin(struct swm_region *r, union arg *args) { struct ws_win *target, *source; @@ -2023,8 +2321,12 @@ swapwin(struct swm_region *r, union arg *args) switch (args->id) { case SWM_ARG_ID_SWAPPREV: + if (source->transient) + source = find_window(source->transient); target = TAILQ_PREV(source, ws_win_list, entry); - TAILQ_REMOVE(wl, cur_focus, entry); + if (target && target->transient) + target = find_window(target->transient); + TAILQ_REMOVE(wl, source, entry); if (target == NULL) TAILQ_INSERT_TAIL(wl, source, entry); else @@ -2032,6 +2334,9 @@ swapwin(struct swm_region *r, union arg *args) break; case SWM_ARG_ID_SWAPNEXT: target = TAILQ_NEXT(source, entry); + /* move the parent and let the sort handle the move */ + if (source->transient) + source = find_window(source->transient); TAILQ_REMOVE(wl, source, entry); if (target == NULL) TAILQ_INSERT_HEAD(wl, source, entry); @@ -2047,7 +2352,7 @@ swapwin(struct swm_region *r, union arg *args) source = source->ws->focus_prev; else return; - } + } if (target == NULL || source == NULL) return; source->ws->focus_prev = target; @@ -2065,6 +2370,8 @@ swapwin(struct swm_region *r, union arg *args) return; } + sort_windows(wl); + stack(); } @@ -2104,7 +2411,8 @@ focus_prev(struct ws_win *win) } /* if in max_stack try harder */ - if (ws->cur_layout->flags & SWM_L_FOCUSPREV) { + if ((win->quirks & SWM_Q_FOCUSPREV) || + (ws->cur_layout->flags & SWM_L_FOCUSPREV)) { if (cur_focus != ws->focus_prev) winfocus = ws->focus_prev; else if (cur_focus != ws->focus) @@ -2122,19 +2430,26 @@ focus_prev(struct ws_win *win) if (winfocus == NULL || winfocus == win) winfocus = TAILQ_NEXT(cur_focus, entry); done: - if (winfocus == winlostfocus || winfocus == NULL) + 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, SWM_F_GENERIC); + focus_magic(winfocus); } void focus(struct swm_region *r, union arg *args) { - struct ws_win *winfocus = NULL, *winlostfocus = NULL; + struct ws_win *winfocus = NULL, *winlostfocus = NULL, *head; struct ws_win *cur_focus = NULL; struct ws_win_list *wl = NULL; struct workspace *ws = NULL; + int all_iconics; if (!(r && r->ws)) return; @@ -2143,14 +2458,16 @@ focus(struct swm_region *r, union arg *args) /* treat FOCUS_CUR special */ if (args->id == SWM_ARG_ID_FOCUSCUR) { - if (r->ws->focus) + if (r->ws->focus && r->ws->focus->iconic == 0) winfocus = r->ws->focus; - else if (r->ws->focus_prev) + else if (r->ws->focus_prev && r->ws->focus_prev->iconic == 0) winfocus = r->ws->focus_prev; else - winfocus = TAILQ_FIRST(&r->ws->winlist); + TAILQ_FOREACH(winfocus, &r->ws->winlist, entry) + if (winfocus->iconic == 0) + break; - focus_magic(winfocus, SWM_F_GENERIC); + focus_magic(winfocus); return; } @@ -2158,20 +2475,61 @@ focus(struct swm_region *r, union arg *args) return; ws = r->ws; wl = &ws->winlist; + if (TAILQ_EMPTY(wl)) + return; + /* make sure there is at least one uniconified window */ + all_iconics = 1; + TAILQ_FOREACH(winfocus, wl, entry) + if (winfocus->iconic == 0) { + all_iconics = 0; + break; + } + if (all_iconics) + return; winlostfocus = cur_focus; switch (args->id) { case SWM_ARG_ID_FOCUSPREV: - winfocus = TAILQ_PREV(cur_focus, ws_win_list, entry); - if (winfocus == NULL) - winfocus = TAILQ_LAST(wl, ws_win_list); + head = TAILQ_PREV(cur_focus, ws_win_list, entry); + if (head == NULL) + head = TAILQ_LAST(wl, ws_win_list); + winfocus = head; + if (WINID(winfocus) == cur_focus->transient) { + head = TAILQ_PREV(winfocus, ws_win_list, entry); + if (head == NULL) + head = TAILQ_LAST(wl, ws_win_list); + winfocus = head; + } + + /* skip iconics */ + if (winfocus && winfocus->iconic) { + while (winfocus != cur_focus) { + if (winfocus == NULL) + winfocus = TAILQ_LAST(wl, ws_win_list); + if (winfocus->iconic == 0) + break; + winfocus = TAILQ_PREV(winfocus, ws_win_list, entry); + } + } break; case SWM_ARG_ID_FOCUSNEXT: - winfocus = TAILQ_NEXT(cur_focus, entry); - if (winfocus == NULL) - winfocus = TAILQ_FIRST(wl); + head = TAILQ_NEXT(cur_focus, entry); + if (head == NULL) + head = TAILQ_FIRST(wl); + winfocus = head; + + /* skip iconics */ + if (winfocus && winfocus->iconic) { + while (winfocus != cur_focus) { + if (winfocus == NULL) + winfocus = TAILQ_FIRST(wl); + if (winfocus->iconic == 0) + break; + winfocus = TAILQ_NEXT(winfocus, entry); + } + } break; case SWM_ARG_ID_FOCUSMAIN: @@ -2183,29 +2541,33 @@ focus(struct swm_region *r, union arg *args) 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(); - if (winfocus == winlostfocus || winfocus == NULL) return; + } - focus_magic(winfocus, SWM_F_GENERIC); + focus_magic(winfocus); } void cycle_layout(struct swm_region *r, union arg *args) { struct workspace *ws = r->ws; - struct ws_win *winfocus; union arg a; DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx); - winfocus = ws->focus; - ws->cur_layout++; if (ws->cur_layout->l_stack == NULL) ws->cur_layout = &layouts[0]; stack(); + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); a.id = SWM_ARG_ID_FOCUSCUR; focus(r, &a); bar_update(); @@ -2222,40 +2584,50 @@ stack_config(struct swm_region *r, union arg *args) if (ws->cur_layout->l_config != NULL) ws->cur_layout->l_config(ws, args->id); - if (args->id != SWM_ARG_ID_STACKINIT); + if (args->id != SWM_ARG_ID_STACKINIT) stack(); + bar_update(); } void stack(void) { struct swm_geometry g; struct swm_region *r; - int i, j; + int i; +#ifdef SWM_DEBUG + int j; +#endif DNPRINTF(SWM_D_STACK, "stack\n"); for (i = 0; i < ScreenCount(display); i++) { +#ifdef SWM_DEBUG j = 0; +#endif TAILQ_FOREACH(r, &screens[i].rl, entry) { DNPRINTF(SWM_D_STACK, "stacking workspace %d " "(screen %d, region %d)\n", r->ws->idx, i, j++); /* start with screen geometry, adjust for bar */ g = r->g; - g.w -= 2; - g.h -= 2; + g.w -= 2 * border_width; + g.h -= 2 * border_width; if (bar_enabled) { if (!bar_at_bottom) g.y += bar_height; g.h -= bar_height; } r->ws->cur_layout->l_stack(r->ws, &g); + r->ws->cur_layout->l_string(r->ws); /* save r so we can track region changes */ r->ws->old_r = r; } } if (font_adjusted) font_adjusted--; + + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); } void @@ -2309,7 +2681,7 @@ stack_floater(struct ws_win *win, struct swm_region *r) (win->g.h >= HEIGHT(r))) wc.border_width = 0; else - wc.border_width = 1; + wc.border_width = border_width; if (win->transient && (win->quirks & SWM_Q_TRANSSZ)) { win->g.w = (double)WIDTH(r) * dialog_ratio; win->g.h = (double)HEIGHT(r) * dialog_ratio; @@ -2320,22 +2692,24 @@ stack_floater(struct ws_win *win, struct swm_region *r) * floaters and transients are auto-centred unless moved * or resized */ - win->g.x = r->g.x + (WIDTH(r) - win->g.w) / 2; - win->g.y = r->g.y + (HEIGHT(r) - win->g.h) / 2; + win->g.x = r->g.x + (WIDTH(r) - win->g.w) / + 2 - wc.border_width; + win->g.y = r->g.y + (HEIGHT(r) - win->g.h) / + 2 - wc.border_width; } /* win can be outside r if new r smaller than old r */ /* Ensure top left corner inside r (move probs otherwise) */ - if (win->g.x < r->g.x ) - win->g.x = r->g.x; + if (win->g.x < r->g.x - wc.border_width) + win->g.x = r->g.x - wc.border_width; if (win->g.x > r->g.x + r->g.w - 1) win->g.x = (win->g.w > r->g.w) ? r->g.x : - (r->g.x + r->g.w - win->g.w - 2); - if (win->g.y < r->g.y ) - win->g.y = r->g.y; + (r->g.x + r->g.w - win->g.w - 2 * wc.border_width); + if (win->g.y < r->g.y - wc.border_width) + win->g.y = r->g.y - wc.border_width; if (win->g.y > r->g.y + r->g.h - 1) win->g.y = (win->g.h > r->g.h) ? r->g.y : - (r->g.y + r->g.h - win->g.h - 2); + (r->g.y + r->g.h - win->g.h - 2 * wc.border_width); wc.x = win->g.x; wc.y = win->g.y; @@ -2353,7 +2727,6 @@ stack_floater(struct ws_win *win, struct swm_region *r) win->id, wc.x, wc.y, wc.width, wc.height); XConfigureWindow(display, win->id, mask, &wc); - configreq_win(win); } /* @@ -2412,7 +2785,8 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) return; TAILQ_FOREACH(win, &ws->winlist, entry) - if (win->transient == 0 && win->floating == 0) + if (win->transient == 0 && win->floating == 0 + && win->iconic == 0) break; if (win == NULL) @@ -2461,17 +2835,20 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) } else { msize = -2; colno = split = winno / stacks; - win_g.w = ((r_g.w - (stacks * 2) + 2) / stacks); + win_g.w = ((r_g.w - (stacks * 2 * border_width) + + 2 * border_width) / stacks); } hrh = r_g.h / colno; extra = r_g.h - (colno * hrh); - win_g.h = hrh - 2; + win_g.h = hrh - 2 * border_width; /* stack all the tiled windows */ i = j = 0, s = stacks; TAILQ_FOREACH(win, &ws->winlist, entry) { if (win->transient != 0 || win->floating != 0) continue; + if (win->iconic != 0) + continue; if (win->ewmh_flags & EWMH_F_FULLSCREEN) { fs_win = win; @@ -2488,15 +2865,16 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) if (flip) win_g.x = r_g.x; else - win_g.x += win_g.w + 2; - win_g.w = (r_g.w - msize - (stacks * 2)) / stacks; + win_g.x += win_g.w + 2 * border_width; + win_g.w = (r_g.w - msize - + (stacks * 2 * border_width)) / stacks; if (s == 1) - win_g.w += (r_g.w - msize - (stacks * 2)) % - stacks; + win_g.w += (r_g.w - msize - + (stacks * 2 * border_width)) % stacks; s--; j = 0; } - win_g.h = hrh - 2; + win_g.h = hrh - 2 * border_width; if (rot) { h_inc = win->sh.width_inc; h_base = win->sh.base_width; @@ -2523,15 +2901,15 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) if (j == 0) win_g.y = r_g.y; else - win_g.y += last_h + 2; + win_g.y += last_h + 2 * border_width; bzero(&wc, sizeof wc); if (disable_border && bar_enabled == 0 && winno == 1){ wc.border_width = 0; - win_g.w += 2; - win_g.h += 2; + win_g.w += 2 * border_width; + win_g.h += 2 * border_width; } else - wc.border_width = 1; + wc.border_width = border_width; reconfigure = 0; if (rot) { if (win->g.x != win_g.y || win->g.y != win_g.x || @@ -2556,7 +2934,6 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) adjust_font(win); mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth; XConfigureWindow(display, win->id, mask, &wc); - configreq_win(win); } if (XGetWindowAttributes(display, win->id, &wa)) @@ -2568,12 +2945,13 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) j++; } - notiles: +notiles: /* now, stack all the floaters and transients */ TAILQ_FOREACH(win, &ws->winlist, entry) { if (win->transient == 0 && win->floating == 0) continue; - + if (win->iconic == 1) + continue; if (win->ewmh_flags & EWMH_F_FULLSCREEN) { fs_win = win; continue; @@ -2725,17 +3103,16 @@ max_stack(struct workspace *ws, struct swm_geometry *g) win->g.x = wc.x = gg.x; win->g.y = wc.y = gg.y; if (bar_enabled){ - wc.border_width = 1; + wc.border_width = border_width; win->g.w = wc.width = gg.w; win->g.h = wc.height = gg.h; } else { wc.border_width = 0; - win->g.w = wc.width = gg.w + 2; - win->g.h = wc.height = gg.h + 2; + win->g.w = wc.width = gg.w + 2 * border_width; + win->g.h = wc.height = gg.h + 2 * border_width; } mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth; XConfigureWindow(display, win->id, mask, &wc); - configreq_win(win); } /* unmap only if we don't have multi screen */ if (win != ws->focus) @@ -2748,7 +3125,7 @@ max_stack(struct workspace *ws, struct swm_geometry *g) if (parent) XMapRaised(display, parent->id); stack_floater(wintrans, ws->r); - focus_magic(wintrans, SWM_F_TRANSIENT); + focus_magic(wintrans); } } @@ -2756,13 +3133,13 @@ void send_to_ws(struct swm_region *r, union arg *args) { int wsid = args->id; - struct ws_win *win = win; + struct ws_win *win = NULL, *parent; struct workspace *ws, *nws; Atom ws_idx_atom = 0; unsigned char ws_idx_str[SWM_PROPLEN]; union arg a; - if (r && r->ws) + if (r && r->ws && r->ws->focus) win = r->ws->focus; else return; @@ -2778,15 +3155,27 @@ send_to_ws(struct swm_region *r, union arg *args) a.id = SWM_ARG_ID_FOCUSPREV; focus(r, &a); + if (win->transient) { + parent = find_window(win->transient); + if (parent) { + unmap_window(parent); + TAILQ_REMOVE(&ws->winlist, parent, entry); + TAILQ_INSERT_TAIL(&nws->winlist, parent, entry); + parent->ws = nws; + } + } unmap_window(win); TAILQ_REMOVE(&ws->winlist, win, entry); TAILQ_INSERT_TAIL(&nws->winlist, win, entry); + if (TAILQ_EMPTY(&ws->winlist)) + r->ws->focus = NULL; win->ws = nws; /* Try to update the window's workspace property */ ws_idx_atom = XInternAtom(display, "_SWM_WS", False); if (ws_idx_atom && - snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < SWM_PROPLEN) { + snprintf((char *)ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < + SWM_PROPLEN) { DNPRINTF(SWM_D_PROP, "setting property _SWM_WS to %s\n", ws_idx_str); XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8, @@ -2797,73 +3186,501 @@ send_to_ws(struct swm_region *r, union arg *args) } void -wkill(struct swm_region *r, union arg *args) +pressbutton(struct swm_region *r, union arg *args) { - DNPRINTF(SWM_D_MISC, "wkill %d\n", args->id); + XTestFakeButtonEvent(display, args->id, True, CurrentTime); + XTestFakeButtonEvent(display, args->id, False, CurrentTime); +} - if (r->ws->focus == NULL) +void +raise_toggle(struct swm_region *r, union arg *args) +{ + if (r && r->ws == NULL) return; - if (args->id == SWM_ARG_ID_KILLWINDOW) - XKillClient(display, r->ws->focus->id); - else - if (r->ws->focus->can_delete) - client_msg(r->ws->focus, adelete); -} + r->ws->always_raise = !r->ws->always_raise; + /* bring floaters back to top */ + if (r->ws->always_raise == 0) + stack(); +} -int -floating_toggle_win(struct ws_win *win) +void +iconify(struct swm_region *r, union arg *args) { - struct swm_region *r; - - if (win == NULL) - return 0; + union arg a; - if (!win->ws->r) - return 0; + if (r->ws->focus == NULL) + return; + unmap_window(r->ws->focus); + update_iconic(r->ws->focus, 1); + stack(); + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); + r->ws->focus = NULL; + a.id = SWM_ARG_ID_FOCUSCUR; + focus(r, &a); +} - r = win->ws->r; +unsigned char * +get_win_name(Display *dpy, Window win, Atom wname, Atom stype, + unsigned long *slen) +{ + int status, retfmt; + unsigned long nitems, nbytes, nextra; + unsigned char *prop = NULL; + Atom rettype; - /* reject floating toggles in max stack mode */ - if (win->ws->cur_layout == &layouts[SWM_MAX_STACK]) - return 0; + status = XGetWindowProperty(dpy, win, wname, 0L, 0L, False, stype, + &rettype, &retfmt, &nitems, &nbytes, &prop); + if (status != Success) + return (NULL); + XFree(prop); - if (win->floating) { - if (!win->floatmaxed) { - /* retain position for refloat */ - store_float_geom(win, r); - } - win->floating = 0; - } else { - if (win->g_floatvalid) { - /* refloat at last floating relative position */ - win->g.x = win->g_float.x - win->rg_float.x + r->g.x; - win->g.y = win->g_float.y - win->rg_float.y + r->g.y; - win->g.w = win->g_float.w; - win->g.h = win->g_float.h; - } - win->floating = 1; + status = XGetWindowProperty(dpy, win, wname, 0L, nbytes, False, + stype, &rettype, &retfmt, &nitems, &nextra, &prop); + if (status != Success) { + XFree(prop); + return (NULL); } - - ewmh_update_actions(win); - - return 1; + if (rettype != stype) { + XFree(prop); + return (NULL); + } + *slen = nitems; + return (prop); } void -floating_toggle(struct swm_region *r, union arg *args) +uniconify(struct swm_region *r, union arg *args) { - struct ws_win *win = r->ws->focus; - union arg a; + struct ws_win *win; + FILE *lfile; + unsigned char *name; + int count = 0; + unsigned long len; - if (win == NULL) + DNPRINTF(SWM_D_MISC, "uniconify\n"); + + if (r && r->ws == NULL) return; - ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom, - _NET_WM_STATE_TOGGLE); + /* make sure we have anything to uniconify */ + TAILQ_FOREACH(win, &r->ws->winlist, entry) { + if (win->ws == NULL) + continue; /* should never happen */ + if (win->iconic == 0) + continue; + count++; + } + if (count == 0) + return; + + search_r = r; + search_resp_action = SWM_SEARCH_UNICONIFY; + + spawn_select(r, args, "search", &searchpid); + + if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) + return; + + TAILQ_FOREACH(win, &r->ws->winlist, entry) { + if (win->ws == NULL) + continue; /* should never happen */ + if (win->iconic == 0) + continue; + + name = get_win_name(display, win->id, a_netwmname, a_utf8_string, + &len); + if (name == NULL) + continue; + fprintf(lfile, "%s.%lu\n", name, win->id); + XFree(name); + } + + fclose(lfile); +} + +void +name_workspace(struct swm_region *r, union arg *args) +{ + FILE *lfile; + + DNPRINTF(SWM_D_MISC, "name_workspace\n"); + + if (r == NULL) + return; + + search_r = r; + search_resp_action = SWM_SEARCH_NAME_WORKSPACE; + + spawn_select(r, args, "name_workspace", &searchpid); + + if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) + return; + + fprintf(lfile, "%s", ""); + fclose(lfile); +} + +void +search_workspace(struct swm_region *r, union arg *args) +{ + int i; + struct workspace *ws; + FILE *lfile; + + DNPRINTF(SWM_D_MISC, "search_workspace\n"); + + if (r == NULL) + return; + + search_r = r; + search_resp_action = SWM_SEARCH_SEARCH_WORKSPACE; + + spawn_select(r, args, "search", &searchpid); + + if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) + return; + + for (i = 0; i < SWM_WS_MAX; i++) { + ws = &r->s->ws[i]; + if (ws == NULL) + continue; + fprintf(lfile, "%d%s%s\n", ws->idx + 1, + (ws->name ? ":" : ""), (ws->name ? ws->name : "")); + } + + fclose(lfile); +} + +void +search_win_cleanup(void) +{ + struct search_window *sw = NULL; + + while ((sw = TAILQ_FIRST(&search_wl)) != NULL) { + XDestroyWindow(display, sw->indicator); + TAILQ_REMOVE(&search_wl, sw, entry); + free(sw); + } +} + +void +search_win(struct swm_region *r, union arg *args) +{ + struct ws_win *win = NULL; + struct search_window *sw = NULL; + Window w; + GC gc; + XGCValues gcv; + int i; + char s[8]; + FILE *lfile; + size_t len; + int textwidth; + + DNPRINTF(SWM_D_MISC, "search_win\n"); + + search_r = r; + search_resp_action = SWM_SEARCH_SEARCH_WINDOW; + + spawn_select(r, args, "search", &searchpid); + + if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL) + return; + + TAILQ_INIT(&search_wl); + + i = 1; + TAILQ_FOREACH(win, &r->ws->winlist, entry) { + if (win->iconic == 1) + continue; + + sw = calloc(1, sizeof(struct search_window)); + if (sw == NULL) { + fprintf(stderr, "search_win: calloc: %s", strerror(errno)); + fclose(lfile); + search_win_cleanup(); + return; + } + sw->idx = i; + sw->win = win; + + snprintf(s, sizeof s, "%d", i); + len = strlen(s); + textwidth = XTextWidth(bar_fs, s, len); + + w = XCreateSimpleWindow(display, + win->id, 0, 0, textwidth + 12, + bar_fs->ascent + bar_fs->descent + 4, 1, + r->s->c[SWM_S_COLOR_UNFOCUS].color, + r->s->c[SWM_S_COLOR_FOCUS].color); + + sw->indicator = w; + TAILQ_INSERT_TAIL(&search_wl, sw, entry); + + gc = XCreateGC(display, w, 0, &gcv); + XSetFont(display, gc, bar_fs->fid); + XMapRaised(display, w); + XSetForeground(display, gc, r->s->c[SWM_S_COLOR_BAR].color); + + XDrawString(display, w, gc, 6, bar_fs->ascent + 2, s, len); + + fprintf(lfile, "%d\n", i); + i++; + } + + fclose(lfile); +} + +void +search_resp_uniconify(char *resp, unsigned long len) +{ + unsigned char *name; + struct ws_win *win; + char *s; + + DNPRINTF(SWM_D_MISC, "search_resp_uniconify: resp %s\n", resp); + + TAILQ_FOREACH(win, &search_r->ws->winlist, entry) { + if (win->iconic == 0) + continue; + name = get_win_name(display, win->id, a_netwmname, a_utf8_string, &len); + if (name == NULL) + continue; + if (asprintf(&s, "%s.%lu", name, win->id) == -1) { + XFree(name); + continue; + } + XFree(name); + if (strncmp(s, resp, len) == 0) { + /* XXX this should be a callback to generalize */ + update_iconic(win, 0); + free(s); + break; + } + free(s); + } +} + +void +search_resp_name_workspace(char *resp, unsigned long len) +{ + struct workspace *ws; + + DNPRINTF(SWM_D_MISC, "search_resp_name_workspace: resp %s\n", resp); + + if (search_r->ws == NULL) + return; + ws = search_r->ws; + + if (ws->name) { + free(search_r->ws->name); + search_r->ws->name = NULL; + } + + if (len > 1) { + ws->name = strdup(resp); + if (ws->name == NULL) { + DNPRINTF(SWM_D_MISC, "search_resp_name_workspace: strdup: %s", + strerror(errno)); + return; + } + } +} + +void +search_resp_search_workspace(char *resp, unsigned long len) +{ + char *p, *q; + int ws_idx; + const char *errstr; + union arg a; + + DNPRINTF(SWM_D_MISC, "search_resp_search_workspace: resp %s\n", resp); + + q = strdup(resp); + if (!q) { + DNPRINTF(SWM_D_MISC, "search_resp_search_workspace: strdup: %s", + strerror(errno)); + return; + } + p = strchr(q, ':'); + if (p != NULL) + *p = '\0'; + ws_idx = strtonum(q, 1, SWM_WS_MAX, &errstr); + if (errstr) { + DNPRINTF(SWM_D_MISC, "workspace idx is %s: %s", + errstr, q); + free(q); + return; + } + free(q); + a.id = ws_idx - 1; + switchws(search_r, &a); +} + +void +search_resp_search_window(char *resp, unsigned long len) +{ + char *s; + int idx; + const char *errstr; + struct search_window *sw; + + DNPRINTF(SWM_D_MISC, "search_resp_search_window: resp %s\n", resp); + + s = strdup(resp); + if (!s) { + DNPRINTF(SWM_D_MISC, "search_resp_search_window: strdup: %s", + strerror(errno)); + return; + } + + idx = strtonum(s, 1, INT_MAX, &errstr); + if (errstr) { + DNPRINTF(SWM_D_MISC, "window idx is %s: %s", + errstr, s); + free(s); + return; + } + free(s); + + TAILQ_FOREACH(sw, &search_wl, entry) + if (idx == sw->idx) { + focus_win(sw->win); + break; + } +} + +#define MAX_RESP_LEN 1024 + +void +search_do_resp(void) +{ + ssize_t rbytes; + char *resp; + unsigned long len; + + DNPRINTF(SWM_D_MISC, "search_do_resp:\n"); + + search_resp = 0; + searchpid = 0; + + if ((resp = calloc(1, MAX_RESP_LEN + 1)) == NULL) { + fprintf(stderr, "search: calloc\n"); + goto done; + } + + rbytes = read(select_resp_pipe[0], resp, MAX_RESP_LEN); + if (rbytes <= 0) { + fprintf(stderr, "search: read error: %s\n", strerror(errno)); + goto done; + } + resp[rbytes] = '\0'; + + /* XXX: + * Older versions of dmenu (Atleast pre 4.4.1) do not send a + * newline, so work around that by sanitizing the resp now. + */ + resp[strcspn(resp, "\n")] = '\0'; + len = strlen(resp); + + switch (search_resp_action) { + case SWM_SEARCH_UNICONIFY: + search_resp_uniconify(resp, len); + break; + case SWM_SEARCH_NAME_WORKSPACE: + search_resp_name_workspace(resp, len); + break; + case SWM_SEARCH_SEARCH_WORKSPACE: + search_resp_search_workspace(resp, len); + break; + case SWM_SEARCH_SEARCH_WINDOW: + search_resp_search_window(resp, len); + break; + } + +done: + if (search_resp_action == SWM_SEARCH_SEARCH_WINDOW) + search_win_cleanup(); + + search_resp_action = SWM_SEARCH_NONE; + close(select_resp_pipe[0]); + free(resp); +} + +void +wkill(struct swm_region *r, union arg *args) +{ + DNPRINTF(SWM_D_MISC, "wkill %d\n", args->id); + + if (r->ws->focus == NULL) + return; + + if (args->id == SWM_ARG_ID_KILLWINDOW) + XKillClient(display, r->ws->focus->id); + else + if (r->ws->focus->can_delete) + client_msg(r->ws->focus, adelete); +} + + +int +floating_toggle_win(struct ws_win *win) +{ + struct swm_region *r; + + if (win == NULL) + return 0; + + if (!win->ws->r) + return 0; + + r = win->ws->r; + + /* reject floating toggles in max stack mode */ + if (win->ws->cur_layout == &layouts[SWM_MAX_STACK]) + return 0; + + if (win->floating) { + if (!win->floatmaxed) { + /* retain position for refloat */ + store_float_geom(win, r); + } + win->floating = 0; + } else { + if (win->g_floatvalid) { + /* refloat at last floating relative position */ + win->g.x = win->g_float.x - win->rg_float.x + r->g.x; + win->g.y = win->g_float.y - win->rg_float.y + r->g.y; + win->g.w = win->g_float.w; + win->g.h = win->g_float.h; + } + win->floating = 1; + } + + ewmh_update_actions(win); + + return 1; +} + +void +floating_toggle(struct swm_region *r, union arg *args) +{ + struct ws_win *win = r->ws->focus; + union arg a; + + if (win == NULL) + return; + + ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom, + _NET_WM_STATE_TOGGLE); stack(); + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); if (win == win->ws->focus) { a.id = SWM_ARG_ID_FOCUSCUR; @@ -2872,40 +3689,83 @@ floating_toggle(struct swm_region *r, union arg *args) } void -resize_window(struct ws_win *win, int center) +constrain_window(struct ws_win *win, struct swm_region *r, int resizable) +{ + if (win->g.x + win->g.w > r->g.x + r->g.w - border_width) { + if (resizable) + win->g.w = r->g.x + r->g.w - win->g.x - border_width; + else + win->g.x = r->g.x + r->g.w - win->g.w - border_width; + } + + if (win->g.x < r->g.x - border_width) { + if (resizable) + win->g.w -= r->g.x - win->g.x - border_width; + + win->g.x = r->g.x - border_width; + } + + if (win->g.y + win->g.h > r->g.y + r->g.h - border_width) { + if (resizable) + win->g.h = r->g.y + r->g.h - win->g.y - border_width; + else + win->g.y = r->g.y + r->g.h - win->g.h - border_width; + } + + if (win->g.y < r->g.y - border_width) { + if (resizable) + win->g.h -= r->g.y - win->g.y - border_width; + + win->g.y = r->g.y - border_width; + } + + if (win->g.w < 1) + win->g.w = 1; + if (win->g.h < 1) + win->g.h = 1; +} + +void +update_window(struct ws_win *win) { unsigned int mask; XWindowChanges wc; - struct swm_region *r; - r = root_to_region(win->wa.root); bzero(&wc, sizeof wc); - mask = CWBorderWidth | CWWidth | CWHeight; - wc.border_width = 1; + mask = CWBorderWidth | CWWidth | CWHeight | CWX | CWY; + wc.border_width = border_width; + wc.x = win->g.x; + wc.y = win->g.y; wc.width = win->g.w; wc.height = win->g.h; - if (center == SWM_ARG_ID_CENTER) { - wc.x = (WIDTH(r) - win->g.w) / 2; - wc.y = (HEIGHT(r) - win->g.h) / 2; - mask |= CWX | CWY; - } - DNPRINTF(SWM_D_STACK, "resize_window: win %lu x %d y %d w %d h %d\n", + DNPRINTF(SWM_D_STACK, "update_window: win %lu x %d y %d w %d h %d\n", win->id, wc.x, wc.y, wc.width, wc.height); XConfigureWindow(display, win->id, mask, &wc); - configreq_win(win); } +#define SWM_RESIZE_STEPS (50) + void resize(struct ws_win *win, union arg *args) { XEvent ev; Time time = 0; - struct swm_region *r = win->ws->r; - int relx, rely; - union arg a; + struct swm_region *r = NULL; + int resize_step = 0; + Window rr, cr; + int x, y, wx, wy; + unsigned int mask; + struct swm_geometry g; + int top = 0, left = 0; + int dx, dy; + Cursor cursor; + unsigned int shape; /* cursor style */ + if (win == NULL) + return; + r = win->ws->r; DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %lu\n", win->id, win->floating, win->transient); @@ -2920,101 +3780,174 @@ resize(struct ws_win *win, union arg *args) win->manual = 1; ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom, _NET_WM_STATE_ADD); - /* raise the window = move to last in window list */ - a.id = SWM_ARG_ID_MOVELAST; - swapwin(r, &a); + stack(); - if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync, - GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess) + switch (args->id) { + case SWM_ARG_ID_WIDTHSHRINK: + win->g.w -= SWM_RESIZE_STEPS; + resize_step = 1; + break; + case SWM_ARG_ID_WIDTHGROW: + win->g.w += SWM_RESIZE_STEPS; + resize_step = 1; + break; + case SWM_ARG_ID_HEIGHTSHRINK: + win->g.h -= SWM_RESIZE_STEPS; + resize_step = 1; + break; + case SWM_ARG_ID_HEIGHTGROW: + win->g.h += SWM_RESIZE_STEPS; + resize_step = 1; + break; + default: + break; + } + if (resize_step) { + constrain_window(win, r, 1); + update_window(win); + store_float_geom(win,r); return; + } - /* place pointer at bottom left corner or nearest point inside r */ - if ( win->g.x + win->g.w < r->g.x + r->g.w - 1) - relx = win->g.w; - else - relx = r->g.x + r->g.w - win->g.x - 2; + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); - if ( win->g.y + win->g.h < r->g.y + r->g.h - 1) - rely = win->g.h; - else - rely = r->g.y + r->g.h - win->g.y - 2; + /* get cursor offset from window root */ + if (!XQueryPointer(display, win->id, &rr, &cr, &x, &y, &wx, &wy, &mask)) + return; + + g = win->g; + + if (wx < win->g.w / 2) + left = 1; + + if (wy < win->g.h / 2) + top = 1; + + if (args->id == SWM_ARG_ID_CENTER) + shape = XC_sizing; + else if (top) + shape = (left) ? XC_top_left_corner : XC_top_right_corner; + else + shape = (left) ? XC_bottom_left_corner : XC_bottom_right_corner; + + cursor = XCreateFontCursor(display, shape); + + if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync, + GrabModeAsync, None, cursor, CurrentTime) != GrabSuccess) { + XFreeCursor(display, cursor); + return; + } - XWarpPointer(display, None, win->id, 0, 0, 0, 0, relx, rely); do { XMaskEvent(display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev); - switch(ev.type) { + switch (ev.type) { case ConfigureRequest: case Expose: case MapRequest: handler[ev.type](&ev); break; case MotionNotify: - /* do not allow resize outside of region */ - if ( ev.xmotion.x_root < r->g.x || - ev.xmotion.x_root > r->g.x + r->g.w - 1 || - ev.xmotion.y_root < r->g.y || - ev.xmotion.y_root > r->g.y + r->g.h - 1) - continue; + /* cursor offset/delta from start of the operation */ + dx = ev.xmotion.x_root - x; + dy = ev.xmotion.y_root - y; + + /* vertical */ + if (top) + dy = -dy; + + if (args->id == SWM_ARG_ID_CENTER) { + if (g.h / 2 + dy < 1) + dy = 1 - g.h / 2; + + win->g.y = g.y - dy; + win->g.h = g.h + 2 * dy; + } else { + if (g.h + dy < 1) + dy = 1 - g.h; + + if (top) + win->g.y = g.y - dy; + + win->g.h = g.h + dy; + } + + /* horizontal */ + if (left) + dx = -dx; + + if (args->id == SWM_ARG_ID_CENTER) { + if (g.w / 2 + dx < 1) + dx = 1 - g.w / 2; + + win->g.x = g.x - dx; + win->g.w = g.w + 2 * dx; + } else { + if (g.w + dx < 1) + dx = 1 - g.w; + + if (left) + win->g.x = g.x - dx; + + win->g.w = g.w + dx; + } - if (ev.xmotion.x <= 1) - ev.xmotion.x = 1; - if (ev.xmotion.y <= 1) - ev.xmotion.y = 1; - win->g.w = ev.xmotion.x; - win->g.h = ev.xmotion.y; + constrain_window(win, r, 1); - /* not free, don't sync more than 60 times / second */ - if ((ev.xmotion.time - time) > (1000 / 60) ) { + /* not free, don't sync more than 120 times / second */ + if ((ev.xmotion.time - time) > (1000 / 120) ) { time = ev.xmotion.time; XSync(display, False); - resize_window(win, args->id); + update_window(win); } break; } } while (ev.type != ButtonRelease); if (time) { XSync(display, False); - resize_window(win, args->id); + update_window(win); } store_float_geom(win,r); - XWarpPointer(display, None, win->id, 0, 0, 0, 0, win->g.w - 1, - win->g.h - 1); XUngrabPointer(display, CurrentTime); + XFreeCursor(display, cursor); /* drain events */ - while (XCheckMaskEvent(display, EnterWindowMask, &ev)); + drain_enter_notify(); } void -move_window(struct ws_win *win) +resize_step(struct swm_region *r, union arg *args) { - unsigned int mask; - XWindowChanges wc; - struct swm_region *r; - - r = root_to_region(win->wa.root); - bzero(&wc, sizeof wc); - mask = CWX | CWY; - wc.x = win->g.x; - wc.y = win->g.y; + struct ws_win *win = NULL; - DNPRINTF(SWM_D_STACK, "move_window: win %lu x %d y %d w %d h %d\n", - win->id, wc.x, wc.y, wc.width, wc.height); + if (r && r->ws && r->ws->focus) + win = r->ws->focus; + else + return; - XConfigureWindow(display, win->id, mask, &wc); - configreq_win(win); + resize(win, args); } +#define SWM_MOVE_STEPS (50) + void move(struct ws_win *win, union arg *args) { XEvent ev; Time time = 0; - struct swm_region *r = win->ws->r; - union arg a; + int move_step = 0; + struct swm_region *r = NULL; + + Window rr, cr; + int x, y, wx, wy; + unsigned int mask; + + if (win == NULL) + return; + r = win->ws->r; DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %lu\n", win->id, win->floating, win->transient); @@ -3025,63 +3958,103 @@ move(struct ws_win *win, union arg *args) win->manual = 1; if (win->floating == 0 && !win->transient) { - win->floating = 1; ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom, _NET_WM_STATE_ADD); } ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom, _NET_WM_STATE_ADD); - /* raise the window = move to last in window list */ - a.id = SWM_ARG_ID_MOVELAST; - swapwin(r, &a); stack(); + move_step = 0; + switch (args->id) { + case SWM_ARG_ID_MOVELEFT: + win->g.x -= (SWM_MOVE_STEPS - border_width); + move_step = 1; + break; + case SWM_ARG_ID_MOVERIGHT: + win->g.x += (SWM_MOVE_STEPS - border_width); + move_step = 1; + break; + case SWM_ARG_ID_MOVEUP: + win->g.y -= (SWM_MOVE_STEPS - border_width); + move_step = 1; + break; + case SWM_ARG_ID_MOVEDOWN: + win->g.y += (SWM_MOVE_STEPS - border_width); + move_step = 1; + break; + default: + break; + } + if (move_step) { + constrain_window(win, r, 0); + update_window(win); + store_float_geom(win,r); + return; + } + if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync, - GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess) + GrabModeAsync, None, XCreateFontCursor(display, XC_fleur), + CurrentTime) != GrabSuccess) return; - XWarpPointer(display, None, win->id, 0, 0, 0, 0, -1, -1); + + /* get cursor offset from window root */ + if (!XQueryPointer(display, win->id, &rr, &cr, &x, &y, &wx, &wy, &mask)) + return; + do { XMaskEvent(display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev); - switch(ev.type) { + switch (ev.type) { case ConfigureRequest: case Expose: case MapRequest: handler[ev.type](&ev); break; case MotionNotify: - /* don't allow to move window origin out of region */ - if ( ev.xmotion.x_root < r->g.x || - ev.xmotion.x_root > r->g.x + r->g.w - 1 || - ev.xmotion.y_root < r->g.y || - ev.xmotion.y_root > r->g.y + r->g.h - 1) - continue; + win->g.x = ev.xmotion.x_root - wx - border_width; + win->g.y = ev.xmotion.y_root - wy - border_width; - win->g.x = ev.xmotion.x_root; - win->g.y = ev.xmotion.y_root; + constrain_window(win, r, 0); - /* not free, don't sync more than 60 times / second */ - if ((ev.xmotion.time - time) > (1000 / 60) ) { + /* not free, don't sync more than 120 times / second */ + if ((ev.xmotion.time - time) > (1000 / 120) ) { time = ev.xmotion.time; XSync(display, False); - move_window(win); + update_window(win); } break; } } while (ev.type != ButtonRelease); if (time) { XSync(display, False); - move_window(win); + update_window(win); } store_float_geom(win,r); - XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0); XUngrabPointer(display, CurrentTime); /* drain events */ - while (XCheckMaskEvent(display, EnterWindowMask, &ev)); + drain_enter_notify(); +} + +void +move_step(struct swm_region *r, union arg *args) +{ + struct ws_win *win = NULL; + + if (r && r->ws && r->ws->focus) + win = r->ws->focus; + else + return; + + if (!(win->transient != 0 || win->floating != 0)) + return; + + move(win, args); } + /* user/key callable function IDs */ enum keyfuncid { kf_cycle_layout, @@ -3114,6 +4087,8 @@ enum keyfuncid { kf_ws_10, kf_ws_next, kf_ws_prev, + kf_ws_next_all, + kf_ws_prev_all, kf_ws_prior, kf_screen_next, kf_screen_prev, @@ -3137,7 +4112,22 @@ enum keyfuncid { kf_spawn_lock, kf_spawn_initscr, kf_spawn_custom, - kf_dumpwins, + kf_iconify, + kf_uniconify, + kf_raise_toggle, + kf_button2, + kf_width_shrink, + kf_width_grow, + kf_height_shrink, + kf_height_grow, + kf_move_left, + kf_move_right, + kf_move_up, + kf_move_down, + kf_name_workspace, + kf_search_workspace, + kf_search_win, + kf_dumpwins, /* MUST BE LAST */ kf_invalid }; @@ -3188,6 +4178,8 @@ struct keyfunc { { "ws_10", switchws, {.id = 9} }, { "ws_next", cyclews, {.id = SWM_ARG_ID_CYCLEWS_UP} }, { "ws_prev", cyclews, {.id = SWM_ARG_ID_CYCLEWS_DOWN} }, + { "ws_next_all", cyclews, {.id = SWM_ARG_ID_CYCLEWS_UP_ALL} }, + { "ws_prev_all", cyclews, {.id = SWM_ARG_ID_CYCLEWS_DOWN_ALL} }, { "ws_prior", priorws, {0} }, { "screen_next", cyclescr, {.id = SWM_ARG_ID_CYCLESC_UP} }, { "screen_prev", cyclescr, {.id = SWM_ARG_ID_CYCLESC_DOWN} }, @@ -3211,7 +4203,22 @@ struct keyfunc { { "spawn_lock", legacyfunc, {0} }, { "spawn_initscr", legacyfunc, {0} }, { "spawn_custom", dummykeyfunc, {0} }, - { "dumpwins", dumpwins, {0} }, + { "iconify", iconify, {0} }, + { "uniconify", uniconify, {0} }, + { "raise_toggle", raise_toggle, {0} }, + { "button2", pressbutton, {2} }, + { "width_shrink", resize_step, {.id = SWM_ARG_ID_WIDTHSHRINK} }, + { "width_grow", resize_step, {.id = SWM_ARG_ID_WIDTHGROW} }, + { "height_shrink", resize_step, {.id = SWM_ARG_ID_HEIGHTSHRINK} }, + { "height_grow", resize_step, {.id = SWM_ARG_ID_HEIGHTGROW} }, + { "move_left", move_step, {.id = SWM_ARG_ID_MOVELEFT} }, + { "move_right", move_step, {.id = SWM_ARG_ID_MOVERIGHT} }, + { "move_up", move_step, {.id = SWM_ARG_ID_MOVEUP} }, + { "move_down", move_step, {.id = SWM_ARG_ID_MOVEDOWN} }, + { "name_workspace", name_workspace, {0} }, + { "search_workspace", search_workspace, {0} }, + { "search_win", search_win, {0} }, + { "dumpwins", dumpwins, {0} }, /* MUST BE LAST */ { "invalid key func", NULL, {0} }, }; struct key { @@ -3267,15 +4274,15 @@ struct spawn_prog { int spawns_size = 0, spawns_length = 0; struct spawn_prog *spawns = NULL; -void -spawn_custom(struct swm_region *r, union arg *args, char *spawn_name) +int +spawn_expand(struct swm_region *r, union arg *args, char *spawn_name, + char ***ret_args) { - union arg a; struct spawn_prog *prog = NULL; int i; char *ap, **real_args; - DNPRINTF(SWM_D_SPAWN, "spawn_custom %s\n", spawn_name); + DNPRINTF(SWM_D_SPAWN, "spawn_expand %s\n", spawn_name); /* find program */ for (i = 0; i < spawns_length; i++) { @@ -3285,7 +4292,7 @@ spawn_custom(struct swm_region *r, union arg *args, char *spawn_name) if (prog == NULL) { fprintf(stderr, "spawn_custom: program %s not found\n", spawn_name); - return; + return (-1); } /* make room for expanded args */ @@ -3342,10 +4349,66 @@ spawn_custom(struct swm_region *r, union arg *args, char *spawn_name) fprintf(stderr, "\n"); } #endif + *ret_args = real_args; + return (prog->argc); +} + +void +spawn_custom(struct swm_region *r, union arg *args, char *spawn_name) +{ + union arg a; + char **real_args; + int spawn_argc, i; + + if ((spawn_argc = spawn_expand(r, args, spawn_name, &real_args)) < 0) + return; + a.argv = real_args; + if (fork() == 0) + spawn(r->ws->idx, &a, 1); + + for (i = 0; i < spawn_argc; i++) + free(real_args[i]); + free(real_args); +} + +void +spawn_select(struct swm_region *r, union arg *args, char *spawn_name, int *pid) +{ + union arg a; + char **real_args; + int i, spawn_argc; + if ((spawn_argc = spawn_expand(r, args, spawn_name, &real_args)) < 0) + return; a.argv = real_args; - spawn(r, &a); - for (i = 0; i < prog->argc; i++) + + if (pipe(select_list_pipe) == -1) + err(1, "pipe error"); + if (pipe(select_resp_pipe) == -1) + err(1, "pipe error"); + + if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) + err(1, "could not disable SIGPIPE"); + switch (*pid = fork()) { + case -1: + err(1, "cannot fork"); + break; + case 0: /* child */ + if (dup2(select_list_pipe[0], 0) == -1) + err(1, "dup2"); + if (dup2(select_resp_pipe[1], 1) == -1) + err(1, "dup2"); + close(select_list_pipe[1]); + close(select_resp_pipe[0]); + spawn(r->ws->idx, &a, 0); + break; + default: /* parent */ + close(select_list_pipe[0]); + close(select_resp_pipe[1]); + break; + } + + for (i = 0; i < spawn_argc; i++) free(real_args[i]); free(real_args); } @@ -3458,8 +4521,9 @@ setconfspawn(char *selector, char *value, int flags) cp += (long)strspn(cp, " \t"); if (strlen(word) > 0) { prog->argc++; - prog->argv = realloc(prog->argv, - prog->argc * sizeof(char *)); + 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"); } @@ -3486,6 +4550,20 @@ setup_spawn(void) " -nf $bar_font_color" " -sb $bar_border" " -sf $bar_color", 0); + setconfspawn("search", "dmenu" + " -i" + " -fn $bar_font" + " -nb $bar_color" + " -nf $bar_font_color" + " -sb $bar_border" + " -sf $bar_color", 0); + setconfspawn("name_workspace", "dmenu" + " -p Workspace" + " -fn $bar_font" + " -nb $bar_color" + " -nf $bar_font_color" + " -sb $bar_border" + " -sf $bar_color", 0); } /* key bindings */ @@ -3551,7 +4629,8 @@ strdupsafe(char *str) } void -setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name) +setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, + char *spawn_name) { int i, j; DNPRINTF(SWM_D_KEY, "setkeybinding: enter %s [%s]\n", @@ -3598,7 +4677,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name keys_size = 4; DNPRINTF(SWM_D_KEY, "setkeybinding: init list %d\n", keys_size); keys = malloc((size_t)keys_size * sizeof(struct key)); - if (!keys) { + if (keys == NULL) { fprintf(stderr, "malloc failed\n"); perror(" failed"); quit(NULL, NULL); @@ -3607,7 +4686,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name keys_size *= 2; DNPRINTF(SWM_D_KEY, "setkeybinding: grow list %d\n", keys_size); keys = realloc(keys, (size_t)keys_size * sizeof(struct key)); - if (!keys) { + if (keys == NULL) { fprintf(stderr, "realloc failed\n"); perror(" failed"); quit(NULL, NULL); @@ -3623,7 +4702,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name keys[j].spawn_name = strdupsafe(spawn_name); } else { fprintf(stderr, "keys array problem?\n"); - if (!keys) { + if (keys == NULL) { fprintf(stderr, "keys array problem\n"); quit(NULL, NULL); } @@ -3695,7 +4774,7 @@ setup_keys(void) setkeybinding(MODKEY|ShiftMask, XK_j, kf_swap_next, NULL); setkeybinding(MODKEY|ShiftMask, XK_k, kf_swap_prev, NULL); setkeybinding(MODKEY|ShiftMask, XK_Return, kf_spawn_term, NULL); - setkeybinding(MODKEY, XK_p, kf_spawn_custom, "menu"); + setkeybinding(MODKEY, XK_p, kf_spawn_custom,"menu"); setkeybinding(MODKEY|ShiftMask, XK_q, kf_quit, NULL); setkeybinding(MODKEY, XK_q, kf_restart, NULL); setkeybinding(MODKEY, XK_m, kf_focus_main, NULL); @@ -3711,6 +4790,8 @@ setup_keys(void) setkeybinding(MODKEY, XK_0, kf_ws_10, NULL); setkeybinding(MODKEY, XK_Right, kf_ws_next, NULL); 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, XK_a, kf_ws_prior, NULL); setkeybinding(MODKEY|ShiftMask, XK_Right, kf_screen_next, NULL); setkeybinding(MODKEY|ShiftMask, XK_Left, kf_screen_prev, NULL); @@ -3729,18 +4810,64 @@ setup_keys(void) setkeybinding(MODKEY|ShiftMask, XK_Tab, kf_focus_prev, NULL); setkeybinding(MODKEY|ShiftMask, XK_x, kf_wind_kill, NULL); setkeybinding(MODKEY, XK_x, kf_wind_del, NULL); - setkeybinding(MODKEY, XK_s, kf_spawn_custom, "screenshot_all"); - setkeybinding(MODKEY|ShiftMask, XK_s, kf_spawn_custom, "screenshot_wind"); + setkeybinding(MODKEY, XK_s, kf_spawn_custom,"screenshot_all"); + setkeybinding(MODKEY|ShiftMask, XK_s, kf_spawn_custom,"screenshot_wind"); setkeybinding(MODKEY, XK_t, kf_float_toggle,NULL); setkeybinding(MODKEY|ShiftMask, XK_v, kf_version, NULL); - setkeybinding(MODKEY|ShiftMask, XK_Delete, kf_spawn_custom, "lock"); - setkeybinding(MODKEY|ShiftMask, XK_i, kf_spawn_custom, "initscr"); + setkeybinding(MODKEY|ShiftMask, XK_Delete, kf_spawn_custom,"lock"); + setkeybinding(MODKEY|ShiftMask, XK_i, kf_spawn_custom,"initscr"); + setkeybinding(MODKEY, XK_w, kf_iconify, NULL); + setkeybinding(MODKEY|ShiftMask, XK_w, kf_uniconify, NULL); + setkeybinding(MODKEY|ShiftMask, XK_r, kf_raise_toggle,NULL); + setkeybinding(MODKEY, XK_v, kf_button2, NULL); + setkeybinding(MODKEY, XK_equal, kf_width_grow, NULL); + setkeybinding(MODKEY, XK_minus, kf_width_shrink,NULL); + setkeybinding(MODKEY|ShiftMask, XK_equal, kf_height_grow, NULL); + setkeybinding(MODKEY|ShiftMask, XK_minus, kf_height_shrink,NULL); + setkeybinding(MODKEY, XK_bracketleft, kf_move_left, NULL); + setkeybinding(MODKEY, XK_bracketright,kf_move_right, NULL); + setkeybinding(MODKEY|ShiftMask, XK_bracketleft, kf_move_up, NULL); + setkeybinding(MODKEY|ShiftMask, XK_bracketright,kf_move_down, NULL); + setkeybinding(MODKEY|ShiftMask, XK_slash, kf_name_workspace,NULL); + setkeybinding(MODKEY, XK_slash, kf_search_workspace,NULL); + setkeybinding(MODKEY, XK_f, kf_search_win, NULL); #ifdef SWM_DEBUG setkeybinding(MODKEY|ShiftMask, XK_d, kf_dumpwins, NULL); #endif } void +clear_keys(void) +{ + int i; + + /* clear all key bindings, if any */ + for (i = 0; i < keys_length; i++) + free(keys[i].spawn_name); + keys_length = 0; +} + +int +setkeymapping(char *selector, char *value, int flags) +{ + char keymapping_file[PATH_MAX]; + DNPRINTF(SWM_D_KEY, "setkeymapping: enter\n"); + if (value[0] == '~') + snprintf(keymapping_file, sizeof keymapping_file, "%s/%s", + pwd->pw_dir, &value[1]); + else + strlcpy(keymapping_file, value, sizeof keymapping_file); + clear_keys(); + /* load new key bindings; if it fails, revert to default bindings */ + if (conf_load(keymapping_file, SWM_CONF_KEYMAPPING)) { + clear_keys(); + setup_keys(); + } + DNPRINTF(SWM_D_KEY, "setkeymapping: leave\n"); + return (0); +} + +void updatenumlockmask(void) { unsigned int i, j; @@ -3752,7 +4879,7 @@ updatenumlockmask(void) for (i = 0; i < 8; i++) for (j = 0; j < modmap->max_keypermod; j++) if (modmap->modifiermap[i * modmap->max_keypermod + j] - == XKeysymToKeycode(display, XK_Num_Lock)) + == XKeysymToKeycode(display, XK_Num_Lock)) numlockmask = (1 << i); XFreeModifiermap(modmap); @@ -3814,6 +4941,7 @@ const char *quirkname[] = { "ANYWHERE", "XTERM_FONTADJ", "FULLSCREEN", + "FOCUSPREV", }; /* SWM_Q_WS: retain '|' for back compat for now (2009-08-11) */ @@ -3834,7 +4962,8 @@ parsequirks(char *qstr, unsigned long *quirk) cp += (long)strspn(cp, SWM_Q_WS); for (i = 0; i < LENGTH(quirkname); i++) { if (!strncasecmp(name, quirkname[i], SWM_QUIRK_LEN)) { - DNPRINTF(SWM_D_QUIRK, "parsequirks: %s\n", name); + DNPRINTF(SWM_D_QUIRK, + "parsequirks: %s\n", name); if (i == 0) { *quirk = 0; return (0); @@ -3897,7 +5026,7 @@ setquirk(const char *class, const char *name, const int quirk) quirks_size = 4; DNPRINTF(SWM_D_QUIRK, "setquirk: init list %d\n", quirks_size); quirks = malloc((size_t)quirks_size * sizeof(struct quirk)); - if (!quirks) { + if (quirks == NULL) { fprintf(stderr, "setquirk: malloc failed\n"); perror(" failed"); quit(NULL, NULL); @@ -3905,8 +5034,9 @@ setquirk(const char *class, const char *name, const int quirk) } else if (quirks_length == quirks_size) { quirks_size *= 2; DNPRINTF(SWM_D_QUIRK, "setquirk: grow list %d\n", quirks_size); - quirks = realloc(quirks, (size_t)quirks_size * sizeof(struct quirk)); - if (!quirks) { + quirks = realloc(quirks, + (size_t)quirks_size * sizeof(struct quirk)); + if (quirks == NULL) { fprintf(stderr, "setquirk: realloc failed\n"); perror(" failed"); quit(NULL, NULL); @@ -3920,7 +5050,7 @@ setquirk(const char *class, const char *name, const int quirk) quirks[j].quirk = quirk; } else { fprintf(stderr, "quirks array problem?\n"); - if (!quirks) { + if (quirks == NULL) { fprintf(stderr, "quirks array problem!\n"); quit(NULL, NULL); } @@ -3948,7 +5078,7 @@ setconfquirk(char *selector, char *value, int flags) void setup_quirks(void) { - setquirk("MPlayer", "xv", SWM_Q_FLOAT | SWM_Q_FULLSCREEN); + setquirk("MPlayer", "xv", SWM_Q_FLOAT | SWM_Q_FULLSCREEN | SWM_Q_FOCUSPREV); setquirk("OpenOffice.org 3.2", "VCLSalFrame", SWM_Q_FLOAT); setquirk("Firefox-bin", "firefox-bin", SWM_Q_TRANSSZ); setquirk("Firefox", "Dialog", SWM_Q_FLOAT); @@ -3960,23 +5090,28 @@ setup_quirks(void) setquirk("Xitk", "Xine Window", SWM_Q_FLOAT | SWM_Q_ANYWHERE); setquirk("xine", "xine Video Fullscreen Window", SWM_Q_FULLSCREEN | SWM_Q_FLOAT); setquirk("pcb", "pcb", SWM_Q_FLOAT); + setquirk("SDL_App", "SDL_App", SWM_Q_FLOAT | SWM_Q_FULLSCREEN); } /* conf file stuff */ #define SWM_CONF_FILE "scrotwm.conf" -enum { SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_STACK_ENABLED, - SWM_S_CLOCK_ENABLED, SWM_S_CLOCK_FORMAT, SWM_S_CYCLE_EMPTY, - SWM_S_CYCLE_VISIBLE, SWM_S_SS_ENABLED, SWM_S_TERM_WIDTH, - SWM_S_TITLE_CLASS_ENABLED, SWM_S_TITLE_NAME_ENABLED, SWM_S_WINDOW_NAME_ENABLED, - SWM_S_FOCUS_MODE, SWM_S_DISABLE_BORDER, SWM_S_BAR_FONT, - SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM, SWM_S_SS_APP, SWM_S_DIALOG_RATIO, - SWM_S_BAR_AT_BOTTOM +enum { SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_BAR_BORDER_WIDTH, + SWM_S_STACK_ENABLED, SWM_S_CLOCK_ENABLED, SWM_S_CLOCK_FORMAT, + SWM_S_CYCLE_EMPTY, SWM_S_CYCLE_VISIBLE, SWM_S_SS_ENABLED, + SWM_S_TERM_WIDTH, SWM_S_TITLE_CLASS_ENABLED, + SWM_S_TITLE_NAME_ENABLED, SWM_S_WINDOW_NAME_ENABLED, SWM_S_URGENT_ENABLED, + SWM_S_FOCUS_MODE, SWM_S_DISABLE_BORDER, SWM_S_BORDER_WIDTH, + SWM_S_BAR_FONT, SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM, + SWM_S_SS_APP, SWM_S_DIALOG_RATIO, SWM_S_BAR_AT_BOTTOM, + SWM_S_VERBOSE_LAYOUT, SWM_S_BAR_JUSTIFY }; int setconfvalue(char *selector, char *value, int flags) { + int i; + switch (flags) { case SWM_S_BAR_DELAY: bar_delay = atoi(value); @@ -3984,9 +5119,22 @@ setconfvalue(char *selector, char *value, int flags) case SWM_S_BAR_ENABLED: bar_enabled = atoi(value); break; + case SWM_S_BAR_BORDER_WIDTH: + bar_border_width = atoi(value); + break; case SWM_S_BAR_AT_BOTTOM: bar_at_bottom = atoi(value); break; + case SWM_S_BAR_JUSTIFY: + if (!strcmp(value, "left")) + bar_justify = SWM_BAR_JUSTIFY_LEFT; + else if (!strcmp(value, "center")) + bar_justify = SWM_BAR_JUSTIFY_CENTER; + else if (!strcmp(value, "right")) + bar_justify = SWM_BAR_JUSTIFY_RIGHT; + else + errx(1, "invalid bar_justify"); + break; case SWM_S_STACK_ENABLED: stack_enabled = atoi(value); break; @@ -4021,6 +5169,9 @@ setconfvalue(char *selector, char *value, int flags) case SWM_S_TITLE_NAME_ENABLED: title_name_enabled = atoi(value); break; + case SWM_S_URGENT_ENABLED: + urgent_enabled = atoi(value); + break; case SWM_S_FOCUS_MODE: if (!strcmp(value, "default")) focus_mode = SWM_FOCUS_DEFAULT; @@ -4029,11 +5180,14 @@ setconfvalue(char *selector, char *value, int flags) else if (!strcmp(value, "synergy")) focus_mode = SWM_FOCUS_SYNERGY; else - err(1, "focus_mode"); + errx(1, "focus_mode"); break; case SWM_S_DISABLE_BORDER: disable_border = atoi(value); break; + case SWM_S_BORDER_WIDTH: + border_width = atoi(value); + break; case SWM_S_BAR_FONT: free(bar_fonts[0]); if ((bar_fonts[0] = strdup(value)) == NULL) @@ -4056,6 +5210,15 @@ setconfvalue(char *selector, char *value, int flags) if (dialog_ratio > 1.0 || dialog_ratio <= .3) dialog_ratio = .6; break; + case SWM_S_VERBOSE_LAYOUT: + verbose_layout = atoi(value); + for (i = 0; layouts[i].l_stack != NULL; i++) { + if (verbose_layout) + layouts[i].l_string = fancy_stacker; + else + layouts[i].l_string = plain_stacker; + } + break; default: return (1); } @@ -4092,21 +5255,155 @@ setconfregion(char *selector, char *value, int flags) return (0); } +int +setautorun(char *selector, char *value, int flags) +{ + int ws_id; + char s[1024]; + char *ap, *sp = s; + union arg a; + int argc = 0; + long pid; + struct pid_e *p; + + if (getenv("SWM_STARTED")) + return (0); + + bzero(s, sizeof s); + if (sscanf(value, "ws[%d]:%1023c", &ws_id, s) != 2) + errx(1, "invalid autorun entry, should be 'ws[]:command'"); + ws_id--; + if (ws_id < 0 || ws_id >= SWM_WS_MAX) + errx(1, "autorun: invalid workspace %d", ws_id + 1); + + /* + * This is a little intricate + * + * If the pid already exists we simply reuse it because it means it was + * used before AND not claimed by manage_window. We get away with + * altering it in the parent after INSERT because this can not be a race + */ + a.argv = NULL; + while ((ap = strsep(&sp, " \t")) != NULL) { + if (*ap == '\0') + continue; + DNPRINTF(SWM_D_SPAWN, "setautorun: arg [%s]\n", ap); + argc++; + if ((a.argv = realloc(a.argv, argc * sizeof(char *))) == NULL) + err(1, "setautorun: realloc"); + a.argv[argc - 1] = ap; + } + + if ((a.argv = realloc(a.argv, (argc + 1) * sizeof(char *))) == NULL) + err(1, "setautorun: realloc"); + a.argv[argc] = NULL; + + if ((pid = fork()) == 0) { + spawn(ws_id, &a, 1); + /* NOTREACHED */ + _exit(1); + } + free(a.argv); + + /* parent */ + p = find_pid(pid); + if (p == NULL) { + p = calloc(1, sizeof *p); + if (p == NULL) + return (1); + TAILQ_INSERT_TAIL(&pidlist, p, entry); + } + + p->pid = pid; + p->ws = ws_id; + + return (0); +} + +int +setlayout(char *selector, char *value, int flags) +{ + int ws_id, i, x, mg, ma, si, raise; + int st = SWM_V_STACK; + char s[1024]; + struct workspace *ws; + + if (getenv("SWM_STARTED")) + return (0); + + bzero(s, sizeof s); + if (sscanf(value, "ws[%d]:%d:%d:%d:%d:%1023c", + &ws_id, &mg, &ma, &si, &raise, s) != 6) + errx(1, "invalid layout entry, should be 'ws[]:" + "::::" + "'"); + ws_id--; + if (ws_id < 0 || ws_id >= SWM_WS_MAX) + errx(1, "layout: invalid workspace %d", ws_id + 1); + + if (!strcasecmp(s, "vertical")) + st = SWM_V_STACK; + else if (!strcasecmp(s, "horizontal")) + st = SWM_H_STACK; + else if (!strcasecmp(s, "fullscreen")) + st = SWM_MAX_STACK; + else + errx(1, "invalid layout entry, should be 'ws[]:" + "::::" + "'"); + + for (i = 0; i < ScreenCount(display); i++) { + ws = (struct workspace *)&screens[i].ws; + ws[ws_id].cur_layout = &layouts[st]; + + ws[ws_id].always_raise = raise; + if (st == SWM_MAX_STACK) + continue; + + /* master grow */ + for (x = 0; x < abs(mg); x++) { + ws[ws_id].cur_layout->l_config(&ws[ws_id], + mg >= 0 ? SWM_ARG_ID_MASTERGROW : + SWM_ARG_ID_MASTERSHRINK); + stack(); + } + /* master add */ + for (x = 0; x < abs(ma); x++) { + ws[ws_id].cur_layout->l_config(&ws[ws_id], + ma >= 0 ? SWM_ARG_ID_MASTERADD : + SWM_ARG_ID_MASTERDEL); + stack(); + } + /* stack inc */ + for (x = 0; x < abs(si); x++) { + ws[ws_id].cur_layout->l_config(&ws[ws_id], + si >= 0 ? SWM_ARG_ID_STACKINC : + SWM_ARG_ID_STACKDEC); + stack(); + } + } + + return (0); +} + /* config options */ struct config_option { char *optname; - int (*func)(char*, char*, int); - int funcflags; + int (*func)(char*, char*, int); + int funcflags; }; struct config_option configopt[] = { { "bar_enabled", setconfvalue, SWM_S_BAR_ENABLED }, { "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 }, { "bar_color", setconfcolor, SWM_S_COLOR_BAR }, { "bar_font_color", setconfcolor, SWM_S_COLOR_BAR_FONT }, { "bar_font", setconfvalue, SWM_S_BAR_FONT }, { "bar_action", setconfvalue, SWM_S_BAR_ACTION }, { "bar_delay", setconfvalue, SWM_S_BAR_DELAY }, + { "bar_justify", setconfvalue, SWM_S_BAR_JUSTIFY }, + { "keyboard_mapping", setkeymapping, 0 }, { "bind", setconfbinding, 0 }, { "stack_enabled", setconfvalue, SWM_S_STACK_ENABLED }, { "clock_enabled", setconfvalue, SWM_S_CLOCK_ENABLED }, @@ -4116,6 +5413,7 @@ struct config_option configopt[] = { { "cycle_empty", setconfvalue, SWM_S_CYCLE_EMPTY }, { "cycle_visible", setconfvalue, SWM_S_CYCLE_VISIBLE }, { "dialog_ratio", setconfvalue, SWM_S_DIALOG_RATIO }, + { "verbose_layout", setconfvalue, SWM_S_VERBOSE_LAYOUT }, { "modkey", setconfmodkey, 0 }, { "program", setconfspawn, 0 }, { "quirk", setconfquirk, 0 }, @@ -4124,16 +5422,20 @@ struct config_option configopt[] = { { "screenshot_enabled", setconfvalue, SWM_S_SS_ENABLED }, { "screenshot_app", setconfvalue, SWM_S_SS_APP }, { "window_name_enabled", setconfvalue, SWM_S_WINDOW_NAME_ENABLED }, + { "urgent_enabled", setconfvalue, SWM_S_URGENT_ENABLED }, { "term_width", setconfvalue, SWM_S_TERM_WIDTH }, { "title_class_enabled", setconfvalue, SWM_S_TITLE_CLASS_ENABLED }, { "title_name_enabled", setconfvalue, SWM_S_TITLE_NAME_ENABLED }, - { "focus_mode", setconfvalue, SWM_S_FOCUS_MODE }, - { "disable_border", setconfvalue, SWM_S_DISABLE_BORDER }, + { "focus_mode", setconfvalue, SWM_S_FOCUS_MODE }, + { "disable_border", setconfvalue, SWM_S_DISABLE_BORDER }, + { "border_width", setconfvalue, SWM_S_BORDER_WIDTH }, + { "autorun", setautorun, 0 }, + { "layout", setlayout, 0 }, }; int -conf_load(char *filename) +conf_load(char *filename, int keymapping) { FILE *config; char *line, *cp, *optsub, *optval; @@ -4148,7 +5450,7 @@ conf_load(char *filename) return (1); } if ((config = fopen(filename, "r")) == NULL) { - warn("conf_load: fopen"); + warn("conf_load: fopen: %s", filename); return (1); } @@ -4172,7 +5474,7 @@ conf_load(char *filename) if (wordlen == 0) { warnx("%s: line %zd: no option found", filename, lineno); - return (1); + goto out; } optind = -1; for (i = 0; i < LENGTH(configopt); i++) { @@ -4186,7 +5488,12 @@ conf_load(char *filename) if (optind == -1) { warnx("%s: line %zd: unknown option %.*s", filename, lineno, wordlen, cp); - return (1); + goto out; + } + if (keymapping && strcmp(opt->optname, "bind")) { + warnx("%s: line %zd: invalid option %.*s", + filename, lineno, wordlen, cp); + goto out; } cp += wordlen; cp += strspn(cp, " \t\n"); /* eat whitespace */ @@ -4199,9 +5506,16 @@ conf_load(char *filename) if (wordlen == 0) { warnx("%s: line %zd: syntax error", filename, lineno); + goto out; + } + + if(asprintf(&optsub, "%.*s", wordlen, cp) == + -1) { + warnx("%s: line %zd: unable to allocate" + "memory for selector", filename, + lineno); return (1); } - asprintf(&optsub, "%.*s", wordlen, cp); } cp += wordlen; cp += strspn(cp, "] \t\n"); /* eat trailing */ @@ -4226,16 +5540,107 @@ conf_load(char *filename) DNPRINTF(SWM_D_CONF, "conf_load end\n"); return (0); + +out: + free(line); + fclose(config); + + return (1); } void -set_child_transient(struct ws_win *win) +set_child_transient(struct ws_win *win, Window *trans) { - struct ws_win *parent; + struct ws_win *parent, *w; + XWMHints *wmh = NULL; + struct swm_region *r; + struct workspace *ws; parent = find_window(win->transient); if (parent) parent->child_trans = win; + else { + DNPRINTF(SWM_D_MISC, "set_child_transient: parent doesn't exist" + " for %lu trans %lu\n", win->id, win->transient); + + if (win->hints == NULL) { + fprintf(stderr, "no hints for %lu\n", win->id); + return; + } + + r = root_to_region(win->wa.root); + ws = r->ws; + /* parent doen't exist in our window list */ + TAILQ_FOREACH(w, &ws->winlist, entry) { + if (wmh) + XFree(wmh); + + if ((wmh = XGetWMHints(display, w->id)) == NULL) { + fprintf(stderr, "can't get hints for %lu\n", + w->id); + continue; + } + + if (win->hints->window_group != wmh->window_group) + continue; + + w->child_trans = win; + win->transient = w->id; + *trans = w->id; + DNPRINTF(SWM_D_MISC, "set_child_transient: asjusting " + "transient to %lu\n", win->transient); + break; + } + } + + if (wmh) + XFree(wmh); +} + +long +window_get_pid(Window win) +{ + Atom actual_type_return; + int actual_format_return = 0; + unsigned long nitems_return = 0; + unsigned long bytes_after_return = 0; + long *pid = NULL; + long ret = 0; + const char *errstr; + unsigned char *prop = NULL; + + if (XGetWindowProperty(display, win, + XInternAtom(display, "_NET_WM_PID", False), 0, 1, False, + XA_CARDINAL, &actual_type_return, &actual_format_return, + &nitems_return, &bytes_after_return, + (unsigned char**)(void*)&pid) != Success) + goto tryharder; + if (actual_type_return != XA_CARDINAL) + goto tryharder; + if (pid == NULL) + goto tryharder; + + ret = *pid; + XFree(pid); + + return (ret); + +tryharder: + if (XGetWindowProperty(display, win, + XInternAtom(display, "_SWM_PID", False), 0, SWM_PROPLEN, False, + XA_STRING, &actual_type_return, &actual_format_return, + &nitems_return, &bytes_after_return, &prop) != Success) + return (0); + if (actual_type_return != XA_STRING) + return (0); + if (prop == NULL) + return (0); + + ret = strtonum((const char *)prop, 0, UINT_MAX, &errstr); + /* ignore error because strtonum returns 0 anyway */ + XFree(prop); + + return (ret); } struct ws_win * @@ -4253,6 +5658,7 @@ manage_window(Window id) long mask; const char *errstr; XWindowChanges wc; + struct pid_e *p; if ((win = find_window(id)) != NULL) return (win); /* already being managed */ @@ -4262,27 +5668,37 @@ manage_window(Window id) DNPRINTF(SWM_D_MISC, "manage previously unmanaged window " "%lu\n", win->id); TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry); - TAILQ_INSERT_TAIL(&win->ws->winlist, win, entry); - if (win->transient) - set_child_transient(win); + if (win->transient) { + set_child_transient(win, &trans); + } if (trans && (ww = find_window(trans))) + TAILQ_INSERT_AFTER(&win->ws->winlist, ww, win, entry); + else + TAILQ_INSERT_TAIL(&win->ws->winlist, win, entry); ewmh_update_actions(win); return (win); } if ((win = calloc(1, sizeof(struct ws_win))) == NULL) - errx(1, "calloc: failed to allocate memory for new window"); + err(1, "calloc: failed to allocate memory for new window"); + + win->id = id; + + /* see if we need to override the workspace */ + p = find_pid(window_get_pid(id)); /* Get all the window data in one shot */ ws_idx_atom = XInternAtom(display, "_SWM_WS", False); - if (ws_idx_atom) + if (ws_idx_atom) { XGetWindowProperty(display, id, ws_idx_atom, 0, SWM_PROPLEN, False, XA_STRING, &type, &format, &nitems, &bytes, &prop); + } XGetWindowAttributes(display, id, &win->wa); XGetWMNormalHints(display, id, &win->sh, &mask); + win->hints = XGetWMHints(display, id); XGetTransientForHint(display, id, &trans); if (trans) { win->transient = trans; - set_child_transient(win); + set_child_transient(win, &trans); DNPRINTF(SWM_D_MISC, "manage_window: win %lu transient %lu\n", win->id, win->transient); } @@ -4299,15 +5715,22 @@ manage_window(Window id) XFree(prot); } + win->iconic = get_iconic(win); + /* * Figure out where to put the window. If it was previously assigned to * a workspace (either by spawn() or manually moving), and isn't * transient, * put it in the same workspace */ r = root_to_region(win->wa.root); - if (prop && win->transient == 0) { + if (p) { + ws = &r->s->ws[p->ws]; + TAILQ_REMOVE(&pidlist, p, entry); + free(p); + p = NULL; + } else if (prop && win->transient == 0) { DNPRINTF(SWM_D_PROP, "got property _SWM_WS=%s\n", prop); - ws_idx = strtonum(prop, 0, 9, &errstr); + ws_idx = strtonum((const char *)prop, 0, 9, &errstr); if (errstr) { DNPRINTF(SWM_D_EVENT, "window idx is %s: %s", errstr, prop); @@ -4333,7 +5756,10 @@ manage_window(Window id) win->id = id; win->ws = ws; win->s = r->s; /* this never changes */ - TAILQ_INSERT_TAIL(&ws->winlist, win, entry); + if (trans && (ww = find_window(trans))) + TAILQ_INSERT_AFTER(&ws->winlist, ww, win, entry); + else + TAILQ_INSERT_TAIL(&ws->winlist, win, entry); win->g.w = win->wa.width; win->g.h = win->wa.height; @@ -4345,7 +5771,8 @@ manage_window(Window id) /* Set window properties so we can remember this after reincarnation */ if (ws_idx_atom && prop == NULL && - snprintf(ws_idx_str, SWM_PROPLEN, "%d", ws->idx) < SWM_PROPLEN) { + snprintf((char *)ws_idx_str, SWM_PROPLEN, "%d", ws->idx) < + SWM_PROPLEN) { DNPRINTF(SWM_D_PROP, "setting property _SWM_WS to %s\n", ws_idx_str); XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8, @@ -4411,17 +5838,14 @@ manage_window(Window id) /* border me */ if (border_me) { bzero(&wc, sizeof wc); - wc.border_width = 1; + wc.border_width = border_width; mask = CWBorderWidth; XConfigureWindow(display, win->id, mask, &wc); - configreq_win(win); } XSelectInput(display, id, EnterWindowMask | FocusChangeMask | PropertyChangeMask | StructureNotifyMask); - set_win_state(win, NormalState); - /* floaters need to be mapped if they are in the current workspace */ if ((win->floating || win->transient) && (ws->idx == r->ws->idx)) XMapRaised(display, win->id); @@ -4474,8 +5898,7 @@ unmanage_window(struct ws_win *win) /* focus on root just in case */ XSetInputFocus(display, PointerRoot, PointerRoot, CurrentTime); - if (!win->floating) - focus_prev(win); + focus_prev(win); TAILQ_REMOVE(&win->ws->winlist, win, entry); TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry); @@ -4484,14 +5907,14 @@ unmanage_window(struct ws_win *win) } void -focus_magic(struct ws_win *win, int do_trans) +focus_magic(struct ws_win *win) { - DNPRINTF(SWM_D_FOCUS, "focus_magic: %lu %d\n", WINID(win), do_trans); + DNPRINTF(SWM_D_FOCUS, "focus_magic: %lu\n", WINID(win)); if (win == NULL) return; - if (do_trans == SWM_F_TRANSIENT && win->child_trans) { + if (win->child_trans) { /* win = parent & has a transient so focus on that */ if (win->java) { focus_win(win->child_trans); @@ -4536,8 +5959,8 @@ keypress(XEvent *e) keysym = XKeycodeToKeysym(display, (KeyCode)ev->keycode, 0); for (i = 0; i < keys_length; i++) if (keysym == keys[i].keysym - && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state) - && keyfuncs[keys[i].funcid].func) { + && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state) + && keyfuncs[keys[i].funcid].func) { if (keys[i].funcid == kf_spawn_custom) spawn_custom( root_to_region(ev->root), @@ -4561,11 +5984,10 @@ buttonpress(XEvent *e) DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window); - action = root_click; if ((win = find_window(ev->window)) == NULL) return; - focus_magic(win, SWM_F_TRANSIENT); + focus_magic(win); action = client_click; for (i = 0; i < LENGTH(buttons); i++) @@ -4602,17 +6024,7 @@ configurerequest(XEvent *e) } else { DNPRINTF(SWM_D_EVENT, "configurerequest: change window: %lu\n", ev->window); - if (win->floating) { - if (ev->value_mask & CWX) - win->g.x = ev->x; - if (ev->value_mask & CWY) - win->g.y = ev->y; - if (ev->value_mask & CWWidth) - win->g.w = ev->width; - if (ev->value_mask & CWHeight) - win->g.h = ev->height; - } - config_win(win); + config_win(win, ev); } } @@ -4631,6 +6043,8 @@ configurenotify(XEvent *e) adjust_font(win); if (font_adjusted) stack(); + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); } } @@ -4654,6 +6068,8 @@ destroynotify(XEvent *e) unmanage_window(win); stack(); + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); free_window(win); } @@ -4673,13 +6089,13 @@ enternotify(XEvent *e) ev->window, ev->mode, ev->detail, ev->root, ev->subwindow, ev->same_screen, ev->focus, ev->state); + if (ev->mode != NotifyNormal) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: generated by cursor grab.\n"); + return; + } + switch (focus_mode) { case SWM_FOCUS_DEFAULT: - if (QLength(display)) { - DNPRINTF(SWM_D_EVENT, "ignore enternotify %d\n", - QLength(display)); - return; - } break; case SWM_FOCUS_FOLLOW: break; @@ -4770,7 +6186,7 @@ enternotify(XEvent *e) return; } - focus_magic(win, SWM_F_TRANSIENT); + focus_magic(win); } /* lets us use one switch statement for arbitrary mode/detail combinations */ @@ -4868,7 +6284,7 @@ maprequest(XEvent *e) /* make new win focused */ r = root_to_region(win->wa.root); if (win->ws == r->ws) - focus_magic(win, SWM_F_GENERIC); + focus_magic(win); } void @@ -4877,18 +6293,24 @@ propertynotify(XEvent *e) struct ws_win *win; XPropertyEvent *ev = &e->xproperty; - DNPRINTF(SWM_D_EVENT, "propertynotify: window: %lu\n", - ev->window); + DNPRINTF(SWM_D_EVENT, "propertynotify: window: %lu atom:%s\n", + ev->window, XGetAtomName(display, ev->atom)); - if (ev->state == PropertyDelete) - return; /* ignore */ win = find_window(ev->window); if (win == NULL) return; + if (ev->state == PropertyDelete && ev->atom == a_swm_iconic) { + update_iconic(win, 0); + XMapRaised(display, win->id); + stack(); + focus_win(win); + return; + } + switch (ev->atom) { - case XA_WM_NORMAL_HINTS: #if 0 + case XA_WM_NORMAL_HINTS: long mask; XGetWMNormalHints(display, win->id, &win->sh, &mask); fprintf(stderr, "normal hints: flag 0x%x\n", win->sh.flags); @@ -4900,6 +6322,11 @@ propertynotify(XEvent *e) XMoveResizeWindow(display, win->id, win->g.x, win->g.y, win->g.w, win->g.h); #endif + case XA_WM_CLASS: + if (title_name_enabled || title_class_enabled) + bar_update(); + break; + case XA_WM_NAME: if (window_name_enabled) bar_update(); break; @@ -4923,7 +6350,25 @@ unmapnotify(XEvent *e) if (getstate(e->xunmap.window) == NormalState) { unmanage_window(win); stack(); + + /* giant hack for apps that don't destroy transient windows */ + /* eat a bunch of events to prevent remanaging the window */ + XEvent cne; + while (XCheckWindowEvent(display, e->xunmap.window, + EnterWindowMask, &cne)) + ; + while (XCheckWindowEvent(display, e->xunmap.window, + StructureNotifyMask, &cne)) + ; + while (XCheckWindowEvent(display, e->xunmap.window, + SubstructureNotifyMask, &cne)) + ; + /* resend unmap because we ated it */ + XUnmapWindow(display, e->xunmap.window); } + + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); } void @@ -4968,7 +6413,8 @@ clientmessage(XEvent *e) XKillClient(display, win->id); } if (ev->message_type == ewmh[_NET_MOVERESIZE_WINDOW].atom) { - DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_MOVERESIZE_WINDOW \n"); + DNPRINTF(SWM_D_EVENT, + "clientmessage: _NET_MOVERESIZE_WINDOW \n"); if (win->floating) { if (ev->data.l[0] & (1<<8)) /* x */ win->g.x = ev->data.l[1]; @@ -4982,13 +6428,14 @@ clientmessage(XEvent *e) else { /* TODO: Change stack sizes */ } - config_win(win); + config_win(win, NULL); } if (ev->message_type == ewmh[_NET_WM_STATE].atom) { DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_WM_STATE \n"); ewmh_update_win_state(win, ev->data.l[1], ev->data.l[0]); if (ev->data.l[2]) - ewmh_update_win_state(win, ev->data.l[2], ev->data.l[0]); + ewmh_update_win_state(win, ev->data.l[2], + ev->data.l[0]); stack(); } @@ -5045,7 +6492,7 @@ new_region(struct swm_screen *s, int x, int y, int w, int h) (X(r) + WIDTH(r)) > x && Y(r) < (y + h) && (Y(r) + HEIGHT(r)) > y) { - if (r->ws->r != NULL) + if (r->ws->r != NULL) r->ws->old_r = r->ws->r; r->ws->r = NULL; XDestroyWindow(display, r->bar_window); @@ -5074,7 +6521,7 @@ new_region(struct swm_screen *s, int x, int y, int w, int h) ws = r->ws; } else if ((r = calloc(1, sizeof(struct swm_region))) == NULL) - errx(1, "calloc: failed to allocate memory for screen"); + err(1, "calloc: failed to allocate memory for screen"); /* if we don't have a workspace already, find one */ if (ws == NULL) { @@ -5086,7 +6533,7 @@ new_region(struct swm_screen *s, int x, int y, int w, int h) } if (ws == NULL) - errx(1, "no free workspaces\n"); + errx(1, "no free workspaces"); X(r) = x; Y(r) = y; @@ -5175,7 +6622,7 @@ screenchange(XEvent *e) { if (screens[i].root == xe->root) break; if (i >= ScreenCount(display)) - errx(1, "screenchange: screen not found\n"); + errx(1, "screenchange: screen not found"); /* brute force for now, just re-enumerate the regions */ scan_xrandr(i); @@ -5185,6 +6632,8 @@ screenchange(XEvent *e) { TAILQ_FOREACH(r, &screens[i].rl, entry) bar_setup(r); stack(); + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); } void @@ -5238,13 +6687,10 @@ setup_screens(void) int i, j, k; int errorbase, major, minor; struct workspace *ws; - int ws_idx_atom; if ((screens = calloc(ScreenCount(display), sizeof(struct swm_screen))) == NULL) - errx(1, "calloc: screens"); - - ws_idx_atom = XInternAtom(display, "_SWM_WS", False); + err(1, "calloc: screens"); /* initial Xrandr setup */ xrandr_support = XRRQueryExtension(display, @@ -5277,6 +6723,7 @@ setup_screens(void) for (j = 0; j < SWM_WS_MAX; j++) { ws = &screens[i].ws[j]; ws->idx = j; + ws->name = NULL; ws->focus = NULL; ws->r = NULL; ws->old_r = NULL; @@ -5288,6 +6735,7 @@ setup_screens(void) layouts[k].l_config(ws, SWM_ARG_ID_STACKINIT); ws->cur_layout = &layouts[0]; + ws->cur_layout->l_string(ws); } scan_xrandr(i); @@ -5313,7 +6761,7 @@ setup_globals(void) if ((spawn_term[0] = strdup("xterm")) == NULL) err(1, "setup_globals: strdup"); if ((clock_format = strdup("%a %b %d %R %Z %Y")) == NULL) - errx(1, "strdup"); + err(1, "strdup"); } void @@ -5345,7 +6793,6 @@ workaround(void) int main(int argc, char *argv[]) { - struct passwd *pwd; struct swm_region *r, *rr; struct ws_win *winfocus = NULL; struct timeval tv; @@ -5358,9 +6805,10 @@ main(int argc, char *argv[]) struct sigaction sact; start_argv = argv; - fprintf(stderr, "Welcome to scrotwm V%s cvs tag: %s\n", - SWM_VERSION, cvstag); - if (!setlocale(LC_CTYPE, "") || !XSupportsLocale()) + fprintf(stderr, "Welcome to scrotwm V%s Build: %s\n", + SCROTWM_VERSION, buildstr); + if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, "") || + !XSupportsLocale()) warnx("no locale support"); if (!(display = XOpenDisplay(0))) @@ -5387,6 +6835,11 @@ main(int argc, char *argv[]) aprot = XInternAtom(display, "WM_PROTOCOLS", False); adelete = XInternAtom(display, "WM_DELETE_WINDOW", False); takefocus = XInternAtom(display, "WM_TAKE_FOCUS", False); + a_wmname = XInternAtom(display, "WM_NAME", False); + a_netwmname = XInternAtom(display, "_NET_WM_NAME", False); + a_utf8_string = XInternAtom(display, "UTF8_STRING", False); + a_string = XInternAtom(display, "STRING", False); + a_swm_iconic = XInternAtom(display, "_SWM_ICONIC", False); /* look for local and global conf file */ pwd = getpwuid(getuid()); @@ -5412,15 +6865,17 @@ main(int argc, char *argv[]) cfile = conf; } if (cfile) - conf_load(cfile); + conf_load(cfile, SWM_CONF_DEFAULT); setup_ewmh(); /* set some values to work around bad programs */ workaround(); - /* grab existing windows (before we build the bars) */ grab_windows(); + if (getenv("SWM_STARTED") == NULL) + setenv("SWM_STARTED", "YES", 1); + /* setup all bars */ for (i = 0; i < ScreenCount(display); i++) TAILQ_FOREACH(r, &screens[i].rl, entry) { @@ -5433,6 +6888,8 @@ main(int argc, char *argv[]) grabkeys(); stack(); + if (focus_mode == SWM_FOCUS_DEFAULT) + drain_enter_notify(); xfd = ConnectionNumber(display); while (running) { @@ -5491,6 +6948,8 @@ main(int argc, char *argv[]) DNPRINTF(SWM_D_MISC, "select failed"); if (restart_wm == 1) restart(NULL, NULL); + if (search_resp == 1) + search_do_resp(); if (running == 0) goto done; if (bar_alarm) {