#include <locale.h>
#include <paths.h>
#include <pwd.h>
+#include <regex.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
char *bar_format = NULL;
int stack_enabled = 1;
int clock_enabled = 1;
+int iconic_enabled = 0;
int urgent_enabled = 0;
char *clock_format = NULL;
-int title_name_enabled = 0;
-int title_class_enabled = 0;
+int window_class_enabled = 0;
+int window_instance_enabled = 0;
int window_name_enabled = 0;
int focus_mode = SWM_FOCUS_DEFAULT;
int focus_close = SWM_STACK_BELOW;
/* quirks */
struct quirk {
TAILQ_ENTRY(quirk) entry;
- char *class;
- char *name;
+ char *class; /* WM_CLASS:class */
+ char *instance; /* WM_CLASS:instance */
+ char *name; /* WM_NAME */
+ regex_t regex_class;
+ regex_t regex_instance;
+ regex_t regex_name;
unsigned long quirk;
#define SWM_Q_FLOAT (1<<0) /* float this window */
#define SWM_Q_TRANSSZ (1<<1) /* transiend window size too small */
/* function prototypes */
void adjust_font(struct ws_win *);
-void bar_class_name(char *, size_t, struct swm_region *);
-void bar_class_title_name(char *, size_t, struct swm_region *);
+char *argsep(char **);
void bar_cleanup(struct swm_region *);
void bar_extra_setup(void);
void bar_extra_stop(void);
void bar_replace_pad(char *, int *, size_t);
char *bar_replace_seq(char *, char *, struct swm_region *, size_t *, size_t);
void bar_setup(struct swm_region *);
-void bar_title_name(char *, size_t, struct swm_region *);
void bar_toggle(struct swm_region *, union arg *);
void bar_urgent(char *, size_t);
+void bar_window_class(char *, size_t, struct swm_region *);
+void bar_window_class_instance(char *, size_t, struct swm_region *);
void bar_window_float(char *, size_t, struct swm_region *);
+void bar_window_instance(char *, size_t, struct swm_region *);
void bar_window_name(char *, size_t, struct swm_region *);
void bar_workspace_name(char *, size_t, struct swm_region *);
void buttonpress(xcb_button_press_event_t *);
int count_win(struct workspace *, int);
void cursors_cleanup(void);
void cursors_load(void);
-void custom_region(char *);
+void custom_region(const char *);
void cyclerg(struct swm_region *, union arg *);
void cyclews(struct swm_region *, union arg *);
void cycle_layout(struct swm_region *, union arg *);
#endif
int32_t get_swm_iconic(struct ws_win *);
char *get_win_name(xcb_window_t);
+void get_wm_protocols(struct ws_win *);
int get_ws_idx(xcb_window_t);
uint32_t getstate(xcb_window_t);
void grabbuttons(struct ws_win *);
uint32_t name_to_pixel(int, const char *);
void name_workspace(struct swm_region *, union arg *);
void new_region(struct swm_screen *, int, int, int, int);
-int parsekeys(char *, unsigned int, unsigned int *, KeySym *);
-int parsequirks(char *, unsigned long *);
+int parsekeys(const char *, unsigned int, unsigned int *, KeySym *);
+int parsequirks(const char *, unsigned long *);
int parse_rgb(const char *, uint16_t *, uint16_t *, uint16_t *);
void pressbutton(struct swm_region *, union arg *);
void priorws(struct swm_region *, union arg *);
void print_win_geom(xcb_window_t);
#endif
void propertynotify(xcb_property_notify_event_t *);
-void quirk_insert(const char *, const char *, unsigned long);
+void quirk_free(struct quirk *);
+void quirk_insert(const char *, const char *, const char *,unsigned long);
void quirk_remove(struct quirk *);
-void quirk_replace(struct quirk *, const char *, const char *,
+void quirk_replace(struct quirk *, const char *, const char *, const char *,
unsigned long);
void quit(struct swm_region *, union arg *);
void raise_toggle(struct swm_region *, union arg *);
void send_to_rg(struct swm_region *, union arg *);
void send_to_ws(struct swm_region *, union arg *);
void set_region(struct swm_region *);
-int setautorun(char *, char *, int);
-int setconfbinding(char *, char *, int);
-int setconfcolor(char *, char *, int);
-int setconfmodkey(char *, char *, int);
-int setconfquirk(char *, char *, int);
-int setconfregion(char *, char *, int);
-int setconfspawn(char *, char *, int);
-int setconfvalue(char *, char *, int);
+int setautorun(const char *, const char *, int);
+int setconfbinding(const char *, const char *, int);
+int setconfcolor(const char *, const char *, int);
+int setconfmodkey(const char *, const char *, int);
+int setconfquirk(const char *, const char *, int);
+int setconfregion(const char *, const char *, int);
+int setconfspawn(const char *, const char *, int);
+int setconfvalue(const char *, const char *, int);
void setkeybinding(unsigned int, KeySym, enum keyfuncid, const char *);
-int setkeymapping(char *, char *, int);
-int setlayout(char *, char *, int);
-void setquirk(const char *, const char *, unsigned long);
-void setscreencolor(char *, int, int);
+int setkeymapping(const char *, const char *, int);
+int setlayout(const char *, const char *, int);
+void setquirk(const char *, const char *, const char *,unsigned long);
+void setscreencolor(const char *, int, int);
void setspawn(const char *, const char *, int);
void setup_ewmh(void);
void setup_globals(void);
void swapwin(struct swm_region *, union arg *);
void switchws(struct swm_region *, union arg *);
void teardown_ewmh(void);
+void unescape_selector(char *);
void unfocus_win(struct ws_win *);
void uniconify(struct swm_region *, union arg *);
void unmanage_window(struct ws_win *);
void validate_spawns(void);
int validate_win(struct ws_win *);
int validate_ws(struct workspace *);
-/*void visibilitynotify(xcb_visibility_notify_event_t *);*/
void version(struct swm_region *, union arg *);
void win_to_ws(struct ws_win *, int, int);
pid_t window_get_pid(xcb_window_t);
return (XCB_ATOM_NONE);
}
+void
+get_wm_protocols(struct ws_win *win) {
+ int i;
+ xcb_icccm_get_wm_protocols_reply_t wpr;
+
+ if (xcb_icccm_get_wm_protocols_reply(conn,
+ xcb_icccm_get_wm_protocols(conn, win->id, a_prot),
+ &wpr, NULL)) {
+ for (i = 0; i < (int)wpr.atoms_len; i++) {
+ if (wpr.atoms[i] == a_takefocus)
+ win->take_focus = 1;
+ if (wpr.atoms[i] == a_delete)
+ win->can_delete = 1;
+ }
+ xcb_icccm_get_wm_protocols_reply_wipe(&wpr);
+ }
+}
+
void
set_swm_iconic(struct ws_win *win, int newv)
{
}
void
-setscreencolor(char *val, int i, int c)
+setscreencolor(const char *val, int i, int c)
{
int num_screens;
}
void
-custom_region(char *val)
+custom_region(const char *val)
{
unsigned int x, y, w, h;
int sidx, num_screens;
}
void
-bar_class_name(char *s, size_t sz, struct swm_region *r)
+bar_window_class(char *s, size_t sz, struct swm_region *r)
{
if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
return;
}
void
-bar_title_name(char *s, size_t sz, struct swm_region *r)
+bar_window_instance(char *s, size_t sz, struct swm_region *r)
{
if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
return;
}
void
-bar_class_title_name(char *s, size_t sz, struct swm_region *r)
+bar_window_class_instance(char *s, size_t sz, struct swm_region *r)
{
if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
return;
- bar_class_name(s, sz, r);
+ bar_window_class(s, sz, r);
strlcat(s, ":", sz);
- bar_title_name(s, sz, r);
+ bar_window_instance(s, sz, r);
}
void
if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
return;
- if ((title = get_win_name(r->ws->focus->id)) == NULL)
- return;
+ title = get_win_name(r->ws->focus->id);
strlcat(s, title, sz);
free(title);
}
void
bar_fmt(const char *fmtexp, char *fmtnew, struct swm_region *r, size_t sz)
{
+ struct ws_win *w;
+
/* if format provided, just copy the buffers */
if (bar_format != NULL) {
strlcpy(fmtnew, fmtexp, sz);
/* only show the workspace name if there's actually one */
if (r != NULL && r->ws != NULL && r->ws->name != NULL)
strlcat(fmtnew, "<+D>", sz);
+
+ /* If enabled, only show the iconic count if there are iconic wins. */
+ if (iconic_enabled && r != NULL && r->ws != NULL)
+ TAILQ_FOREACH(w, &r->ws->winlist, entry)
+ if (w->iconic) {
+ strlcat(fmtnew, "{+M}", sz);
+ break;
+ }
+
strlcat(fmtnew, "+3<", sz);
if (clock_enabled) {
if (urgent_enabled)
strlcat(fmtnew, "* +U*+4<", sz);
- if (title_class_enabled) {
+ if (window_class_enabled) {
strlcat(fmtnew, "+C", sz);
- if (!title_name_enabled)
+ if (!window_instance_enabled)
strlcat(fmtnew, "+4<", sz);
}
/* checks needed by the colon and floating strlcat(3) calls below */
if (r != NULL && r->ws != NULL && r->ws->focus != NULL) {
- if (title_name_enabled) {
- if (title_class_enabled)
+ if (window_instance_enabled) {
+ if (window_class_enabled)
strlcat(fmtnew, ":", sz);
strlcat(fmtnew, "+T+4<", sz);
}
bar_replace_seq(char *fmt, char *fmtrep, struct swm_region *r, size_t *offrep,
size_t sz)
{
+ struct ws_win *w;
char *ptr;
char tmp[SWM_BAR_MAX];
- int limit, size;
+ int limit, size, count;
size_t len;
/* reset strlcat(3) buffer */
snprintf(tmp, sizeof tmp, "%s", bar_ext);
break;
case 'C':
- bar_class_name(tmp, sizeof tmp, r);
+ bar_window_class(tmp, sizeof tmp, r);
break;
case 'D':
bar_workspace_name(tmp, sizeof tmp, r);
case 'I':
snprintf(tmp, sizeof tmp, "%d", r->ws->idx + 1);
break;
+ case 'M':
+ count = 0;
+ TAILQ_FOREACH(w, &r->ws->winlist, entry)
+ if (w->iconic)
+ ++count;
+
+ snprintf(tmp, sizeof tmp, "%d", count);
+ break;
case 'N':
snprintf(tmp, sizeof tmp, "%d", r->s->idx + 1);
break;
case 'P':
- bar_class_title_name(tmp, sizeof tmp, r);
+ bar_window_class_instance(tmp, sizeof tmp, r);
break;
case 'S':
snprintf(tmp, sizeof tmp, "%s", r->ws->stacker);
break;
case 'T':
- bar_title_name(tmp, sizeof tmp, r);
+ bar_window_instance(tmp, sizeof tmp, r);
break;
case 'U':
bar_urgent(tmp, sizeof tmp);
win->hints.input))
xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
win->id, last_event_time);
+ else
+ xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
+ ws->r->id, XCB_CURRENT_TIME);
/* Tell app it can adjust focus to a specific window. */
if (win->take_focus) {
c = xcb_get_property(conn, 0, win, ewmh[_NET_WM_NAME].atom,
XCB_GET_PROPERTY_TYPE_ANY, 0, UINT_MAX);
r = xcb_get_property_reply(conn, c, NULL);
- if (r) {
- if (r->type == XCB_NONE) {
- free(r);
- /* Use WM_NAME instead; no UTF-8. */
- c = xcb_get_property(conn, 0, win, XCB_ATOM_WM_NAME,
- XCB_GET_PROPERTY_TYPE_ANY, 0, UINT_MAX);
- r = xcb_get_property_reply(conn, c, NULL);
- if (r == NULL)
- return (NULL);
- if (r->type == XCB_NONE) {
- free(r);
- return (NULL);
- }
- }
- if (r->length > 0)
- name = strndup(xcb_get_property_value(r),
- xcb_get_property_value_length(r));
-
+ if (r && r->type == XCB_NONE) {
free(r);
+ /* Use WM_NAME instead; no UTF-8. */
+ c = xcb_get_property(conn, 0, win, XCB_ATOM_WM_NAME,
+ XCB_GET_PROPERTY_TYPE_ANY, 0, UINT_MAX);
+ r = xcb_get_property_reply(conn, c, NULL);
}
+ if (r && r->type != XCB_NONE && r->length > 0)
+ name = strndup(xcb_get_property_value(r),
+ xcb_get_property_value_length(r));
+ else
+ name = strdup("");
+
+ if (name == NULL)
+ err(1, "get_win_name: failed to allocate memory.");
+
+ free(r);
+
return (name);
}
continue;
name = get_win_name(win->id);
- if (name == NULL)
- continue;
fprintf(lfile, "%s.%u\n", name, win->id);
free(name);
}
if (!win->iconic)
continue;
name = get_win_name(win->id);
- if (name == NULL)
- continue;
if (asprintf(&s, "%s.%u", name, win->id) == -1) {
free(name);
continue;
void
wkill(struct swm_region *r, union arg *args)
{
- DNPRINTF(SWM_D_MISC, "wkill: id: %d\n", args->id);
+ DNPRINTF(SWM_D_MISC, "wkill: win %#x, id: %d\n", WINID(r->ws->focus),
+ args->id);
if (r->ws->focus == NULL)
return;
free(real_args);
}
+/* Argument tokenizer. */
+char *
+argsep(char **sp) {
+ int single_quoted = 0, double_quoted = 0;
+ char *arg, *cp, *next;
+
+ if (*sp == NULL)
+ return NULL;
+
+ /* Eat and move characters until end of argument is found. */
+ for (arg = next = cp = *sp; *cp != '\0'; ++cp) {
+ if (!double_quoted && *cp == '\'') {
+ /* Eat single-quote. */
+ single_quoted = !single_quoted;
+ } else if (!single_quoted && *cp == '"') {
+ /* Eat double-quote. */
+ double_quoted = !double_quoted;
+ } else if (!single_quoted && *cp == '\\' && *(cp + 1) == '"') {
+ /* Eat backslash; copy escaped character to arg. */
+ *next++ = *(++cp);
+ } else if (!single_quoted && !double_quoted && *cp == '\\' &&
+ (*(cp + 1) == '\'' || *(cp + 1) == ' ')) {
+ /* Eat backslash; move escaped character. */
+ *next++ = *(++cp);
+ } else if (!single_quoted && !double_quoted &&
+ (*cp == ' ' || *cp == '\t')) {
+ /* Terminate argument. */
+ *next++ = '\0';
+ /* Point sp to beginning of next argument. */
+ *sp = ++cp;
+ break;
+ } else {
+ /* Move regular character. */
+ *next++ = *cp;
+ }
+ }
+
+ /* Terminate argument if end of string. */
+ if (*cp == '\0') {
+ *next = '\0';
+ *sp = NULL;
+ }
+
+ return arg;
+}
+
void
spawn_insert(const char *name, const char *args, int flags)
{
- char *arg, *cp, *ptr;
struct spawn_prog *sp;
+ char *arg, *dup, *ptr;
+
+ DNPRINTF(SWM_D_SPAWN, "spawn_insert: %s[%s]\n", name, args);
- DNPRINTF(SWM_D_SPAWN, "spawn_insert: %s\n", name);
+ if (args == NULL || *args == '\0')
+ return;
if ((sp = calloc(1, sizeof *sp)) == NULL)
err(1, "spawn_insert: calloc");
if ((sp->name = strdup(name)) == NULL)
err(1, "spawn_insert: strdup");
- /* convert the arguments to an argument list */
- if ((ptr = cp = strdup(args)) == NULL)
+ /* Convert the arguments to an argument list. */
+ if ((ptr = dup = strdup(args)) == NULL)
err(1, "spawn_insert: strdup");
- while ((arg = strsep(&ptr, " \t")) != NULL) {
- /* empty field; skip it */
+ while ((arg = argsep(&ptr)) != NULL) {
+ /* Null argument; skip it. */
if (*arg == '\0')
continue;
if ((sp->argv[sp->argc - 1] = strdup(arg)) == NULL)
err(1, "spawn_insert: strdup");
}
- free(cp);
+ free(dup);
sp->flags = flags;
+ DNPRINTF(SWM_D_SPAWN, "arg %d: [%s]\n", sp->argc, sp->argv[sp->argc-1]);
TAILQ_INSERT_TAIL(&spawns, sp, entry);
DNPRINTF(SWM_D_SPAWN, "spawn_insert: leave\n");
}
}
int
-setconfspawn(char *selector, char *value, int flags)
+setconfspawn(const char *selector, const char *value, int flags)
{
char *args;
+ if (selector == NULL || strlen(selector) == 0)
+ return (1);
+
args = expand_tilde(value);
DNPRINTF(SWM_D_SPAWN, "setconfspawn: [%s] [%s]\n", selector, args);
#define SWM_MODNAME_SIZE 32
#define SWM_KEY_WS "\n+ \t"
int
-parsekeys(char *keystr, unsigned int currmod, unsigned int *mod, KeySym *ks)
+parsekeys(const char *keystr, unsigned int currmod, unsigned int *mod, KeySym *ks)
{
- char *cp, *name;
+ char *str, *cp, *name;
KeySym uks;
+
DNPRINTF(SWM_D_KEY, "parsekeys: enter [%s]\n", keystr);
if (mod == NULL || ks == NULL) {
DNPRINTF(SWM_D_KEY, "parsekeys: no mod or key vars\n");
DNPRINTF(SWM_D_KEY, "parsekeys: no keystr\n");
return (1);
}
- cp = keystr;
+
+ if ((cp = str = strdup(keystr)) == NULL)
+ err(1, "parsekeys: strdup");
+
*ks = XCB_NO_SYMBOL;
*mod = 0;
while ((name = strsep(&cp, SWM_KEY_WS)) != NULL) {
DNPRINTF(SWM_D_KEY,
"parsekeys: invalid key %s\n",
name);
+ free(str);
return (1);
}
}
}
+
+ free(str);
DNPRINTF(SWM_D_KEY, "parsekeys: leave ok\n");
return (0);
}
}
int
-setconfbinding(char *selector, char *value, int flags)
+setconfbinding(const char *selector, const char *value, int flags)
{
enum keyfuncid kfid;
unsigned int mod;
/* suppress unused warning since var is needed */
(void)flags;
- DNPRINTF(SWM_D_KEY, "setconfbinding: enter\n");
- if (selector == NULL) {
+ DNPRINTF(SWM_D_KEY, "setconfbinding: enter selector: [%s], "
+ "value: [%s]\n", selector, value);
+ if (selector == NULL || strlen(selector) == 0) {
DNPRINTF(SWM_D_KEY, "setconfbinding: unbind %s\n", value);
if (parsekeys(value, mod_key, &mod, &ks) == 0) {
kfid = KF_INVALID;
}
int
-setkeymapping(char *selector, char *value, int flags)
+setkeymapping(const char *selector, const char *value, int flags)
{
char *keymapping_file;
+ j];
keycode = xcb_key_symbols_get_keycode(syms,
XK_Num_Lock);
- if (kc == *keycode)
- numlockmask = (1 << i);
- free(keycode);
+ if (keycode) {
+ if (kc == *keycode)
+ numlockmask = (1 << i);
+ free(keycode);
+ }
}
}
free(modmap_r);
/* SWM_Q_WS: retain '|' for back compat for now (2009-08-11) */
#define SWM_Q_WS "\n|+ \t"
int
-parsequirks(char *qstr, unsigned long *quirk)
+parsequirks(const char *qstr, unsigned long *quirk)
{
- char *cp, *name;
+ char *str, *cp, *name;
int i;
- if (quirk == NULL)
+ if (quirk == NULL || qstr == NULL)
return (1);
- cp = qstr;
+ if ((str = strdup(qstr)) == NULL)
+ err(1, "parsequirks: strdup");
+
+ cp = str;
*quirk = 0;
while ((name = strsep(&cp, SWM_Q_WS)) != NULL) {
if (cp)
"parsequirks: %s\n", name);
if (i == 0) {
*quirk = 0;
+ free(str);
return (0);
}
*quirk |= 1 << (i-1);
if (i >= LENGTH(quirkname)) {
DNPRINTF(SWM_D_QUIRK,
"parsequirks: invalid quirk [%s]\n", name);
+ free(str);
return (1);
}
}
+
+ free(str);
return (0);
}
void
-quirk_insert(const char *class, const char *name, unsigned long quirk)
+quirk_insert(const char *class, const char *instance, const char *name,
+ unsigned long quirk)
{
struct quirk *qp;
+ int failed = 0;
+ char *str;
- DNPRINTF(SWM_D_QUIRK, "quirk_insert: %s:%s [%lu]\n", class, name,
- quirk);
+ DNPRINTF(SWM_D_QUIRK, "quirk_insert: class: %s, instance: %s, name: %s,"
+ " value: %lu\n", class, instance, name, quirk);
if ((qp = malloc(sizeof *qp)) == NULL)
err(1, "quirk_insert: malloc");
+
if ((qp->class = strdup(class)) == NULL)
err(1, "quirk_insert: strdup");
+ if ((qp->instance = strdup(instance)) == NULL)
+ err(1, "quirk_insert: strdup");
if ((qp->name = strdup(name)) == NULL)
err(1, "quirk_insert: strdup");
- qp->quirk = quirk;
- TAILQ_INSERT_TAIL(&quirks, qp, entry);
-
+ if (asprintf(&str, "^%s$", class) == -1)
+ err(1, "quirk_insert: asprintf");
+ if (regcomp(&qp->regex_class, str, REG_EXTENDED | REG_NOSUB)) {
+ add_startup_exception("regex failed to compile quirk 'class' "
+ "field: %s", class);
+ failed = 1;
+ }
+ DNPRINTF(SWM_D_QUIRK, "quirk_insert: compiled: %s\n", str);
+ free(str);
+
+ if (asprintf(&str, "^%s$", instance) == -1)
+ err(1, "quirk_insert: asprintf");
+ if (regcomp(&qp->regex_instance, str, REG_EXTENDED | REG_NOSUB)) {
+ add_startup_exception("regex failed to compile quirk 'instance'"
+ " field: %s", instance);
+ failed = 1;
+ }
+ DNPRINTF(SWM_D_QUIRK, "quirk_insert: compiled: %s\n", str);
+ free(str);
+
+ if (asprintf(&str, "^%s$", name) == -1)
+ err(1, "quirk_insert: asprintf");
+ if (regcomp(&qp->regex_name, str, REG_EXTENDED | REG_NOSUB)) {
+ add_startup_exception("regex failed to compile quirk 'name' "
+ "field: %s", name);
+ failed = 1;
+ }
+ DNPRINTF(SWM_D_QUIRK, "quirk_insert: compiled: %s\n", str);
+ free(str);
+
+ if (failed) {
+ DNPRINTF(SWM_D_QUIRK, "quirk_insert: regex error; skipping.\n");
+ quirk_free(qp);
+ } else {
+ qp->quirk = quirk;
+ TAILQ_INSERT_TAIL(&quirks, qp, entry);
+ }
DNPRINTF(SWM_D_QUIRK, "quirk_insert: leave\n");
}
qp->name, qp->quirk);
TAILQ_REMOVE(&quirks, qp, entry);
+ quirk_free(qp);
+
+ DNPRINTF(SWM_D_QUIRK, "quirk_remove: leave\n");
+}
+
+void
+quirk_free(struct quirk *qp)
+{
+ regfree(&qp->regex_class);
+ regfree(&qp->regex_instance);
+ regfree(&qp->regex_name);
free(qp->class);
+ free(qp->instance);
free(qp->name);
free(qp);
-
- DNPRINTF(SWM_D_QUIRK, "quirk_remove: leave\n");
}
void
-quirk_replace(struct quirk *qp, const char *class, const char *name,
- unsigned long quirk)
+quirk_replace(struct quirk *qp, const char *class, const char *instance,
+ const char *name, unsigned long quirk)
{
- DNPRINTF(SWM_D_QUIRK, "quirk_replace: %s:%s [%lu]\n", qp->class,
- qp->name, qp->quirk);
+ DNPRINTF(SWM_D_QUIRK, "quirk_replace: %s:%s:%s [%lu]\n", qp->class,
+ qp->instance, qp->name, qp->quirk);
quirk_remove(qp);
- quirk_insert(class, name, quirk);
+ quirk_insert(class, instance, name, quirk);
DNPRINTF(SWM_D_QUIRK, "quirk_replace: leave\n");
}
void
-setquirk(const char *class, const char *name, unsigned long quirk)
+setquirk(const char *class, const char *instance, const char *name,
+ unsigned long quirk)
{
struct quirk *qp;
- DNPRINTF(SWM_D_QUIRK, "setquirk: enter %s:%s [%lu]\n", class, name,
- quirk);
+ DNPRINTF(SWM_D_QUIRK, "setquirk: enter %s:%s:%s [%lu]\n", class,
+ instance, name, quirk);
/* Remove/replace existing quirk. */
TAILQ_FOREACH(qp, &quirks, entry) {
if (strcmp(qp->class, class) == 0 &&
+ strcmp(qp->instance, instance) == 0 &&
strcmp(qp->name, name) == 0) {
if (quirk == 0)
quirk_remove(qp);
else
- quirk_replace(qp, class, name, quirk);
+ quirk_replace(qp, class, instance, name, quirk);
DNPRINTF(SWM_D_QUIRK, "setquirk: leave\n");
return;
}
/* Only insert if quirk is not NONE. */
if (quirk)
- quirk_insert(class, name, quirk);
+ quirk_insert(class, instance, name, quirk);
DNPRINTF(SWM_D_QUIRK, "setquirk: leave\n");
}
+/* Eat '\' in str used to escape square brackets and colon. */
+void
+unescape_selector(char *str)
+{
+ char *cp;
+
+ for (cp = str; *str != '\0'; ++str, ++cp) {
+ if (*str == '\\' && (*(str + 1) == ':' || *(str + 1) == ']' ||
+ *(str + 1) == '['))
+ ++str;
+
+ *cp = *str;
+ }
+ *cp = '\0';
+}
+
int
-setconfquirk(char *selector, char *value, int flags)
+setconfquirk(const char *selector, const char *value, int flags)
{
- char *cp, *class, *name;
- int retval;
+ char *str, *cp, *class;
+ char *instance = NULL, *name = NULL;
+ int retval, count = 0;
unsigned long qrks;
/* suppress unused warning since var is needed */
(void)flags;
- if (selector == NULL)
+ if (selector == NULL || strlen(selector) == 0)
return (0);
- if ((cp = strchr(selector, ':')) == NULL)
- return (0);
- *cp = '\0';
- class = selector;
- name = cp + 1;
+
+ if ((str = strdup(selector)) == NULL)
+ err(1, "setconfquirk: strdup");
+
+ /* Find non-escaped colon. */
+ class = cp = str;
+ if (*cp == ':') {
+ *cp = '\0';
+ ++count;
+ }
+
+ for (++cp; *cp != '\0'; ++cp) {
+ if (*cp == ':' && *(cp - 1) != '\\') {
+ *cp = '\0';
+ ++count;
+ }
+ }
+
+ unescape_selector(class);
+ if (count) {
+ instance = class + strlen(class) + 1;
+ unescape_selector(instance);
+ } else {
+ instance = ".*";
+ }
+
+ if (count > 1) {
+ name = instance + strlen(instance) + 1;
+ unescape_selector(name);
+ } else {
+ name = ".*";
+ }
+
+ DNPRINTF(SWM_D_CONF, "setconfquirk: class: %s, instance: %s, "
+ "name: %s\n", class, instance, name);
+
if ((retval = parsequirks(value, &qrks)) == 0)
- setquirk(class, name, qrks);
+ setquirk(class, instance, name, qrks);
+
+ free(str);
return (retval);
}
void
setup_quirks(void)
{
- setquirk("MPlayer", "xv", SWM_Q_FLOAT | SWM_Q_FULLSCREEN | SWM_Q_FOCUSPREV);
- 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);
- setquirk("XTerm", "xterm", SWM_Q_XTERM_FONTADJ);
- setquirk("xine", "Xine Window", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
- setquirk("Xitk", "Xitk Combo", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
- setquirk("xine", "xine Panel", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
- setquirk("Xitk", "Xine Window", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
- setquirk("xine", "xine Video Fullscreen Window", SWM_Q_FULLSCREEN | SWM_Q_FLOAT);
- setquirk("pcb", "pcb", SWM_Q_FLOAT);
- setquirk("SDL_App", "SDL_App", SWM_Q_FLOAT | SWM_Q_FULLSCREEN);
+ setquirk("MPlayer", "xv", ".*", SWM_Q_FLOAT | SWM_Q_FULLSCREEN | SWM_Q_FOCUSPREV);
+ 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);
+ setquirk("XTerm", "xterm", ".*", SWM_Q_XTERM_FONTADJ);
+ setquirk("xine", "Xine Window", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+ setquirk("Xitk", "Xitk Combo", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+ setquirk("xine", "xine Panel", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+ setquirk("Xitk", "Xine Window", ".*", SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+ setquirk("xine", "xine Video Fullscreen Window", ".*", SWM_Q_FULLSCREEN | SWM_Q_FLOAT);
+ setquirk("pcb", "pcb", ".*", SWM_Q_FLOAT);
+ setquirk("SDL_App", "SDL_App", ".*", SWM_Q_FLOAT | SWM_Q_FULLSCREEN);
}
/* conf file stuff */
SWM_S_FOCUS_CLOSE_WRAP,
SWM_S_FOCUS_DEFAULT,
SWM_S_FOCUS_MODE,
+ SWM_S_ICONIC_ENABLED,
SWM_S_REGION_PADDING,
SWM_S_SPAWN_ORDER,
SWM_S_SPAWN_TERM,
SWM_S_STACK_ENABLED,
SWM_S_TERM_WIDTH,
SWM_S_TILE_GAP,
- SWM_S_TITLE_CLASS_ENABLED,
- SWM_S_TITLE_NAME_ENABLED,
SWM_S_URGENT_ENABLED,
SWM_S_VERBOSE_LAYOUT,
+ SWM_S_WINDOW_CLASS_ENABLED,
+ SWM_S_WINDOW_INSTANCE_ENABLED,
SWM_S_WINDOW_NAME_ENABLED,
SWM_S_WORKSPACE_LIMIT
};
int
-setconfvalue(char *selector, char *value, int flags)
+setconfvalue(const char *selector, const char *value, int flags)
{
struct workspace *ws;
int i, ws_id, num_screens;
- char *b;
-
- /* suppress unused warning since var is needed */
- (void)selector;
+ char *b, *str;
switch (flags) {
case SWM_S_BAR_ACTION:
if (!bar_font_legacy)
break;
+ if ((str = strdup(value)) == NULL)
+ err(1, "setconfvalue: strdup");
+
/* If there are any non-XLFD entries, switch to Xft mode. */
- while ((b = strsep(&value, ",")) != NULL) {
+ while ((b = strsep(&str, ",")) != NULL) {
if (*b == '\0')
continue;
if (!isxlfd(b)) {
break;
}
}
+
+ free(str);
break;
case SWM_S_BAR_FORMAT:
free(bar_format);
else
errx(1, "focus_mode");
break;
+ case SWM_S_ICONIC_ENABLED:
+ iconic_enabled = atoi(value);
+ break;
case SWM_S_REGION_PADDING:
region_padding = atoi(value);
if (region_padding < 0)
case SWM_S_TILE_GAP:
tile_gap = atoi(value);
break;
- case SWM_S_TITLE_CLASS_ENABLED:
- title_class_enabled = atoi(value);
- break;
- case SWM_S_TITLE_NAME_ENABLED:
- title_name_enabled = atoi(value);
- break;
case SWM_S_URGENT_ENABLED:
urgent_enabled = atoi(value);
break;
layouts[i].l_string = plain_stacker;
}
break;
+ case SWM_S_WINDOW_CLASS_ENABLED:
+ window_class_enabled = atoi(value);
+ break;
+ case SWM_S_WINDOW_INSTANCE_ENABLED:
+ window_instance_enabled = atoi(value);
+ break;
case SWM_S_WINDOW_NAME_ENABLED:
window_name_enabled = atoi(value);
break;
}
int
-setconfmodkey(char *selector, char *value, int flags)
+setconfmodkey(const char *selector, const char *value, int flags)
{
/* suppress unused warnings since vars are needed */
(void)selector;
}
int
-setconfcolor(char *selector, char *value, int flags)
+setconfcolor(const char *selector, const char *value, int flags)
{
- setscreencolor(value, ((selector == NULL)?-1:atoi(selector)), flags);
+ setscreencolor(value,
+ (selector == NULL || strlen(selector) == 0) ? -1 : atoi(selector),
+ flags);
return (0);
}
int
-setconfregion(char *selector, char *value, int flags)
+setconfregion(const char *selector, const char *value, int flags)
{
/* suppress unused warnings since vars are needed */
(void)selector;
}
int
-setautorun(char *selector, char *value, int flags)
+setautorun(const char *selector, const char *value, int flags)
{
int ws_id;
char s[1024];
}
int
-setlayout(char *selector, char *value, int flags)
+setlayout(const char *selector, const char *value, int flags)
{
int ws_id, i, x, mg, ma, si, ar, f = 0;
int st = SWM_V_STACK, num_screens;
/* config options */
struct config_option {
char *optname;
- int (*func)(char*, char*, int);
+ int (*func)(const char*, const char*, int);
int funcflags;
};
struct config_option configopt[] = {
{ "focus_close_wrap", setconfvalue, SWM_S_FOCUS_CLOSE_WRAP },
{ "focus_default", setconfvalue, SWM_S_FOCUS_DEFAULT },
{ "focus_mode", setconfvalue, SWM_S_FOCUS_MODE },
+ { "iconic_enabled", setconfvalue, SWM_S_ICONIC_ENABLED },
{ "keyboard_mapping", setkeymapping, 0 },
{ "layout", setlayout, 0 },
{ "modkey", setconfmodkey, 0 },
{ "stack_enabled", setconfvalue, SWM_S_STACK_ENABLED },
{ "term_width", setconfvalue, SWM_S_TERM_WIDTH },
{ "tile_gap", setconfvalue, SWM_S_TILE_GAP },
- { "title_class_enabled", setconfvalue, SWM_S_TITLE_CLASS_ENABLED },
- { "title_name_enabled", setconfvalue, SWM_S_TITLE_NAME_ENABLED },
+ { "title_class_enabled", setconfvalue, SWM_S_WINDOW_CLASS_ENABLED }, /* For backwards compat. */
+ { "title_name_enabled", setconfvalue, SWM_S_WINDOW_INSTANCE_ENABLED }, /* For backwards compat. */
{ "urgent_enabled", setconfvalue, SWM_S_URGENT_ENABLED },
{ "verbose_layout", setconfvalue, SWM_S_VERBOSE_LAYOUT },
+ { "window_class_enabled", setconfvalue, SWM_S_WINDOW_CLASS_ENABLED },
+ { "window_instance_enabled", setconfvalue, SWM_S_WINDOW_INSTANCE_ENABLED },
{ "window_name_enabled", setconfvalue, SWM_S_WINDOW_NAME_ENABLED },
{ "workspace_limit", setconfvalue, SWM_S_WORKSPACE_LIMIT },
};
conf_load(const char *filename, int keymapping)
{
FILE *config;
- char *line = NULL, *cp, *optsub, *optval = NULL;
+ char *line = NULL, *cp, *ce, *optsub, *optval = NULL;
size_t linelen, lineno = 0;
- int wordlen, i, optidx;
+ int wordlen, i, optidx, count;
struct config_option *opt = NULL;
DNPRINTF(SWM_D_CONF, "conf_load: begin\n");
cp += wordlen;
cp += strspn(cp, " \t\n"); /* eat whitespace */
- /* from here on out we call goto invalid to continue */
-
/* get [selector] if any */
optsub = NULL;
+ count = 0;
if (*cp == '[') {
- cp++;
- wordlen = strcspn(cp, "]");
- if (*cp != ']') {
- if (wordlen == 0) {
- add_startup_exception("%s: line %zd: "
- "syntax error", filename, lineno);
- goto invalid;
+ ++count;
+ /* Get length of selector. */
+ for (ce = ++cp; *ce != '\0'; ++ce) {
+ /* Find matching (not escaped) bracket. */
+ if (*ce == ']' && *(ce - 1) != '\\') {
+ --count;
+ break;
}
+ }
- if (asprintf(&optsub, "%.*s", wordlen, cp) ==
- -1) {
- add_startup_exception("%s: line %zd: "
- "unable to allocatememory for "
- "selector", filename, lineno);
- goto invalid;
- }
+ if (count > 0) {
+ add_startup_exception("%s: line %zd: syntax "
+ "error: unterminated selector", filename,
+ lineno);
+ continue;
}
- cp += wordlen;
- cp += strspn(cp, "] \t\n"); /* eat trailing */
+
+ /* ce points at ']'; terminate optsub. */
+ *ce = '\0';
+ optsub = cp;
+ cp = ce + 1;
}
cp += strspn(cp, "= \t\n"); /* eat trailing */
/* get RHS value */
- optval = strdup(cp);
+ optval = cp;
if (strlen(optval) == 0) {
add_startup_exception("%s: line %zd: must supply value "
"to %s", filename, lineno,
configopt[optidx].optname);
- goto invalid;
+ continue;
}
/* call function to deal with it all */
if (configopt[optidx].func(optsub, optval,
configopt[optidx].funcflags) != 0) {
add_startup_exception("%s: line %zd: invalid data for "
"%s", filename, lineno, configopt[optidx].optname);
- goto invalid;
- }
-invalid:
- if (optval) {
- free(optval);
- optval = NULL;
- }
- if (optsub) {
- free(optsub);
- optsub = NULL;
+ continue;
}
}
struct ws_win *win, *ww;
int ws_idx;
char ws_idx_str[SWM_PROPLEN];
+ char *class, *instance, *name;
struct swm_region *r;
struct pid_e *p;
struct quirk *qp;
uint32_t i, wa[2];
xcb_get_geometry_reply_t *gr;
- xcb_icccm_get_wm_protocols_reply_t wpr;
if ((win = find_window(id)) != NULL) {
DNPRINTF(SWM_D_MISC, "manage_window: win 0x%x already "
free(gr);
+ /* Select which X events to monitor and set border pixel color. */
+ wa[0] = win->s->c[SWM_S_COLOR_UNFOCUS].pixel;
+ wa[1] = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_PROPERTY_CHANGE |
+ XCB_EVENT_MASK_STRUCTURE_NOTIFY;
+#ifdef SWM_DEBUG
+ wa[1] |= XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_FOCUS_CHANGE;
+#endif
+
+ xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL |
+ XCB_CW_EVENT_MASK, wa);
+
/* Get WM_SIZE_HINTS. */
xcb_icccm_get_wm_normal_hints_reply(conn,
xcb_icccm_get_wm_normal_hints(conn, win->id),
set_child_transient(win, &win->transient);
}
- /* Get supported protocols. */
- if (xcb_icccm_get_wm_protocols_reply(conn,
- xcb_icccm_get_wm_protocols(conn, win->id, a_prot),
- &wpr, NULL)) {
- for (i = 0; i < wpr.atoms_len; i++) {
- if (wpr.atoms[i] == a_takefocus)
- win->take_focus = 1;
- if (wpr.atoms[i] == a_delete)
- win->can_delete = 1;
- }
- xcb_icccm_get_wm_protocols_reply_wipe(&wpr);
- }
+ /* Get WM_PROTOCOLS. */
+ get_wm_protocols(win);
win->iconic = get_swm_iconic(win);
ewmh_autoquirk(win);
/* Determine initial quirks. */
- if (xcb_icccm_get_wm_class_reply(conn,
+ xcb_icccm_get_wm_class_reply(conn,
xcb_icccm_get_wm_class(conn, win->id),
- &win->ch, NULL)) {
- DNPRINTF(SWM_D_CLASS, "manage_window: class: %s, name: %s\n",
- win->ch.class_name, win->ch.instance_name);
-
- /* java is retarded so treat it special */
- if (strstr(win->ch.instance_name, "sun-awt")) {
- DNPRINTF(SWM_D_CLASS, "manage_window: java window "
- "detected.\n");
- win->java = 1;
- }
-
- TAILQ_FOREACH(qp, &quirks, entry) {
- if (strcmp(win->ch.class_name, qp->class) == 0 &&
- strcmp(win->ch.instance_name, qp->name) == 0) {
- DNPRINTF(SWM_D_CLASS, "manage_window: on quirks"
- "list; mask: 0x%lx\n", qp->quirk);
- if (qp->quirk & SWM_Q_FLOAT)
- win->floating = 1;
- win->quirks = qp->quirk;
- }
+ &win->ch, NULL);
+
+ class = win->ch.class_name ? win->ch.class_name : "";
+ instance = win->ch.instance_name ? win->ch.instance_name : "";
+ name = get_win_name(win->id);
+
+ DNPRINTF(SWM_D_CLASS, "manage_window: class: %s, instance: %s, "
+ "name: %s\n", class, instance, name);
+
+ /* java is retarded so treat it special */
+ if (win->ch.instance_name && strstr(win->ch.instance_name, "sun-awt")) {
+ DNPRINTF(SWM_D_CLASS, "manage_window: java window detected.\n");
+ win->java = 1;
+ }
+
+ TAILQ_FOREACH(qp, &quirks, entry) {
+ if (regexec(&qp->regex_class, class, 0, NULL, 0) == 0 &&
+ regexec(&qp->regex_instance, instance, 0, NULL, 0) == 0 &&
+ regexec(&qp->regex_name, name, 0, NULL, 0) == 0) {
+ DNPRINTF(SWM_D_CLASS, "manage_window: matched "
+ "quirk: %s:%s:%s mask: %#lx\n", qp->class,
+ qp->instance, qp->name, qp->quirk);
+ if (qp->quirk & SWM_Q_FLOAT)
+ win->floating = 1;
+ win->quirks = qp->quirk;
}
}
+ free(name);
+
/* Alter window position if quirky */
if (win->quirks & SWM_Q_ANYWHERE)
win->manual = 1;
update_window(win);
}
- /* Select which X events to monitor and set border pixel color. */
- wa[0] = win->s->c[SWM_S_COLOR_UNFOCUS].pixel;
- wa[1] = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_PROPERTY_CHANGE |
- XCB_EVENT_MASK_STRUCTURE_NOTIFY;
-#ifdef SWM_DEBUG
- wa[1] |= XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_FOCUS_CHANGE;
-#endif
-
- xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL |
- XCB_CW_EVENT_MASK, wa);
-
out:
/* Figure out where to stack the window in the workspace. */
if (trans && (ww = find_window(trans)))
void
mappingnotify(xcb_mapping_notify_event_t *e)
{
+ struct ws_win *w;
+ int i, j, num_screens;
+
xcb_refresh_keyboard_mapping(syms, e);
- if (e->request == XCB_MAPPING_KEYBOARD)
+ if (e->request == XCB_MAPPING_KEYBOARD) {
grabkeys();
+
+ /* Regrab buttons on all managed windows. */
+ num_screens = get_screen_count();
+ for (i = 0; i < num_screens; i++)
+ for (j = 0; j < workspace_limit; j++)
+ TAILQ_FOREACH(w, &screens[i].ws[j].winlist,
+ entry)
+ grabbuttons(w);
+ }
}
void
/* The new window should get focus; prepare. */
if (focus_mode != SWM_FOCUS_FOLLOW &&
- !(win->quirks & SWM_Q_NOFOCUSONMAP)) {
+ !(win->quirks & SWM_Q_NOFOCUSONMAP) &&
+ (!(win->hints.flags & XCB_ICCCM_WM_HINT_INPUT) ||
+ (win->hints.flags & XCB_ICCCM_WM_HINT_INPUT &&
+ win->hints.input))) {
if (win->quirks & SWM_Q_FOCUSONMAP_SINGLE) {
/* See if other wins of same type are already mapped. */
TAILQ_FOREACH(w, &win->ws->winlist, entry) {
get_atom_name(xcb_atom_t atom)
{
char *name = NULL;
-#if 0
+#ifdef SWM_DEBUG_ATOM_NAMES
/*
* This should be disabled during most debugging since
* xcb_get_* causes an xcb_flush.
focus_flush();
}
} else if (e->state == XCB_PROPERTY_DELETE) {
+ /* Reload floating geometry in case region changed. */
+ if (win->floating)
+ load_float_geom(win);
+
/* The window is no longer iconic, restack ws. */
if (focus_mode != SWM_FOCUS_FOLLOW)
ws->focus_pending = get_focus_magic(win);
} else if (e->atom == XCB_ATOM_WM_CLASS ||
e->atom == XCB_ATOM_WM_NAME) {
bar_draw();
+ } else if (e->atom == a_prot) {
+ get_wm_protocols(win);
}
xcb_flush(conn);
focus_flush();
}
-#if 0
-void
-visibilitynotify(xcb_visibility_notify_event_t *e)
-{
- DNPRINTF(SWM_D_EVENT, "visibilitynotify: window: 0x%x\n",
- e->window);
-}
-#endif
-
void
clientmessage(xcb_client_message_event_t *e)
{
/*EVENT(XCB_SELECTION_NOTIFY, );*/
/*EVENT(XCB_SELECTION_REQUEST, );*/
EVENT(XCB_UNMAP_NOTIFY, unmapnotify);
- /*EVENT(XCB_VISIBILITY_NOTIFY, visibilitynotify);*/
+ /*EVENT(XCB_VISIBILITY_NOTIFY, );*/
#undef EVENT
}
if (type - xrandr_eventbase == XCB_RANDR_SCREEN_CHANGE_NOTIFY)