X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=5c4fbe807e1ecf5d79c2520cdffe359269d651f2;hb=3cd1a5315bccb23e07468e11cfafe1340ca347bf;hp=067806b64da2581e332852f94cc28cad90517515;hpb=d5344e7f5c52dc479df74dc29ed6f90f45455129;p=spectrwm.git

diff --git a/scrotwm.c b/scrotwm.c
index 067806b..5c4fbe8 100644
--- a/scrotwm.c
+++ b/scrotwm.c
@@ -52,7 +52,7 @@
 
 static const char	*cvstag = "$scrotwm$";
 
-#define	SWM_VERSION	"0.9.18"
+#define	SWM_VERSION	"0.9.22"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -84,6 +84,10 @@ static const char	*cvstag = "$scrotwm$";
 #include <X11/Xutil.h>
 #include <X11/extensions/Xrandr.h>
 
+#ifdef __OSX__
+#include <osx.h>
+#endif
+
 #if RANDR_MAJOR < 1
 #  error XRandR versions less than 1.0 are not supported
 #endif
@@ -161,6 +165,7 @@ 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;
@@ -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;
@@ -606,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 *);
@@ -623,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,
@@ -839,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++) {
@@ -851,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);
@@ -1119,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
@@ -1230,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);
 }
 
@@ -1353,6 +1381,10 @@ validate_ws(struct workspace *testws)
 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)
@@ -1383,29 +1415,39 @@ unfocus_win(struct ws_win *win)
 		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
-unfocus_all_except(struct ws_win *except)
+unfocus_all(void)
 {
 	struct ws_win		*win;
 	int			i, j;
 
-	DNPRINTF(SWM_D_FOCUS, "unfocus_all_except: id: %lu\n", except->id);
+	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)
-				if (win != except)
-					unfocus_win(win);
+				unfocus_win(win);
 }
 
 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)
@@ -1420,25 +1462,30 @@ focus_win(struct ws_win *win)
 		return;
 	}
 
-	/* use big hammer to make sure it works under all use cases */
-	unfocus_all_except(win);
-
 	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);
 	}
 }
 
@@ -1670,24 +1717,27 @@ focus_prev(struct ws_win *win)
 	}
 
 	/* if in max_stack try harder */
-	/* XXX needs more love */
 	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;
-		goto done;
+ 		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_FIRST(wl);
+		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);
 }
 
@@ -1712,7 +1762,7 @@ focus(struct swm_region *r, union arg *args)
 			winfocus = r->ws->focus_prev;
 		else
 			winfocus = TAILQ_FIRST(&r->ws->winlist);
-			
+
 		focus_magic(winfocus, SWM_F_GENERIC);
 		return;
 	}
@@ -1904,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;
@@ -2057,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++;
@@ -3294,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)
@@ -3315,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;
@@ -3408,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 },
@@ -3753,7 +3816,10 @@ unmanage_window(struct ws_win *win)
 			parent->child_trans = NULL;
 	}
 
-	focus_prev(win);
+	/* 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);
 
@@ -3918,6 +3984,9 @@ destroynotify(XEvent *e)
 		return;
 	}
 
+	/* make sure we focus on something */
+	win->floating = 0;
+
 	unmanage_window(win);
 	stack();
 	free_window(win);
@@ -3927,33 +3996,160 @@ 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
+	 */
+
+	/*
+	 * 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;
+	}
+
+	/* 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
+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);
 }
 
-void
-focusin(XEvent *e)
-{
-	DNPRINTF(SWM_D_EVENT, "focusin: window: %lu\n", e->xfocus.window);
-}
+/* 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
@@ -4054,13 +4250,6 @@ unmapnotify(XEvent *e)
 	if (win == NULL)
 		return;
 
-	/*
-	 * XXX this is a work around for going fullscreen on mplayer
-	 * remove this and find a better heuristic
-	 */
-	if (win->floating)
-		return;
-
 	if (getstate(e->xunmap.window) == NormalState) {
 		unmanage_window(win);
 		stack();
@@ -4384,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
@@ -4480,6 +4671,8 @@ main(int argc, char *argv[])
 	/* set some values to work around bad programs */
 	workaround();
 
+	unfocus_all();
+
 	grabkeys();
 	stack();