static const char *cvstag = "$scrotwm$";
-#define SWM_VERSION "0.9.17"
+#define SWM_VERSION "0.9.19"
#include <stdio.h>
#include <stdlib.h>
#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"
Atom takefocus;
volatile sig_atomic_t running = 1;
int outputs = 0;
+int last_focus_event = 0;
int (*xerrorxlib)(Display *, XErrorEvent *);
int other_wm;
int ss_enabled = 0;
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 *);
[ConfigureNotify] = configurenotify,
[DestroyNotify] = destroynotify,
[EnterNotify] = enternotify,
- [FocusIn] = focusin,
- [FocusOut] = focusout,
+ [FocusIn] = focusevent,
+ [FocusOut] = focusevent,
[MapNotify] = mapnotify,
[MappingNotify] = mappingnotify,
[MapRequest] = maprequest,
void
unfocus_win(struct ws_win *win)
{
+ DNPRINTF(SWM_D_FOCUS, "unfocus_win: id: %lu\n", WINID(win));
+
if (win == NULL)
return;
if (win->ws == NULL)
}
void
-unfocus_all(void)
+unfocus_all_except(struct ws_win *except)
{
struct ws_win *win;
int i, j;
- DNPRINTF(SWM_D_FOCUS, "unfocus_all:\n");
+ DNPRINTF(SWM_D_FOCUS, "unfocus_all_except: id: %lu\n", except->id);
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);
+ if (win != except)
+ unfocus_win(win);
}
void
focus_win(struct ws_win *win)
{
+ int rtr;
+ Window wf;
+
DNPRINTF(SWM_D_FOCUS, "focus_win: id: %lu\n", win ? win->id : 0);
if (win == NULL)
}
/* use big hammer to make sure it works under all use cases */
- unfocus_all();
+ unfocus_all_except(win);
if (validate_win(win)) {
kill_refs(win);
win->ws->focus = win;
if (win->ws->r != NULL) {
- grabbuttons(win, 1);
- if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS)
- XMapRaised(display, win->id);
+ XGetInputFocus(display, &wf, &rtr);
+ if (wf != win->id) {
+ grabbuttons(win, 1);
+ if (win->java == 0)
+ XSetInputFocus(display, win->id,
+ RevertToParent, CurrentTime);
+ }
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);
}
}
}
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 = NULL, *winlostfocus = NULL;
winfocus = r->ws->focus_prev;
else
winfocus = TAILQ_FIRST(&r->ws->winlist);
-
+
focus_magic(winfocus, SWM_F_GENERIC);
return;
}
- if (r->ws->focus == NULL)
+ if ((cur_focus = r->ws->focus) == NULL)
return;
-
- cur_focus = r->ws->focus;
ws = r->ws;
wl = &ws->winlist;
winlostfocus = cur_focus;
switch (args->id) {
- case SWM_ARG_ID_FOCUSPREV:
- if (cur_focus->transient)
- winfocus = find_window(cur_focus->transient);
- else if (ws->focus == cur_focus) {
- /* 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;
- }
-
- /* fallback and normal handling */
- if (winfocus == NULL) {
- if (TAILQ_FIRST(wl) == cur_focus)
- winfocus = TAILQ_NEXT(cur_focus, entry);
- else {
- winfocus = TAILQ_PREV(ws->focus,
- ws_win_list, entry);
- if (winfocus == NULL)
- winfocus = TAILQ_LAST(wl,
- ws_win_list);
- }
- }
- }
+ case SWM_ARG_ID_FOCUSPREV:
+ winfocus = TAILQ_PREV(cur_focus, ws_win_list, entry);
+ if (winfocus == NULL)
+ winfocus = TAILQ_LAST(wl, ws_win_list);
break;
+
case SWM_ARG_ID_FOCUSNEXT:
winfocus = TAILQ_NEXT(cur_focus, entry);
if (winfocus == NULL)
winfocus = TAILQ_FIRST(wl);
if (winfocus == cur_focus)
winfocus = cur_focus->ws->focus_prev;
- if (winfocus == NULL)
- return;
break;
default:
stack();
a.id = SWM_ARG_ID_FOCUSCUR;
focus(r, &a);
+ bar_update();
}
void
return;
if (win == NULL)
return;
+ if (win->ws->idx == wsid)
+ return;
DNPRINTF(SWM_D_MOVE, "send_to_ws: win: %lu\n", win->id);
parent->child_trans = NULL;
}
+ focus_prev(win);
TAILQ_REMOVE(&win->ws->winlist, win, entry);
TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry);
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;
{
struct ws_win *win;
XDestroyWindowEvent *ev = &e->xdestroywindow;
- union arg a;
DNPRINTF(SWM_D_EVENT, "destroynotify: window %lu\n", ev->window);
return;
}
- a.id = SWM_ARG_ID_FOCUSPREV;
- focus(win->ws->r, &a);
unmanage_window(win);
- free_window(win);
stack();
+ free_window(win);
}
void
enternotify(XEvent *e)
{
XCrossingEvent *ev = &e->xcrossing;
+ XEvent cne;
struct ws_win *win;
- DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window);
+ 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);
+
+ /*
+ * 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) {
+ struct ws_win *w;
+ Window focus_return;
+ int revert_to_return;
+
+ 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;
+ }
+ }
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);
+ 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);
+
+ 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:
+ DNPRINTF(SWM_D_FOCUS, "ignoring focusevent\n");
+ break;
+ }
}
void
unmapnotify(XEvent *e)
{
struct ws_win *win;
- union arg a;
DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window);
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) {
- /* trash window and refocus */
- a.id = SWM_ARG_ID_FOCUSPREV;
- focus(win->ws->r, &a);
unmanage_window(win);
stack();
}