int term_width = 0;
int font_adjusted = 0;
unsigned int mod_key = MODKEY;
+bool warp_pointer = false;
/* dmenu search */
struct swm_region *search_r;
int composite_enabled = 0;
double opacity_focus = 1.0;
double opacity_unfocus = 0.6;
+bool urgent_collapse = false;
char *clock_format = NULL;
bool window_class_enabled = false;
bool window_instance_enabled = false;
bool can_delete;
bool take_focus;
bool java;
- unsigned long quirks;
+ uint32_t quirks;
struct workspace *ws; /* always valid */
struct swm_screen *s; /* always valid, never changes */
xcb_size_hints_t sh;
regex_t regex_class;
regex_t regex_instance;
regex_t regex_name;
- unsigned long quirk;
+ uint32_t quirk;
+ int ws; /* Initial workspace. */
#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 */
void bar_window_state(char *, size_t, struct swm_region *);
void bar_workspace_name(char *, size_t, struct swm_region *);
void buttonpress(xcb_button_press_event_t *);
+void center_pointer(struct swm_region *);
void check_conn(void);
void clear_keys(void);
int clear_maximized(struct workspace *);
char *get_stack_mode_name(uint8_t);
#endif
int32_t get_swm_ws(xcb_window_t);
+bool get_urgent(struct ws_win *);
char *get_win_name(xcb_window_t);
uint8_t get_win_state(xcb_window_t);
void get_wm_protocols(struct ws_win *);
void name_workspace(struct swm_region *, union arg *);
void new_region(struct swm_screen *, int, int, int, int);
int parsekeys(const char *, unsigned int, unsigned int *, KeySym *);
-int parsequirks(const char *, unsigned long *);
+int parsequirks(const char *, uint32_t *, int *);
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 *);
#endif
void propertynotify(xcb_property_notify_event_t *);
void quirk_free(struct quirk *);
-void quirk_insert(const char *, const char *, const char *,unsigned long);
+void quirk_insert(const char *, const char *, const char *, uint32_t, int);
void quirk_remove(struct quirk *);
void quirk_replace(struct quirk *, const char *, const char *, const char *,
- unsigned long);
+ uint32_t, int);
void quit(struct swm_region *, union arg *);
void raise_toggle(struct swm_region *, union arg *);
void raise_window(struct ws_win *);
void setkeybinding(unsigned int, KeySym, enum keyfuncid, const char *);
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 setquirk(const char *, const char *, const char *, uint32_t, int);
void setscreencolor(const char *, int, int);
void setspawn(const char *, const char *, int);
void setup_ewmh(void);
free(title);
}
+bool
+get_urgent(struct ws_win *win)
+{
+ xcb_icccm_wm_hints_t hints;
+ xcb_get_property_cookie_t c;
+ bool urgent = false;
+
+ if (win) {
+ c = xcb_icccm_get_wm_hints(conn, win->id);
+ if (xcb_icccm_get_wm_hints_reply(conn, c, &hints, NULL))
+ urgent = xcb_icccm_wm_hints_get_urgency(&hints);
+ }
+
+ return urgent;
+}
+
void
bar_urgent(char *s, size_t sz)
{
int i, j, num_screens;
bool urgent[SWM_WS_MAX];
char b[8];
- xcb_get_property_cookie_t c;
- xcb_icccm_wm_hints_t hints;
for (i = 0; i < workspace_limit; i++)
urgent[i] = false;
num_screens = get_screen_count();
for (i = 0; i < num_screens; i++)
for (j = 0; j < workspace_limit; j++)
- TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) {
- c = xcb_icccm_get_wm_hints(conn, win->id);
- if (xcb_icccm_get_wm_hints_reply(conn, c,
- &hints, NULL) == 0)
- continue;
- if (hints.flags & XCB_ICCCM_WM_HINT_X_URGENCY)
- urgent[j] = true;
- }
+ TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
+ urgent[j] = get_urgent(win);
for (i = 0; i < workspace_limit; i++) {
- if (urgent[i])
+ if (urgent[i]) {
snprintf(b, sizeof b, "%d ", i + 1);
- else
- snprintf(b, sizeof b, "- ");
- strlcat(s, b, sz);
+ strlcat(s, b, sz);
+ } else if (!urgent_collapse) {
+ strlcat(s, "- ", sz);
+ }
}
}
return win;
}
+void
+center_pointer(struct swm_region *r)
+{
+ struct ws_win *win;
+
+ if (!warp_pointer || r == NULL)
+ return;
+
+ win = r->ws->focus;
+
+ DNPRINTF(SWM_D_EVENT, "center_pointer: win %#x.\n", WINID(win));
+
+ if (win && win->mapped)
+ xcb_warp_pointer(conn, XCB_NONE, win->id, 0, 0, 0, 0,
+ WIDTH(win) / 2, HEIGHT(win) / 2);
+ else
+ xcb_warp_pointer(conn, XCB_NONE, r->id, 0, 0, 0, 0,
+ WIDTH(r) / 2, HEIGHT(r) / 2);
+}
+
struct swm_region *
root_to_region(xcb_window_t root, int check)
{
ewmh_update_current_desktop();
+ center_pointer(r);
focus_flush();
new_ws->state = SWM_WS_STATE_MAPPED;
return;
focus_region(rr);
+ center_pointer(rr);
focus_flush();
DNPRINTF(SWM_D_FOCUS, "focusrg: done\n");
}
return;
focus_region(rr);
+ center_pointer(rr);
focus_flush();
DNPRINTF(SWM_D_FOCUS, "cyclerg: done\n");
}
ewmh_update_client_list();
stack();
+ center_pointer(r);
focus_flush();
out:
DNPRINTF(SWM_D_MOVE, "swapwin: done\n");
struct workspace *ws = NULL;
union arg a;
int i;
- xcb_icccm_wm_hints_t hints;
if (!(r && r->ws))
goto out;
head = TAILQ_FIRST(&r->s->ws[(ws->idx + i) %
workspace_limit].winlist);
- while (head != NULL &&
- (head = TAILQ_NEXT(head, entry)) != NULL) {
+ while (head) {
if (head == cur_focus) {
- winfocus = cur_focus;
- break;
- }
- if (xcb_icccm_get_wm_hints_reply(conn,
- xcb_icccm_get_wm_hints(conn, head->id),
- &hints, NULL) != 0 &&
- xcb_icccm_wm_hints_get_urgency(&hints)) {
+ if (i > 0) {
+ winfocus = cur_focus;
+ break;
+ }
+ } else if (get_urgent(head)) {
winfocus = head;
break;
}
+
+ head = TAILQ_NEXT(head, entry);
}
- if (winfocus != NULL)
+ if (winfocus)
break;
}
/* Switch ws if new focus is on a different ws. */
- if (winfocus != NULL && winfocus->ws != ws) {
+ if (winfocus && winfocus->ws != ws) {
a.id = winfocus->ws->idx;
switchws(r, &a);
}
stack();
focus_win(get_focus_magic(winfocus));
+ center_pointer(r);
focus_flush();
out:
focus_win(get_region_focus(r));
+ center_pointer(r);
focus_flush();
}
stack();
bar_draw();
+ center_pointer(r);
focus_flush();
}
win_g.y += last_h + 2 * border_width + tile_gap;
if (disable_border && !(bar_enabled && ws->bar_enabled) &&
- winno == 1){
+ winno == 1) {
bordered = false;
win_g.w += 2 * border_width;
win_g.h += 2 * border_width;
if (X(w) != gg.x || Y(w) != gg.y || WIDTH(w) != gg.w ||
HEIGHT(w) != gg.h) {
w->g = gg;
- if (bar_enabled && ws->bar_enabled){
- w->bordered = true;
- } else {
+
+ if (disable_border && !(bar_enabled && ws->bar_enabled)) {
w->bordered = false;
WIDTH(w) += 2 * border_width;
HEIGHT(w) += 2 * border_width;
+ } else {
+ w->bordered = true;
}
update_window(w);
}
}
+ center_pointer(r);
focus_flush();
}
if (w == w->ws->focus)
focus_win(w);
+ center_pointer(r);
focus_flush();
DNPRINTF(SWM_D_MISC, "maximize_toggle: done\n");
}
if (w == w->ws->focus)
focus_win(w);
+ center_pointer(r);
focus_flush();
DNPRINTF(SWM_D_MISC, "floating_toggle: done\n");
}
return;
resize(win, args);
+ center_pointer(r);
focus_flush();
}
return;
move(win, args);
+ center_pointer(r);
focus_flush();
}
"IGNORESPAWNWS",
};
-/* SWM_Q_WS: retain '|' for back compat for now (2009-08-11) */
-#define SWM_Q_WS "\n|+ \t"
+/* SWM_Q_DELIM: retain '|' for back compat for now (2009-08-11) */
+#define SWM_Q_DELIM "\n|+ \t"
int
-parsequirks(const char *qstr, unsigned long *quirk)
+parsequirks(const char *qstr, uint32_t *quirk, int *ws)
{
char *str, *cp, *name;
int i;
cp = str;
*quirk = 0;
- while ((name = strsep(&cp, SWM_Q_WS)) != NULL) {
+ while ((name = strsep(&cp, SWM_Q_DELIM)) != NULL) {
if (cp)
- cp += (long)strspn(cp, SWM_Q_WS);
+ cp += (long)strspn(cp, SWM_Q_DELIM);
+
+ if (sscanf(name, "WS[%d]", ws) == 1) {
+ if (*ws > 0)
+ *ws -= 1;
+ continue;
+ }
+
for (i = 0; i < LENGTH(quirkname); i++) {
if (strncasecmp(name, quirkname[i],
SWM_QUIRK_LEN) == 0) {
void
quirk_insert(const char *class, const char *instance, const char *name,
- unsigned long quirk)
+ uint32_t quirk, int ws)
{
struct quirk *qp;
char *str;
bool failed = false;
DNPRINTF(SWM_D_QUIRK, "quirk_insert: class: %s, instance: %s, name: %s,"
- " value: %lu\n", class, instance, name, quirk);
+ " value: %u, ws: %d\n", class, instance, name, quirk, ws);
if ((qp = malloc(sizeof *qp)) == NULL)
err(1, "quirk_insert: malloc");
quirk_free(qp);
} else {
qp->quirk = quirk;
+ qp->ws = ws;
TAILQ_INSERT_TAIL(&quirks, qp, entry);
}
DNPRINTF(SWM_D_QUIRK, "quirk_insert: leave\n");
void
quirk_remove(struct quirk *qp)
{
- DNPRINTF(SWM_D_QUIRK, "quirk_remove: %s:%s [%lu]\n", qp->class,
+ DNPRINTF(SWM_D_QUIRK, "quirk_remove: %s:%s [%u]\n", qp->class,
qp->name, qp->quirk);
TAILQ_REMOVE(&quirks, qp, entry);
void
quirk_replace(struct quirk *qp, const char *class, const char *instance,
- const char *name, unsigned long quirk)
+ const char *name, uint32_t quirk, int ws)
{
- DNPRINTF(SWM_D_QUIRK, "quirk_replace: %s:%s:%s [%lu]\n", qp->class,
- qp->instance, qp->name, qp->quirk);
+ DNPRINTF(SWM_D_QUIRK, "quirk_replace: %s:%s:%s [%u], ws: %d\n", qp->class,
+ qp->instance, qp->name, qp->quirk, qp->ws);
quirk_remove(qp);
- quirk_insert(class, instance, name, quirk);
+ quirk_insert(class, instance, name, quirk, ws);
DNPRINTF(SWM_D_QUIRK, "quirk_replace: leave\n");
}
void
setquirk(const char *class, const char *instance, const char *name,
- unsigned long quirk)
+ uint32_t quirk, int ws)
{
struct quirk *qp;
- DNPRINTF(SWM_D_QUIRK, "setquirk: enter %s:%s:%s [%lu]\n", class,
- instance, name, quirk);
+ DNPRINTF(SWM_D_QUIRK, "setquirk: enter %s:%s:%s [%u], ws: %d\n", class,
+ instance, name, quirk, ws);
/* 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)
+ if (quirk == 0 && ws == -1)
quirk_remove(qp);
else
- quirk_replace(qp, class, instance, name, quirk);
+ quirk_replace(qp, class, instance, name, quirk,
+ ws);
DNPRINTF(SWM_D_QUIRK, "setquirk: leave\n");
return;
}
}
- /* Only insert if quirk is not NONE. */
- if (quirk)
- quirk_insert(class, instance, name, quirk);
+ /* Only insert if quirk is not NONE or forced ws is set. */
+ if (quirk || ws != -1)
+ quirk_insert(class, instance, name, quirk, ws);
DNPRINTF(SWM_D_QUIRK, "setquirk: leave\n");
}
{
char *str, *cp, *class;
char *instance = NULL, *name = NULL;
- int retval, count = 0;
- unsigned long qrks;
+ int retval, count = 0, ws = -1;
+ uint32_t qrks;
/* suppress unused warning since var is needed */
(void)flags;
DNPRINTF(SWM_D_CONF, "setconfquirk: class: %s, instance: %s, "
"name: %s\n", class, instance, name);
- if ((retval = parsequirks(value, &qrks)) == 0)
- setquirk(class, instance, name, qrks);
+ if ((retval = parsequirks(value, &qrks, &ws)) == 0)
+ setquirk(class, instance, name, qrks, ws);
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, -1);
+ setquirk("OpenOffice.org 3.2", "VCLSalFrame", ".*",
+ SWM_Q_FLOAT, -1);
+ setquirk("Firefox-bin", "firefox-bin", ".*",
+ SWM_Q_TRANSSZ, -1);
+ setquirk("Firefox", "Dialog", ".*",
+ SWM_Q_FLOAT, -1);
+ setquirk("Gimp", "gimp", ".*",
+ SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1);
+ setquirk("XTerm", "xterm", ".*",
+ SWM_Q_XTERM_FONTADJ, -1);
+ setquirk("xine", "Xine Window", ".*",
+ SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1);
+ setquirk("Xitk", "Xitk Combo", ".*",
+ SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1);
+ setquirk("xine", "xine Panel", ".*",
+ SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1);
+ setquirk("Xitk", "Xine Window", ".*",
+ SWM_Q_FLOAT | SWM_Q_ANYWHERE, -1);
+ setquirk("xine", "xine Video Fullscreen Window", ".*",
+ SWM_Q_FULLSCREEN | SWM_Q_FLOAT, -1);
+ setquirk("pcb", "pcb", ".*",
+ SWM_Q_FLOAT, -1);
+ setquirk("SDL_App", "SDL_App", ".*",
+ SWM_Q_FLOAT | SWM_Q_FULLSCREEN, -1);
}
/* conf file stuff */
SWM_S_STACK_ENABLED,
SWM_S_TERM_WIDTH,
SWM_S_TILE_GAP,
+ SWM_S_URGENT_COLLAPSE,
SWM_S_URGENT_ENABLED,
SWM_S_VERBOSE_LAYOUT,
+ SWM_S_WARP_POINTER,
SWM_S_WINDOW_CLASS_ENABLED,
SWM_S_WINDOW_INSTANCE_ENABLED,
SWM_S_WINDOW_NAME_ENABLED,
case SWM_S_TILE_GAP:
tile_gap = atoi(value);
break;
+ case SWM_S_URGENT_COLLAPSE:
+ urgent_collapse = (atoi(value) != 0);
+ break;
case SWM_S_URGENT_ENABLED:
urgent_enabled = (atoi(value) != 0);
break;
layouts[i].l_string = plain_stacker;
}
break;
+ case SWM_S_WARP_POINTER:
+ warp_pointer = (atoi(value) != 0);
+ break;
case SWM_S_WINDOW_CLASS_ENABLED:
window_class_enabled = (atoi(value) != 0);
break;
{ "tile_gap", setconfvalue, SWM_S_TILE_GAP },
{ "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_collapse", setconfvalue, SWM_S_URGENT_COLLAPSE },
{ "urgent_enabled", setconfvalue, SWM_S_URGENT_ENABLED },
{ "verbose_layout", setconfvalue, SWM_S_VERBOSE_LAYOUT },
+ { "warp_pointer", setconfvalue, SWM_S_WARP_POINTER },
{ "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 },
xcb_get_geometry_reply_t *gr;
xcb_window_t trans = XCB_WINDOW_NONE;
uint32_t i, wa[2], new_flags;
- int ws_idx;
+ int ws_idx, force_ws = -1;
char *class, *instance, *name;
if ((win = find_window(id)) != NULL) {
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);
+ "quirk: %s:%s:%s mask: %#x, ws: %d\n", qp->class,
+ qp->instance, qp->name, qp->quirk, qp->ws);
win->quirks = qp->quirk;
+ if (qp->ws >= 0 && qp->ws < workspace_limit)
+ force_ws = qp->ws;
}
}
win->ws = r->ws;
}
+ if (force_ws != -1)
+ win->ws = &r->s->ws[force_ws];
+
/* Set the _NET_WM_DESKTOP atom. */
DNPRINTF(SWM_D_PROP, "manage_window: set _NET_WM_DESKTOP: %d\n",
win->ws->idx);
if (ws->focus_pending == win) {
focus_win(win);
ws->focus_pending = NULL;
+ center_pointer(win->ws->r);
focus_flush();
}
}
}
}
+ center_pointer(ws->r);
focus_flush();
}
Got questions, comments, patches, etc.? Contact Jason Woofenden