/* $scrotwm$ */
/*
- * Copyright (c) 2009 Marco Peereboom <marco@peereboom.us>
+ * Copyright (c) 2009-2010 Marco Peereboom <marco@peereboom.us>
* Copyright (c) 2009 Ryan McBride <mcbride@countersiege.com>
* Copyright (c) 2009 Darrin Chandler <dwchandler@stilyagin.com>
* Copyright (c) 2009 Pierre-Yves Ritschard <pyr@spootnik.org>
static const char *cvstag = "$scrotwm$";
-#define SWM_VERSION "0.9.22"
+#define SWM_VERSION "0.9.26"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <util.h>
#include <pwd.h>
+#include <paths.h>
#include <ctype.h>
#include <sys/types.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"
#endif
Atom adelete;
Atom takefocus;
volatile sig_atomic_t running = 1;
+volatile sig_atomic_t restart_wm = 0;
int outputs = 0;
int last_focus_event = FocusOut;
int (*xerrorxlib)(Display *, XErrorEvent *);
sig_atomic_t bar_alarm = 0;
int bar_delay = 30;
int bar_enabled = 1;
+int bar_at_bottom = 0;
int bar_extra = 1;
int bar_extra_running = 0;
int bar_verbose = 1;
char *clock_format = NULL;
int title_name_enabled = 0;
int title_class_enabled = 0;
+int focus_mode = SWM_FOCUS_DEFAULT;
+int disable_border = 0;
pid_t bar_pid;
GC bar_gc;
XGCValues bar_gcv;
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;
};
Window id;
Window transient;
struct ws_win *child_trans; /* transient child window */
- struct swm_geometry g;
+ 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 manual;
int font_size_boundary[SWM_MAX_FONT_STEPS];
};
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);
{ 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 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)
void
sighdlr(int sig)
{
+ int saved_errno, status;
pid_t pid;
+ saved_errno = errno;
+
switch (sig) {
case SIGCHLD:
- while ((pid = waitpid(WAIT_ANY, NULL, WNOHANG)) != -1) {
- DNPRINTF(SWM_D_MISC, "reaping: %d\n", pid);
- if (pid <= 0)
+ while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) != 0) {
+ if (pid == -1) {
+ if (errno == EINTR)
+ continue;
+#ifdef SWM_DEBUG
+ if (errno != ECHILD)
+ warn("sighdlr: waitpid");
+#endif /* SWM_DEBUG */
break;
+ }
+
+#ifdef SWM_DEBUG
+ if (WIFEXITED(status)) {
+ if (WEXITSTATUS(status) != 0)
+ warnx("sighdlr: child exit status: %d",
+ WEXITSTATUS(status));
+ } else
+ warnx("sighdlr: child is terminated "
+ "abnormally");
+#endif /* SWM_DEBUG */
}
break;
+
+ case SIGHUP:
+ restart_wm = 1;
+ break;
case SIGINT:
case SIGTERM:
- case SIGHUP:
case SIGQUIT:
running = 0;
break;
}
-}
-void
-installsignal(int sig, char *name)
-{
- struct sigaction sa;
-
- sa.sa_handler = sighdlr;
- sigemptyset(&sa.sa_mask);
- sa.sa_flags = 0;
- if (sigaction(sig, &sa, NULL) == -1)
- err(1, "could not install %s handler", name);
+ errno = saved_errno;
}
unsigned long
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 = "";
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);
}
void
bar_setup(struct swm_region *r)
{
- int i;
+ int i, x, y;
+
+ if (bar_fs) {
+ XFreeFont(display, bar_fs);
+ bar_fs = NULL;
+ }
for (i = 0; bar_fonts[i] != NULL; i++) {
bar_fs = XLoadQueryFont(display, bar_fonts[i]);
}
if (bar_fonts[i] == NULL)
errx(1, "couldn't load font");
+ if (bar_fs == NULL)
+ errx(1, "couldn't create font structure");
+
bar_height = bar_fs->ascent + bar_fs->descent + 3;
+ x = X(r);
+ y = bar_at_bottom ? (Y(r) + HEIGHT(r) - bar_height) : Y(r);
r->bar_window = XCreateSimpleWindow(display,
- r->s->root, X(r), Y(r), WIDTH(r) - 2, bar_height - 2,
+ r->s->root, x, y, WIDTH(r) - 2, bar_height - 2,
1, r->s->c[SWM_S_COLOR_BAR_BORDER].color,
r->s->c[SWM_S_COLOR_BAR].color);
bar_gc = XCreateGC(display, r->bar_window, 0, &bar_gcv);
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);
+ XSetWindowBorder(display, win->id,
+ win->s->c[SWM_S_COLOR_UNFOCUS].color);
}
void
void
spawn(struct swm_region *r, union arg *args)
{
- char *ret;
- int si;
+ int fd;
+ char *ret = NULL;
DNPRINTF(SWM_D_MISC, "spawn: %s\n", args->argv[0]);
- /*
- * The double-fork construct avoids zombie processes and keeps the code
- * clean from stupid signal handlers.
- */
+
if (fork() == 0) {
- if (fork() == 0) {
- if (display)
- close(ConnectionNumber(display));
- setenv("LD_PRELOAD", SWM_LIB, 1);
- if (asprintf(&ret, "%d", r->ws->idx)) {
- setenv("_SWM_WS", ret, 1);
- free(ret);
- }
- if (asprintf(&ret, "%d", getpid())) {
- setenv("_SWM_PID", ret, 1);
- free(ret);
- }
- setsid();
- /* kill stdin, mplayer, ssh-add etc. need that */
- si = open("/dev/null", O_RDONLY, 0);
- if (si == -1)
- err(1, "open /dev/null");
- if (dup2(si, 0) == -1)
- err(1, "dup2 /dev/null");
- execvp(args->argv[0], args->argv);
- fprintf(stderr, "execvp failed\n");
- perror(" failed");
+ if (display)
+ close(ConnectionNumber(display));
+
+ setenv("LD_PRELOAD", SWM_LIB, 1);
+
+ if (asprintf(&ret, "%d", r->ws->idx) == -1) {
+ perror("_SWM_WS");
+ _exit(1);
+ }
+ setenv("_SWM_WS", ret, 1);
+ free(ret);
+ ret = NULL;
+
+ if (asprintf(&ret, "%d", getpid()) == -1) {
+ perror("_SWM_PID");
+ _exit(1);
+ }
+ setenv("_SWM_PID", ret, 1);
+ free(ret);
+ ret = NULL;
+
+ if (setsid() == -1) {
+ perror("setsid");
+ _exit(1);
+ }
+
+ /*
+ * close stdin and stdout to prevent interaction between apps
+ * and the baraction script
+ * leave stderr open to record errors
+ */
+ if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1) {
+ perror("open");
+ _exit(1);
}
- exit(0);
+ dup2(fd, STDIN_FILENO);
+ dup2(fd, STDOUT_FILENO);
+ if (fd > 2)
+ close(fd);
+
+ execvp(args->argv[0], args->argv);
+
+ perror("execvp");
+ _exit(1);
}
}
return;
if (validate_ws(win->ws))
- abort();
+ abort(); /* XXX replace with return at some point */
if (win->ws->r == NULL)
return;
return;
if (validate_ws(win->ws))
- abort();
+ abort(); /* XXX replace with return at some point */
+
if (validate_win(win)) {
kill_refs(win);
return;
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;
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;
-
- 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;
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
+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 = NULL;
/* move mouse to region */
x = rr->g.x + 1;
- y = rr->g.y + 1 + bar_enabled ? bar_height : 0;
+ 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;
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;
/* 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;
+ 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)
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);
g.w -= 2;
g.h -= 2;
if (bar_enabled) {
- g.y += bar_height;
+ if (!bar_at_bottom)
+ g.y += bar_height;
g.h -= bar_height;
}
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)
}
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
stack_floater(struct ws_win *win, struct swm_region *r)
{
unsigned int mask;
bzero(&wc, sizeof wc);
mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight;
+
+ /*
+ * 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;
win->g.w = (double)WIDTH(r) * dialog_ratio;
win->g.h = (double)HEIGHT(r) * dialog_ratio;
}
- 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;
+
+ 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;
}
- /* adjust for region */
- if (wc.x < r->g.x)
- wc.x += r->g.x;
- if (wc.y < r->g.y)
- wc.y += r->g.y;
+ /* 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);
- win->g.x = wc.x;
- win->g.y = wc.y;
- win->g.w = wc.width;
- win->g.h = wc.height;
+ wc.x = win->g.x;
+ wc.y = win->g.y;
+ wc.width = win->g.w;
+ wc.height = win->g.h;
+
+ /*
+ * Retain floater and transient geometry for correct positioning
+ * when ws changes region
+ */
+ store_float_geom(win, r);
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);
win_g.y += last_h + 2;
bzero(&wc, sizeof wc);
- wc.border_width = 1;
+ if (disable_border && 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) {
if (win->g.x != win_g.y || win->g.y != win_g.x ||
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);
}
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);
configreq_win(win);
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();
a.id = SWM_ARG_ID_FOCUSCUR;
focus(win->ws->r, &a);
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 %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);
break;
case MotionNotify:
/* do not allow resize outside of region */
- if (ev.xmotion.y_root < r->g.y ||
- ev.xmotion.y_root >= r->g.y + r->g.h - 1)
- continue;
- if (ev.xmotion.x_root < r->g.x ||
- ev.xmotion.x_root >= r->g.x + r->g.w - 1)
+ 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)
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);
{
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 %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);
handler[ev.type](&ev);
break;
case MotionNotify:
- /* don't allow to move window out of region */
- if (ev.xmotion.y_root < r->g.y ||
- ev.xmotion.y_root + win->g.h >= r->g.y + r->g.h - 1)
- continue;
- if (ev.xmotion.x_root < r->g.x ||
- ev.xmotion.x_root + win->g.w >= r->g.x + r->g.w - 1)
+ /* 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;
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)
{ "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} },
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);
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);
enum { SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_STACK_ENABLED,
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
+ SWM_S_TITLE_CLASS_ENABLED, SWM_S_TITLE_NAME_ENABLED,
+ SWM_S_FOCUS_MODE, SWM_S_DISABLE_BORDER, SWM_S_BAR_FONT,
+ SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM, SWM_S_SS_APP, SWM_S_DIALOG_RATIO,
+ SWM_S_BAR_AT_BOTTOM
};
int
case SWM_S_BAR_ENABLED:
bar_enabled = atoi(value);
break;
+ case SWM_S_BAR_AT_BOTTOM:
+ bar_at_bottom = atoi(value);
+ break;
case SWM_S_STACK_ENABLED:
stack_enabled = 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_DISABLE_BORDER:
+ disable_border = atoi(value);
+ break;
case SWM_S_BAR_FONT:
free(bar_fonts[0]);
if ((bar_fonts[0] = strdup(value)) == NULL)
};
struct config_option configopt[] = {
{ "bar_enabled", setconfvalue, SWM_S_BAR_ENABLED },
+ { "bar_at_bottom", setconfvalue, SWM_S_BAR_AT_BOTTOM },
{ "bar_border", setconfcolor, SWM_S_COLOR_BAR_BORDER },
{ "bar_color", setconfcolor, SWM_S_COLOR_BAR },
{ "bar_font_color", setconfcolor, SWM_S_COLOR_BAR_FONT },
{ "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 },
+ { "disable_border", setconfvalue, SWM_S_DISABLE_BORDER },
};
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 &&
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);
+ /* make sure transient hasn't dissapeared */
+ if (validate_win(win->child_trans) == 0) {
+ focus_win(win->child_trans);
+ if (win->child_trans->take_focus)
+ client_msg(win->child_trans, takefocus);
+ } else {
+ win->child_trans = NULL;
+ focus_win(win);
+ if (win->take_focus)
+ client_msg(win, takefocus);
+ }
}
} else {
/* regular focus */
ev->window, ev->mode, ev->detail, ev->root, ev->subwindow,
ev->same_screen, ev->focus, ev->state);
- goto focusme;
+ 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
}
}
#endif
-focusme:
- if (QLength(display)) {
- DNPRINTF(SWM_D_EVENT, "ignore enternotify %d\n",
- QLength(display));
- return;
+ break;
}
if ((win = find_window(ev->window)) == NULL) {
void
focusevent(XEvent *e)
{
- 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;
(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);
HEIGHT(r) = h;
r->s = s;
r->ws = ws;
+ r->ws_prior = NULL;
ws->r = r;
+ outputs++;
TAILQ_INSERT_TAIL(&s->rl, r, entry);
}
TAILQ_REMOVE(&screens[i].rl, r, entry);
TAILQ_INSERT_TAIL(&screens[i].orl, r, entry);
}
+ outputs = 0;
/* map virtual screens onto physical screens */
#ifdef SWM_XRR_HAS_CRTC
- outputs = 0;
if (xrandr_support) {
sr = XRRGetScreenResources(display, screens[i].root);
if (sr == NULL)
ci = XRRGetCrtcInfo(display, sr, sr->crtcs[c]);
if (ci->noutput == 0)
continue;
- outputs++;
if (ci != NULL && ci->mode == None)
new_region(&screens[i], 0, 0,
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++) {
XEvent e;
int xfd, i;
fd_set rd;
+ struct sigaction sact;
start_argv = argv;
fprintf(stderr, "Welcome to scrotwm V%s cvs tag: %s\n",
if (active_wm())
errx(1, "other wm running");
- /* handle some signale */
- installsignal(SIGINT, "INT");
- installsignal(SIGHUP, "HUP");
- installsignal(SIGQUIT, "QUIT");
- installsignal(SIGTERM, "TERM");
- installsignal(SIGCHLD, "CHLD");
+ /* handle some signals */
+ bzero(&sact, sizeof(sact));
+ sigemptyset(&sact.sa_mask);
+ sact.sa_flags = 0;
+ sact.sa_handler = sighdlr;
+ sigaction(SIGINT, &sact, NULL);
+ sigaction(SIGQUIT, &sact, NULL);
+ sigaction(SIGTERM, &sact, NULL);
+ sigaction(SIGHUP, &sact, NULL);
+
+ sact.sa_handler = sighdlr;
+ sact.sa_flags = SA_NOCLDSTOP;
+ sigaction(SIGCHLD, &sact, NULL);
astate = XInternAtom(display, "WM_STATE", False);
aprot = XInternAtom(display, "WM_PROTOCOLS", False);
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);
+ rr->g.y + (bar_enabled ? bar_height : 0));
a.id = SWM_ARG_ID_FOCUSCUR;
focus(rr, &a);
if (select(xfd + 1, &rd, NULL, NULL, &tv) == -1)
if (errno != EINTR)
DNPRINTF(SWM_D_MISC, "select failed");
+ if (restart_wm == 1)
+ restart(NULL, NULL);
if (running == 0)
goto done;
if (bar_alarm) {
}
done:
bar_extra_stop();
-
+ XFreeGC(display, bar_gc);
XCloseDisplay(display);
return (0);
Got questions, comments, patches, etc.? Contact Jason Woofenden