static const char *cvstag = "$scrotwm$";
-#define SWM_VERSION "0.8"
+#define SWM_VERSION "0.9"
#include <stdio.h>
#include <stdlib.h>
#define Y(r) (r)->g.y
#define WIDTH(r) (r)->g.w
#define HEIGHT(r) (r)->g.h
+#define SWM_MAX_FONT_STEPS (3)
#ifndef SWM_LIB
#define SWM_LIB "/usr/X11R6/lib/swmhack.so"
char **start_argv;
Atom astate;
+Atom aprot;
+Atom adelete;
int (*xerrorxlib)(Display *, XErrorEvent *);
int other_wm;
int running = 1;
int cycle_empty = 0;
int cycle_visible = 0;
+int term_width = 0;
+int font_adjusted = 0;
/* dialog windows */
double dialog_ratio = .6;
int floating;
int transient;
int manual;
+ int font_size_boundary[SWM_MAX_FONT_STEPS];
+ int font_steps;
+ int last_inc;
+ int can_delete;
unsigned long quirks;
struct workspace *ws; /* always valid */
struct swm_screen *s; /* always valid, never changes */
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 ws_win_list winlist; /* list of windows in ws */
#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_COLINC (16)
-#define SWM_ARG_ID_COLDEC (17)
-#define SWM_ARG_ID_ROWINC (16)
-#define SWM_ARG_ID_ROWDEL (17)
+#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)
char **argv;
};
#define SWM_Q_FLOAT (1<<0) /* float this window */
#define SWM_Q_TRANSSZ (1<<1) /* transiend window size too small */
#define SWM_Q_ANYWHERE (1<<2) /* don't position this window */
+#define SWM_Q_XTERM_FONTADJ (1<<3) /* adjust xterm fonts when resizing */
+#define SWM_Q_FULLSCREEN (1<<4) /* remove border */
} quirks[] = {
- { "MPlayer", "xv", SWM_Q_FLOAT },
+ { "MPlayer", "xv", SWM_Q_FLOAT | SWM_Q_FULLSCREEN },
{ "OpenOffice.org 2.4", "VCLSalFrame", SWM_Q_FLOAT },
{ "OpenOffice.org 3.0", "VCLSalFrame", SWM_Q_FLOAT },
- { "Firefox-bin", "firefox-bin", SWM_Q_TRANSSZ},
- { "Gimp", "gimp", SWM_Q_FLOAT | SWM_Q_ANYWHERE},
+ { "Firefox-bin", "firefox-bin", SWM_Q_TRANSSZ },
+ { "Gimp", "gimp", SWM_Q_FLOAT | SWM_Q_ANYWHERE },
+ { "XTerm", "xterm", SWM_Q_XTERM_FONTADJ },
+ { "xine", "Xine Window", SWM_Q_FLOAT | SWM_Q_ANYWHERE },
+ { "Xitk", "Xitk Combo", SWM_Q_FLOAT | SWM_Q_ANYWHERE },
+ { "xine", "xine Panel", SWM_Q_FLOAT | SWM_Q_ANYWHERE },
+ { "Xitk", "Xine Window", SWM_Q_FLOAT | SWM_Q_ANYWHERE },
+ { "xine", "xine Video Fullscreen Window", SWM_Q_FULLSCREEN | SWM_Q_FLOAT },
{ NULL, NULL, 0},
};
case 's':
if (!strncmp(var, "spawn_term", strlen("spawn_term")))
asprintf(&spawn_term[0], "%s", val);
- if (!strncmp(var, "screenshot_enabled",
+ else if (!strncmp(var, "screenshot_enabled",
strlen("screenshot_enabled")))
ss_enabled = atoi(val);
- if (!strncmp(var, "screenshot_app",
+ else if (!strncmp(var, "screenshot_app",
strlen("screenshot_app")))
asprintf(&spawn_screenshot[0], "%s", val);
+ else
+ goto bad;
+ break;
+
+ case 't':
+ if (!strncmp(var, "term_width", strlen("term_width")))
+ term_width = atoi(val);
+ else
+ goto bad;
break;
+
default:
goto bad;
}
if (bar_enabled == 0)
return;
-
if (bar_extra && bar_extra_running) {
/* ignore short reads; it'll correct itself */
while ((b = fgetln(stdin, &len)) != NULL)
XMapRaised(display, tmpr->bar_window);
}
bar_enabled = !bar_enabled;
- XSync(display, False);
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 */
- for (i = 0; i < sc; i++)
- TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
- bar_update();
+ bar_update();
}
void
}
void
+client_msg(struct ws_win *win, Atom a)
+{
+ XClientMessageEvent cm;
+
+ bzero(&cm, sizeof cm);
+ cm.type = ClientMessage;
+ cm.window = win->id;
+ cm.message_type = aprot;
+ cm.format = 32;
+ cm.data.l[0] = a;
+ cm.data.l[1] = CurrentTime;
+ XSendEvent(display, win->id, False, 0L, (XEvent *)&cm);
+}
+
+void
config_win(struct ws_win *win)
{
XConfigureEvent ce;
}
void
+fake_keypress(struct ws_win *win, int keysym, int modifiers)
+{
+ XKeyEvent event;
+
+ event.display = display; /* Ignored, but what the hell */
+ event.window = win->id;
+ event.root = win->s->root;
+ event.subwindow = None;
+ event.time = CurrentTime;
+ event.x = win->g.x;
+ event.y = win->g.y;
+ event.x_root = 1;
+ event.y_root = 1;
+ event.same_screen = True;
+ event.keycode = XKeysymToKeycode(display, keysym);
+ event.state = modifiers;
+
+ event.type = KeyPress;
+ XSendEvent(event.display, event.window, True,
+ KeyPressMask, (XEvent *)&event);
+
+ event.type = KeyRelease;
+ XSendEvent(event.display, event.window, True,
+ KeyPressMask, (XEvent *)&event);
+
+}
+
+void
restart(struct swm_region *r, union arg *args)
{
DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]);
}
void
+spawnterm(struct swm_region *r, union arg *args)
+{
+ DNPRINTF(SWM_D_MISC, "spawnterm\n");
+
+ if (term_width)
+ setenv("_SWM_XTERM_FONTADJ", "", 1);
+ spawn(r, args);
+}
+
+void
spawnmenu(struct swm_region *r, union arg *args)
{
DNPRINTF(SWM_D_MISC, "spawnmenu\n");
if (win == NULL)
return;
+ if (win->ws->focus != win && win->ws->focus != NULL)
+ win->ws->focus_prev = win->ws->focus;
+
unfocus_all();
win->ws->focus = win;
if (win->ws->r != NULL) {
void
swapwin(struct swm_region *r, union arg *args)
{
- struct ws_win *target;
+ struct ws_win *target, *source;
struct ws_win_list *wl;
if (cur_focus == NULL)
return;
- wl = &cur_focus->ws->winlist;
+ source = cur_focus;
+ wl = &source->ws->winlist;
switch (args->id) {
case SWM_ARG_ID_SWAPPREV:
- target = TAILQ_PREV(cur_focus, ws_win_list, entry);
+ target = TAILQ_PREV(source, ws_win_list, entry);
TAILQ_REMOVE(wl, cur_focus, entry);
if (target == NULL)
- TAILQ_INSERT_TAIL(wl, cur_focus, entry);
+ TAILQ_INSERT_TAIL(wl, source, entry);
else
- TAILQ_INSERT_BEFORE(target, cur_focus, entry);
+ TAILQ_INSERT_BEFORE(target, source, entry);
break;
case SWM_ARG_ID_SWAPNEXT:
- target = TAILQ_NEXT(cur_focus, entry);
- TAILQ_REMOVE(wl, cur_focus, entry);
+ target = TAILQ_NEXT(source, entry);
+ TAILQ_REMOVE(wl, source, entry);
if (target == NULL)
- TAILQ_INSERT_HEAD(wl, cur_focus, entry);
+ TAILQ_INSERT_HEAD(wl, source, entry);
else
- TAILQ_INSERT_AFTER(wl, target, cur_focus, entry);
+ TAILQ_INSERT_AFTER(wl, target, source, entry);
break;
case SWM_ARG_ID_SWAPMAIN:
target = TAILQ_FIRST(wl);
- if (target == cur_focus)
- return;
+ if (target == source) {
+ if (source->ws->focus_prev != NULL &&
+ source->ws->focus_prev != target)
+
+ source = source->ws->focus_prev;
+ else
+ return;
+ }
+ source->ws->focus_prev = target;
TAILQ_REMOVE(wl, target, entry);
- TAILQ_INSERT_BEFORE(cur_focus, target, entry);
- TAILQ_REMOVE(wl, cur_focus, entry);
- TAILQ_INSERT_HEAD(wl, cur_focus, entry);
+ TAILQ_INSERT_BEFORE(source, target, entry);
+ TAILQ_REMOVE(wl, source, entry);
+ TAILQ_INSERT_HEAD(wl, source, entry);
break;
default:
DNPRINTF(SWM_D_MOVE, "invalid id: %d\n", args->id);
return;
}
- ignore_enter = 2;
+ ignore_enter = 1;
stack();
}
r->ws->cur_layout->l_stack(r->ws, &g);
}
}
+ if (font_adjusted)
+ font_adjusted--;
XSync(display, False);
}
bzero(&wc, sizeof wc);
mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight;
- wc.border_width = 1;
+ 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;
if (win->transient && (win->quirks & SWM_Q_TRANSSZ)) {
win->g.w = (double)WIDTH(r) * dialog_ratio;
win->g.h = (double)HEIGHT(r) * dialog_ratio;
XConfigureWindow(display, win->id, mask, &wc);
}
+/*
+ * Send keystrokes to terminal to decrease/increase the font size as the
+ * window size changes.
+ */
+void
+adjust_font(struct ws_win *win)
+{
+ if (!(win->quirks & SWM_Q_XTERM_FONTADJ) ||
+ win->floating || win->transient)
+ return;
+
+ if (win->sh.width_inc && win->last_inc != win->sh.width_inc &&
+ win->g.w / win->sh.width_inc < term_width &&
+ win->font_steps < SWM_MAX_FONT_STEPS) {
+ win->font_size_boundary[win->font_steps] =
+ (win->sh.width_inc * term_width) + win->sh.base_width;
+ win->font_steps++;
+ font_adjusted++;
+ win->last_inc = win->sh.width_inc;
+ fake_keypress(win, XK_KP_Subtract, ShiftMask);
+ } else if (win->font_steps && win->last_inc != win->sh.width_inc &&
+ win->g.w > win->font_size_boundary[win->font_steps - 1]) {
+ win->font_steps--;
+ font_adjusted++;
+ win->last_inc = win->sh.width_inc;
+ fake_keypress(win, XK_KP_Add, ShiftMask);
+ }
+}
+
#define SWAPXY(g) do { \
int tmp; \
tmp = (g)->y; (g)->y = (g)->x; (g)->x = tmp; \
XWindowChanges wc;
struct swm_geometry win_g, r_g = *g;
struct ws_win *win, *winfocus;
- int i, j, s, w_inc, h_inc, w_base, h_base, stacks;
- int hrh, extra, h_slice, last_h = 0;
+ 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;;
unsigned int mask;
ws->focus = TAILQ_FIRST(&ws->winlist);
winfocus = cur_focus ? cur_focus : ws->focus;
- win = TAILQ_FIRST(&ws->winlist);
+ TAILQ_FOREACH(win, &ws->winlist, entry)
+ if (win->transient == 0 && win->floating == 0)
+ break;
+
+ if (win == NULL)
+ goto notiles;
+
if (rot) {
w_inc = win->sh.width_inc;
w_base = win->sh.base_width;
if (stacks > winno - mwin)
stacks = winno - mwin;
+ if (stacks < 1)
+ stacks = 1;
h_slice = r_g.h / SWM_H_SLICE;
if (mwin && winno > mwin) {
/* adjust for window's requested size increment */
remain = (win_g.w - w_base) % w_inc;
missing = w_inc - remain;
-
- if (missing <= extra || j == 0) {
- extra -= missing;
- win_g.w += missing;
- } else {
- win_g.w -= remain;
- extra += remain;
- }
+ win_g.w -= remain;
+ extra += remain;
}
msize = win_g.w;
if (flip)
win_g.x += r_g.w - msize;
} else {
- if (stacks > 1) {
- colno = split = (winno - mwin) / stacks;
- } else {
- split = 0;
- colno = winno;
- }
+ msize = -2;
+ colno = split = winno / stacks;
+ win_g.w = ((r_g.w - (stacks * 2) + 2) / stacks);
}
hrh = r_g.h / colno;
extra = r_g.h - (colno * hrh);
win_g.x = r_g.x;
else
win_g.x += win_g.w + 2;
- win_g.w = (((r_g.w - (msize + 2)) -
- ((stacks - 1) * 2)) / stacks);
+ win_g.w = (r_g.w - msize - (stacks * 2)) / stacks;
if (s == 1)
- win_g.w += (((r_g.w - (msize + 2)) -
- ((stacks - 1) * 2)) % stacks);
+ win_g.w += (r_g.w - msize - (stacks * 2)) %
+ stacks;
s--;
j = 0;
}
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);
j++;
}
+ notiles:
/* now, stack all the floaters and transients */
TAILQ_FOREACH(win, &ws->winlist, entry) {
if (win->transient == 0 && win->floating == 0)
case SWM_ARG_ID_MASTERDEL:
if (ws->l_state.vertical_mwin > 0)
ws->l_state.vertical_mwin--;
- case SWM_ARG_ID_COLINC:
+ break;
+ case SWM_ARG_ID_STACKINC:
ws->l_state.vertical_stacks++;
break;
- case SWM_ARG_ID_COLDEC:
+ case SWM_ARG_ID_STACKDEC:
if (ws->l_state.vertical_stacks > 1)
ws->l_state.vertical_stacks--;
break;
if (ws->l_state.horizontal_mwin > 0)
ws->l_state.horizontal_mwin--;
break;
- case SWM_ARG_ID_COLINC:
+ case SWM_ARG_ID_STACKINC:
ws->l_state.horizontal_stacks++;
break;
- case SWM_ARG_ID_COLDEC:
+ case SWM_ARG_ID_STACKDEC:
if (ws->l_state.horizontal_stacks > 1)
ws->l_state.horizontal_stacks--;
+ break;
default:
return;
}
void
wkill(struct swm_region *r, union arg *args)
{
- DNPRINTF(SWM_D_MISC, "wkill\n");
- if(r->ws->focus != NULL)
+ DNPRINTF(SWM_D_MISC, "wkill %d\n", args->id);
+
+ if(r->ws->focus == NULL)
+ return;
+
+ if (args->id == SWM_ARG_ID_KILLWINDOW)
XKillClient(display, r->ws->focus->id);
+ else
+ if (r->ws->focus->can_delete)
+ client_msg(r->ws->focus, adelete);
}
void
{ MODKEY, XK_l, stack_config, {.id = SWM_ARG_ID_MASTERGROW} },
{ MODKEY, XK_comma, stack_config, {.id = SWM_ARG_ID_MASTERADD} },
{ MODKEY, XK_period, stack_config, {.id = SWM_ARG_ID_MASTERDEL} },
- { MODKEY | ShiftMask, XK_comma, stack_config, {.id = SWM_ARG_ID_COLINC} },
- { MODKEY | ShiftMask, XK_period, stack_config, {.id = SWM_ARG_ID_COLDEC} },
+ { MODKEY | ShiftMask, XK_comma, stack_config, {.id = SWM_ARG_ID_STACKINC} },
+ { MODKEY | ShiftMask, XK_period, stack_config, {.id = SWM_ARG_ID_STACKDEC} },
{ MODKEY, XK_Return, swapwin, {.id = SWM_ARG_ID_SWAPMAIN} },
{ MODKEY, XK_j, focus, {.id = SWM_ARG_ID_FOCUSNEXT} },
{ MODKEY, XK_k, focus, {.id = SWM_ARG_ID_FOCUSPREV} },
{ MODKEY | ShiftMask, XK_j, swapwin, {.id = SWM_ARG_ID_SWAPNEXT} },
{ MODKEY | ShiftMask, XK_k, swapwin, {.id = SWM_ARG_ID_SWAPPREV} },
- { MODKEY | ShiftMask, XK_Return, spawn, {.argv = spawn_term} },
+ { MODKEY | ShiftMask, XK_Return, spawnterm, {.argv = spawn_term} },
{ MODKEY, XK_p, spawnmenu, {.argv = spawn_menu} },
{ MODKEY | ShiftMask, XK_q, quit, {0} },
{ MODKEY, XK_q, restart, {0} },
{ MODKEY, XK_b, bar_toggle, {0} },
{ MODKEY, XK_Tab, focus, {.id = SWM_ARG_ID_FOCUSNEXT} },
{ MODKEY | ShiftMask, XK_Tab, focus, {.id = SWM_ARG_ID_FOCUSPREV} },
- { MODKEY | ShiftMask, XK_x, wkill, {0} },
+ { MODKEY | ShiftMask, XK_x, wkill, {.id = SWM_ARG_ID_KILLWINDOW} },
+ { MODKEY, XK_x, wkill, {.id = SWM_ARG_ID_DELETEWINDOW} },
{ MODKEY, XK_s, screenshot, {.id = SWM_ARG_ID_SS_ALL} },
{ MODKEY | ShiftMask, XK_s, screenshot, {.id = SWM_ARG_ID_SS_WINDOW} },
{ MODKEY, XK_t, floating_toggle,{0} },
handler[ev.type](&ev);
break;
case MotionNotify:
- if (ev.xmotion.x < 0)
- ev.xmotion.x = 0;
- if (ev.xmotion.y < 0)
- ev.xmotion.y = 0;
+ if (ev.xmotion.x <= 1)
+ ev.xmotion.x = 1;
+ if (ev.xmotion.y <= 1)
+ ev.xmotion.y = 1;
win->g.w = ev.xmotion.x;
win->g.h = ev.xmotion.y;
Window trans;
struct workspace *ws;
struct ws_win *win;
- int format, i, ws_idx;
+ int format, i, ws_idx, n;
unsigned long nitems, bytes;
Atom ws_idx_atom = 0, type;
+ Atom *prot = NULL, *pp;
unsigned char ws_idx_str[SWM_PROPLEN], *prop = NULL;
struct swm_region *r;
long mask;
DNPRINTF(SWM_D_MISC, "manage_window: win %u transient %u\n",
(unsigned)win->id, win->transient);
}
+ /* get supported protocols */
+ if (XGetWMProtocols(display, id, &prot, &n)) {
+ for (i = 0, pp = prot; i < n; i++, pp++)
+ if (*pp == adelete)
+ win->can_delete = 1;
+ if (prot)
+ XFree(prot);
+ }
/*
* Figure out where to put the window. If it was previously assigned to
XConfigureWindow(display, win->id, mask, &wc);
}
+ /* Reset font sizes (the bruteforce way; no default keybinding). */
+ if (win->quirks & SWM_Q_XTERM_FONTADJ) {
+ for (i = 0; i < SWM_MAX_FONT_STEPS; i++)
+ fake_keypress(win, XK_KP_Subtract, ShiftMask);
+ for (i = 0; i < SWM_MAX_FONT_STEPS; i++)
+ fake_keypress(win, XK_KP_Add, ShiftMask);
+ }
+
XSelectInput(display, id, EnterWindowMask | FocusChangeMask |
PropertyChangeMask | StructureNotifyMask);
unfocus_all();
} else
focus_win(ws->focus);
+ if (ws->focus_prev == win)
+ ws->focus_prev = NULL;
TAILQ_REMOVE(&win->ws->winlist, win, entry);
set_win_state(win, WithdrawnState);
if (win->ws->r != NULL) {
/* this seems to be full screen */
if (win->g.w >= WIDTH(win->ws->r)) {
- win->g.x = -1;
+ 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 = -1;
+ win->g.y = 0;
win->g.h = HEIGHT(win->ws->r);
ev->value_mask |= CWY | CWHeight;
}
void
configurenotify(XEvent *e)
{
+ struct ws_win *win;
+ long mask;
+
DNPRINTF(SWM_D_EVENT, "configurenotify: window: %lu\n",
e->xconfigure.window);
+
+ win = find_window(e->xconfigure.window);
+ XMapWindow(display, win->id);
+ XGetWMNormalHints(display, win->id, &win->sh, &mask);
+ adjust_font(win);
+ XMapWindow(display, win->id);
+ if (font_adjusted)
+ stack();
}
void
r->ws = ws;
ws->r = r;
TAILQ_INSERT_TAIL(&s->rl, r, entry);
- bar_setup(r);
}
void
main(int argc, char *argv[])
{
struct passwd *pwd;
+ struct swm_region *r;
char conf[PATH_MAX], *cfile = NULL;
struct stat sb;
XEvent e;
- int xfd;
+ int xfd, i;
fd_set rd;
start_argv = argv;
errx(1, "other wm running");
astate = XInternAtom(display, "WM_STATE", False);
+ aprot = XInternAtom(display, "WM_PROTOCOLS", False);
+ adelete = XInternAtom(display, "WM_DELETE_WINDOW", False);
/* look for local and global conf file */
pwd = getpwuid(getuid());
}
if (cfile)
conf_load(cfile);
- bar_refresh();
+
+ /* setup all bars */
+ for (i = 0; i < ScreenCount(display); i++)
+ TAILQ_FOREACH(r, &screens[i].rl, entry)
+ bar_setup(r);
/* ws[0].focus = TAILQ_FIRST(&ws[0].winlist); */