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 */
void max_stack(struct workspace *, struct swm_geometry *);
void grabbuttons(struct ws_win *, int);
+void new_region(struct swm_screen *, int, int, int, int);
struct layout {
void (*l_stack)(struct workspace *, struct swm_geometry *);
#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 },
+ { "pcb", "pcb", SWM_Q_FLOAT },
{ NULL, NULL, 0},
};
i, ScreenCount(display));
}
-void new_region(struct swm_screen *, int, int, int, int);
-
void
custom_region(char *val)
{
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)
DNPRINTF(SWM_D_MISC, "bar_toggle\n");
- if (bar_enabled) {
+ if (bar_enabled)
for (i = 0; i < sc; i++)
TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
XUnmapWindow(display, tmpr->bar_window);
- } else {
+ else
for (i = 0; i < sc; i++)
TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
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");
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;
/* 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;
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)
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_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);
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
unsigned long n, extra;
Atom real;
- astate = XInternAtom(display, "WM_STATE", False);
status = XGetWindowProperty(display, w, astate, 0L, 2L, False, astate,
&real, &format, &n, &extra, (unsigned char **)&p);
if (status != Success)
return (-1);
if (n != 0)
- result = *p;
+ result = *((long *)p);
XFree(p);
return (result);
}
r->ws = ws;
ws->r = r;
TAILQ_INSERT_TAIL(&s->rl, r, entry);
- bar_setup(r);
}
void
TAILQ_FOREACH(r, &screens[i].rl, entry)
TAILQ_FOREACH(win, &r->ws->winlist, entry)
XUnmapWindow(display, win->id);
+
+ /* add bars to all regions */
+ for (i = 0; i < ScreenCount(display); i++)
+ TAILQ_FOREACH(r, &screens[i].rl, entry)
+ bar_setup(r);
stack();
}
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); */
Got questions, comments, patches, etc.? Contact Jason Woofenden