X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=9f6d7ff8a57e7b4277ce7b8c38db7a413d8fe4d9;hb=63f6779ee0a5d8458a290284c233767788892448;hp=cbba2491a1cdc4bca26528ac67b83bac07e2424d;hpb=a916f33b0a702bde6ed1db75bb078755f5699180;p=spectrwm.git diff --git a/scrotwm.c b/scrotwm.c index cbba249..9f6d7ff 100644 --- a/scrotwm.c +++ b/scrotwm.c @@ -52,7 +52,7 @@ static const char *cvstag = "$scrotwm$"; -#define SWM_VERSION "0.9.9" +#define SWM_VERSION "0.9.25" #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,8 +152,11 @@ 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 SWM_EV_PROLOGUE(x) do { XGrabServer(x); } while (0) -#define SWM_EV_EPILOGUE(x) do { XUngrabServer(x); XFlush(x); } while (0) +#define WINID(w) (w ? w->id : 0) + +#define SWM_FOCUS_DEFAULT (0) +#define SWM_FOCUS_SYNERGY (1) +#define SWM_FOCUS_FOLLOW (2) #ifndef SWM_LIB #define SWM_LIB "/usr/local/lib/libswmhack.so" @@ -159,14 +166,15 @@ char **start_argv; Atom astate; Atom aprot; 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; @@ -194,8 +202,10 @@ 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; +int focus_mode = SWM_FOCUS_DEFAULT; pid_t bar_pid; GC bar_gc; XGCValues bar_gcv; @@ -226,6 +236,7 @@ struct swm_region { TAILQ_ENTRY(swm_region) entry; struct swm_geometry g; struct workspace *ws; /* current workspace on this region */ + struct workspace *ws_prior; /* prior workspace on this region */ struct swm_screen *s; /* screen idx */ Window bar_window; }; @@ -234,14 +245,21 @@ TAILQ_HEAD(swm_region_list, swm_region); struct ws_win { TAILQ_ENTRY(ws_win) entry; Window id; - struct swm_geometry g; + Window transient; + struct ws_win *child_trans; /* transient child window */ + struct swm_geometry g; /* current geometry */ + struct swm_geometry g_float; /* geometry when floating */ + struct swm_geometry rg_float; /* region geom when floating */ + int g_floatvalid; /* flag: geometry in g_float is valid */ + int floatmaxed; /* flag: floater was maxed in max_stack */ int floating; - int transient; int manual; int font_size_boundary[SWM_MAX_FONT_STEPS]; int font_steps; int last_inc; int can_delete; + int take_focus; + int java; unsigned long quirks; struct workspace *ws; /* always valid */ struct swm_screen *s; /* always valid, never changes */ @@ -251,63 +269,6 @@ struct ws_win { }; TAILQ_HEAD(ws_win_list, ws_win); -/* user/key callable function IDs */ -enum keyfuncid { - kf_cycle_layout, - kf_stack_reset, - kf_master_shrink, - kf_master_grow, - kf_master_add, - kf_master_del, - kf_stack_inc, - kf_stack_dec, - kf_swap_main, - kf_focus_next, - kf_focus_prev, - kf_swap_next, - kf_swap_prev, - kf_spawn_term, - kf_spawn_menu, - kf_quit, - kf_restart, - kf_focus_main, - kf_ws_1, - kf_ws_2, - kf_ws_3, - kf_ws_4, - kf_ws_5, - kf_ws_6, - kf_ws_7, - kf_ws_8, - kf_ws_9, - kf_ws_10, - kf_ws_next, - kf_ws_prev, - kf_screen_next, - kf_screen_prev, - kf_mvws_1, - kf_mvws_2, - kf_mvws_3, - kf_mvws_4, - kf_mvws_5, - kf_mvws_6, - kf_mvws_7, - kf_mvws_8, - kf_mvws_9, - kf_mvws_10, - kf_bar_toggle, - kf_wind_kill, - kf_wind_del, - kf_screenshot_all, - kf_screenshot_wind, - kf_float_toggle, - kf_version, - kf_spawn_lock, - kf_spawn_initscr, - kf_spawn_custom, - kf_invalid -}; - /* layout handlers */ void stack(void); void vertical_config(struct workspace *, int); @@ -316,8 +277,12 @@ 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 *); +long getstate(Window); struct layout { void (*l_stack)(struct workspace *, struct swm_geometry *); @@ -331,23 +296,26 @@ 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 }, }; +/* position of max_stack mode in the layouts array */ +#define SWM_MAX_STACK 2 + #define SWM_H_SLICE (32) #define SWM_V_SLICE (32) /* define work spaces */ struct workspace { int idx; /* workspace index */ - int restack; /* restack on switch */ struct layout *cur_layout; /* current layout handlers */ struct ws_win *focus; /* may be NULL */ struct ws_win *focus_prev; /* may be NULL */ struct swm_region *r; /* may be NULL */ 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 */ /* stacker state */ struct { @@ -364,9 +332,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; @@ -387,30 +355,36 @@ 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_MOVELAST (13) +#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; @@ -543,8 +517,48 @@ dumpevent(XEvent *e) "remaining\n", e->xany.window, e->type, QLength(display)); } + +void +dumpwins(struct swm_region *r, union arg *args) +{ + struct ws_win *win; + unsigned int state; + XWindowAttributes wa; + + if (r->ws == NULL) { + fprintf(stderr, "invalid workspace\n"); + return; + } + + fprintf(stderr, "=== managed window list ws %02d ===\n", r->ws->idx); + + TAILQ_FOREACH(win, &r->ws->winlist, entry) { + state = getstate(win->id); + 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, "===== unmanaged window list =====\n"); + TAILQ_FOREACH(win, &r->ws->unmanagedlist, entry) { + state = getstate(win->id); + 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, "=================================\n"); +} #else #define dumpevent(e) +void +dumpwins(struct swm_region *r, union arg *args) +{ +} #endif /* SWM_DEBUG */ void expose(XEvent *); @@ -554,9 +568,9 @@ 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 *); void propertynotify(XEvent *); void unmapnotify(XEvent *); @@ -570,9 +584,10 @@ void (*handler[LASTEvent])(XEvent *) = { [ConfigureNotify] = configurenotify, [DestroyNotify] = destroynotify, [EnterNotify] = enternotify, - [FocusIn] = focusin, - [FocusOut] = focusout, + [FocusIn] = focusevent, + [FocusOut] = focusevent, [MapNotify] = mapnotify, + [MappingNotify] = mappingnotify, [MapRequest] = maprequest, [PropertyNotify] = propertynotify, [UnmapNotify] = unmapnotify, @@ -759,6 +774,7 @@ bar_update(void) int i, x; size_t len; char s[SWM_BAR_MAX]; + char cn[SWM_BAR_MAX]; char loc[SWM_BAR_MAX]; char *b; char *stack = ""; @@ -785,20 +801,22 @@ 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++) { x = 1; TAILQ_FOREACH(r, &screens[i].rl, entry) { + strlcpy(cn, "", sizeof cn); if (r && r->ws) - bar_class_name(s, sizeof s, r->ws->focus); + bar_class_name(cn, sizeof cn, r->ws->focus); if (stack_enabled) stack = r->ws->cur_layout->name; - snprintf(loc, sizeof loc, "%d:%d %s %s %s %s", - x++, r->ws->idx + 1, stack, s, bar_ext, + snprintf(loc, sizeof loc, "%d:%d %s %s%s %s %s", + x++, r->ws->idx + 1, stack, s, cn, bar_ext, bar_vertext); bar_print(r, loc); } @@ -816,7 +834,7 @@ void bar_toggle(struct swm_region *r, union arg *args) { struct swm_region *tmpr; - int i, j, sc = ScreenCount(display); + int i, sc = ScreenCount(display); DNPRINTF(SWM_D_MISC, "bar_toggle\n"); @@ -830,9 +848,6 @@ bar_toggle(struct swm_region *r, union arg *args) XMapRaised(display, tmpr->bar_window); bar_enabled = !bar_enabled; - for (i = 0; i < sc; i++) - for (j = 0; j < SWM_WS_MAX; j++) - screens[i].ws[j].restack = 1; stack(); /* must be after stack */ @@ -927,6 +942,9 @@ set_win_state(struct ws_win *win, long state) DNPRINTF(SWM_D_EVENT, "set_win_state: window: %lu\n", win->id); + if (win == NULL) + return; + XChangeProperty(display, win->id, astate, astate, 32, PropModeReplace, (unsigned char *)data, 2); } @@ -967,6 +985,9 @@ client_msg(struct ws_win *win, Atom a) { XClientMessageEvent cm; + if (win == NULL) + return; + bzero(&cm, sizeof cm); cm.type = ClientMessage; cm.window = win->id; @@ -978,12 +999,38 @@ 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) { 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; @@ -1029,8 +1076,16 @@ unmap_window(struct ws_win *win) if (win == NULL) return; + /* don't unmap again */ + if (getstate(win->id) == IconicState) + return; + 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 @@ -1050,6 +1105,9 @@ fake_keypress(struct ws_win *win, int keysym, int modifiers) { XKeyEvent event; + if (win == NULL) + return; + event.display = display; /* Ignored, but what the hell */ event.window = win->id; event.root = win->s->root; @@ -1121,16 +1179,50 @@ root_to_region(Window root) } struct ws_win * -find_window(Window id) +find_unmanaged_window(Window id) { struct ws_win *win; int i, j; for (i = 0; i < ScreenCount(display); i++) for (j = 0; j < SWM_WS_MAX; j++) + TAILQ_FOREACH(win, &screens[i].ws[j].unmanagedlist, + entry) + if (id == win->id) + return (win); + return (NULL); +} + +struct ws_win * +find_window(Window id) +{ + struct ws_win *win; + 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); } @@ -1171,7 +1263,6 @@ spawn(struct swm_region *r, union arg *args) } exit(0); } - wait(0); } void @@ -1185,22 +1276,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; - grabbuttons(win, 0); - XSetWindowBorder(display, win->id, - win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color); + 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 @@ -1209,46 +1389,75 @@ 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++) TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) unfocus_win(win); - XSync(display, False); } 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) return; + if (win->ws == NULL) + return; + + 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); - /* use big hammer to make sure it works under all use cases */ - unfocus_all(); 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); XSetWindowBorder(display, win->id, win->ws->r->s->c[SWM_S_COLOR_FOCUS].color); - grabbuttons(win, 1); if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS) XMapRaised(display, win->id); - XSetInputFocus(display, win->id, - RevertToPointerRoot, CurrentTime); - XSync(display, False); } } void switchws(struct swm_region *r, union arg *args) { - int wsid = args->id; + int wsid = args->id, unmap_old = 0; struct swm_region *this_r, *other_r; - struct ws_win *win, *winfocus = NULL; + struct ws_win *win; struct workspace *new_ws, *old_ws; + union arg a; + + if (!(r && r->s)) + return; this_r = r; old_ws = this_r->ws; @@ -1258,46 +1467,35 @@ switchws(struct swm_region *r, union arg *args) "%d -> %d\n", r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), old_ws->idx, wsid); + if (new_ws == NULL || old_ws == NULL) + return; 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 */ - if (old_ws->r != NULL) - old_ws->old_r = old_ws->r; + /* the other workspace is hidden, hide this one */ old_ws->r = NULL; - old_ws->restack = 1; - - /* - * Map new windows first if they were here before - * to minimize ugly blinking. - */ - if (new_ws->old_r == this_r) - TAILQ_FOREACH(win, &new_ws->winlist, entry) - XMapRaised(display, win->id); - - TAILQ_FOREACH(win, &old_ws->winlist, entry) - unmap_window(win); + unmap_old = 1; } else { + /* the other ws is visible in another region, exchange them */ + other_r->ws_prior = new_ws; other_r->ws = old_ws; old_ws->r = other_r; } + this_r->ws_prior = old_ws; this_r->ws = new_ws; new_ws->r = this_r; - ignore_enter = 1; stack(); - focus_win(winfocus); + 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); } void @@ -1339,10 +1537,27 @@ cyclews(struct swm_region *r, union arg *args) } void +priorws(struct swm_region *r, union arg *args) +{ + union arg a; + + DNPRINTF(SWM_D_WS, "priorws id %d " + "in screen[%d]:%dx%d+%d+%d ws %d\n", args->id, + r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx); + + if (r->ws_prior == NULL) + return; + + a.id = r->ws_prior->idx; + switchws(r, &a); +} + +void cyclescr(struct swm_region *r, union arg *args) { - struct swm_region *rr; - int i; + struct swm_region *rr = NULL; + union arg a; + int i, x, y; /* do nothing if we don't have more than one screen */ if (!(ScreenCount(display) > 1 || outputs > 1)) @@ -1363,10 +1578,23 @@ cyclescr(struct swm_region *r, union arg *args) default: return; }; - unfocus_all(); - XSetInputFocus(display, PointerRoot, RevertToPointerRoot, CurrentTime); - XWarpPointer(display, None, rr->s[i].root, 0, 0, 0, 0, rr->g.x + 1, - rr->g.y + bar_enabled + 1 ? bar_height : 0); + if (rr == NULL) + return; + + /* 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); + + 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 @@ -1415,40 +1643,121 @@ swapwin(struct swm_region *r, union arg *args) else return; } + if (target == NULL || source == NULL) + return; source->ws->focus_prev = target; TAILQ_REMOVE(wl, target, entry); TAILQ_INSERT_BEFORE(source, target, entry); TAILQ_REMOVE(wl, source, entry); TAILQ_INSERT_HEAD(wl, source, entry); break; + case SWM_ARG_ID_MOVELAST: + TAILQ_REMOVE(wl, source, entry); + TAILQ_INSERT_TAIL(wl, source, entry); + break; default: DNPRINTF(SWM_D_MOVE, "invalid id: %d\n", args->id); 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); @@ -1464,8 +1773,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: @@ -1475,7 +1782,7 @@ focus(struct swm_region *r, union arg *args) if (winfocus == winlostfocus || winfocus == NULL) return; - focus_win(winfocus); + focus_magic(winfocus, SWM_F_GENERIC); } void @@ -1483,6 +1790,7 @@ 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); @@ -1492,10 +1800,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(); - focus_win(winfocus); - ignore_enter = 0; + a.id = SWM_ARG_ID_FOCUSCUR; + focus(r, &a); + bar_update(); } void @@ -1535,14 +1843,28 @@ stack(void) { g.y += bar_height; g.h -= bar_height; } - - r->ws->restack = 0; r->ws->cur_layout->l_stack(r->ws, &g); + /* save r so we can track region changes */ + r->ws->old_r = r; } } if (font_adjusted) font_adjusted--; - XSync(display, False); +} + +void +store_float_geom(struct ws_win *win, struct swm_region *r) +{ + /* retain window geom and region geom */ + win->g_float.x = win->g.x; + win->g_float.y = win->g.y; + win->g_float.w = win->g.w; + win->g_float.h = win->g.h; + win->rg_float.x = r->g.x; + win->rg_float.y = r->g.y; + win->rg_float.w = r->g.w; + win->rg_float.h = r->g.h; + win->g_floatvalid = 1; } void @@ -1556,8 +1878,28 @@ stack_floater(struct ws_win *win, struct swm_region *r) bzero(&wc, sizeof wc); mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight; - if ((win->quirks & SWM_Q_FULLSCREEN) && (win->g.w == WIDTH(r)) && - (win->g.h == HEIGHT(r))) + + /* + * to allow windows to change their size (e.g. mplayer fs) only retrieve + * geom on ws switches or return from max mode + */ + + if (win->floatmaxed || (r != r->ws->old_r && win->g_floatvalid) ) { + /* + * use stored g and rg to set relative position and size + * as in old region or before max stack mode + */ + 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->g_floatvalid = 0; + } + + win->floatmaxed = 0; + + if ((win->quirks & SWM_Q_FULLSCREEN) && (win->g.w >= WIDTH(r)) && + (win->g.h >= HEIGHT(r))) wc.border_width = 0; else wc.border_width = 1; @@ -1565,24 +1907,45 @@ stack_floater(struct ws_win *win, struct swm_region *r) win->g.w = (double)WIDTH(r) * dialog_ratio; win->g.h = (double)HEIGHT(r) * dialog_ratio; } + + if (!win->manual) { + /* + * 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 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 + 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; + 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); + + wc.x = win->g.x; + wc.y = win->g.y; wc.width = win->g.w; wc.height = win->g.h; - if (win->manual) { - wc.x = win->g.x; - wc.y = win->g.y; - } else { - wc.x = (WIDTH(r) - win->g.w) / 2; - wc.y = (HEIGHT(r) - win->g.h) / 2; - } - /* adjust for region */ - wc.x += r->g.x; - wc.y += r->g.y; + /* + * Retain floater and transient geometry for correct positioning + * when ws changes region + */ + store_float_geom(win, r); - DNPRINTF(SWM_D_STACK, "stack_floater: win %lu x %d y %d w %d h %d\n", + DNPRINTF(SWM_D_MISC, "stack_floater: 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); } /* @@ -1623,13 +1986,14 @@ 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; int w_inc = 1, h_inc, w_base = 1, h_base; int hrh, extra = 0, h_slice, last_h = 0; int split, colno, winno, mwin, msize, mscale; - int remain, missing, v_slice; + int remain, missing, v_slice, reconfigure; unsigned int mask; DNPRINTF(SWM_D_STACK, "stack_master: workspace: %d\n rot=%s flip=%s", @@ -1749,22 +2113,42 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip) win_g.y += last_h + 2; bzero(&wc, sizeof wc); - wc.border_width = 1; + if (bar_enabled == 0 && winno == 1){ + wc.border_width = 0; + win_g.w += 2; + win_g.h += 2; + } else + wc.border_width = 1; + reconfigure = 0; if (rot) { - win->g.x = wc.x = win_g.y; - win->g.y = wc.y = win_g.x; - win->g.w = wc.width = win_g.h; - win->g.h = wc.height = win_g.w; + if (win->g.x != win_g.y || win->g.y != win_g.x || + win->g.w != win_g.h || win->g.h != win_g.w) { + reconfigure = 1; + win->g.x = wc.x = win_g.y; + win->g.y = wc.y = win_g.x; + win->g.w = wc.width = win_g.h; + win->g.h = wc.height = win_g.w; + } } else { - win->g.x = wc.x = win_g.x; - win->g.y = wc.y = win_g.y; - win->g.w = wc.width = win_g.w; - win->g.h = wc.height = win_g.h; + if (win->g.x != win_g.x || win->g.y != win_g.y || + win->g.w != win_g.w || win->g.h != win_g.h) { + reconfigure = 1; + win->g.x = wc.x = win_g.x; + win->g.y = wc.y = win_g.y; + win->g.w = wc.width = win_g.w; + win->g.h = wc.height = win_g.h; + } } - adjust_font(win); - mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth; - XConfigureWindow(display, win->id, mask, &wc); - XMapRaised(display, win->id); + if (reconfigure) { + adjust_font(win); + mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth; + XConfigureWindow(display, win->id, mask, &wc); + configreq_win(win); + } + + if (XGetWindowAttributes(display, win->id, &wa)) + if (wa.map_state == IsUnmapped) + XMapRaised(display, win->id); last_h = win_g.h; i++; @@ -1871,7 +2255,7 @@ horizontal_config(struct workspace *ws, int id) void horizontal_stack(struct workspace *ws, struct swm_geometry *g) { - DNPRINTF(SWM_D_STACK, "vertical_stack: workspace: %d\n", ws->idx); + DNPRINTF(SWM_D_STACK, "horizontal_stack: workspace: %d\n", ws->idx); stack_master(ws, g, 1, 0); } @@ -1882,7 +2266,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; @@ -1896,29 +2280,52 @@ max_stack(struct workspace *ws, struct swm_geometry *g) return; TAILQ_FOREACH(win, &ws->winlist, entry) { - if (win->transient != 0) { + if (win->transient) { wintrans = win; - } else { + parent = find_window(win->transient); + continue; + } + + if (win->floating && win->floatmaxed == 0 ) { + /* + * retain geometry for retrieval on exit from + * max_stack mode + */ + store_float_geom(win, ws->r); + win->floatmaxed = 1; + } + + /* only reconfigure if necessary */ + if (win->g.x != gg.x || win->g.y != gg.y || win->g.w != gg.w || + win->g.h != gg.h) { bzero(&wc, sizeof wc); - wc.border_width = 1; win->g.x = wc.x = gg.x; win->g.y = wc.y = gg.y; - win->g.w = wc.width = gg.w; - win->g.h = wc.height = gg.h; + if (bar_enabled){ + wc.border_width = 1; + 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; + } mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth; XConfigureWindow(display, win->id, mask, &wc); - - /* unmap only if we don't have multi screen */ - if (win != ws->focus) - if (!(ScreenCount(display) > 1 || outputs > 1)) - unmap_window(win); + configreq_win(win); } + /* unmap only if we don't have multi screen */ + if (win != ws->focus) + if (!(ScreenCount(display) > 1 || outputs > 1)) + unmap_window(win); } /* 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); } } @@ -1926,10 +2333,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; @@ -1937,27 +2345,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); @@ -1972,15 +2369,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; - ws->restack = 1; - nws->restack = 1; - stack(); - if (winfocus) - focus_win(winfocus); } void @@ -2002,14 +2391,35 @@ void floating_toggle(struct swm_region *r, union arg *args) { struct ws_win *win = r->ws->focus; + union arg a; if (win == NULL) return; - win->floating = !win->floating; - win->manual = 0; + /* reject floating toggles in max stack mode */ + if (r->ws->cur_layout == &layouts[SWM_MAX_STACK]) + return; + + 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; + } + stack(); - focus_win(win); + a.id = SWM_ARG_ID_FOCUSCUR; + focus(win->ws->r, &a); } void @@ -2035,7 +2445,7 @@ resize_window(struct ws_win *win, int center) win->id, wc.x, wc.y, wc.width, wc.height); XConfigureWindow(display, win->id, mask, &wc); - config_win(win); + configreq_win(win); } void @@ -2043,17 +2453,43 @@ 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; + - 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)) return; + /* reject resizes in max mode for floaters (transient ok) */ + if (win->floatmaxed) + return; + + win->manual = 1; + /* 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) return; - XWarpPointer(display, None, win->id, 0, 0, 0, 0, win->g.w, win->g.h); + + /* 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 ( 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; + + XWarpPointer(display, None, win->id, 0, 0, 0, 0, relx, rely); do { XMaskEvent(display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev); @@ -2064,6 +2500,13 @@ resize(struct ws_win *win, union arg *args) 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; + if (ev.xmotion.x <= 1) ev.xmotion.x = 1; if (ev.xmotion.y <= 1) @@ -2084,6 +2527,8 @@ resize(struct ws_win *win, union arg *args) XSync(display, False); resize_window(win, args->id); } + 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); @@ -2109,7 +2554,7 @@ move_window(struct ws_win *win) win->id, wc.x, wc.y, wc.width, wc.height); XConfigureWindow(display, win->id, mask, &wc); - config_win(win); + configreq_win(win); } void @@ -2117,21 +2562,30 @@ move(struct ws_win *win, union arg *args) { XEvent ev; Time time = 0; - int restack = 0; + struct swm_region *r = win->ws->r; + union arg a; - 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) { + /* in max_stack mode should only move transients */ + if (win->ws->cur_layout == &layouts[SWM_MAX_STACK] && !win->transient) + return; + + win->manual = 1; + if (win->floating == 0 && !win->transient) { win->floating = 1; - win->manual = 1; - restack = 1; } + /* 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) return; - XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0); + XWarpPointer(display, None, win->id, 0, 0, 0, 0, -1, -1); do { XMaskEvent(display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev); @@ -2142,6 +2596,13 @@ move(struct ws_win *win, union arg *args) 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; win->g.y = ev.xmotion.y_root; @@ -2158,15 +2619,73 @@ move(struct ws_win *win, union arg *args) XSync(display, False); move_window(win); } + store_float_geom(win,r); XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0); XUngrabPointer(display, CurrentTime); - if (restack) - stack(); /* drain events */ while (XCheckMaskEvent(display, EnterWindowMask, &ev)); } +/* user/key callable function IDs */ +enum keyfuncid { + kf_cycle_layout, + kf_stack_reset, + kf_master_shrink, + kf_master_grow, + kf_master_add, + kf_master_del, + kf_stack_inc, + kf_stack_dec, + kf_swap_main, + kf_focus_next, + kf_focus_prev, + kf_swap_next, + kf_swap_prev, + kf_spawn_term, + kf_spawn_menu, + kf_quit, + kf_restart, + kf_focus_main, + kf_ws_1, + kf_ws_2, + kf_ws_3, + kf_ws_4, + kf_ws_5, + kf_ws_6, + kf_ws_7, + kf_ws_8, + kf_ws_9, + kf_ws_10, + kf_ws_next, + kf_ws_prev, + kf_ws_prior, + kf_screen_next, + kf_screen_prev, + kf_mvws_1, + kf_mvws_2, + kf_mvws_3, + kf_mvws_4, + kf_mvws_5, + kf_mvws_6, + kf_mvws_7, + kf_mvws_8, + kf_mvws_9, + kf_mvws_10, + kf_bar_toggle, + kf_wind_kill, + kf_wind_del, + kf_screenshot_all, + kf_screenshot_wind, + kf_float_toggle, + kf_version, + kf_spawn_lock, + kf_spawn_initscr, + kf_spawn_custom, + kf_dumpwins, + kf_invalid +}; + /* key definitions */ void dummykeyfunc(struct swm_region *r, union arg *args) @@ -2214,6 +2733,7 @@ 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_prior", priorws, {0} }, { "screen_next", cyclescr, {.id = SWM_ARG_ID_CYCLESC_UP} }, { "screen_prev", cyclescr, {.id = SWM_ARG_ID_CYCLESC_DOWN} }, { "mvws_1", send_to_ws, {.id = 0} }, @@ -2236,6 +2756,7 @@ struct keyfunc { { "spawn_lock", legacyfunc, {0} }, { "spawn_initscr", legacyfunc, {0} }, { "spawn_custom", dummykeyfunc, {0} }, + { "dumpwins", dumpwins, {0} }, { "invalid key func", NULL, {0} }, }; struct key { @@ -2564,6 +3085,7 @@ parsekeys(char *keystr, unsigned int currmod, unsigned int *mod, KeySym *ks) DNPRINTF(SWM_D_KEY, "parsekeys: leave ok\n"); return (0); } + char * strdupsafe(char *str) { @@ -2572,6 +3094,7 @@ strdupsafe(char *str) else return (strdup(str)); } + void setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name) { @@ -2652,6 +3175,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name } DNPRINTF(SWM_D_KEY, "setkeybinding: leave\n"); } + int setconfbinding(char *selector, char *value, int flags) { @@ -2698,6 +3222,7 @@ setconfbinding(char *selector, char *value, int flags) DNPRINTF(SWM_D_KEY, "setconfbinding: no match\n"); return (1); } + void setup_keys(void) { @@ -2731,6 +3256,7 @@ 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_a, kf_ws_prior, NULL); setkeybinding(MODKEY|ShiftMask, XK_Right, kf_screen_next, NULL); setkeybinding(MODKEY|ShiftMask, XK_Left, kf_screen_prev, NULL); setkeybinding(MODKEY|ShiftMask, XK_1, kf_mvws_1, NULL); @@ -2754,7 +3280,11 @@ setup_keys(void) 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"); +#ifdef SWM_DEBUG + setkeybinding(MODKEY|ShiftMask, XK_d, kf_dumpwins, NULL); +#endif } + void updatenumlockmask(void) { @@ -2866,6 +3396,7 @@ parsequirks(char *qstr, unsigned long *quirk) } return (0); } + void setquirk(const char *class, const char *name, const int quirk) { @@ -2940,6 +3471,7 @@ setquirk(const char *class, const char *name, const int quirk) } } } + int setconfquirk(char *selector, char *value, int flags) { @@ -2962,8 +3494,7 @@ void setup_quirks(void) { setquirk("MPlayer", "xv", SWM_Q_FLOAT | SWM_Q_FULLSCREEN); - setquirk("OpenOffice.org 2.4", "VCLSalFrame", SWM_Q_FLOAT); - setquirk("OpenOffice.org 3.0", "VCLSalFrame", SWM_Q_FLOAT); + setquirk("OpenOffice.org 3.2", "VCLSalFrame", SWM_Q_FLOAT); setquirk("Firefox-bin", "firefox-bin", SWM_Q_TRANSSZ); setquirk("Firefox", "Dialog", SWM_Q_FLOAT); setquirk("Gimp", "gimp", SWM_Q_FLOAT | SWM_Q_ANYWHERE); @@ -2980,10 +3511,12 @@ 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_FOCUS_MODE, 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) @@ -3001,6 +3534,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; @@ -3019,6 +3559,16 @@ setconfvalue(char *selector, char *value, int flags) case SWM_S_TITLE_NAME_ENABLED: title_name_enabled = atoi(value); break; + case SWM_S_FOCUS_MODE: + if (!strcmp(value, "default")) + focus_mode = SWM_FOCUS_DEFAULT; + else if (!strcmp(value, "follow_cursor")) + focus_mode = SWM_FOCUS_FOLLOW; + else if (!strcmp(value, "synergy")) + focus_mode = SWM_FOCUS_SYNERGY; + else + err(1, "focus_mode"); + break; case SWM_S_BAR_FONT: free(bar_fonts[0]); if ((bar_fonts[0] = strdup(value)) == NULL) @@ -3094,6 +3644,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 }, @@ -3108,7 +3659,8 @@ struct config_option configopt[] = { { "screenshot_app", setconfvalue, SWM_S_SS_APP }, { "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 } + { "title_name_enabled", setconfvalue, SWM_S_TITLE_NAME_ENABLED }, + { "focus_mode", setconfvalue, SWM_S_FOCUS_MODE }, }; @@ -3208,6 +3760,16 @@ 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) { @@ -3225,7 +3787,18 @@ manage_window(Window id) XWindowChanges wc; if ((win = find_window(id)) != NULL) - return (win); /* already being managed */ + return (win); /* already being managed */ + + /* see if we are on the unmanaged list */ + if ((win = find_unmanaged_window(id)) != NULL) { + 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); + return (win); + } if ((win = calloc(1, sizeof(struct ws_win))) == NULL) errx(1, "calloc: failed to allocate memory for new window"); @@ -3240,14 +3813,18 @@ manage_window(Window id) XGetTransientForHint(display, id, &trans); if (trans) { win->transient = trans; - 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)) { - for (i = 0, pp = prot; i < n; i++, pp++) + for (i = 0, pp = prot; i < n; i++, pp++) { + if (*pp == takefocus) + win->take_focus = 1; if (*pp == adelete) win->can_delete = 1; + } if (prot) XFree(prot); } @@ -3292,6 +3869,8 @@ manage_window(Window id) win->g.h = win->wa.height; win->g.x = win->wa.x; win->g.y = win->wa.y; + win->g_floatvalid = 0; + win->floatmaxed = 0; /* Set window properties so we can remember this after reincarnation */ if (ws_idx_atom && prop == NULL && @@ -3306,13 +3885,22 @@ manage_window(Window id) if (XGetClassHint(display, win->id, &win->ch)) { DNPRINTF(SWM_D_CLASS, "class: %s name: %s\n", win->ch.res_class, win->ch.res_name); + + /* java is retarded so treat it special */ + 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) && !strcmp(win->ch.res_name, quirks[i].name)) { DNPRINTF(SWM_D_CLASS, "found: %s name: %s\n", win->ch.res_class, win->ch.res_name); - if (quirks[i].quirk & SWM_Q_FLOAT) + if (quirks[i].quirk & SWM_Q_FLOAT) { win->floating = 1; + border_me = 1; + } win->quirks = quirks[i].quirk; } } @@ -3348,6 +3936,7 @@ manage_window(Window id) wc.border_width = 1; mask = CWBorderWidth; XConfigureWindow(display, win->id, mask, &wc); + configreq_win(win); } XSelectInput(display, id, EnterWindowMask | FocusChangeMask | @@ -3363,26 +3952,85 @@ manage_window(Window id) } void -unmanage_window(struct ws_win *win) +free_window(struct ws_win *win) { - struct workspace *ws; + DNPRINTF(SWM_D_MISC, "free_window: %lu\n", win->id); if (win == NULL) return; - DNPRINTF(SWM_D_MISC, "unmanage_window: %lu\n", win->id); - - ws = win->ws; - TAILQ_REMOVE(&win->ws->winlist, win, entry); + /* needed for restart wm */ set_win_state(win, WithdrawnState); + + TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry); + if (win->ch.res_class) 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); } void +unmanage_window(struct ws_win *win) +{ + struct ws_win *parent; + + if (win == NULL) + return; + + DNPRINTF(SWM_D_MISC, "unmanage_window: %lu\n", win->id); + + if (win->transient) { + parent = find_window(win->transient); + if (parent) + 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, int do_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); + if (win->child_trans->take_focus) + client_msg(win, takefocus); + } else { + focus_win(win->child_trans); + if (win->child_trans->take_focus) + client_msg(win->child_trans, takefocus); + } + } else { + /* regular focus */ + focus_win(win); + if (win->take_focus) + client_msg(win, takefocus); + } +} + +void expose(XEvent *e) { DNPRINTF(SWM_D_EVENT, "expose: window: %lu\n", e->xexpose.window); @@ -3419,20 +4067,18 @@ 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); action = root_click; if ((win = find_window(ev->window)) == NULL) return; - else { - focus_win(win); - action = client_click; - } + + focus_magic(win, SWM_F_TRANSIENT); + action = client_click; for (i = 0; i < LENGTH(buttons); i++) if (action == buttons[i].action && buttons[i].func && @@ -3450,7 +4096,8 @@ configurerequest(XEvent *e) XWindowChanges wc; if ((win = find_window(ev->window)) == NULL) - new = 1; + if ((win = find_unmanaged_window(ev->window)) == NULL) + new = 1; if (new) { DNPRINTF(SWM_D_EVENT, "configurerequest: new window: %lu\n", @@ -3476,27 +4123,8 @@ configurerequest(XEvent *e) win->g.w = ev->width; if (ev->value_mask & CWHeight) win->g.h = ev->height; - if (win->ws->r != NULL) { - /* this seems to be full screen */ - if (win->g.w >= WIDTH(win->ws->r)) { - win->g.x = 0; - win->g.w = WIDTH(win->ws->r); - ev->value_mask |= CWX | CWWidth; - } - if (win->g.h >= HEIGHT(win->ws->r)) { - /* kill border */ - win->g.y = 0; - win->g.h = HEIGHT(win->ws->r); - ev->value_mask |= CWY | CWHeight; - } - } - if ((ev->value_mask & (CWX | CWY)) && - !(ev->value_mask & (CWWidth | CWHeight))) - config_win(win); - XMoveResizeWindow(display, win->id, - win->g.x, win->g.y, win->g.w, win->g.h); - } else - config_win(win); + } + config_win(win); } } @@ -3509,12 +4137,10 @@ configurenotify(XEvent *e) DNPRINTF(SWM_D_EVENT, "configurenotify: window: %lu\n", e->xconfigure.window); - XMapWindow(display, e->xconfigure.window); win = find_window(e->xconfigure.window); if (win) { XGetWMNormalHints(display, win->id, &win->sh, &mask); adjust_font(win); - XMapWindow(display, win->id); if (font_adjusted) stack(); } @@ -3523,108 +4149,210 @@ configurenotify(XEvent *e) void destroynotify(XEvent *e) { - struct ws_win *win, *winfocus = NULL; - struct workspace *ws; - struct ws_win_list *wl; - + struct ws_win *win; XDestroyWindowEvent *ev = &e->xdestroywindow; DNPRINTF(SWM_D_EVENT, "destroynotify: window %lu\n", ev->window); - SWM_EV_PROLOGUE(display); - - if ((win = find_window(ev->window)) != NULL) { - /* find a window to focus */ - ws = win->ws; - wl = &ws->winlist; - - /* 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 && win != ws->focus_prev) - winfocus = ws->focus_prev; - - /* 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); - } - } - } - - unmanage_window(win); - stack(); - if (winfocus) - focus_win(winfocus); + if ((win = find_window(ev->window)) == NULL) { + if ((win = find_unmanaged_window(ev->window)) == NULL) + return; + free_window(win); + return; } - SWM_EV_EPILOGUE(display); + /* make sure we focus on something */ + win->floating = 0; + + unmanage_window(win); + stack(); + 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); + + 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; + case SWM_FOCUS_SYNERGY: +#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 + */ - DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window); - - 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) - focus_win(win); -} + /* this window already has focus */ + if (ev->mode == NotifyNormal && ev->detail == NotifyInferior) { + DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win has focus\n"); + return; + } -void -focusin(XEvent *e) -{ - DNPRINTF(SWM_D_EVENT, "focusin: window: %lu\n", e->xfocus.window); + /* 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; + } + + 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 + break; + } + + 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); +#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 mapnotify(XEvent *e) { struct ws_win *win; - XMappingEvent *ev = &e->xmapping; + XMapEvent *ev = &e->xmap; DNPRINTF(SWM_D_EVENT, "mapnotify: window: %lu\n", ev->window); - SWM_EV_PROLOGUE(display); - - win = find_window(ev->window); + win = manage_window(ev->window); if (win) set_win_state(win, NormalState); +} + +void +mappingnotify(XEvent *e) +{ + XMappingEvent *ev = &e->xmapping; XRefreshKeyboardMapping(ev); if (ev->request == MappingKeyboard) grabkeys(); - - SWM_EV_EPILOGUE(display); } void @@ -3632,33 +4360,27 @@ 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); - SWM_EV_PROLOGUE(display); - if (!XGetWindowAttributes(display, ev->window, &wa)) - goto done; + return; if (wa.override_redirect) - goto done; + return; - manage_window(e->xmaprequest.window); + win = manage_window(e->xmaprequest.window); + if (win == NULL) + return; /* can't happen */ stack(); /* make new win focused */ - win = find_window(ev->window); r = root_to_region(win->wa.root); - if (win->ws == r->ws) - focus_win(win); - -done: - SWM_EV_EPILOGUE(display); + focus_magic(win, SWM_F_GENERIC); } void @@ -3699,54 +4421,19 @@ 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); - SWM_EV_PROLOGUE(display); - /* determine if we need to help unmanage this window */ win = find_window(e->xunmap.window); if (win == NULL) - goto done; - if (win->transient) - goto done; + 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 != ws->focus && win != ws->focus_prev) - winfocus = ws->focus_prev; - - /* 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 { - 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); stack(); - focus_win(winfocus); } - -done: - SWM_EV_EPILOGUE(display); } void @@ -3815,6 +4502,9 @@ 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) + r->ws->old_r = r->ws->r; + r->ws->r = NULL; XDestroyWindow(display, r->bar_window); TAILQ_REMOVE(&s->rl, r, entry); TAILQ_INSERT_TAIL(&s->orl, r, entry); @@ -3861,6 +4551,7 @@ new_region(struct swm_screen *s, int x, int y, int w, int h) HEIGHT(r) = h; r->s = s; r->ws = ws; + r->ws_prior = NULL; ws->r = r; TAILQ_INSERT_TAIL(&s->rl, r, entry); } @@ -3993,16 +4684,20 @@ setup_screens(void) setscreencolor("black", i + 1, SWM_S_COLOR_BAR); setscreencolor("rgb:a0/a0/a0", i + 1, SWM_S_COLOR_BAR_FONT); + /* set default cursor */ + XDefineCursor(display, screens[i].root, + XCreateFontCursor(display, XC_left_ptr)); + /* init all workspaces */ /* XXX these should be dynamically allocated too */ for (j = 0; j < SWM_WS_MAX; j++) { ws = &screens[i].ws[j]; ws->idx = j; - ws->restack = 1; ws->focus = NULL; ws->r = NULL; ws->old_r = NULL; TAILQ_INIT(&ws->winlist); + TAILQ_INIT(&ws->unmanagedlist); for (k = 0; layouts[k].l_stack != NULL; k++) if (layouts[k].l_config != NULL) @@ -4023,24 +4718,24 @@ setup_screens(void) /* attach windows to a region */ /* normal windows */ for (j = 0; j < no; j++) { - XGetWindowAttributes(display, wins[j], &wa); if (!XGetWindowAttributes(display, wins[j], &wa) || wa.override_redirect || XGetTransientForHint(display, wins[j], &d1)) continue; state = getstate(wins[j]); - manage = state == NormalState || state == IconicState; + manage = state == IconicState; if (wa.map_state == IsViewable || manage) manage_window(wins[j]); } /* transient windows */ for (j = 0; j < no; j++) { - if (!XGetWindowAttributes(display, wins[j], &wa)) + if (!XGetWindowAttributes(display, wins[j], &wa) || + wa.override_redirect) continue; state = getstate(wins[j]); - manage = state == NormalState || state == IconicState; + manage = state == IconicState; if (XGetTransientForHint(display, wins[j], &d1) && manage) manage_window(wins[j]); @@ -4051,6 +4746,7 @@ setup_screens(void) } } } + void setup_globals(void) { @@ -4065,6 +4761,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 @@ -4093,6 +4791,8 @@ main(int argc, char *argv[]) struct passwd *pwd; 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; @@ -4121,6 +4821,7 @@ main(int argc, char *argv[]) astate = XInternAtom(display, "WM_STATE", False); aprot = XInternAtom(display, "WM_PROTOCOLS", False); adelete = XInternAtom(display, "WM_DELETE_WINDOW", False); + takefocus = XInternAtom(display, "WM_TAKE_FOCUS", False); /* look for local and global conf file */ pwd = getpwuid(getuid()); @@ -4158,6 +4859,8 @@ main(int argc, char *argv[]) /* set some values to work around bad programs */ workaround(); + unfocus_all(); + grabkeys(); stack(); @@ -4191,21 +4894,29 @@ 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; } FD_ZERO(&rd); FD_SET(xfd, &rd); - if (select(xfd + 1, &rd, NULL, NULL, NULL) == -1) + tv.tv_sec = 1; + tv.tv_usec = 0; + if (select(xfd + 1, &rd, NULL, NULL, &tv) == -1) if (errno != EINTR) DNPRINTF(SWM_D_MISC, "select failed"); if (running == 0) @@ -4217,7 +4928,7 @@ main(int argc, char *argv[]) } done: bar_extra_stop(); - + XFreeGC(display, bar_gc); XCloseDisplay(display); return (0);