static const char *cvstag = "$scrotwm$";
-#define SWM_VERSION "0.9.17"
+#define SWM_VERSION "0.9.24"
#include <stdio.h>
#include <stdlib.h>
#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
#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)
+
+#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"
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 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;
};
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_dumpwins,
- kf_invalid
-};
-
/* layout handlers */
void stack(void);
void vertical_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 *);
{ vertical_stack, vertical_config, 0, "[|]" },
{ horizontal_stack, horizontal_config, 0, "[-]" },
{ max_stack, NULL,
- SWM_L_FOCUSPREV | SWM_L_MAPONFOCUS, "[ ]"},
+ SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV, "[ ]"},
{ NULL, NULL, 0, NULL },
};
};
void focus(struct swm_region *, union arg *);
-void focus_magic(struct ws_win *);
-
+void focus_magic(struct ws_win *, int);
+#define SWM_F_GENERIC (0)
+#define SWM_F_TRANSIENT (1)
/* quirks */
struct quirk {
char *class;
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,
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++) {
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);
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
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);
}
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)
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
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++)
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;
}
- /* use big hammer to make sure it works under all use cases */
- unfocus_all();
-
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);
}
}
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;
struct workspace *new_ws, *old_ws;
if (old_ws->r != NULL)
old_ws->old_r = old_ws->r;
old_ws->r = NULL;
-
- TAILQ_FOREACH(win, &old_ws->winlist, entry)
- unmap_window(win);
+ unmap_old = 1;
} else {
other_r->ws = old_ws;
old_ws->r = other_r;
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
}
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;
winfocus = r->ws->focus_prev;
else
winfocus = TAILQ_FIRST(&r->ws->winlist);
-
- focus_magic(winfocus);
+
+ focus_magic(winfocus, SWM_F_GENERIC);
return;
}
- cur_focus = r->ws->focus;
- if (cur_focus == NULL)
+ if ((cur_focus = r->ws->focus) == NULL)
return;
-
- wl = &cur_focus->ws->winlist;
+ 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);
winfocus = TAILQ_FIRST(wl);
if (winfocus == cur_focus)
winfocus = cur_focus->ws->focus_prev;
- if (winfocus == NULL)
- return;
break;
default:
if (winfocus == winlostfocus || winfocus == NULL)
return;
- focus_magic(winfocus);
+ focus_magic(winfocus, SWM_F_GENERIC);
}
void
stack();
a.id = SWM_ARG_ID_FOCUSCUR;
focus(r, &a);
+ bar_update();
}
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;
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++;
{
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;
TAILQ_FOREACH(win, &ws->winlist, entry) {
if (win->transient) {
wintrans = win;
+ parent = find_window(win->transient);
continue;
}
/* put the last transient on top */
if (wintrans) {
+ if (parent)
+ XMapRaised(display, parent->id);
stack_floater(wintrans, ws->r);
- focus_magic(wintrans); /* override */
+ focus_magic(wintrans, SWM_F_TRANSIENT);
}
}
return;
if (win == NULL)
return;
+ if (win->ws->idx == wsid)
+ return;
DNPRINTF(SWM_D_MOVE, "send_to_ws: win: %lu\n", win->id);
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_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)
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);
#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)
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;
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)
{ "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 },
{ "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 },
};
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;
"%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);
}
XGetTransientForHint(display, id, &trans);
if (trans) {
win->transient = trans;
- parent = find_window(win->transient);
- if (parent)
- parent->child_trans = win;
+ set_child_transient(win);
DNPRINTF(SWM_D_MISC, "manage_window: win %lu transient %lu\n",
win->id, win->transient);
}
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);
}
void
-focus_magic(struct ws_win *win)
+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 (win->child_trans) {
+ 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 = 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++)
{
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);
+ /* make sure we focus on something */
+ win->floating = 0;
+
unmanage_window(win);
- free_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);
+ /*
+ * 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
+ 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);
+ 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
/* make new win focused */
r = root_to_region(win->wa.root);
if (win->ws == r->ws)
- focus_magic(win);
+ focus_magic(win, SWM_F_GENERIC);
}
void
unmapnotify(XEvent *e)
{
struct ws_win *win;
- union arg a;
DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window);
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();
}
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
/* set some values to work around bad programs */
workaround();
+ unfocus_all();
+
grabkeys();
stack();
}
done:
bar_extra_stop();
-
+ XFreeGC(display, bar_gc);
XCloseDisplay(display);
return (0);
Got questions, comments, patches, etc.? Contact Jason Woofenden