#define Y(r) (r)->g.y
#define WIDTH(r) (r)->g.w
#define HEIGHT(r) (r)->g.h
+#define SH_MIN(w) (w)->sh_mask & PMinSize
+#define SH_MIN_W(w) (w)->sh.min_width
+#define SH_MIN_H(w) (w)->sh.min_height
+#define SH_MAX(w) (w)->sh_mask & PMaxSize
+#define SH_MAX_W(w) (w)->sh.max_width
+#define SH_MAX_H(w) (w)->sh.max_height
+#define SH_INC(w) (w)->sh_mask & PResizeInc
+#define SH_INC_W(w) (w)->sh.width_inc
+#define SH_INC_H(w) (w)->sh.height_inc
#define SWM_MAX_FONT_STEPS (3)
-#define WINID(w) (w ? w->id : 0)
-#define YESNO(x) (x ? "yes" : "no")
+#define WINID(w) ((w) ? (w)->id : 0)
+#define YESNO(x) ((x) ? "yes" : "no")
#define SWM_FOCUS_DEFAULT (0)
#define SWM_FOCUS_SYNERGY (1)
struct swm_screen *s; /* always valid, never changes */
XWindowAttributes wa;
XSizeHints sh;
+ long sh_mask;
XClassHint ch;
XWMHints *hints;
};
#define SWM_Q_FOCUSPREV (1<<5) /* focus on caller */
};
TAILQ_HEAD(quirk_list, quirk);
-struct quirk_list quirks = TAILQ_HEAD_INITIALIZER(quirks);
+struct quirk_list quirks = TAILQ_HEAD_INITIALIZER(quirks);
/*
* Supported EWMH hints should be added to
void store_float_geom(struct ws_win *, struct swm_region *);
int floating_toggle_win(struct ws_win *);
void spawn_select(struct swm_region *, union arg *, char *, int *);
-unsigned char *get_win_name(Display *, Window, Atom, Atom, unsigned long *);
+unsigned char *get_win_name(Window);
int
-get_property(Window id, Atom atom, long count, Atom type,
- unsigned long *n, unsigned char **data)
+get_property(Window id, Atom atom, long count, Atom type, unsigned long *nitems,
+ unsigned long *nbytes, unsigned char **data)
{
int format, status;
- unsigned long tmp, extra;
- unsigned long *nitems;
+ unsigned long *nbytes_ret, *nitems_ret;
+ unsigned long nbytes_tmp, nitems_tmp;
Atom real;
- nitems = n != NULL ? n : &tmp;
+ nbytes_ret = nbytes != NULL ? nbytes : &nbytes_tmp;
+ nitems_ret = nitems != NULL ? nitems : &nitems_tmp;
+
status = XGetWindowProperty(display, id, atom, 0L, count, False, type,
- &real, &format, nitems, &extra, data);
+ &real, &format, nitems_ret, nbytes_ret, data);
if (status != Success)
return False;
for (i = 0; i < ScreenCount(display); i++) {
/* Get the support check window and destroy it */
success = get_property(screens[i].root, sup_check, 1, XA_WINDOW,
- &n, &data);
+ &n, NULL, &data);
if (success) {
id = data[0];
Atom type;
success = get_property(win->id, ewmh[_NET_WM_WINDOW_TYPE].atom, (~0L),
- XA_ATOM, &n, (void *)&data);
+ XA_ATOM, &n, NULL, (void *)&data);
if (!success) {
XFree(data);
win->ewmh_flags |= SWM_F_MANUAL;
success = get_property(win->id, ewmh[_NET_WM_STATE].atom,
- (~0L), XA_ATOM, &n, (void *)&states);
+ (~0L), XA_ATOM, &n, NULL, (void *)&states);
if (!success)
return;
char *
xrandr_geteventname(XEvent *e)
{
- char *name = NULL;
+ char *name = NULL;
switch(e->type - xrandr_eventbase) {
case RRScreenChangeNotify:
XWindowAttributes wa;
if (r->ws == NULL) {
- fprintf(stderr, "dumpwins: invalid workspace\n");
+ warnx("dumpwins: invalid workspace");
return;
}
- fprintf(stderr, "=== managed window list ws %02d ===\n", r->ws->idx);
+ warnx("=== managed window list ws %02d ===", r->ws->idx);
TAILQ_FOREACH(win, &r->ws->winlist, entry) {
state = getstate(win->id);
if (!XGetWindowAttributes(display, win->id, &wa))
- fprintf(stderr, "window: 0x%lx, failed "
- "XGetWindowAttributes\n", win->id);
- fprintf(stderr, "window: 0x%lx, map_state: %d, state: %d, "
- "transient: 0x%lx\n",
- win->id, wa.map_state, state, win->transient);
+ warnx("window: 0x%lx, failed XGetWindowAttributes",
+ win->id);
+ warnx("window: 0x%lx, map_state: %d, state: %d, "
+ "transient: 0x%lx", win->id, wa.map_state, state,
+ win->transient);
}
- fprintf(stderr, "===== unmanaged window list =====\n");
+ warnx("===== unmanaged window list =====");
TAILQ_FOREACH(win, &r->ws->unmanagedlist, entry) {
state = getstate(win->id);
if (!XGetWindowAttributes(display, win->id, &wa))
- fprintf(stderr, "window: 0x%lx, failed "
- "XGetWindowAttributes\n", win->id);
- fprintf(stderr, "window: 0x%lx, map_state: %d, state: %d, "
- "transient: 0x%lx\n",
- win->id, wa.map_state, state, win->transient);
+ warnx("window: 0x%lx, failed XGetWindowAttributes",
+ win->id);
+ warnx("window: 0x%lx, map_state: %d, state: %d, "
+ "transient: 0x%lx", win->id, wa.map_state, state,
+ win->transient);
}
- fprintf(stderr, "=================================\n");
+ warnx("=================================");
}
#else
void
if (status)
result = screen_def.pixel;
else
- fprintf(stderr, "color '%s' not found.\n", colorname);
+ warnx("color '%s' not found", colorname);
return (result);
}
y > DisplayHeight(display, sidx) ||
w + x > DisplayWidth(display, sidx) ||
h + y > DisplayHeight(display, sidx)) {
- fprintf(stderr, "ignoring region %ux%u+%u+%u "
- "- not within screen boundaries "
- "(%ux%u)\n", w, h, x, y,
+ warnx("ignoring region %ux%u+%u+%u - not within screen "
+ "boundaries (%ux%u)", w, h, x, y,
DisplayWidth(display, sidx), DisplayHeight(display, sidx));
return;
}
bar_window_name(char *s, ssize_t sz, struct ws_win *cur_focus)
{
unsigned char *title;
- unsigned long len;
if (window_name_enabled && cur_focus != NULL) {
- if ((title = get_win_name(display, cur_focus->id, a_netwmname,
- a_utf8_string, &len)) != NULL) {
+ title = get_win_name(cur_focus->id);
+ if (title != NULL) {
DNPRINTF(SWM_D_BAR, "bar_window_name: title: %s\n",
title);
strlcpy((char *)bar_ext, b, sizeof bar_ext);
}
if (b == NULL && errno != EAGAIN) {
- fprintf(stderr, "bar_update: bar_extra failed: "
- "errno: %d %s\n", errno, strerror(errno));
+ warn("bar_update: bar_extra failed");
bar_extra_stop();
}
} else
else {
time(&tmt);
localtime_r(&tmt, &tm);
- strftime(s, sizeof s, clock_format, &tm);
+ len = strftime(s, sizeof s, clock_format, &tm);
+ s[len] = '\0';
strlcat(s, " ", sizeof s);
}
unsigned char *p = NULL;
unsigned long n;
- if (!get_property(w, astate, 2L, astate, &n, &p))
+ if (!get_property(w, astate, 2L, astate, &n, NULL, &p))
return (-1);
if (n != 0)
result = *((long *)p);
ce.display = ev->display;
ce.event = ev->window;
ce.window = ev->window;
+
+ /* make response appear more WM_SIZE_HINTS-compliant */
+ if (win->sh_mask)
+ DNPRINTF(SWM_D_MISC, "config_win: hints: window: 0x%lx,"
+ " sh_mask: %ld, min: %d x %d, max: %d x %d, inc: "
+ "%d x %d\n", win->id, win->sh_mask, SH_MIN_W(win),
+ SH_MIN_H(win), SH_MAX_W(win), SH_MAX_H(win),
+ SH_INC_W(win), SH_INC_H(win));
+
+ /* min size */
+ if (SH_MIN(win)) {
+ /* the hint may be set... to 0! */
+ if (SH_MIN_W(win) > 0 && ce.width < SH_MIN_W(win))
+ ce.width = SH_MIN_W(win);
+ if (SH_MIN_H(win) > 0 && ce.height < SH_MIN_H(win))
+ ce.height = SH_MIN_H(win);
+ }
+
+ /* max size */
+ if (SH_MAX(win)) {
+ /* may also be advertized as 0 */
+ if (SH_MAX_W(win) > 0 && ce.width > SH_MAX_W(win))
+ ce.width = SH_MAX_W(win);
+ if (SH_MAX_H(win) > 0 && ce.height > SH_MAX_H(win))
+ ce.height = SH_MAX_H(win);
+ }
+
+ /* resize increment. */
+ if (SH_INC(win)) {
+ if (SH_INC_W(win) > 1 && ce.width > SH_INC_W(win))
+ ce.width -= (ce.width - SH_MIN_W(win)) %
+ SH_INC_W(win);
+ if (SH_INC_H(win) > 1 && ce.height > SH_INC_H(win))
+ ce.height -= (ce.height - SH_MIN_H(win)) %
+ SH_INC_H(win);
+ }
+
/* adjust x and y for requested border_width. */
ce.x += border_width - ev->border_width;
ce.y += border_width - ev->border_width;
unmap_all();
XCloseDisplay(display);
execvp(start_argv[0], start_argv);
- fprintf(stderr, "execvp failed\n");
- perror(" failed");
+ warn("execvp failed");
quit(NULL, NULL);
}
setenv("LD_PRELOAD", SWM_LIB, 1);
if (asprintf(&ret, "%d", ws_idx) == -1) {
- perror("_SWM_WS");
+ warn("spawn: asprintf SWM_WS");
_exit(1);
}
setenv("_SWM_WS", ret, 1);
ret = NULL;
if (asprintf(&ret, "%d", getpid()) == -1) {
- perror("_SWM_PID");
+ warn("spawn: asprintf _SWM_PID");
_exit(1);
}
setenv("_SWM_PID", ret, 1);
ret = NULL;
if (setsid() == -1) {
- perror("setsid");
+ warn("spawn: setsid");
_exit(1);
}
* leave stderr open to record errors
*/
if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1) {
- perror("open");
+ warn("spawn: open");
_exit(1);
}
dup2(fd, STDIN_FILENO);
execvp(args->argv[0], args->argv);
- perror("execvp");
+ warn("spawn: execvp");
_exit(1);
}
PropModeReplace, (unsigned char *)&win->id,1);
}
- if (window_name_enabled)
+ if (window_name_enabled || title_class_enabled || title_name_enabled)
bar_update();
}
if (win->transient) {
parent = find_window(win->transient);
if (parent == NULL) {
- fprintf(stderr, "not possible bug\n");
+ warnx("not possible bug");
continue;
}
TAILQ_REMOVE(wl, win, entry);
if (window_name_enabled || title_name_enabled ||
title_class_enabled)
bar_update();
-
return;
}
}
unsigned char *
-get_win_name(Display *dpy, Window win, Atom wname, Atom stype,
- unsigned long *slen)
+get_win_name(Window win)
{
- int status, retfmt;
- unsigned long nitems, nbytes, nextra;
unsigned char *prop = NULL;
- Atom rettype;
+ unsigned long nbytes, nitems;
- status = XGetWindowProperty(dpy, win, wname, 0L, 0L, False, stype,
- &rettype, &retfmt, &nitems, &nbytes, &prop);
- if (status != Success)
- return (NULL);
+ /* try _NET_WM_NAME first */
+ if (get_property(win, a_netwmname, 0L, a_utf8_string, NULL, &nbytes,
+ &prop)) {
+ XFree(prop);
+ if (get_property(win, a_netwmname, nbytes, a_utf8_string,
+ &nitems, NULL, &prop))
+ return (prop);
+ }
+
+ /* fallback to WM_NAME */
+ if (!get_property(win, a_wmname, 0L, a_string, NULL, &nbytes, &prop))
+ return (NULL);
XFree(prop);
+ if (get_property(win, a_wmname, nbytes, a_string, &nitems, NULL, &prop))
+ return (prop);
- status = XGetWindowProperty(dpy, win, wname, 0L, nbytes, False,
- stype, &rettype, &retfmt, &nitems, &nextra, &prop);
- if (status != Success) {
- XFree(prop);
- return (NULL);
- }
- if (rettype != stype) {
- XFree(prop);
- return (NULL);
- }
- *slen = nitems;
- return (prop);
+ return (NULL);
}
void
FILE *lfile;
unsigned char *name;
int count = 0;
- unsigned long len;
DNPRINTF(SWM_D_MISC, "uniconify\n");
if (win->iconic == 0)
continue;
- name = get_win_name(display, win->id, a_netwmname,
- a_utf8_string, &len);
+ name = get_win_name(win->id);
if (name == NULL)
continue;
fprintf(lfile, "%s.%lu\n", name, win->id);
sw = calloc(1, sizeof(struct search_window));
if (sw == NULL) {
- fprintf(stderr, "search_win: calloc: %s",
- strerror(errno));
+ warn("search_win: calloc");
fclose(lfile);
search_win_cleanup();
return;
TAILQ_FOREACH(win, &search_r->ws->winlist, entry) {
if (win->iconic == 0)
continue;
- name = get_win_name(display, win->id, a_netwmname,
- a_utf8_string, &len);
+ name = get_win_name(win->id);
if (name == NULL)
continue;
if (asprintf(&s, "%s.%lu", name, win->id) == -1) {
searchpid = 0;
if ((resp = calloc(1, MAX_RESP_LEN + 1)) == NULL) {
- fprintf(stderr, "search: calloc\n");
+ warn("search: calloc");
goto done;
}
rbytes = read(select_resp_pipe[0], resp, MAX_RESP_LEN);
if (rbytes <= 0) {
- fprintf(stderr, "search: read error: %s\n", strerror(errno));
+ warn("search: read error");
goto done;
}
resp[rbytes] = '\0';
prog = &spawns[i];
}
if (prog == NULL) {
- fprintf(stderr, "spawn_custom: program %s not found\n",
- spawn_name);
+ warnx("spawn_custom: program %s not found", spawn_name);
return (-1);
}
}
if (prog->argv == NULL) {
- fprintf(stderr,
- "error: setspawn: cannot find program: %s", prog->name);
+ warnx("error: setspawn: cannot find program: %s", prog->name);
free(prog);
return;
}
spawns = malloc((size_t)spawns_size *
sizeof(struct spawn_prog));
if (spawns == NULL) {
- fprintf(stderr, "setspawn: malloc failed\n");
- perror(" failed");
+ warn("setspawn: malloc failed");
quit(NULL, NULL);
}
} else if (spawns_length == spawns_size) {
spawns = realloc(spawns, (size_t)spawns_size *
sizeof(struct spawn_prog));
if (spawns == NULL) {
- fprintf(stderr, "setspawn: realloc failed\n");
- perror(" failed");
+ warn("setspawn: realloc failed");
quit(NULL, NULL);
}
}
i = spawns_length++;
spawns[i] = *prog;
} else {
- fprintf(stderr, "spawns array problem?\n");
+ warnx("spawns array problem?");
if (spawns == NULL) {
- fprintf(stderr, "spawns array is NULL!\n");
+ warnx("spawns array is NULL!");
quit(NULL, NULL);
}
}
void
quirk_insert(const char *class, const char *name, unsigned long quirk)
{
- struct quirk *qp;
+ struct quirk *qp;
DNPRINTF(SWM_D_QUIRK, "quirk_insert: %s:%s [%lu]\n", class, name,
quirk);
void
setquirk(const char *class, const char *name, unsigned long quirk)
{
- struct quirk *qp;
+ struct quirk *qp;
DNPRINTF(SWM_D_QUIRK, "setquirk: enter %s:%s [%lu]\n", class, name,
- quirk);
+ quirk);
TAILQ_FOREACH(qp, &quirks, entry) {
if (!strcmp(qp->class, class) && !strcmp(qp->name, name)) {
DNPRINTF(SWM_D_CONF, "conf_load: begin\n");
if (filename == NULL) {
- fprintf(stderr, "conf_load: no filename\n");
+ warnx("conf_load: no filename");
return (1);
}
if ((config = fopen(filename, "r")) == NULL) {
optval = strdup(cp);
/* call function to deal with it all */
if (configopt[optind].func(optsub, optval,
- configopt[optind].funcflags) != 0) {
- fprintf(stderr, "%s line %zd: %s\n",
- filename, lineno, line);
+ configopt[optind].funcflags) != 0)
errx(1, "%s: line %zd: invalid data for %s",
filename, lineno, configopt[optind].optname);
- }
free(optval);
free(optsub);
free(line);
" for 0x%lx trans 0x%lx\n", win->id, win->transient);
if (win->hints == NULL) {
- fprintf(stderr, "no hints for 0x%lx\n", win->id);
+ warnx("no hints for 0x%lx", win->id);
return;
}
XFree(wmh);
if ((wmh = XGetWMHints(display, w->id)) == NULL) {
- fprintf(stderr, "can't get hints for 0x%lx\n",
- w->id);
+ warnx("can't get hints for 0x%lx", w->id);
continue;
}
False, XA_STRING, &type, &format, &nitems, &bytes, &prop);
}
XGetWindowAttributes(display, id, &win->wa);
- XGetWMNormalHints(display, id, &win->sh, &mask);
+ XGetWMNormalHints(display, id, &win->sh, &win->sh_mask);
win->hints = XGetWMHints(display, id);
XGetTransientForHint(display, id, &trans);
if (trans) {
if (ww->ws->r)
r = ww->ws->r;
else
- fprintf(stderr,
- "manage_window: fix this "
- "bug mcbride\n");
+ warnx("manage_window: fix this "
+ "bug mcbride");
border_me = 1;
}
}
focus_prev(win);
- XFree(win->hints);
+ if (win->hints) {
+ XFree(win->hints);
+ win->hints = NULL;
+ }
TAILQ_REMOVE(&win->ws->winlist, win, entry);
TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry);
configurenotify(XEvent *e)
{
struct ws_win *win;
- long mask;
DNPRINTF(SWM_D_EVENT, "configurenotify: window: 0x%lx\n",
e->xconfigure.window);
win = find_window(e->xconfigure.window);
if (win) {
- XGetWMNormalHints(display, win->id, &win->sh, &mask);
+ XGetWMNormalHints(display, win->id, &win->sh, &win->sh_mask);
adjust_font(win);
if (font_adjusted)
stack();
SWM_S_COLOR_FOCUS : SWM_S_COLOR_UNFOCUS].color);
break;
default:
- fprintf(stderr, "ignoring focusevent\n");
+ warnx("ignoring focusevent");
DNPRINTF(SWM_D_FOCUS, "ignoring focusevent\n");
break;
}
case XA_WM_NORMAL_HINTS:
long mask;
XGetWMNormalHints(display, win->id, &win->sh, &mask);
- fprintf(stderr, "normal hints: flag 0x%x\n", win->sh.flags);
+ warnx("normal hints: flag 0x%x", win->sh.flags);
if (win->sh.flags & PMinSize) {
WIDTH(win) = win->sh.min_width;
HEIGHT(win) = win->sh.min_height;
- fprintf(stderr, "min %d %d\n", WIDTH(win), HEIGHT(win));
+ warnx("min %d %d", WIDTH(win), HEIGHT(win));
}
XMoveResizeWindow(display, win->id,
X(win), Y(win), WIDTH(win), HEIGHT(win));
int
xerror(Display *d, XErrorEvent *ee)
{
- /* fprintf(stderr, "error: %p %p\n", display, ee); */
+ /* warnx("error: %p %p", display, ee); */
return (-1);
}
struct sigaction sact;
start_argv = argv;
- fprintf(stderr, "Welcome to scrotwm V%s Build: %s\n",
- SCROTWM_VERSION, buildstr);
+ warnx("Welcome to scrotwm V%s Build: %s", SCROTWM_VERSION, buildstr);
if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, "") ||
!XSupportsLocale())
warnx("no locale support");