X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=5c4fbe807e1ecf5d79c2520cdffe359269d651f2;hb=3cd1a5315bccb23e07468e11cfafe1340ca347bf;hp=be7b57f1398d9c3d177d6ef1983537cb0cb577fb;hpb=4b754adf748b912abe34696e873f89dee0b368e3;p=spectrwm.git diff --git a/scrotwm.c b/scrotwm.c index be7b57f..5c4fbe8 100644 --- a/scrotwm.c +++ b/scrotwm.c @@ -52,7 +52,7 @@ static const char *cvstag = "$scrotwm$"; -#define SWM_VERSION "0.9.14" +#define SWM_VERSION "0.9.22" #include #include @@ -84,6 +84,10 @@ static const char *cvstag = "$scrotwm$"; #include #include +#ifdef __OSX__ +#include +#endif + #if RANDR_MAJOR < 1 # error XRandR versions less than 1.0 are not supported #endif @@ -148,6 +152,7 @@ u_int32_t swm_debug = 0 #define WIDTH(r) (r)->g.w #define HEIGHT(r) (r)->g.h #define SWM_MAX_FONT_STEPS (3) +#define WINID(w) (w ? w->id : 0) #ifndef SWM_LIB #define SWM_LIB "/usr/local/lib/libswmhack.so" @@ -160,12 +165,12 @@ Atom adelete; Atom takefocus; volatile sig_atomic_t running = 1; int outputs = 0; +int last_focus_event = FocusOut; int (*xerrorxlib)(Display *, XErrorEvent *); int other_wm; int ss_enabled = 0; int xrandr_support; int xrandr_eventbase; -int ignore_enter = 0; unsigned int numlockmask = 0; Display *display; @@ -193,6 +198,7 @@ int bar_verbose = 1; int bar_height = 0; int stack_enabled = 1; int clock_enabled = 1; +char *clock_format = NULL; int title_name_enabled = 0; int title_class_enabled = 0; pid_t bar_pid; @@ -304,10 +310,10 @@ enum keyfuncid { kf_screenshot_wind, kf_float_toggle, kf_version, - kf_dumpwins, kf_spawn_lock, kf_spawn_initscr, kf_spawn_custom, + kf_dumpwins, kf_invalid }; @@ -319,6 +325,8 @@ void horizontal_config(struct workspace *, int); void horizontal_stack(struct workspace *, struct swm_geometry *); void max_stack(struct workspace *, struct swm_geometry *); +struct ws_win *find_window(Window); + void grabbuttons(struct ws_win *, int); void new_region(struct swm_screen *, int, int, int, int); void unmanage_window(struct ws_win *); @@ -336,8 +344,8 @@ struct layout { { vertical_stack, vertical_config, 0, "[|]" }, { horizontal_stack, horizontal_config, 0, "[-]" }, { max_stack, NULL, - SWM_L_FOCUSPREV | SWM_L_MAPONFOCUS, "[ ]"}, - { NULL, NULL, 0}, + SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV, "[ ]"}, + { NULL, NULL, 0, NULL }, }; #define SWM_H_SLICE (32) @@ -369,9 +377,9 @@ enum { SWM_S_COLOR_BAR, SWM_S_COLOR_BAR_BORDER, SWM_S_COLOR_BAR_FONT, SWM_S_COLOR_FOCUS, SWM_S_COLOR_UNFOCUS, SWM_S_COLOR_MAX }; /* physical screen mapping */ -#define SWM_WS_MAX (10) /* XXX Too small? */ +#define SWM_WS_MAX (10) struct swm_screen { - int idx; /* screen index */ + int idx; /* screen index */ struct swm_region_list rl; /* list of regions on this screen */ struct swm_region_list orl; /* list of old regions */ Window root; @@ -392,30 +400,35 @@ union arg { #define SWM_ARG_ID_FOCUSNEXT (0) #define SWM_ARG_ID_FOCUSPREV (1) #define SWM_ARG_ID_FOCUSMAIN (2) -#define SWM_ARG_ID_SWAPNEXT (3) -#define SWM_ARG_ID_SWAPPREV (4) -#define SWM_ARG_ID_SWAPMAIN (5) -#define SWM_ARG_ID_MASTERSHRINK (6) -#define SWM_ARG_ID_MASTERGROW (7) -#define SWM_ARG_ID_MASTERADD (8) -#define SWM_ARG_ID_MASTERDEL (9) -#define SWM_ARG_ID_STACKRESET (10) -#define SWM_ARG_ID_STACKINIT (11) -#define SWM_ARG_ID_CYCLEWS_UP (12) -#define SWM_ARG_ID_CYCLEWS_DOWN (13) -#define SWM_ARG_ID_CYCLESC_UP (14) -#define SWM_ARG_ID_CYCLESC_DOWN (15) -#define SWM_ARG_ID_STACKINC (16) -#define SWM_ARG_ID_STACKDEC (17) -#define SWM_ARG_ID_SS_ALL (0) -#define SWM_ARG_ID_SS_WINDOW (1) -#define SWM_ARG_ID_DONTCENTER (0) -#define SWM_ARG_ID_CENTER (1) -#define SWM_ARG_ID_KILLWINDOW (0) -#define SWM_ARG_ID_DELETEWINDOW (1) +#define SWM_ARG_ID_FOCUSCUR (4) +#define SWM_ARG_ID_SWAPNEXT (10) +#define SWM_ARG_ID_SWAPPREV (11) +#define SWM_ARG_ID_SWAPMAIN (12) +#define SWM_ARG_ID_MASTERSHRINK (20) +#define SWM_ARG_ID_MASTERGROW (21) +#define SWM_ARG_ID_MASTERADD (22) +#define SWM_ARG_ID_MASTERDEL (23) +#define SWM_ARG_ID_STACKRESET (30) +#define SWM_ARG_ID_STACKINIT (31) +#define SWM_ARG_ID_CYCLEWS_UP (40) +#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_STACKINC (50) +#define SWM_ARG_ID_STACKDEC (51) +#define SWM_ARG_ID_SS_ALL (60) +#define SWM_ARG_ID_SS_WINDOW (61) +#define SWM_ARG_ID_DONTCENTER (70) +#define SWM_ARG_ID_CENTER (71) +#define SWM_ARG_ID_KILLWINDOW (80) +#define SWM_ARG_ID_DELETEWINDOW (81) 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) /* quirks */ struct quirk { char *class; @@ -599,8 +612,7 @@ void configurerequest(XEvent *); void configurenotify(XEvent *); void destroynotify(XEvent *); void enternotify(XEvent *); -void focusin(XEvent *); -void focusout(XEvent *); +void focusevent(XEvent *); void mapnotify(XEvent *); void mappingnotify(XEvent *); void maprequest(XEvent *); @@ -616,8 +628,8 @@ void (*handler[LASTEvent])(XEvent *) = { [ConfigureNotify] = configurenotify, [DestroyNotify] = destroynotify, [EnterNotify] = enternotify, - [FocusIn] = focusin, - [FocusOut] = focusout, + [FocusIn] = focusevent, + [FocusOut] = focusevent, [MapNotify] = mapnotify, [MappingNotify] = mappingnotify, [MapRequest] = maprequest, @@ -832,7 +844,8 @@ bar_update(void) else { time(&tmt); localtime_r(&tmt, &tm); - strftime(s, sizeof s, "%a %b %d %R %Z %Y ", &tm); + strftime(s, sizeof s, clock_format, &tm); + strlcat(s, " ", sizeof s); } for (i = 0; i < ScreenCount(display); i++) { @@ -844,7 +857,7 @@ bar_update(void) if (stack_enabled) stack = r->ws->cur_layout->name; - snprintf(loc, sizeof loc, "%d:%d %s %s %s %s", + snprintf(loc, sizeof loc, "%d:%d %s %s %s %s", x++, r->ws->idx + 1, stack, s, bar_ext, bar_vertext); bar_print(r, loc); @@ -1112,6 +1125,9 @@ unmap_window(struct ws_win *win) set_win_state(win, IconicState); XUnmapWindow(display, win->id); + if (win->ws->r) + XSetWindowBorder(display, win->id, + win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color); } void @@ -1223,13 +1239,32 @@ struct ws_win * find_window(Window id) { struct ws_win *win; - int i, j; + Window wrr, wpr, *wcr = NULL; + int i, j, nc; for (i = 0; i < ScreenCount(display); i++) for (j = 0; j < SWM_WS_MAX; j++) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) if (id == win->id) return (win); + + /* if we were looking for the parent return that window instead */ + if (XQueryTree(display, id, &wrr, &wpr, &wcr, &nc) == 0) + return (NULL); + if (wcr) + XFree(wcr); + + /* ignore not found and root */ + if (wpr == 0 || wrr == wpr) + return (NULL); + + /* look for parent */ + for (i = 0; i < ScreenCount(display); i++) + for (j = 0; j < SWM_WS_MAX; j++) + TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) + if (wpr == win->id) + return (win); + return (NULL); } @@ -1283,23 +1318,111 @@ spawnterm(struct swm_region *r, union arg *args) } void +kill_refs(struct ws_win *win) +{ + int i, x; + struct swm_region *r; + struct workspace *ws; + + if (win == NULL) + return; + + 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]; + if (win == ws->focus) + ws->focus = NULL; + if (win == ws->focus_prev) + ws->focus_prev = NULL; + } +} + +int +validate_win(struct ws_win *testwin) +{ + struct ws_win *win; + struct workspace *ws; + struct swm_region *r; + int i, x, foundit = 0; + + if (testwin == NULL) + return(0); + + for (i = 0, foundit = 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]; + TAILQ_FOREACH(win, &ws->winlist, entry) + if (win == testwin) + return (0); + } + return (1); +} + +int +validate_ws(struct workspace *testws) +{ + struct swm_region *r; + struct workspace *ws; + int foundit, i, x; + + /* validate all ws */ + for (i = 0, foundit = 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]; + if (ws == testws) + return (0); + } + return (1); +} + +void unfocus_win(struct ws_win *win) { + XEvent cne; + + DNPRINTF(SWM_D_FOCUS, "unfocus_win: id: %lu\n", WINID(win)); + if (win == NULL) return; if (win->ws == NULL) return; + + if (validate_ws(win->ws)) + abort(); + if (win->ws->r == NULL) return; + if (validate_win(win)) { + kill_refs(win); + return; + } + if (win->ws->focus == win) { win->ws->focus = NULL; win->ws->focus_prev = win; } + if (validate_win(win->ws->focus)) { + kill_refs(win->ws->focus); + win->ws->focus = NULL; + } + if (validate_win(win->ws->focus_prev)) { + kill_refs(win->ws->focus_prev); + win->ws->focus_prev = NULL; + } + + /* drain all previous unfocus events */ + while (XCheckTypedEvent(display, FocusOut, &cne) == True) + ; + grabbuttons(win, 0); XSetWindowBorder(display, win->id, win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color); + } void @@ -1308,7 +1431,7 @@ unfocus_all(void) struct ws_win *win; int i, j; - DNPRINTF(SWM_D_FOCUS, "unfocus_all:\n"); + DNPRINTF(SWM_D_FOCUS, "unfocus_all\n"); for (i = 0; i < ScreenCount(display); i++) for (j = 0; j < SWM_WS_MAX; j++) @@ -1319,6 +1442,12 @@ unfocus_all(void) void focus_win(struct ws_win *win) { + XEvent cne; + Window cur_focus; + int rr; + struct ws_win *cfw = NULL; + + DNPRINTF(SWM_D_FOCUS, "focus_win: id: %lu\n", win ? win->id : 0); if (win == NULL) @@ -1326,19 +1455,37 @@ focus_win(struct ws_win *win) if (win->ws == NULL) return; - /* use big hammer to make sure it works under all use cases */ - unfocus_all(); + if (validate_ws(win->ws)) + abort(); + if (validate_win(win)) { + kill_refs(win); + return; + } + + if (validate_win(win)) { + kill_refs(win); + return; + } + + XGetInputFocus(display, &cur_focus, &rr); + if ((cfw = find_window(cur_focus)) != NULL) + unfocus_win(cfw); + win->ws->focus = win; if (win->ws->r != NULL) { + /* drain all previous focus events */ + while (XCheckTypedEvent(display, FocusIn, &cne) == True) + ; + + if (win->java == 0) + XSetInputFocus(display, win->id, + RevertToParent, CurrentTime); grabbuttons(win, 1); - if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS) - XMapRaised(display, win->id); XSetWindowBorder(display, win->id, win->ws->r->s->c[SWM_S_COLOR_FOCUS].color); - if (win->java == 0) - XSetInputFocus(display, win->id, - RevertToPointerRoot, CurrentTime); + if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS) + XMapRaised(display, win->id); } } @@ -1347,8 +1494,9 @@ switchws(struct swm_region *r, union arg *args) { int wsid = args->id; struct swm_region *this_r, *other_r; - struct ws_win *win, *winfocus = NULL, *parent = NULL; + struct ws_win *win; struct workspace *new_ws, *old_ws; + union arg a; if (!(r && r->s)) return; @@ -1366,14 +1514,6 @@ switchws(struct swm_region *r, union arg *args) if (new_ws == old_ws) return; - /* get focus window */ - if (new_ws->focus) - winfocus = new_ws->focus; - else if (new_ws->focus_prev) - winfocus = new_ws->focus_prev; - else - winfocus = TAILQ_FIRST(&new_ws->winlist); - other_r = new_ws->r; if (other_r == NULL) { /* if the other workspace is hidden, switch windows */ @@ -1390,19 +1530,9 @@ switchws(struct swm_region *r, union arg *args) this_r->ws = new_ws; new_ws->r = this_r; - ignore_enter = 1; stack(); - if (winfocus) { - /* make sure we see the parent window */ - if (winfocus->transient) { - parent = find_window(winfocus->transient); - if (parent) - focus_win(parent); - } - - focus_win(winfocus); - } - ignore_enter = 0; + a.id = SWM_ARG_ID_FOCUSCUR; + focus(new_ws->r, &a); bar_update(); } @@ -1448,8 +1578,7 @@ void cyclescr(struct swm_region *r, union arg *args) { struct swm_region *rr = NULL; - struct workspace *ws = NULL; - struct ws_win *winfocus = NULL; + union arg a; int i, x, y; /* do nothing if we don't have more than one screen */ @@ -1474,25 +1603,20 @@ cyclescr(struct swm_region *r, union arg *args) if (rr == NULL) return; - ws = rr->ws; - winfocus = ws->focus; - if (winfocus == NULL) - winfocus = ws->focus_prev; - if (winfocus) { - /* use window coordinates */ - x = winfocus->g.x + 1; - y = winfocus->g.y + 1; - } else { - /* use region coordinates */ - x = rr->g.x + 1; - y = rr->g.y + 1 + bar_enabled ? bar_height : 0; - } - - unfocus_all(); - XSetInputFocus(display, PointerRoot, RevertToPointerRoot, CurrentTime); + /* move mouse to region */ + x = rr->g.x + 1; + y = rr->g.y + 1 + bar_enabled ? bar_height : 0; XWarpPointer(display, None, rr->s[i].root, 0, 0, 0, 0, x, y); - focus_win(winfocus); + a.id = SWM_ARG_ID_FOCUSCUR; + focus(rr, &a); + + if (rr->ws->focus) { + /* move to focus window */ + x = rr->ws->focus->g.x + 1; + y = rr->ws->focus->g.y + 1; + XWarpPointer(display, None, rr->s[i].root, 0, 0, 0, 0, x, y); + } } void @@ -1554,29 +1678,104 @@ swapwin(struct swm_region *r, union arg *args) return; } - ignore_enter = 1; stack(); } void +focus_prev(struct ws_win *win) +{ + struct ws_win *winfocus = NULL, *winlostfocus = NULL; + struct ws_win *cur_focus = NULL; + struct ws_win_list *wl = NULL; + struct workspace *ws = NULL; + + DNPRINTF(SWM_D_FOCUS, "focus_prev: id %lu\n", WINID(win)); + + if (!(win && win->ws)) + return; + + ws = win->ws; + wl = &ws->winlist; + cur_focus = ws->focus; + winlostfocus = cur_focus; + + /* pickle, just focus on whatever */ + if (cur_focus == NULL) { + /* use prev_focus if valid */ + if (ws->focus_prev && ws->focus_prev != cur_focus && + find_window(WINID(ws->focus_prev))) + winfocus = ws->focus_prev; + if (winfocus == NULL) + winfocus = TAILQ_FIRST(wl); + goto done; + } + + /* if transient focus on parent */ + if (cur_focus->transient) { + winfocus = find_window(cur_focus->transient); + goto done; + } + + /* if in max_stack try harder */ + if (ws->cur_layout->flags & SWM_L_FOCUSPREV) { + if (cur_focus != ws->focus_prev) + winfocus = ws->focus_prev; + else if (cur_focus != ws->focus) + winfocus = ws->focus; + else + winfocus = TAILQ_PREV(win, ws_win_list, entry); + if (winfocus) + goto done; + } + + if (cur_focus == win) + winfocus = TAILQ_PREV(win, ws_win_list, entry); + if (winfocus == NULL) + winfocus = TAILQ_LAST(wl, ws_win_list); + if (winfocus == NULL || winfocus == win) + winfocus = TAILQ_NEXT(cur_focus, entry); +done: + if (winfocus == winlostfocus || winfocus == NULL) + return; + + focus_magic(winfocus, SWM_F_GENERIC); +} + +void focus(struct swm_region *r, union arg *args) { - struct ws_win *winfocus, *winlostfocus; - struct ws_win_list *wl; - struct ws_win *cur_focus; + struct ws_win *winfocus = NULL, *winlostfocus = NULL; + struct ws_win *cur_focus = NULL; + struct ws_win_list *wl = NULL; + struct workspace *ws = NULL; + + if (!(r && r->ws)) + return; DNPRINTF(SWM_D_FOCUS, "focus: id %d\n", args->id); - cur_focus = r->ws->focus; - if (cur_focus == NULL) + /* treat FOCUS_CUR special */ + if (args->id == SWM_ARG_ID_FOCUSCUR) { + if (r->ws->focus) + winfocus = r->ws->focus; + else if (r->ws->focus_prev) + winfocus = r->ws->focus_prev; + else + winfocus = TAILQ_FIRST(&r->ws->winlist); + + focus_magic(winfocus, SWM_F_GENERIC); return; + } - wl = &cur_focus->ws->winlist; + if ((cur_focus = r->ws->focus) == NULL) + return; + ws = r->ws; + wl = &ws->winlist; winlostfocus = cur_focus; switch (args->id) { - case SWM_ARG_ID_FOCUSPREV: + case SWM_ARG_ID_FOCUSPREV: winfocus = TAILQ_PREV(cur_focus, ws_win_list, entry); if (winfocus == NULL) winfocus = TAILQ_LAST(wl, ws_win_list); @@ -1592,8 +1791,6 @@ focus(struct swm_region *r, union arg *args) winfocus = TAILQ_FIRST(wl); if (winfocus == cur_focus) winfocus = cur_focus->ws->focus_prev; - if (winfocus == NULL) - return; break; default: @@ -1603,14 +1800,15 @@ focus(struct swm_region *r, union arg *args) if (winfocus == winlostfocus || winfocus == NULL) return; - focus_win(winfocus); + focus_magic(winfocus, SWM_F_GENERIC); } void cycle_layout(struct swm_region *r, union arg *args) { struct workspace *ws = r->ws; - struct ws_win *winfocus, *parent = NULL; + struct ws_win *winfocus; + union arg a; DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx); @@ -1620,17 +1818,10 @@ cycle_layout(struct swm_region *r, union arg *args) if (ws->cur_layout->l_stack == NULL) ws->cur_layout = &layouts[0]; - ignore_enter = 1; stack(); - /* make sure we see the parent window */ - if (winfocus) { - if (winfocus->transient) - parent = find_window(winfocus->transient); - if (parent) - focus_win(parent); - focus_win(winfocus); - } - ignore_enter = 0; + a.id = SWM_ARG_ID_FOCUSCUR; + focus(r, &a); + bar_update(); } void @@ -1707,7 +1898,6 @@ stack_floater(struct ws_win *win, struct swm_region *r) wc.y = (HEIGHT(r) - win->g.h) / 2; } - /* XXX need to fix manual moving into a new region */ /* adjust for region */ if (wc.x < r->g.x) wc.x += r->g.x; @@ -1764,6 +1954,7 @@ void stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) { XWindowChanges wc; + XWindowAttributes wa; struct swm_geometry win_g, r_g = *g; struct ws_win *win; int i, j, s, stacks; @@ -1917,7 +2108,10 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) XConfigureWindow(display, win->id, mask, &wc); configreq_win(win); } - XMapRaised(display, win->id); + + if (XGetWindowAttributes(display, win->id, &wa)) + if (wa.map_state == IsUnmapped) + XMapRaised(display, win->id); last_h = win_g.h; i++; @@ -2035,7 +2229,7 @@ max_stack(struct workspace *ws, struct swm_geometry *g) { XWindowChanges wc; struct swm_geometry gg = *g; - struct ws_win *win, *wintrans = NULL; + struct ws_win *win, *wintrans = NULL, *parent = NULL; unsigned int mask; int winno; @@ -2051,6 +2245,7 @@ max_stack(struct workspace *ws, struct swm_geometry *g) TAILQ_FOREACH(win, &ws->winlist, entry) { if (win->transient) { wintrans = win; + parent = find_window(win->transient); continue; } @@ -2075,8 +2270,10 @@ max_stack(struct workspace *ws, struct swm_geometry *g) /* put the last transient on top */ if (wintrans) { + if (parent) + XMapRaised(display, parent->id); stack_floater(wintrans, ws->r); - focus_win(wintrans); /* override */ + focus_magic(wintrans, SWM_F_TRANSIENT); } } @@ -2084,10 +2281,11 @@ void send_to_ws(struct swm_region *r, union arg *args) { int wsid = args->id; - struct ws_win *win = win, *winfocus = NULL; + struct ws_win *win = win; struct workspace *ws, *nws; Atom ws_idx_atom = 0; unsigned char ws_idx_str[SWM_PROPLEN]; + union arg a; if (r && r->ws) win = r->ws->focus; @@ -2095,26 +2293,16 @@ send_to_ws(struct swm_region *r, union arg *args) return; if (win == NULL) return; + if (win->ws->idx == wsid) + return; DNPRINTF(SWM_D_MOVE, "send_to_ws: win: %lu\n", win->id); ws = win->ws; nws = &win->s->ws[wsid]; - /* find a window to focus */ - winfocus = TAILQ_PREV(win, ws_win_list, entry); - if (TAILQ_FIRST(&ws->winlist) == win) - winfocus = TAILQ_NEXT(win, entry); - else { - winfocus = TAILQ_PREV(win, ws_win_list, entry); - if (winfocus == NULL) - winfocus = TAILQ_LAST(&ws->winlist, ws_win_list); - } - /* out of windows in ws so focus on nws instead if we multi screen */ - if (winfocus == NULL) - if (ScreenCount(display) > 1 || outputs > 1) - winfocus = win; - + a.id = SWM_ARG_ID_FOCUSPREV; + focus(r, &a); unmap_window(win); TAILQ_REMOVE(&ws->winlist, win, entry); TAILQ_INSERT_TAIL(&nws->winlist, win, entry); @@ -2129,13 +2317,7 @@ send_to_ws(struct swm_region *r, union arg *args) XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8, PropModeReplace, ws_idx_str, SWM_PROPLEN); } - - if (count_win(nws, 1) == 1) - nws->focus = win; - stack(); - if (winfocus) - focus_win(winfocus); } void @@ -2157,6 +2339,7 @@ void floating_toggle(struct swm_region *r, union arg *args) { struct ws_win *win = r->ws->focus; + union arg a; if (win == NULL) return; @@ -2164,7 +2347,8 @@ floating_toggle(struct swm_region *r, union arg *args) win->floating = !win->floating; win->manual = 0; stack(); - focus_win(win); + a.id = SWM_ARG_ID_FOCUSCUR; + focus(win->ws->r, &a); } void @@ -2200,7 +2384,7 @@ resize(struct ws_win *win, union arg *args) Time time = 0; struct swm_region *r = win->ws->r; - DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %d\n", + DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %lu\n", win->id, win->floating, win->transient); if (!(win->transient != 0 || win->floating != 0)) @@ -2284,7 +2468,7 @@ move(struct ws_win *win, union arg *args) int restack = 0; struct swm_region *r = win->ws->r; - DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %d\n", + DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %lu\n", win->id, win->floating, win->transient); if (win->floating == 0) { @@ -2338,8 +2522,6 @@ move(struct ws_win *win, union arg *args) /* drain events */ while (XCheckMaskEvent(display, EnterWindowMask, &ev)); - - /* XXX need to fix manual moving into a new region */ } /* key definitions */ @@ -3166,10 +3348,11 @@ setup_quirks(void) #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_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_BAR_FONT, SWM_S_BAR_ACTION, - SWM_S_SPAWN_TERM, SWM_S_SS_APP, SWM_S_DIALOG_RATIO }; + 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_BAR_FONT, + SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM, SWM_S_SS_APP, SWM_S_DIALOG_RATIO + }; int setconfvalue(char *selector, char *value, int flags) @@ -3187,6 +3370,13 @@ setconfvalue(char *selector, char *value, int flags) case SWM_S_CLOCK_ENABLED: clock_enabled = atoi(value); break; + case SWM_S_CLOCK_FORMAT: +#ifndef SWM_DENY_CLOCK_FORMAT + free(clock_format); + if ((clock_format = strdup(value)) == NULL) + err(1, "setconfvalue: clock_format"); +#endif + break; case SWM_S_CYCLE_EMPTY: cycle_empty = atoi(value); break; @@ -3280,6 +3470,7 @@ struct config_option configopt[] = { { "bind", setconfbinding, 0 }, { "stack_enabled", setconfvalue, SWM_S_STACK_ENABLED }, { "clock_enabled", setconfvalue, SWM_S_CLOCK_ENABLED }, + { "clock_format", setconfvalue, SWM_S_CLOCK_FORMAT }, { "color_focus", setconfcolor, SWM_S_COLOR_FOCUS }, { "color_unfocus", setconfcolor, SWM_S_COLOR_UNFOCUS }, { "cycle_empty", setconfvalue, SWM_S_CYCLE_EMPTY }, @@ -3394,12 +3585,22 @@ conf_load(char *filename) return (0); } +void +set_child_transient(struct ws_win *win) +{ + struct ws_win *parent; + + parent = find_window(win->transient); + if (parent) + parent->child_trans = win; +} + struct ws_win * manage_window(Window id) { Window trans = 0; struct workspace *ws; - struct ws_win *win, *ww, *parent; + struct ws_win *win, *ww; int format, i, ws_idx, n, border_me = 0; unsigned long nitems, bytes; Atom ws_idx_atom = 0, type; @@ -3419,6 +3620,8 @@ manage_window(Window id) "%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); return (win); } @@ -3435,11 +3638,9 @@ manage_window(Window id) XGetTransientForHint(display, id, &trans); if (trans) { win->transient = trans; - parent = find_window(win->transient); - if (parent) - parent->child_trans = win; - DNPRINTF(SWM_D_MISC, "manage_window: win %u transient %u\n", - (unsigned)win->id, win->transient); + set_child_transient(win); + DNPRINTF(SWM_D_MISC, "manage_window: win %lu transient %lu\n", + win->id, win->transient); } /* get supported protocols */ if (XGetWMProtocols(display, id, &prot, &n)) { @@ -3509,8 +3710,10 @@ manage_window(Window id) win->ch.res_class, win->ch.res_name); /* java is retarded so treat it special */ - if (strstr(win->ch.res_name, "sun-awt")) + if (strstr(win->ch.res_name, "sun-awt")) { win->java = 1; + border_me = 1; + } for (i = 0; i < quirks_length; i++){ if (!strcmp(win->ch.res_class, quirks[i].class) && @@ -3588,6 +3791,12 @@ free_window(struct ws_win *win) XFree(win->ch.res_class); if (win->ch.res_name) XFree(win->ch.res_name); + + kill_refs(win); + + /* paint memory */ + memset(win, 0xff, sizeof *win); /* XXX kill later */ + free(win); } @@ -3607,14 +3816,25 @@ unmanage_window(struct ws_win *win) parent->child_trans = NULL; } + /* work around for mplayer going full screen */ + if (!win->floating) + focus_prev(win); + TAILQ_REMOVE(&win->ws->winlist, win, entry); TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry); + + kill_refs(win); } void -focus_magic(struct ws_win *win) +focus_magic(struct ws_win *win, int do_trans) { - if (win->child_trans) { + DNPRINTF(SWM_D_FOCUS, "focus_magic: %lu %d\n", WINID(win), do_trans); + + if (win == NULL) + return; + + if (do_trans == SWM_F_TRANSIENT && win->child_trans) { /* win = parent & has a transient so focus on that */ if (win->java) { focus_win(win->child_trans); @@ -3633,15 +3853,6 @@ focus_magic(struct ws_win *win) } } -Bool -destroy_notify_cb(Display *d, XEvent *e, char *arg) -{ - struct ws_win *win = (struct ws_win *)arg; - if (win && win->id == e->xany.window && e->xany.type == DestroyNotify) - return (True); - return (False); -} - void expose(XEvent *e) { @@ -3679,10 +3890,9 @@ keypress(XEvent *e) void buttonpress(XEvent *e) { - XButtonPressedEvent *ev = &e->xbutton; - struct ws_win *win; int i, action; + XButtonPressedEvent *ev = &e->xbutton; DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window); @@ -3690,7 +3900,7 @@ buttonpress(XEvent *e) if ((win = find_window(ev->window)) == NULL) return; - focus_magic(win); + focus_magic(win, SWM_F_TRANSIENT); action = client_click; for (i = 0; i < LENGTH(buttons); i++) @@ -3762,106 +3972,184 @@ configurenotify(XEvent *e) void destroynotify(XEvent *e) { - struct ws_win *win, *w, *wn, *winfocus = NULL; - struct workspace *ws; - struct ws_win_list *wl; + struct ws_win *win; XDestroyWindowEvent *ev = &e->xdestroywindow; - int unmanaged = 0; DNPRINTF(SWM_D_EVENT, "destroynotify: window %lu\n", ev->window); if ((win = find_window(ev->window)) == NULL) { if ((win = find_unmanaged_window(ev->window)) == NULL) return; - unmanaged = 1; - } - - /* find a window to focus */ - ws = win->ws; - wl = &ws->winlist; - - for (w = TAILQ_FIRST(&ws->winlist); w != TAILQ_END(&ws->winlist); - w = wn) { - wn = TAILQ_NEXT(w, entry); - if (win == w) - continue; /* can't happen but oh well */ - - if (getstate(w->id) != -1) - continue; - unmanage_window(w); + free_window(win); + return; } - /* if we are transient give focus to parent */ - if (win->transient) - winfocus = find_window(win->transient); - else if (ws->focus == win) { - /* if in max_stack try harder */ - if (ws->cur_layout->flags & SWM_L_FOCUSPREV) { - if (win != ws->focus_prev) - winfocus = ws->focus_prev; - else if (win != ws->focus) - winfocus = ws->focus; - } - /* fallback and normal handling */ - if (winfocus == NULL) { - if (TAILQ_FIRST(wl) == win) - winfocus = TAILQ_NEXT(win, entry); - else { - winfocus = TAILQ_PREV(ws->focus, - ws_win_list, entry); - if (winfocus == NULL) - winfocus = TAILQ_LAST(wl, - ws_win_list); - } - } - } - if (unmanaged == 0) - unmanage_window(win); - free_window(win); + /* make sure we focus on something */ + win->floating = 0; - ignore_enter = 1; + unmanage_window(win); stack(); - if (winfocus) - focus_win(winfocus); - ignore_enter = 0; + free_window(win); } void enternotify(XEvent *e) { XCrossingEvent *ev = &e->xcrossing; + XEvent cne; struct ws_win *win; +#if 0 + struct ws_win *w; + Window focus_return; + int revert_to_return; +#endif + DNPRINTF(SWM_D_FOCUS, "enternotify: window: %lu mode %d detail %d root " + "%lu subwindow %lu same_screen %d focus %d state %d\n", + ev->window, ev->mode, ev->detail, ev->root, ev->subwindow, + ev->same_screen, ev->focus, ev->state); - DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window); + goto focusme; +#if 0 + /* + * all these checks need to be in this order because the + * XCheckTypedWindowEvent relies on weeding out the previous events + * + * making this code an option would enable a follow mouse for focus + * feature + */ - if (ignore_enter) { - /* eat event(r) to prevent autofocus */ - ignore_enter = 0; + /* + * state is set when we are switching workspaces and focus is set when + * the window or a subwindow already has focus (occurs during restart). + * + * Only honor the focus flag if last_focus_event is not FocusOut, + * this allows scrotwm to continue to control focus when another + * program is also playing with it. + */ + if (ev->state || (ev->focus && last_focus_event != FocusOut)) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: focus\n"); return; } + /* * happens when a window is created or destroyed and the border - * crosses the mouse pointer + * crosses the mouse pointer and when switching ws + * + * we need the subwindow test to see if we came from root in order + * to give focus to floaters */ - if (QLength(display)) + if (ev->mode == NotifyNormal && ev->detail == NotifyVirtual && + ev->subwindow == 0) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: NotifyVirtual\n"); return; + } - if ((win = find_window(ev->window)) == NULL) + /* this window already has focus */ + if (ev->mode == NotifyNormal && ev->detail == NotifyInferior) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win has focus\n"); return; + } - focus_magic(win); -} + /* this window is being deleted or moved to another ws */ + if (XCheckTypedWindowEvent(display, ev->window, ConfigureNotify, + &cne) == True) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: configurenotify\n"); + XPutBackEvent(display, &cne); + return; + } -void -focusin(XEvent *e) -{ - DNPRINTF(SWM_D_EVENT, "focusin: window: %lu\n", e->xfocus.window); + if ((win = find_window(ev->window)) == NULL) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win == NULL\n"); + return; + } + + /* + * In fullstack kill all enters unless they come from a different ws + * (i.e. another region) or focus has been grabbed externally. + */ + if (win->ws->cur_layout->flags & SWM_L_FOCUSPREV && + last_focus_event != FocusOut) { + XGetInputFocus(display, &focus_return, &revert_to_return); + if ((w = find_window(focus_return)) == NULL || + w->ws == win->ws) { + DNPRINTF(SWM_D_EVENT, "ignoring event: fullstack\n"); + return; + } + } +#endif +focusme: + if (QLength(display)) { + DNPRINTF(SWM_D_EVENT, "ignore enternotify %d\n", + QLength(display)); + return; + } + + if ((win = find_window(ev->window)) == NULL) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win == NULL\n"); + return; + } + + /* + * if we have more enternotifies let them handle it in due time + */ + if (XCheckTypedEvent(display, EnterNotify, &cne) == True) { + DNPRINTF(SWM_D_EVENT, + "ignoring enternotify: got more enternotify\n"); + XPutBackEvent(display, &cne); + return; + } + + focus_magic(win, SWM_F_TRANSIENT); } +/* lets us use one switch statement for arbitrary mode/detail combinations */ +#define MERGE_MEMBERS(a,b) (((a & 0xffff) << 16) | (b & 0xffff)) + void -focusout(XEvent *e) +focusevent(XEvent *e) { - DNPRINTF(SWM_D_EVENT, "focusout: window: %lu\n", e->xfocus.window); + DNPRINTF(SWM_D_EVENT, "focusevent: %s window: %lu mode %d detail %d\n", + ev->type == FocusIn ? "entering" : "leaving", + ev->window, ev->mode, ev->detail); +#if 0 + struct ws_win *win; + u_int32_t mode_detail; + XFocusChangeEvent *ev = &e->xfocus; + + DNPRINTF(SWM_D_EVENT, "focusevent: %s window: %lu mode %d detail %d\n", + ev->type == FocusIn ? "entering" : "leaving", + ev->window, ev->mode, ev->detail); + + if (last_focus_event == ev->type) { + DNPRINTF(SWM_D_FOCUS, "ignoring focusevent: bad ordering\n"); + return; + } + + last_focus_event = ev->type; + mode_detail = MERGE_MEMBERS(ev->mode, ev->detail); + + switch (mode_detail) { + /* synergy client focus operations */ + case MERGE_MEMBERS(NotifyNormal, NotifyNonlinear): + case MERGE_MEMBERS(NotifyNormal, NotifyNonlinearVirtual): + + /* synergy server focus operations */ + case MERGE_MEMBERS(NotifyWhileGrabbed, NotifyNonlinear): + + /* Entering applications like rdesktop that mangle the pointer */ + case MERGE_MEMBERS(NotifyNormal, NotifyPointer): + + if ((win = find_window(e->xfocus.window)) != NULL && win->ws->r) + XSetWindowBorder(display, win->id, + win->ws->r->s->c[ev->type == FocusIn ? + SWM_S_COLOR_FOCUS : SWM_S_COLOR_UNFOCUS].color); + break; + default: + fprintf(stderr, "ignoring focusevent\n"); + DNPRINTF(SWM_D_FOCUS, "ignoring focusevent\n"); + break; + } +#endif } void @@ -3892,9 +4180,8 @@ maprequest(XEvent *e) { struct ws_win *win; struct swm_region *r; - - XMapRequestEvent *ev = &e->xmaprequest; XWindowAttributes wa; + XMapRequestEvent *ev = &e->xmaprequest; DNPRINTF(SWM_D_EVENT, "maprequest: window: %lu\n", e->xmaprequest.window); @@ -3908,14 +4195,12 @@ maprequest(XEvent *e) if (win == NULL) return; /* can't happen */ - ignore_enter = 1; stack(); - ignore_enter = 0; /* make new win focused */ r = root_to_region(win->wa.root); if (win->ws == r->ws) - focus_win(win); + focus_magic(win, SWM_F_GENERIC); } void @@ -3956,8 +4241,7 @@ propertynotify(XEvent *e) void unmapnotify(XEvent *e) { - struct ws_win *win, *winfocus = NULL; - struct workspace *ws; + struct ws_win *win; DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window); @@ -3966,47 +4250,9 @@ unmapnotify(XEvent *e) if (win == NULL) return; - /* java can not deal with this heuristic */ - if (win->java) - return; - if (getstate(e->xunmap.window) == NormalState) { - /* - * this window does not have a destroy event but but it is no - * longer visible due to the app unmapping it so unmanage it - */ - ws = win->ws; - /* if we are max_stack try harder to focus on something */ - if (ws->cur_layout->flags & SWM_L_FOCUSPREV) { - if (win->transient) - winfocus = find_window(win->transient); - else if (win != ws->focus_prev) - winfocus = ws->focus_prev; - else if (win != ws->focus) - winfocus = ws->focus; - } - - /* normal and fallback if haven't found anything to focus on */ - if (winfocus == NULL) { - winfocus = TAILQ_PREV(win, ws_win_list, entry); - if (TAILQ_FIRST(&ws->winlist) == win) - winfocus = TAILQ_NEXT(win, entry); - else { - if (ws->focus) - winfocus = TAILQ_PREV(ws->focus, - ws_win_list, entry); - if (winfocus == NULL) - winfocus = TAILQ_LAST(&ws->winlist, - ws_win_list); - } - } - - /* trash window and refocus */ unmanage_window(win); - ignore_enter = 1; stack(); - focus_win(winfocus); - ignore_enter = 0; } } @@ -4327,6 +4573,8 @@ setup_globals(void) err(1, "setup_globals: strdup"); 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"); } void @@ -4356,6 +4604,7 @@ main(int argc, char *argv[]) struct swm_region *r, *rr; struct ws_win *winfocus = NULL; struct timeval tv; + union arg a; char conf[PATH_MAX], *cfile = NULL; struct stat sb; XEvent e; @@ -4422,6 +4671,8 @@ main(int argc, char *argv[]) /* set some values to work around bad programs */ workaround(); + unfocus_all(); + grabkeys(); stack(); @@ -4455,14 +4706,20 @@ main(int argc, char *argv[]) /* if we are being restarted go focus on first window */ if (winfocus) { - rr = TAILQ_FIRST(&screens[0].rl); + rr = winfocus->ws->r; + if (rr == NULL) { + /* not a visible window */ + winfocus = NULL; + continue; + } /* move pointer to first screen if multi screen */ if (ScreenCount(display) > 1 || outputs > 1) XWarpPointer(display, None, rr->s[0].root, 0, 0, 0, 0, rr->g.x, rr->g.y + bar_enabled ? bar_height : 0); - focus_win(winfocus); + a.id = SWM_ARG_ID_FOCUSCUR; + focus(rr, &a); winfocus = NULL; continue; }