#include <locale.h>
#include <paths.h>
#include <pwd.h>
+#include <regex.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#define xcb_icccm_get_wm_class_reply_t xcb_get_wm_class_reply_t
#define xcb_icccm_get_wm_class_reply_wipe xcb_get_wm_class_reply_wipe
#define xcb_icccm_get_wm_hints xcb_get_wm_hints
+#define xcb_icccm_wm_hints_get_urgency xcb_wm_hints_get_urgency
#define xcb_icccm_get_wm_hints_reply xcb_get_wm_hints_reply
#define xcb_icccm_get_wm_name xcb_get_wm_name
#define xcb_icccm_get_wm_name_reply xcb_get_wm_name_reply
#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 WINID(w) ((w) ? (w)->id : XCB_WINDOW_NONE)
+#define WS_FOCUSED(ws) ((ws)->r && (ws)->r->s->r_focus == (ws)->r)
#define YESNO(x) ((x) ? "yes" : "no")
+/* Constrain Window flags */
+#define SWM_CW_RESIZABLE (0x01)
+#define SWM_CW_SOFTBOUNDARY (0x02)
+#define SWM_CW_HARDBOUNDARY (0x04)
+#define SWM_CW_RIGHT (0x10)
+#define SWM_CW_LEFT (0x20)
+#define SWM_CW_BOTTOM (0x40)
+#define SWM_CW_TOP (0x80)
+#define SWM_CW_ALLSIDES (0xf0)
+
#define SWM_FOCUS_DEFAULT (0)
#define SWM_FOCUS_FOLLOW (1)
#define SWM_FOCUS_MANUAL (2)
xcb_atom_t a_prot;
xcb_atom_t a_delete;
xcb_atom_t a_takefocus;
-xcb_atom_t a_wmname;
-xcb_atom_t a_netwmname;
xcb_atom_t a_utf8_string;
-xcb_atom_t a_string;
xcb_atom_t a_swm_iconic;
xcb_atom_t a_swm_ws;
-volatile sig_atomic_t running = 1;
-volatile sig_atomic_t restart_wm = 0;
+volatile sig_atomic_t running = 1;
+volatile sig_atomic_t restart_wm = 0;
xcb_timestamp_t last_event_time = 0;
int outputs = 0;
int other_wm;
xcb_connection_t *conn;
xcb_key_symbols_t *syms;
+int boundary_width = 50;
int cycle_empty = 0;
int cycle_visible = 0;
int term_width = 0;
#define SWM_BAR_JUSTIFY_CENTER (1)
#define SWM_BAR_JUSTIFY_RIGHT (2)
#define SWM_BAR_OFFSET (4)
-#define SWM_BAR_FONTS "-*-terminus-medium-*-*-*-12-*-*-*-*-*-*-*," \
- "-*-profont-*-*-*-*-12-*-*-*-*-*-*-*," \
- "-*-times-medium-r-*-*-12-*-*-*-*-*-*-*," \
- "-misc-fixed-medium-r-*-*-12-*-*-*-*-*-*-*," \
+#define SWM_BAR_FONTS "-*-terminus-medium-*-*-*-12-*-*-*-*-*-*-*,"\
+ "-*-profont-*-*-*-*-12-*-*-*-*-*-*-*,"\
+ "-*-times-medium-r-*-*-12-*-*-*-*-*-*-*,"\
+ "-misc-fixed-medium-r-*-*-12-*-*-*-*-*-*-*,"\
"-*-*-*-r-*-*-*-*-*-*-*-*-*-*"
#ifdef X_HAVE_UTF8_STRING
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;
unsigned long quirks;
struct workspace *ws; /* always valid */
struct swm_screen *s; /* always valid, never changes */
- xcb_get_geometry_reply_t *wa;
xcb_size_hints_t sh;
xcb_icccm_get_wm_class_reply_t ch;
xcb_icccm_wm_hints_t hints;
#define SWM_ARG_ID_FOCUSNEXT (0)
#define SWM_ARG_ID_FOCUSPREV (1)
#define SWM_ARG_ID_FOCUSMAIN (2)
+#define SWM_ARG_ID_FOCUSURGENT (3)
#define SWM_ARG_ID_SWAPNEXT (10)
#define SWM_ARG_ID_SWAPPREV (11)
#define SWM_ARG_ID_SWAPMAIN (12)
/* 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 */
char *name;
xcb_atom_t atom;
} ewmh[SWM_EWMH_HINT_MAX] = {
- /* must be in same order as in the enum */
- {"_NET_ACTIVE_WINDOW", XCB_ATOM_NONE},
- {"_NET_CLOSE_WINDOW", XCB_ATOM_NONE},
- {"_NET_MOVERESIZE_WINDOW", XCB_ATOM_NONE},
- {"_NET_WM_ACTION_ABOVE", XCB_ATOM_NONE},
- {"_NET_WM_ACTION_CLOSE", XCB_ATOM_NONE},
- {"_NET_WM_ACTION_FULLSCREEN", XCB_ATOM_NONE},
- {"_NET_WM_ACTION_MOVE", XCB_ATOM_NONE},
- {"_NET_WM_ACTION_RESIZE", XCB_ATOM_NONE},
- {"_NET_WM_ALLOWED_ACTIONS", XCB_ATOM_NONE},
- {"_NET_WM_NAME", XCB_ATOM_NONE},
- {"_NET_WM_STATE", XCB_ATOM_NONE},
- {"_NET_WM_STATE_ABOVE", XCB_ATOM_NONE},
- {"_NET_WM_STATE_FULLSCREEN", XCB_ATOM_NONE},
- {"_NET_WM_STATE_HIDDEN", XCB_ATOM_NONE},
- {"_NET_WM_STATE_MAXIMIZED_HORZ", XCB_ATOM_NONE},
- {"_NET_WM_STATE_MAXIMIZED_VERT", XCB_ATOM_NONE},
- {"_NET_WM_STATE_SKIP_PAGER", XCB_ATOM_NONE},
- {"_NET_WM_STATE_SKIP_TASKBAR", XCB_ATOM_NONE},
- {"_NET_WM_WINDOW_TYPE", XCB_ATOM_NONE},
- {"_NET_WM_WINDOW_TYPE_DIALOG", XCB_ATOM_NONE},
- {"_NET_WM_WINDOW_TYPE_DOCK", XCB_ATOM_NONE},
- {"_NET_WM_WINDOW_TYPE_NORMAL", XCB_ATOM_NONE},
- {"_NET_WM_WINDOW_TYPE_SPLASH", XCB_ATOM_NONE},
- {"_NET_WM_WINDOW_TYPE_TOOLBAR", XCB_ATOM_NONE},
- {"_NET_WM_WINDOW_TYPE_UTILITY", XCB_ATOM_NONE},
- {"_SWM_WM_STATE_MANUAL", XCB_ATOM_NONE},
+ /* must be in same order as in the enum */
+ {"_NET_ACTIVE_WINDOW", XCB_ATOM_NONE},
+ {"_NET_CLOSE_WINDOW", XCB_ATOM_NONE},
+ {"_NET_MOVERESIZE_WINDOW", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_ABOVE", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_CLOSE", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_FULLSCREEN", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_MOVE", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_RESIZE", XCB_ATOM_NONE},
+ {"_NET_WM_ALLOWED_ACTIONS", XCB_ATOM_NONE},
+ {"_NET_WM_NAME", XCB_ATOM_NONE},
+ {"_NET_WM_STATE", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_ABOVE", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_FULLSCREEN", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_HIDDEN", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_MAXIMIZED_HORZ", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_MAXIMIZED_VERT", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_SKIP_PAGER", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_SKIP_TASKBAR", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_DIALOG", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_DOCK", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_NORMAL", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_SPLASH", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_TOOLBAR", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_UTILITY", XCB_ATOM_NONE},
+ {"_SWM_WM_STATE_MANUAL", XCB_ATOM_NONE},
};
/* Cursors */
KF_FOCUS_MAIN,
KF_FOCUS_NEXT,
KF_FOCUS_PREV,
+ KF_FOCUS_URGENT,
KF_HEIGHT_GROW,
KF_HEIGHT_SHRINK,
KF_ICONIFY,
};
struct key {
- RB_ENTRY(key) entry;
- unsigned int mod;
- KeySym keysym;
- enum keyfuncid funcid;
- char *spawn_name;
+ RB_ENTRY(key) entry;
+ unsigned int mod;
+ KeySym keysym;
+ enum keyfuncid funcid;
+ char *spawn_name;
};
RB_HEAD(key_tree, key);
/* 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 *);
-void bar_cleanup(struct swm_region *);
-void bar_extra_setup(void);
-void bar_extra_stop(void);
-int bar_extra_update(void);
-void bar_fmt(const char *, char *, struct swm_region *, size_t);
-void bar_fmt_expand(char *, size_t);
-void bar_draw(void);
-void bar_print(struct swm_region *, const char *);
-void bar_print_legacy(struct swm_region *, const char *);
-void bar_replace(char *, char *, struct swm_region *, size_t);
-void bar_replace_pad(char *, int *, size_t);
+void adjust_font(struct ws_win *);
+char *argsep(char **);
+void bar_cleanup(struct swm_region *);
+void bar_extra_setup(void);
+void bar_extra_stop(void);
+int bar_extra_update(void);
+void bar_fmt(const char *, char *, struct swm_region *, size_t);
+void bar_fmt_expand(char *, size_t);
+void bar_draw(void);
+void bar_print(struct swm_region *, const char *);
+void bar_print_legacy(struct swm_region *, const char *);
+void bar_replace(char *, char *, struct swm_region *, size_t);
+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_float(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 *);
-void check_conn(void);
-void clear_keys(void);
-void clientmessage(xcb_client_message_event_t *);
-void client_msg(struct ws_win *, xcb_atom_t, xcb_timestamp_t);
-int conf_load(const char *, int);
-void configurenotify(xcb_configure_notify_event_t *);
-void configurerequest(xcb_configure_request_event_t *);
-void config_win(struct ws_win *, xcb_configure_request_event_t *);
-void constrain_window(struct ws_win *, struct swm_region *, int);
-int count_win(struct workspace *, int);
-void cursors_cleanup(void);
-void cursors_load(void);
-void custom_region(char *);
-void cyclerg(struct swm_region *, union arg *);
-void cyclews(struct swm_region *, union arg *);
-void cycle_layout(struct swm_region *, union arg *);
-void destroynotify(xcb_destroy_notify_event_t *);
-void dumpwins(struct swm_region *, union arg *);
-int enable_wm(void);
-void enternotify(xcb_enter_notify_event_t *);
-void event_drain(uint8_t);
-void event_error(xcb_generic_error_t *);
-void event_handle(xcb_generic_event_t *);
-void ewmh_autoquirk(struct ws_win *);
-void ewmh_get_win_state(struct ws_win *);
-int ewmh_set_win_fullscreen(struct ws_win *, int);
-void ewmh_update_actions(struct ws_win *);
-void ewmh_update_win_state(struct ws_win *, xcb_atom_t, long);
+void bar_setup(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 *);
+void check_conn(void);
+void clear_keys(void);
+void clientmessage(xcb_client_message_event_t *);
+void client_msg(struct ws_win *, xcb_atom_t, xcb_timestamp_t);
+int conf_load(const char *, int);
+void configurenotify(xcb_configure_notify_event_t *);
+void configurerequest(xcb_configure_request_event_t *);
+void config_win(struct ws_win *, xcb_configure_request_event_t *);
+void constrain_window(struct ws_win *, struct swm_geometry *, int *);
+int count_win(struct workspace *, int);
+void cursors_cleanup(void);
+void cursors_load(void);
+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 *);
+void destroynotify(xcb_destroy_notify_event_t *);
+void dumpwins(struct swm_region *, union arg *);
+int enable_wm(void);
+void enternotify(xcb_enter_notify_event_t *);
+void event_drain(uint8_t);
+void event_error(xcb_generic_error_t *);
+void event_handle(xcb_generic_event_t *);
+void ewmh_autoquirk(struct ws_win *);
+void ewmh_get_win_state(struct ws_win *);
+int ewmh_set_win_fullscreen(struct ws_win *, int);
+void ewmh_update_actions(struct ws_win *);
+void ewmh_update_win_state(struct ws_win *, xcb_atom_t, long);
char *expand_tilde(const char *);
-void expose(xcb_expose_event_t *);
-void fake_keypress(struct ws_win *, xcb_keysym_t, uint16_t);
+void expose(xcb_expose_event_t *);
+void fake_keypress(struct ws_win *, xcb_keysym_t, uint16_t);
+void floating_toggle(struct swm_region *, union arg *);
+int floating_toggle_win(struct ws_win *);
+void focus(struct swm_region *, union arg *);
+void focus_flush(void);
+void focus_region(struct swm_region *);
+void focusrg(struct swm_region *, union arg *);
+void focus_win(struct ws_win *);
+void fontset_init(void);
+void free_window(struct ws_win *);
+void search_do_resp(void);
+void search_resp_name_workspace(const char *, size_t);
+void search_resp_search_window(const char *);
+void search_resp_search_workspace(const char *);
+void search_resp_uniconify(const char *, size_t);
+void search_win(struct swm_region *, union arg *);
+void search_win_cleanup(void);
+void search_workspace(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(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(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 setup_keys(void);
+void setup_quirks(void);
+void setup_screens(void);
+void setup_spawn(void);
+void set_child_transient(struct ws_win *, xcb_window_t *);
+void set_swm_iconic(struct ws_win *, int);
+void set_win_state(struct ws_win *, uint16_t);
+void shutdown_cleanup(void);
+void sighdlr(int);
+void socket_setnonblock(int);
+void sort_windows(struct ws_win_list *);
+void spawn(int, union arg *, int);
+void spawn_custom(struct swm_region *, union arg *, const char *);
+int spawn_expand(struct swm_region *, union arg *, const char *, char ***);
+void spawn_insert(const char *, const char *, int);
+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);
+void grabbuttons(struct ws_win *);
+void grabkeys(void);
+void grab_windows(void);
+void iconify(struct swm_region *, union arg *);
+int isxlfd(char *);
+void keypress(xcb_key_press_event_t *);
+int key_cmp(struct key *, struct key *);
+void key_insert(unsigned int, KeySym, enum keyfuncid, const char *);
+void key_remove(struct key *);
+void key_replace(struct key *, unsigned int, KeySym, enum keyfuncid,
+ const char *);
+void kill_bar_extra_atexit(void);
+void kill_refs(struct ws_win *);
+void load_float_geom(struct ws_win *);
+void map_window(struct ws_win *, xcb_window_t);
+void mapnotify(xcb_map_notify_event_t *);
+void mappingnotify(xcb_mapping_notify_event_t *);
+void maprequest(xcb_map_request_event_t *);
+void motionnotify(xcb_motion_notify_event_t *);
+void move(struct ws_win *, union arg *);
+void move_step(struct swm_region *, union arg *);
+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(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 propertynotify(xcb_property_notify_event_t *);
+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 *, const char *,
+ unsigned long);
+void quit(struct swm_region *, union arg *);
+void raise_toggle(struct swm_region *, union arg *);
+void region_containment(struct ws_win *, struct swm_region *, int);
+void regionize(struct ws_win *, int, int);
+void resize(struct ws_win *, union arg *);
+void resize_step(struct swm_region *, union arg *);
+void restart(struct swm_region *, union arg *);
+void screenchange(xcb_randr_screen_change_notify_event_t *);
+void scan_xrandr(int);
+void spawn_remove(struct spawn_prog *);
+void spawn_replace(struct spawn_prog *, const char *, const char *, int);
+void spawn_select(struct swm_region *, union arg *, const char *, int *);
+void stack_config(struct swm_region *, union arg *);
+void stack_floater(struct ws_win *, struct swm_region *);
+void stack_master(struct workspace *, struct swm_geometry *, int, int);
+void store_float_geom(struct ws_win *);
+char *strdupsafe(const char *);
+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 unmapnotify(xcb_unmap_notify_event_t *);
+void unmap_all(void);
+void unmap_window(struct ws_win *);
+void updatenumlockmask(void);
+void update_modkey(unsigned int);
+void update_window(struct ws_win *);
+void validate_spawns(void);
+int validate_win(struct ws_win *);
+int validate_ws(struct workspace *);
+void version(struct swm_region *, union arg *);
+void win_to_ws(struct ws_win *, int, int);
+pid_t window_get_pid(xcb_window_t);
+void wkill(struct swm_region *, union arg *);
+void workaround(void);
+void xft_init(struct swm_region *);
+void _add_startup_exception(const char *, va_list);
+void add_startup_exception(const char *, ...);
+#ifdef SWM_DEBUG
+void focusin(xcb_focus_in_event_t *);
+void focusout(xcb_focus_out_event_t *);
+void leavenotify(xcb_leave_notify_event_t *);
+void print_win_geom(xcb_window_t);
+#endif
+
struct pid_e *find_pid(pid_t);
struct ws_win *find_unmanaged_window(xcb_window_t);
struct ws_win *find_window(xcb_window_t);
-void floating_toggle(struct swm_region *, union arg *);
-int floating_toggle_win(struct ws_win *);
-void focus(struct swm_region *, union arg *);
-#ifdef SWM_DEBUG
-void focusin(xcb_focus_in_event_t *);
-void focusout(xcb_focus_out_event_t *);
-#endif
-void focus_flush(void);
-void focus_region(struct swm_region *);
-void focusrg(struct swm_region *, union arg *);
-void focus_win(struct ws_win *);
-void fontset_init(void);
-void free_window(struct ws_win *);
-xcb_atom_t get_atom_from_string(const char *);
-#ifdef SWM_DEBUG
-char *get_atom_name(xcb_atom_t);
-#endif
-struct ws_win *get_focus_magic(struct ws_win *);
-struct ws_win *get_focus_prev(struct ws_win *);
-#ifdef SWM_DEBUG
-char *get_notify_detail_label(uint8_t);
-char *get_notify_mode_label(uint8_t);
-#endif
+struct ws_win *get_focus_magic(struct ws_win *);
+struct ws_win *get_focus_prev(struct ws_win *);
struct ws_win *get_pointer_win(xcb_window_t);
struct ws_win *get_region_focus(struct swm_region *);
-int get_region_index(struct swm_region *);
+struct ws_win *manage_window(xcb_window_t, uint16_t);
+int get_region_index(struct swm_region *);
+xcb_atom_t get_atom_from_string(const char *);
xcb_screen_t *get_screen(int);
-int get_screen_count(void);
-#ifdef SWM_DEBUG
-char *get_stack_mode_name(uint8_t);
-#endif
-int32_t get_swm_iconic(struct ws_win *);
-char *get_win_name(xcb_window_t);
-int get_ws_idx(xcb_window_t);
-uint32_t getstate(xcb_window_t);
-void grabbuttons(struct ws_win *);
-void grabkeys(void);
-void grab_windows(void);
-void iconify(struct swm_region *, union arg *);
-int isxlfd(char *);
-void keypress(xcb_key_press_event_t *);
-int key_cmp(struct key *, struct key *);
-void key_insert(unsigned int, KeySym, enum keyfuncid, const char *);
+xcb_window_t get_sibling(struct ws_win *, int);
+int get_screen_count(void);
+uint32_t getstate(xcb_window_t);
struct key *key_lookup(unsigned int, KeySym);
-void key_remove(struct key *);
-void key_replace(struct key *, unsigned int, KeySym, enum keyfuncid,
- const char *);
-void kill_bar_extra_atexit(void);
-void kill_refs(struct ws_win *);
-#ifdef SWM_DEBUG
-void leavenotify(xcb_leave_notify_event_t *);
-#endif
-void load_float_geom(struct ws_win *, struct swm_region *);
-struct ws_win *manage_window(xcb_window_t, uint16_t);
-void map_window(struct ws_win *);
-void mapnotify(xcb_map_notify_event_t *);
-void mappingnotify(xcb_mapping_notify_event_t *);
-void maprequest(xcb_map_request_event_t *);
-void motionnotify(xcb_motion_notify_event_t *);
-void move(struct ws_win *, union arg *);
-void move_step(struct swm_region *, union arg *);
-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 parse_rgb(const char *, uint16_t *, uint16_t *, uint16_t *);
-void pressbutton(struct swm_region *, union arg *);
-void priorws(struct swm_region *, union arg *);
#ifdef SWM_DEBUG
-void print_win_geom(xcb_window_t);
+char *get_atom_name(xcb_atom_t);
+char *get_notify_detail_label(uint8_t);
+char *get_notify_mode_label(uint8_t);
+char *get_stack_mode_name(uint8_t);
#endif
-void propertynotify(xcb_property_notify_event_t *);
-void quirk_insert(const char *, const char *, unsigned long);
-void quirk_remove(struct quirk *);
-void quirk_replace(struct quirk *, const char *, const char *,
- unsigned long);
-void quit(struct swm_region *, union arg *);
-void raise_toggle(struct swm_region *, union arg *);
-void resize(struct ws_win *, union arg *);
-void resize_step(struct swm_region *, union arg *);
-void restart(struct swm_region *, union arg *);
+
+struct swm_region *region_under(struct swm_screen *, int, int);
struct swm_region *root_to_region(xcb_window_t, int);
-void screenchange(xcb_randr_screen_change_notify_event_t *);
-void scan_xrandr(int);
-void search_do_resp(void);
-void search_resp_name_workspace(const char *, size_t);
-void search_resp_search_window(const char *);
-void search_resp_search_workspace(const char *);
-void search_resp_uniconify(const char *, size_t);
-void search_win(struct swm_region *, union arg *);
-void search_win_cleanup(void);
-void search_workspace(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);
-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);
-void setspawn(const char *, const char *, int);
-void setup_ewmh(void);
-void setup_globals(void);
-void setup_keys(void);
-void setup_quirks(void);
-void setup_screens(void);
-void setup_spawn(void);
-void set_child_transient(struct ws_win *, xcb_window_t *);
-void set_swm_iconic(struct ws_win *, int);
-void set_win_state(struct ws_win *, uint16_t);
-void shutdown_cleanup(void);
-void sighdlr(int);
-void socket_setnonblock(int);
-void sort_windows(struct ws_win_list *);
-void spawn(int, union arg *, int);
-void spawn_custom(struct swm_region *, union arg *, const char *);
-int spawn_expand(struct swm_region *, union arg *, const char *, char ***);
-void spawn_insert(const char *, const char *, int);
-void spawn_remove(struct spawn_prog *);
-void spawn_replace(struct spawn_prog *, const char *, const char *, int);
-void spawn_select(struct swm_region *, union arg *, const char *, int *);
-void stack_config(struct swm_region *, union arg *);
-void stack_floater(struct ws_win *, struct swm_region *);
-void stack_master(struct workspace *, struct swm_geometry *, int, int);
-void store_float_geom(struct ws_win *, struct swm_region *);
-char *strdupsafe(const char *);
-void swapwin(struct swm_region *, union arg *);
-void switchws(struct swm_region *, union arg *);
-void teardown_ewmh(void);
-void unfocus_win(struct ws_win *);
-void uniconify(struct swm_region *, union arg *);
-void unmanage_window(struct ws_win *);
-void unmapnotify(xcb_unmap_notify_event_t *);
-void unmap_all(void);
-void unmap_window(struct ws_win *);
-void updatenumlockmask(void);
-void update_modkey(unsigned int);
-void update_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 *);
-pid_t window_get_pid(xcb_window_t);
-void wkill(struct swm_region *, union arg *);
-void workaround(void);
-void xft_init(struct swm_region *);
-void _add_startup_exception(const char *, va_list);
-void add_startup_exception(const char *, ...);
+struct spawn_prog *spawn_find(const char *);
RB_PROTOTYPE(key_tree, key, entry, key_cmp);
RB_GENERATE(key_tree, key, entry, key_cmp);
-struct key_tree keys;
+struct key_tree keys;
void
cursors_load(void)
char *
expand_tilde(const char *s)
{
- struct passwd *ppwd;
- int i;
+ struct passwd *ppwd;
+ int i;
long max;
- char *user;
- const char *sc = s;
+ char *user;
+ const char *sc = s;
char *result;
if (s == NULL)
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)
{
pr = xcb_get_property_reply(conn,
xcb_get_property(conn, 0, win->id, a_swm_iconic,
XCB_ATOM_INTEGER, 0, 1), NULL);
- if (!pr)
+ if (pr == NULL)
goto out;
if (pr->type != XCB_ATOM_INTEGER || pr->format != 32)
goto out;
pc = xcb_get_property(conn, 0, screens[i].root, sup_check,
XCB_ATOM_WINDOW, 0, 1);
pr = xcb_get_property_reply(conn, pc, NULL);
- if (!pr)
+ if (pr == NULL)
continue;
if (pr->format == sup_check) {
id = *((xcb_window_t *)xcb_get_property_value(pr));
c = xcb_get_property(conn, 0, win->id,
ewmh[_NET_WM_WINDOW_TYPE].atom, XCB_ATOM_ATOM, 0, UINT32_MAX);
r = xcb_get_property_reply(conn, c, NULL);
- if (!r)
+ if (r == NULL)
return;
n = xcb_get_property_value_length(r);
int
ewmh_set_win_fullscreen(struct ws_win *win, int fs)
{
- if (!win->ws->r)
+ if (win->ws->r == NULL)
return (0);
if (!win->floating)
if (fs) {
if (!win->g_floatvalid)
- store_float_geom(win, win->ws->r);
+ store_float_geom(win);
win->g = win->ws->r->g;
win->bordered = 0;
} else {
- load_float_geom(win, win->ws->r);
+ load_float_geom(win);
}
return (1);
ewmh[_NET_WM_ALLOWED_ACTIONS].atom, XCB_ATOM_ATOM, 32, 1, actions);
}
-#define _NET_WM_STATE_REMOVE 0 /* remove/unset property */
-#define _NET_WM_STATE_ADD 1 /* add/set property */
-#define _NET_WM_STATE_TOGGLE 2 /* toggle property */
+#define _NET_WM_STATE_REMOVE 0 /* remove/unset property */
+#define _NET_WM_STATE_ADD 1 /* add/set property */
+#define _NET_WM_STATE_TOGGLE 2 /* toggle property */
void
ewmh_update_win_state(struct ws_win *win, xcb_atom_t state, long action)
c = xcb_get_property(conn, 0, win->id, ewmh[_NET_WM_STATE].atom,
XCB_ATOM_ATOM, 0, UINT32_MAX);
r = xcb_get_property_reply(conn, c, NULL);
- if (!r)
+ if (r == NULL)
return;
states = xcb_get_property_value(r);
nr = xcb_alloc_named_color_reply(conn,
xcb_alloc_named_color(conn, cmap, strlen(colorname),
colorname), NULL);
- if (!nr) {
+ if (nr == NULL) {
strlcat(cname, colorname + 2, sizeof cname - 1);
nr = xcb_alloc_named_color_reply(conn,
xcb_alloc_named_color(conn, cmap, strlen(cname),
}
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_print(struct swm_region *r, const char *s)
{
- size_t len;
- xcb_rectangle_t rect;
- uint32_t gcv[1];
- int32_t x = 0;
- XGlyphInfo info;
- XftDraw *draw;
+ size_t len;
+ xcb_rectangle_t rect;
+ uint32_t gcv[1];
+ int32_t x = 0;
+ XGlyphInfo info;
+ XftDraw *draw;
len = strlen(s);
}
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);
font);
}
- if (!bar_font) {
+ if (bar_font == NULL) {
warnx("unable to load font %s", font);
continue;
} else {
c = xcb_get_property(conn, 0, w, a_state, a_state, 0L, 2L);
r = xcb_get_property_reply(conn, c, NULL);
-
if (r) {
if (r->type == a_state && r->format == 32 && r->length == 2)
result = *((uint32_t *)xcb_get_property_value(r));
}
void
-map_window(struct ws_win *win)
+map_window(struct ws_win *win, xcb_window_t sibling)
{
- uint32_t val = XCB_STACK_MODE_ABOVE;
+ uint16_t mode = XCB_CONFIG_WINDOW_STACK_MODE;
+ uint32_t val[2];
+ int i = 0;
+
+ /* If sibling is specified, stack right above it. */
+ if (sibling != XCB_WINDOW_NONE) {
+ mode |= XCB_CONFIG_WINDOW_SIBLING;
+ val[i++] = sibling;
+ }
+
+ val[i] = XCB_STACK_MODE_ABOVE;
if (win == NULL)
return;
- DNPRINTF(SWM_D_EVENT, "map_window: win 0x%x, mapped: %s\n", win->id,
- YESNO(win->mapped));
+ DNPRINTF(SWM_D_EVENT, "map_window: win 0x%x, mapped: %s, "
+ "sibling: 0x%x\n", win->id, YESNO(win->mapped), sibling);
- xcb_configure_window(conn, win->id,
- XCB_CONFIG_WINDOW_STACK_MODE, &val);
+ xcb_configure_window(conn, win->id, mode, val);
if (win->mapped)
return;
/* No region with an active focus; try to use pointer. */
qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn,
screens[i].root), NULL);
-
if (qpr) {
DNPRINTF(SWM_D_MISC, "root_to_region: pointer: "
"(%d,%d)\n", qpr->root_x, qpr->root_y);
return (win);
r = xcb_query_tree_reply(conn, xcb_query_tree(conn, id), NULL);
- if (!r)
+ if (r == NULL)
return (NULL);
/* if we were looking for the parent return that window instead */
return (1);
}
+xcb_window_t
+get_sibling(struct ws_win *win, int mode)
+{
+ struct ws_win *w = win;
+
+ switch (mode) {
+ case SWM_STACK_TOP:
+ TAILQ_FOREACH_REVERSE(w, &w->ws->winlist, ws_win_list, entry)
+ if (w != win && !w->floating && !w->iconic)
+ break;
+ break;
+ case SWM_STACK_ABOVE:
+ do {
+ w = TAILQ_NEXT(w, entry);
+ } while (w != NULL && (w == win || w->floating || w->iconic));
+ break;
+ case SWM_STACK_BELOW:
+ do {
+ w = TAILQ_PREV(w, ws_win_list, entry);
+ } while (w != NULL && (w == win || w->floating || w->iconic));
+ break;
+ case SWM_STACK_BOTTOM:
+ TAILQ_FOREACH(w, &w->ws->winlist, entry)
+ if (w != win && !w->floating && !w->iconic)
+ break;
+ break;
+ default:
+ w = NULL;
+ }
+
+ if (w == NULL)
+ return (win->ws->r->id);
+ else
+ return (w->id);
+}
+
void
unfocus_win(struct ws_win *win)
{
}
if (win->ws->focus == win) {
+ if (tile_gap < 0 && !win->floating)
+ map_window(win, get_sibling(win, SWM_STACK_BELOW));
win->ws->focus = NULL;
win->ws->focus_prev = win;
}
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) {
ws->always_raise) {
/* If a parent exists, map it first. */
if (parent) {
- map_window(parent);
+ map_window(parent, XCB_WINDOW_NONE);
/* Map siblings next. */
TAILQ_FOREACH(w, &ws->winlist, entry)
if (w != win && !w->iconic &&
w->transient == parent->id)
- map_window(w);
+ map_window(w, XCB_WINDOW_NONE);
}
/* Map focused window. */
- map_window(win);
+ map_window(win, XCB_WINDOW_NONE);
/* Finally, map children of focus window. */
TAILQ_FOREACH(w, &ws->winlist, entry)
if (w->transient == win->id && !w->iconic)
- map_window(w);
+ map_window(w, XCB_WINDOW_NONE);
+ } else if (tile_gap < 0 && !win->floating) {
+ /*
+ * Windows overlap in the layout.
+ * Raise focused win above all tiled wins.
+ */
+ if (tile_gap < 0 && !win->floating)
+ map_window(win,
+ get_sibling(win, SWM_STACK_TOP));
}
set_region(ws->r);
void
switchws(struct swm_region *r, union arg *args)
{
- int wsid = args->id, unmap_old = 0;
struct swm_region *this_r, *other_r;
struct ws_win *win;
struct workspace *new_ws, *old_ws;
+ xcb_window_t none = XCB_WINDOW_NONE;
+ int wsid = args->id, unmap_old = 0;
if (!(r && r->s))
return;
if (new_ws == old_ws)
return;
- unfocus_win(old_ws->focus);
+ if ((win = old_ws->focus) != NULL) {
+ xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL,
+ &win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].pixel);
+
+ xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root,
+ ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1,
+ &none);
+ }
other_r = new_ws->r;
if (other_r == NULL) {
/* Set focus_pending before stacking, if needed. */
if (focus_mode != SWM_FOCUS_FOLLOW && (!new_ws->focus_pending ||
- validate_win(new_ws->focus_pending)))
+ validate_win(new_ws->focus_pending))) {
new_ws->focus_pending = get_region_focus(new_ws->r);
+ new_ws->focus = new_ws->focus_prev;
+ new_ws->focus_prev = NULL;
+ }
stack();
void
priorws(struct swm_region *r, union arg *args)
{
- union arg a;
+ union arg a;
(void)args;
DNPRINTF(SWM_D_FOCUS, "focusrg: id: %d\n", ridx);
rr = TAILQ_FIRST(&r->s->rl);
- for (i = 0; i < ridx; ++i)
+ for (i = 0; i < ridx && rr != NULL; ++i)
rr = TAILQ_NEXT(rr, entry);
if (rr == NULL)
struct ws_win *head, *cur_focus = NULL, *winfocus = NULL;
struct ws_win_list *wl = NULL;
struct workspace *ws = NULL;
- int all_iconics;
+ union arg a;
+ int i;
+ xcb_icccm_wm_hints_t hints;
if (!(r && r->ws))
- return;
+ goto out;
DNPRINTF(SWM_D_FOCUS, "focus: id: %d\n", args->id);
- if ((cur_focus = r->ws->focus) == NULL)
- return;
+ cur_focus = r->ws->focus;
ws = r->ws;
wl = &ws->winlist;
- if (TAILQ_EMPTY(wl))
- return;
- /* make sure there is at least one uniconified window */
- all_iconics = 1;
- TAILQ_FOREACH(winfocus, wl, entry)
- if (!winfocus->iconic) {
- all_iconics = 0;
- break;
- }
- if (all_iconics)
- return;
+
+ /* Make sure an uniconified window has focus, if one exists. */
+ if (cur_focus == NULL) {
+ cur_focus = TAILQ_FIRST(wl);
+ while (cur_focus != NULL && cur_focus->iconic)
+ cur_focus = TAILQ_NEXT(cur_focus, entry);
+ }
switch (args->id) {
case SWM_ARG_ID_FOCUSPREV:
- head = TAILQ_PREV(cur_focus, ws_win_list, entry);
- if (head == NULL)
- head = TAILQ_LAST(wl, ws_win_list);
- winfocus = head;
- if (WINID(winfocus) == cur_focus->transient) {
- head = TAILQ_PREV(winfocus, ws_win_list, entry);
- if (head == NULL)
- head = TAILQ_LAST(wl, ws_win_list);
- winfocus = head;
- }
+ if (cur_focus == NULL)
+ goto out;
- /* skip iconics */
- if (winfocus && winfocus->iconic) {
- while (winfocus != cur_focus) {
- if (winfocus == NULL)
- winfocus = TAILQ_LAST(wl, ws_win_list);
- if (!winfocus->iconic)
- break;
- winfocus = TAILQ_PREV(winfocus, ws_win_list,
- entry);
- }
- }
+ winfocus = cur_focus;
+ do {
+ winfocus = TAILQ_PREV(winfocus, ws_win_list, entry);
+ if (winfocus == NULL)
+ winfocus = TAILQ_LAST(wl, ws_win_list);
+ if (winfocus == cur_focus)
+ break;
+ } while (winfocus != NULL &&
+ (winfocus->iconic || winfocus->id == cur_focus->transient));
break;
-
case SWM_ARG_ID_FOCUSNEXT:
- head = TAILQ_NEXT(cur_focus, entry);
- if (head == NULL)
- head = TAILQ_FIRST(wl);
- winfocus = head;
-
- /* skip iconics */
- if (winfocus && winfocus->iconic) {
- while (winfocus != cur_focus) {
- if (winfocus == NULL)
- winfocus = TAILQ_FIRST(wl);
- if (!winfocus->iconic)
- break;
- winfocus = TAILQ_NEXT(winfocus, entry);
- }
- }
- break;
+ if (cur_focus == NULL)
+ goto out;
+ winfocus = cur_focus;
+ do {
+ winfocus = TAILQ_NEXT(winfocus, entry);
+ if (winfocus == NULL)
+ winfocus = TAILQ_FIRST(wl);
+ if (winfocus == cur_focus)
+ break;
+ } while (winfocus != NULL &&
+ (winfocus->iconic || winfocus->id == cur_focus->transient));
+ break;
case SWM_ARG_ID_FOCUSMAIN:
+ if (cur_focus == NULL)
+ goto out;
+
winfocus = TAILQ_FIRST(wl);
if (winfocus == cur_focus)
winfocus = cur_focus->ws->focus_prev;
break;
+ case SWM_ARG_ID_FOCUSURGENT:
+ /* Search forward for the next urgent window. */
+ winfocus = NULL;
+ head = cur_focus;
+
+ for (i = 0; i <= workspace_limit; ++i) {
+ if (head == NULL)
+ head = TAILQ_FIRST(&r->s->ws[(ws->idx + i) %
+ workspace_limit].winlist);
+
+ while (head != NULL &&
+ (head = TAILQ_NEXT(head, entry)) != NULL) {
+ 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)) {
+ winfocus = head;
+ break;
+ }
+ }
+ if (winfocus != NULL)
+ break;
+ }
+
+ /* Switch ws if new focus is on a different ws. */
+ if (winfocus != NULL && winfocus->ws != ws) {
+ a.id = winfocus->ws->idx;
+ switchws(r, &a);
+ }
+ break;
default:
- return;
+ goto out;
}
focus_win(get_focus_magic(winfocus));
-
focus_flush();
+
+out:
+ DNPRINTF(SWM_D_FOCUS, "focus: done\n");
}
void
}
void
-store_float_geom(struct ws_win *win, struct swm_region *r)
+store_float_geom(struct ws_win *win)
{
- if (win == NULL || r == NULL)
+ if (win == NULL || win->ws->r == NULL)
return;
/* retain window geom and region geom */
win->g_float = win->g;
- win->g_float.x -= X(r);
- win->g_float.y -= Y(r);
+ win->g_float.x -= X(win->ws->r);
+ win->g_float.y -= Y(win->ws->r);
win->g_floatvalid = 1;
DNPRINTF(SWM_D_MISC, "store_float_geom: window: 0x%x, g: (%d,%d)"
" %d x %d, g_float: (%d,%d) %d x %d\n", win->id, X(win), Y(win),
}
void
-load_float_geom(struct ws_win *win, struct swm_region *r)
+load_float_geom(struct ws_win *win)
{
- if (win == NULL || r == NULL)
+ if (win == NULL || win->ws->r == NULL)
return;
if (win->g_floatvalid) {
win->g = win->g_float;
- X(win) += X(r);
- Y(win) += Y(r);
+ X(win) += X(win->ws->r);
+ Y(win) += Y(win->ws->r);
DNPRINTF(SWM_D_MISC, "load_float_geom: window: 0x%x, g: (%d,%d)"
"%d x %d\n", win->id, X(win), Y(win), WIDTH(win),
HEIGHT(win));
if (win->floatmaxed || (r != r->ws->old_r &&
!(win->ewmh_flags & EWMH_F_FULLSCREEN))) {
/* update geometry for the new region */
- load_float_geom(win, r);
+ load_float_geom(win);
}
win->floatmaxed = 0;
*/
if (win->ewmh_flags & EWMH_F_FULLSCREEN) {
if (!win->g_floatvalid)
- store_float_geom(win, win->ws->r);
+ store_float_geom(win);
win->g = r->g;
}
X(win) = X(r) + (WIDTH(r) - WIDTH(win)) / 2 - BORDER(win);
Y(win) = Y(r) + (HEIGHT(r) - HEIGHT(win)) / 2 - BORDER(win);
- store_float_geom(win, r);
+ store_float_geom(win);
}
- /* keep window within region bounds */
- constrain_window(win, r, 0);
+ /* Ensure at least 1 pixel of the window is in the region. */
+ region_containment(win, r, SWM_CW_ALLSIDES);
update_window(win);
}
update_window(win);
}
- map_window(win);
+ map_window(win, get_sibling(win, SWM_STACK_BELOW));
last_h = win_g.h;
i++;
j++;
}
+ /* Map/raise focused tiled window to top if windows could overlap. */
+ if (tile_gap < 0 && ws->focus != NULL && !ws->focus->floating)
+ map_window(ws->focus, get_sibling(ws->focus, SWM_STACK_TOP));
+
notiles:
/* now, stack all the floaters and transients */
TAILQ_FOREACH(win, &ws->winlist, entry) {
}
stack_floater(win, ws->r);
- map_window(win);
+ map_window(win, XCB_WINDOW_NONE);
}
/* Make sure fs_win is stacked last so it's on top. */
if (fs_win) {
stack_floater(fs_win, ws->r);
- map_window(fs_win);
+ map_window(fs_win, XCB_WINDOW_NONE);
}
}
continue;
if (!w->mapped && w != win)
- map_window(w);
+ map_window(w, XCB_WINDOW_NONE);
if (w->floating && !w->floatmaxed) {
/*
* retain geometry for retrieval on exit from
* max_stack mode
*/
- store_float_geom(w, ws->r);
+ store_float_geom(w);
w->floatmaxed = 1;
}
/* If a parent exists, map/raise it first. */
if (parent) {
- map_window(parent);
+ map_window(parent, XCB_WINDOW_NONE);
/* Map siblings next. */
TAILQ_FOREACH(w, &ws->winlist, entry)
if (w != win && !w->iconic &&
w->transient == parent->id) {
stack_floater(w, ws->r);
- map_window(w);
+ map_window(w, XCB_WINDOW_NONE);
}
}
/* Map/raise focused window. */
- map_window(win);
+ map_window(win, XCB_WINDOW_NONE);
/* Finally, map/raise children of focus window. */
TAILQ_FOREACH(w, &ws->winlist, entry)
if (w->transient == win->id && !w->iconic) {
stack_floater(w, ws->r);
- map_window(w);
+ map_window(w, XCB_WINDOW_NONE);
}
}
DNPRINTF(SWM_D_FOCUS, "send_to_rg: id: %d\n", ridx);
rr = TAILQ_FIRST(&r->s->rl);
- for (i = 0; i < ridx; ++i)
+ for (i = 0; i < ridx && rr != NULL; ++i)
rr = TAILQ_NEXT(rr, entry);
if (rr == NULL)
send_to_ws(r, &a);
}
+struct swm_region *
+region_under(struct swm_screen *s, int x, int y)
+{
+ struct swm_region *r = NULL;
+
+ TAILQ_FOREACH(r, &s->rl, entry) {
+ DNPRINTF(SWM_D_MISC, "region_under: ws: %d, region g: (%d,%d) "
+ "%d x %d, coords: (%d,%d)\n", r->ws->idx, X(r), Y(r),
+ WIDTH(r), HEIGHT(r), x, y);
+ if (X(r) <= x && x < MAX_X(r))
+ if (Y(r) <= y && y < MAX_Y(r))
+ return (r);
+ }
+
+ return (NULL);
+}
+
void
send_to_ws(struct swm_region *r, union arg *args)
{
int wsid = args->id;
- struct ws_win *win = NULL, *parent;
- struct workspace *ws, *nws, *pws;
- char ws_idx_str[SWM_PROPLEN];
-
- if (wsid >= workspace_limit)
- return;
+ struct ws_win *win = NULL;
if (r && r->ws && r->ws->focus)
win = r->ws->focus;
else
return;
- if (win->ws->idx == wsid)
+ DNPRINTF(SWM_D_MOVE, "send_to_ws: win 0x%x, ws %d\n", win->id, wsid);
+
+ win_to_ws(win, wsid, 1);
+
+ /* Restack and set new focus. */
+ stack();
+
+ if (focus_mode != SWM_FOCUS_FOLLOW) {
+ if (r->ws->focus_pending) {
+ focus_win(r->ws->focus_pending);
+ r->ws->focus_pending = NULL;
+ } else {
+ xcb_set_input_focus(conn,
+ XCB_INPUT_FOCUS_PARENT, r->id,
+ XCB_CURRENT_TIME);
+ }
+ }
+
+ focus_flush();
+}
+
+void
+win_to_ws(struct ws_win *win, int wsid, int unfocus)
+{
+ struct ws_win *parent;
+ struct workspace *ws, *nws, *pws;
+ char ws_idx_str[SWM_PROPLEN];
+
+ if (wsid >= workspace_limit)
return;
- DNPRINTF(SWM_D_MOVE, "send_to_ws: win 0x%x, ws %d -> %d\n", win->id,
- win->ws->idx, wsid);
+ if (win->ws->idx == wsid)
+ return;
ws = win->ws;
nws = &win->s->ws[wsid];
+ DNPRINTF(SWM_D_MOVE, "win_to_ws: win 0x%x, ws %d -> %d\n", win->id,
+ ws->idx, wsid);
+
/* Update the window's workspace property: _SWM_WS */
if (snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < SWM_PROPLEN) {
if (focus_mode != SWM_FOCUS_FOLLOW)
TAILQ_INSERT_TAIL(&nws->winlist, parent, entry);
parent->ws = nws;
- DNPRINTF(SWM_D_PROP, "send_to_ws: set "
+ DNPRINTF(SWM_D_PROP, "win_to_ws: set "
"property: _SWM_WS: %s\n", ws_idx_str);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE,
parent->id, a_swm_ws, XCB_ATOM_STRING, 8,
}
}
- unfocus_win(win);
+ if (unfocus)
+ unfocus_win(win);
/* Don't unmap if new ws is visible */
if (nws->r == NULL)
unfocus_win(nws->focus);
nws->focus = win;
- DNPRINTF(SWM_D_PROP, "send_to_ws: set property: _SWM_WS: %s\n",
+ DNPRINTF(SWM_D_PROP, "win_to_ws: set property: _SWM_WS: %s\n",
ws_idx_str);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id,
a_swm_ws, XCB_ATOM_STRING, 8, strlen(ws_idx_str),
ws_idx_str);
-
- /* Restack and set new focus. */
- stack();
-
- if (focus_mode != SWM_FOCUS_FOLLOW) {
- if (ws->focus_pending) {
- focus_win(ws->focus_pending);
- ws->focus_pending = NULL;
- } else {
- xcb_set_input_focus(conn,
- XCB_INPUT_FOCUS_PARENT, r->id,
- XCB_CURRENT_TIME);
- }
- }
-
- focus_flush();
}
- DNPRINTF(SWM_D_MOVE, "send_to_ws: done.\n");
+ DNPRINTF(SWM_D_MOVE, "win_to_ws: done.\n");
}
void
xcb_get_property_reply_t *r;
/* First try _NET_WM_NAME for UTF-8. */
- c = xcb_get_property(conn, 0, win, a_netwmname,
+ 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)
- 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;
DNPRINTF(SWM_D_MISC, "search_resp_search_workspace: resp: %s\n", resp);
q = strdup(resp);
- if (!q) {
+ if (q == NULL) {
DNPRINTF(SWM_D_MISC, "search_resp_search_workspace: strdup: %s",
strerror(errno));
return;
DNPRINTF(SWM_D_MISC, "search_resp_search_window: resp: %s\n", resp);
s = strdup(resp);
- if (!s) {
+ if (s == NULL) {
DNPRINTF(SWM_D_MISC, "search_resp_search_window: strdup: %s",
strerror(errno));
return;
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;
int
floating_toggle_win(struct ws_win *win)
{
- struct swm_region *r;
-
if (win == NULL)
return (0);
- if (!win->ws->r)
+ if (win->ws->r == NULL)
return (0);
- r = win->ws->r;
-
/* reject floating toggles in max stack mode */
if (win->ws->cur_layout == &layouts[SWM_MAX_STACK])
return (0);
if (win->floating) {
if (!win->floatmaxed) {
/* retain position for refloat */
- store_float_geom(win, r);
+ store_float_geom(win);
}
win->floating = 0;
} else {
- load_float_geom(win, r);
+ load_float_geom(win);
win->floating = 1;
}
}
void
-constrain_window(struct ws_win *win, struct swm_region *r, int resizable)
+region_containment(struct ws_win *win, struct swm_region *r, int opts)
+{
+ struct swm_geometry g = r->g;
+ int rt, lt, tp, bm, bw;
+
+ bw = (opts & SWM_CW_SOFTBOUNDARY) ? boundary_width : 0;
+
+ /*
+ * Perpendicular distance of each side of the window to the respective
+ * side of the region boundary. Positive values indicate the side of
+ * the window has passed beyond the region boundary.
+ */
+ rt = opts & SWM_CW_RIGHT ? MAX_X(win) + BORDER(win) - MAX_X(r) : bw;
+ lt = opts & SWM_CW_LEFT ? X(r) - X(win) + BORDER(win) : bw;
+ bm = opts & SWM_CW_BOTTOM ? MAX_Y(win) + BORDER(win) - MAX_Y(r) : bw;
+ tp = opts & SWM_CW_TOP ? Y(r) - Y(win) + BORDER(win) : bw;
+
+ DNPRINTF(SWM_D_MISC, "region_containment: win 0x%x, rt: %d, lt: %d, "
+ "bm: %d, tp: %d, SOFTBOUNDARY: %s, HARDBOUNDARY: %s\n", win->id, rt,
+ lt, bm, tp, YESNO(opts & SWM_CW_SOFTBOUNDARY),
+ YESNO(opts & SWM_CW_HARDBOUNDARY));
+
+ /*
+ * Disable containment if any of the flagged sides went beyond the
+ * containment boundary, or if containment is disabled.
+ */
+ if (!(opts & SWM_CW_HARDBOUNDARY || opts & SWM_CW_SOFTBOUNDARY) ||
+ (bw != 0 && ((rt > bw) || (lt > bw) || (bm > bw) || (tp > bw)))) {
+ /* Make sure window has at least 1 pixel in the region */
+ g.x += 1 - WIDTH(win);
+ g.y += 1 - HEIGHT(win);
+ g.w += 2 * WIDTH(win) - 2;
+ g.h += 2 * HEIGHT(win) - 2;
+ }
+
+ constrain_window(win, &g, &opts);
+}
+
+/* Move or resize a window so that flagged side(s) fit into the supplied box. */
+void
+constrain_window(struct ws_win *win, struct swm_geometry *b, int *opts)
{
- if (MAX_X(win) + BORDER(win) > MAX_X(r)) {
- if (resizable)
- WIDTH(win) = MAX_X(r) - X(win) - BORDER(win);
+ DNPRINTF(SWM_D_MISC, "constrain_window: window: 0x%x, (x,y) w x h: "
+ "(%d,%d) %d x %d, box: (x,y) w x h: (%d,%d) %d x %d, rt: %s, "
+ "lt: %s, bt: %s, tp: %s, allow resize: %s\n", win->id, X(win),
+ Y(win), WIDTH(win), HEIGHT(win), b->x, b->y, b->w, b->h,
+ YESNO(*opts & SWM_CW_RIGHT), YESNO(*opts & SWM_CW_LEFT),
+ YESNO(*opts & SWM_CW_BOTTOM), YESNO(*opts & SWM_CW_TOP),
+ YESNO(*opts & SWM_CW_RESIZABLE));
+
+ if ((*opts & SWM_CW_RIGHT) && MAX_X(win) + BORDER(win) > b->x + b->w) {
+ if (*opts & SWM_CW_RESIZABLE)
+ WIDTH(win) = b->x + b->w - X(win) - BORDER(win);
else
- X(win) = MAX_X(r)- WIDTH(win) - BORDER(win);
+ X(win) = b->x + b->w - WIDTH(win) - BORDER(win);
}
- if (X(win) + BORDER(win) < X(r)) {
- if (resizable)
- WIDTH(win) -= X(r) - X(win) - BORDER(win);
+ if ((*opts & SWM_CW_LEFT) && X(win) + BORDER(win) < b->x) {
+ if (*opts & SWM_CW_RESIZABLE)
+ WIDTH(win) -= b->x - X(win) - BORDER(win);
- X(win) = X(r) - BORDER(win);
+ X(win) = b->x - BORDER(win);
}
- if (MAX_Y(win) + BORDER(win) > MAX_Y(r)) {
- if (resizable)
- HEIGHT(win) = MAX_Y(r) - Y(win) - BORDER(win);
+ if ((*opts & SWM_CW_BOTTOM) && MAX_Y(win) + BORDER(win) > b->y + b->h) {
+ if (*opts & SWM_CW_RESIZABLE)
+ HEIGHT(win) = b->y + b->h - Y(win) - BORDER(win);
else
- Y(win) = MAX_Y(r) - HEIGHT(win) - BORDER(win);
+ Y(win) = b->y + b->h - HEIGHT(win) - BORDER(win);
}
- if (Y(win) + BORDER(win) < Y(r)) {
- if (resizable)
- HEIGHT(win) -= Y(r) - Y(win) - BORDER(win);
+ if ((*opts & SWM_CW_TOP) && Y(win) + BORDER(win) < b->y) {
+ if (*opts & SWM_CW_RESIZABLE)
+ HEIGHT(win) -= b->y - Y(win) - BORDER(win);
- Y(win) = Y(r) - BORDER(win);
+ Y(win) = b->y - BORDER(win);
}
- if (resizable) {
+ if (*opts & SWM_CW_RESIZABLE) {
if (WIDTH(win) < 1)
WIDTH(win) = 1;
if (HEIGHT(win) < 1)
/* It's possible for win to have been freed during focus_flush(). */
if (validate_win(win)) {
- DNPRINTF(SWM_D_EVENT, "move: invalid win.\n");
+ DNPRINTF(SWM_D_EVENT, "resize: invalid win.\n");
goto out;
}
break;
}
if (resize_stp) {
- constrain_window(win, r, 1);
+ region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_RESIZABLE |
+ SWM_CW_HARDBOUNDARY);
update_window(win);
- store_float_geom(win,r);
+ store_float_geom(win);
return;
}
+ region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_RESIZABLE |
+ SWM_CW_SOFTBOUNDARY);
+ update_window(win);
+
/* get cursor offset from window root */
xpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id),
NULL);
- if (!xpr)
+ if (xpr == NULL)
return;
g = win->g;
WIDTH(win) = g.w + dx;
}
- constrain_window(win, r, 1);
-
/* not free, don't sync more than 120 times / second */
if ((mne->time - timestamp) > (1000 / 120) ) {
timestamp = mne->time;
+ regionize(win, mne->root_x, mne->root_y);
+ region_containment(win, r, SWM_CW_ALLSIDES |
+ SWM_CW_RESIZABLE | SWM_CW_HARDBOUNDARY |
+ SWM_CW_SOFTBOUNDARY);
update_window(win);
xcb_flush(conn);
}
/* It's possible for win to have been freed above. */
if (validate_win(win)) {
- DNPRINTF(SWM_D_EVENT, "move: invalid win.\n");
+ DNPRINTF(SWM_D_EVENT, "resize: invalid win.\n");
goto out;
}
break;
free(evt);
}
if (timestamp) {
+ region_containment(win, r, SWM_CW_ALLSIDES | SWM_CW_RESIZABLE |
+ SWM_CW_HARDBOUNDARY | SWM_CW_SOFTBOUNDARY);
update_window(win);
xcb_flush(conn);
}
- store_float_geom(win,r);
+ store_float_geom(win);
out:
xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
free(xpr);
focus_flush();
}
+/* Try to set window region based on supplied coordinates or window center. */
+void
+regionize(struct ws_win *win, int x, int y)
+{
+ struct swm_region *r = NULL;
+
+ r = region_under(win->s, x, y);
+ if (r == NULL)
+ r = region_under(win->s, X(win) + WIDTH(win) / 2,
+ Y(win) + HEIGHT(win) / 2);
+
+ if (r && r != win->ws->r) {
+ win_to_ws(win, r->ws->idx, 0);
+ set_region(r);
+ }
+}
+
#define SWM_MOVE_STEPS (50)
void
{
xcb_timestamp_t timestamp = 0;
int move_stp = 0, moving;
- struct swm_region *r = NULL;
xcb_query_pointer_reply_t *qpr = NULL;
xcb_generic_event_t *evt;
xcb_motion_notify_event_t *mne;
if (win == NULL)
return;
- r = win->ws->r;
if (win->ewmh_flags & EWMH_F_FULLSCREEN)
return;
if (win->ws->cur_layout == &layouts[SWM_MAX_STACK] && !win->transient)
return;
- win->manual = 1;
+ if (!win->manual) {
+ win->manual = 1;
+ ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom,
+ _NET_WM_STATE_ADD);
+ }
+
+ /* When a stacked win is moved, float it and restack. */
if (!win->floating && !win->transient) {
- store_float_geom(win, r);
+ store_float_geom(win);
ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom,
_NET_WM_STATE_ADD);
+ stack();
}
- ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom,
- _NET_WM_STATE_ADD);
-
- stack();
focus_flush();
break;
}
if (move_stp) {
- constrain_window(win, r, 0);
+ regionize(win, -1, -1);
+ region_containment(win, win->ws->r, SWM_CW_ALLSIDES);
update_window(win);
- store_float_geom(win, r);
+ store_float_geom(win);
return;
}
/* get cursor offset from window root */
qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id),
NULL);
- if (!qpr) {
+ if (qpr == NULL) {
xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
return;
}
+ regionize(win, qpr->root_x, qpr->root_y);
+ region_containment(win, win->ws->r, SWM_CW_ALLSIDES |
+ SWM_CW_SOFTBOUNDARY);
+ update_window(win);
xcb_flush(conn);
moving = 1;
while (moving && (evt = xcb_wait_for_event(conn))) {
break;
case XCB_MOTION_NOTIFY:
mne = (xcb_motion_notify_event_t *)evt;
+ DNPRINTF(SWM_D_EVENT, "motion: root: 0x%x\n", mne->root);
X(win) = mne->root_x - qpr->win_x - border_width;
Y(win) = mne->root_y - qpr->win_y - border_width;
- constrain_window(win, r, 0);
-
/* not free, don't sync more than 120 times / second */
if ((mne->time - timestamp) > (1000 / 120) ) {
timestamp = mne->time;
+ regionize(win, mne->root_x, mne->root_y);
+ region_containment(win, win->ws->r,
+ SWM_CW_ALLSIDES | SWM_CW_SOFTBOUNDARY);
update_window(win);
xcb_flush(conn);
}
free(evt);
}
if (timestamp) {
+ region_containment(win, win->ws->r, SWM_CW_ALLSIDES |
+ SWM_CW_SOFTBOUNDARY);
update_window(win);
xcb_flush(conn);
}
- store_float_geom(win, r);
+ store_float_geom(win);
out:
free(qpr);
xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
{ "focus_main", focus, {.id = SWM_ARG_ID_FOCUSMAIN} },
{ "focus_next", focus, {.id = SWM_ARG_ID_FOCUSNEXT} },
{ "focus_prev", focus, {.id = SWM_ARG_ID_FOCUSPREV} },
+ { "focus_urgent", focus, {.id = SWM_ARG_ID_FOCUSURGENT} },
{ "height_grow", resize_step, {.id = SWM_ARG_ID_HEIGHTGROW} },
{ "height_shrink", resize_step, {.id = SWM_ARG_ID_HEIGHTSHRINK} },
{ "iconify", iconify, {0} },
char ***ret_args)
{
struct spawn_prog *prog = NULL;
- int i;
+ int i, c;
char *ap, **real_args;
/* suppress unused warning since var is needed */
/* find program */
TAILQ_FOREACH(prog, &spawns, entry) {
- if (!strcasecmp(spawn_name, prog->name))
+ if (strcasecmp(spawn_name, prog->name) == 0)
break;
}
if (prog == NULL) {
err(1, "spawn_custom: calloc real_args");
/* expand spawn_args into real_args */
- for (i = 0; i < prog->argc; i++) {
+ for (i = c = 0; i < prog->argc; i++) {
ap = prog->argv[i];
DNPRINTF(SWM_D_SPAWN, "spawn_custom: raw arg: %s\n", ap);
- if (!strcasecmp(ap, "$bar_border")) {
- if ((real_args[i] =
+ if (strcasecmp(ap, "$bar_border") == 0) {
+ if ((real_args[c] =
strdup(r->s->c[SWM_S_COLOR_BAR_BORDER].name))
== NULL)
err(1, "spawn_custom border color");
- } else if (!strcasecmp(ap, "$bar_color")) {
- if ((real_args[i] =
+ } else if (strcasecmp(ap, "$bar_color") == 0) {
+ if ((real_args[c] =
strdup(r->s->c[SWM_S_COLOR_BAR].name))
== NULL)
err(1, "spawn_custom bar color");
- } else if (!strcasecmp(ap, "$bar_font")) {
- if ((real_args[i] = strdup(bar_fonts))
+ } else if (strcasecmp(ap, "$bar_font") == 0) {
+ if ((real_args[c] = strdup(bar_fonts))
== NULL)
err(1, "spawn_custom bar fonts");
- } else if (!strcasecmp(ap, "$bar_font_color")) {
- if ((real_args[i] =
+ } else if (strcasecmp(ap, "$bar_font_color") == 0) {
+ if ((real_args[c] =
strdup(r->s->c[SWM_S_COLOR_BAR_FONT].name))
== NULL)
err(1, "spawn_custom color font");
- } else if (!strcasecmp(ap, "$color_focus")) {
- if ((real_args[i] =
+ } else if (strcasecmp(ap, "$color_focus") == 0) {
+ if ((real_args[c] =
strdup(r->s->c[SWM_S_COLOR_FOCUS].name))
== NULL)
err(1, "spawn_custom color focus");
- } else if (!strcasecmp(ap, "$color_unfocus")) {
- if ((real_args[i] =
+ } else if (strcasecmp(ap, "$color_unfocus") == 0) {
+ if ((real_args[c] =
strdup(r->s->c[SWM_S_COLOR_UNFOCUS].name))
== NULL)
err(1, "spawn_custom color unfocus");
- } else if (!strcasecmp(ap, "$region_index")) {
- if (asprintf(&real_args[i], "%d",
+ } else if (strcasecmp(ap, "$region_index") == 0) {
+ if (asprintf(&real_args[c], "%d",
get_region_index(r) + 1) < 1)
err(1, "spawn_custom region index");
- } else if (!strcasecmp(ap, "$workspace_index")) {
- if (asprintf(&real_args[i], "%d", r->ws->idx + 1) < 1)
+ } else if (strcasecmp(ap, "$workspace_index") == 0) {
+ if (asprintf(&real_args[c], "%d", r->ws->idx + 1) < 1)
+ err(1, "spawn_custom workspace index");
+ } else if (strcasecmp(ap, "$dmenu_bottom") == 0) {
+ if (!bar_at_bottom)
+ continue;
+ if ((real_args[c] = strdup("-b")) == NULL)
err(1, "spawn_custom workspace index");
} else {
/* no match --> copy as is */
- if ((real_args[i] = strdup(ap)) == NULL)
+ if ((real_args[c] = strdup(ap)) == NULL)
err(1, "spawn_custom strdup(ap)");
}
DNPRINTF(SWM_D_SPAWN, "spawn_custom: cooked arg: %s\n",
- real_args[i]);
+ real_args[c]);
+ ++c;
}
#ifdef SWM_DEBUG
DNPRINTF(SWM_D_SPAWN, "spawn_custom: result: ");
- for (i = 0; i < prog->argc; i++)
- DNPRINTF(SWM_D_SPAWN, "\"%s\" ", real_args[i]);
- DNPRINTF(SWM_D_SPAWN, "\n");
+ for (i = 0; i < c; ++i)
+ DPRINTF("\"%s\" ", real_args[i]);
+ DPRINTF("\n");
#endif
*ret_args = real_args;
- return (prog->argc);
+ return (c);
}
void
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");
}
DNPRINTF(SWM_D_SPAWN, "spawn_remove: leave\n");
}
+struct spawn_prog*
+spawn_find(const char *name)
+{
+ struct spawn_prog *sp;
+
+ TAILQ_FOREACH(sp, &spawns, entry)
+ if (strcasecmp(sp->name, name) == 0)
+ return sp;
+
+ return NULL;
+}
+
void
setspawn(const char *name, const char *args, int flags)
{
return;
/* Remove any old spawn under the same name. */
- TAILQ_FOREACH(sp, &spawns, entry)
- if (!strcmp(sp->name, name)) {
- spawn_remove(sp);
- break;
- }
+ if ((sp = spawn_find(name)) != NULL)
+ spawn_remove(sp);
if (*args != '\0')
spawn_insert(name, args, flags);
}
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);
continue;
/* find program */
- TAILQ_FOREACH(sp, &spawns, entry) {
- if (!strcasecmp(kp->spawn_name, sp->name))
- break;
- }
-
+ sp = spawn_find(kp->spawn_name);
if (sp == NULL || sp->flags & SWM_SPAWN_OPTIONAL)
continue;
setconfspawn("spawn_term", "xterm", 0);
setconfspawn("menu", "dmenu_run"
+ " $dmenu_bottom"
" -fn $bar_font"
" -nb $bar_color"
" -nf $bar_font_color"
" -sf $bar_color", 0);
setconfspawn("search", "dmenu"
+ " $dmenu_bottom"
" -i"
" -fn $bar_font"
" -nb $bar_color"
" -sf $bar_color", 0);
setconfspawn("name_workspace", "dmenu"
+ " $dmenu_bottom"
" -p Workspace"
" -fn $bar_font"
" -nb $bar_color"
#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) {
cp += (long)strspn(cp, SWM_KEY_WS);
if (strncasecmp(name, "MOD", SWM_MODNAME_SIZE) == 0)
*mod |= currmod;
- else if (!strncasecmp(name, "Mod1", SWM_MODNAME_SIZE))
+ else if (strncasecmp(name, "Mod1", SWM_MODNAME_SIZE) == 0)
*mod |= XCB_MOD_MASK_1;
- else if (!strncasecmp(name, "Mod2", SWM_MODNAME_SIZE))
+ else if (strncasecmp(name, "Mod2", SWM_MODNAME_SIZE) == 0)
*mod += XCB_MOD_MASK_2;
- else if (!strncmp(name, "Mod3", SWM_MODNAME_SIZE))
+ else if (strncmp(name, "Mod3", SWM_MODNAME_SIZE) == 0)
*mod |= XCB_MOD_MASK_3;
- else if (!strncmp(name, "Mod4", SWM_MODNAME_SIZE))
+ else if (strncmp(name, "Mod4", SWM_MODNAME_SIZE) == 0)
*mod |= XCB_MOD_MASK_4;
else if (strncasecmp(name, "SHIFT", SWM_MODNAME_SIZE) == 0)
*mod |= XCB_MOD_MASK_SHIFT;
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;
}
}
/* search by custom spawn name */
- TAILQ_FOREACH(sp, &spawns, entry) {
- if (strcasecmp(selector, sp->name) == 0) {
- DNPRINTF(SWM_D_KEY, "setconfbinding: %s: match "
- "spawn\n", selector);
- if (parsekeys(value, mod_key, &mod, &ks) == 0) {
- setkeybinding(mod, ks, KF_SPAWN_CUSTOM,
- sp->name);
- return (0);
- } else
- return (1);
- }
+ if ((sp = spawn_find(selector)) != NULL) {
+ DNPRINTF(SWM_D_KEY, "setconfbinding: %s: match "
+ "spawn\n", selector);
+ if (parsekeys(value, mod_key, &mod, &ks) == 0) {
+ setkeybinding(mod, ks, KF_SPAWN_CUSTOM,
+ sp->name);
+ return (0);
+ } else
+ return (1);
}
DNPRINTF(SWM_D_KEY, "setconfbinding: no match\n");
return (1);
setkeybinding(MODKEY, XK_Tab, KF_FOCUS_NEXT, NULL);
setkeybinding(MODKEY, XK_k, KF_FOCUS_PREV, NULL);
setkeybinding(MODKEY_SHIFT, XK_Tab, KF_FOCUS_PREV, NULL);
+ setkeybinding(MODKEY, XK_u, KF_FOCUS_URGENT,NULL);
setkeybinding(MODKEY_SHIFT, XK_equal, KF_HEIGHT_GROW,NULL);
setkeybinding(MODKEY_SHIFT, XK_minus, KF_HEIGHT_SHRINK,NULL);
setkeybinding(MODKEY, XK_w, KF_ICONIFY, NULL);
}
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)
cp += (long)strspn(cp, SWM_Q_WS);
for (i = 0; i < LENGTH(quirkname); i++) {
- if (!strncasecmp(name, quirkname[i], SWM_QUIRK_LEN)) {
+ if (strncasecmp(name, quirkname[i],
+ SWM_QUIRK_LEN) == 0) {
DNPRINTF(SWM_D_QUIRK,
"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) && !strcmp(qp->name, name)) {
- if (!quirk)
+ 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)
- return (0);
- if ((cp = strchr(selector, ':')) == NULL)
+ if (selector == NULL || strlen(selector) == 0)
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_BAR_FORMAT,
SWM_S_BAR_JUSTIFY,
SWM_S_BORDER_WIDTH,
+ SWM_S_BOUNDARY_WIDTH,
SWM_S_CLOCK_ENABLED,
SWM_S_CLOCK_FORMAT,
SWM_S_CYCLE_EMPTY,
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);
err(1, "setconfvalue: bar_format");
break;
case SWM_S_BAR_JUSTIFY:
- if (!strcmp(value, "left"))
+ if (strcmp(value, "left") == 0)
bar_justify = SWM_BAR_JUSTIFY_LEFT;
- else if (!strcmp(value, "center"))
+ else if (strcmp(value, "center") == 0)
bar_justify = SWM_BAR_JUSTIFY_CENTER;
- else if (!strcmp(value, "right"))
+ else if (strcmp(value, "right") == 0)
bar_justify = SWM_BAR_JUSTIFY_RIGHT;
else
errx(1, "invalid bar_justify");
if (border_width < 0)
border_width = 0;
break;
+ case SWM_S_BOUNDARY_WIDTH:
+ boundary_width = atoi(value);
+ if (boundary_width < 0)
+ boundary_width = 0;
+ break;
case SWM_S_CLOCK_ENABLED:
clock_enabled = atoi(value);
break;
disable_border = atoi(value);
break;
case SWM_S_FOCUS_CLOSE:
- if (!strcmp(value, "first"))
+ if (strcmp(value, "first") == 0)
focus_close = SWM_STACK_BOTTOM;
- else if (!strcmp(value, "last"))
+ else if (strcmp(value, "last") == 0)
focus_close = SWM_STACK_TOP;
- else if (!strcmp(value, "next"))
+ else if (strcmp(value, "next") == 0)
focus_close = SWM_STACK_ABOVE;
- else if (!strcmp(value, "previous"))
+ else if (strcmp(value, "previous") == 0)
focus_close = SWM_STACK_BELOW;
else
errx(1, "focus_close");
focus_close_wrap = atoi(value);
break;
case SWM_S_FOCUS_DEFAULT:
- if (!strcmp(value, "last"))
+ if (strcmp(value, "last") == 0)
focus_default = SWM_STACK_TOP;
- else if (!strcmp(value, "first"))
+ else if (strcmp(value, "first") == 0)
focus_default = SWM_STACK_BOTTOM;
else
errx(1, "focus_default");
break;
case SWM_S_FOCUS_MODE:
- if (!strcmp(value, "default"))
+ if (strcmp(value, "default") == 0)
focus_mode = SWM_FOCUS_DEFAULT;
- else if (!strcmp(value, "follow") ||
- !strcmp(value, "follow_cursor"))
+ else if (strcmp(value, "follow") == 0 ||
+ strcmp(value, "follow_cursor") == 0)
focus_mode = SWM_FOCUS_FOLLOW;
- else if (!strcmp(value, "manual"))
+ else if (strcmp(value, "manual") == 0)
focus_mode = SWM_FOCUS_MANUAL;
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)
region_padding = 0;
break;
case SWM_S_SPAWN_ORDER:
- if (!strcmp(value, "first"))
+ if (strcmp(value, "first") == 0)
spawn_position = SWM_STACK_BOTTOM;
- else if (!strcmp(value, "last"))
+ else if (strcmp(value, "last") == 0)
spawn_position = SWM_STACK_TOP;
- else if (!strcmp(value, "next"))
+ else if (strcmp(value, "next") == 0)
spawn_position = SWM_STACK_ABOVE;
- else if (!strcmp(value, "previous"))
+ else if (strcmp(value, "previous") == 0)
spawn_position = SWM_STACK_BELOW;
else
errx(1, "spawn_position");
break;
case SWM_S_TILE_GAP:
tile_gap = atoi(value);
- if (tile_gap < 0)
- tile_gap = 0;
- 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);
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;
(void)flags;
- if (!strncasecmp(value, "Mod1", strlen("Mod1")))
+ if (strncasecmp(value, "Mod1", strlen("Mod1")) == 0)
update_modkey(XCB_MOD_MASK_1);
- else if (!strncasecmp(value, "Mod2", strlen("Mod2")))
+ else if (strncasecmp(value, "Mod2", strlen("Mod2")) == 0)
update_modkey(XCB_MOD_MASK_2);
- else if (!strncasecmp(value, "Mod3", strlen("Mod3")))
+ else if (strncasecmp(value, "Mod3", strlen("Mod3")) == 0)
update_modkey(XCB_MOD_MASK_3);
- else if (!strncasecmp(value, "Mod4", strlen("Mod4")))
+ else if (strncasecmp(value, "Mod4", strlen("Mod4")) == 0)
update_modkey(XCB_MOD_MASK_4);
else
return (1);
}
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;
if (ws_id < 0 || ws_id >= workspace_limit)
errx(1, "layout: invalid workspace %d", ws_id + 1);
- if (!strcasecmp(s, "vertical"))
+ if (strcasecmp(s, "vertical") == 0)
st = SWM_V_STACK;
- else if (!strcasecmp(s, "vertical_flip")) {
+ else if (strcasecmp(s, "vertical_flip") == 0) {
st = SWM_V_STACK;
f = 1;
- } else if (!strcasecmp(s, "horizontal"))
+ } else if (strcasecmp(s, "horizontal") == 0)
st = SWM_H_STACK;
- else if (!strcasecmp(s, "horizontal_flip")) {
+ else if (strcasecmp(s, "horizontal_flip") == 0) {
st = SWM_H_STACK;
f = 1;
- } else if (!strcasecmp(s, "fullscreen"))
+ } else if (strcasecmp(s, "fullscreen") == 0)
st = SWM_MAX_STACK;
else
errx(1, "invalid layout entry, should be 'ws[<idx>]:"
/* 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[] = {
{ "bar_justify", setconfvalue, SWM_S_BAR_JUSTIFY },
{ "bind", setconfbinding, 0 },
{ "border_width", setconfvalue, SWM_S_BORDER_WIDTH },
+ { "boundary_width", setconfvalue, SWM_S_BOUNDARY_WIDTH },
{ "clock_enabled", setconfvalue, SWM_S_CLOCK_ENABLED },
{ "clock_format", setconfvalue, SWM_S_CLOCK_FORMAT },
{ "color_focus", setconfcolor, SWM_S_COLOR_FOCUS },
{ "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");
optidx = -1;
for (i = 0; i < LENGTH(configopt); i++) {
opt = &configopt[i];
- if (!strncasecmp(cp, opt->optname, wordlen) &&
+ if (strncasecmp(cp, opt->optname, wordlen) == 0 &&
(int)strlen(opt->optname) == wordlen) {
optidx = i;
break;
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;
}
}
DNPRINTF(SWM_D_MISC, "set_child_transient: parent doesn't exist"
" for 0x%x trans 0x%x\n", win->id, win->transient);
- r = root_to_region(win->wa->root, SWM_CK_ALL);
+ r = root_to_region(win->s->root, SWM_CK_ALL);
ws = r->ws;
/* parent doen't exist in our window list */
TAILQ_FOREACH(w, &ws->winlist, entry) {
pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_CARDINAL, 0, 1);
pr = xcb_get_property_reply(conn, pc, NULL);
- if (!pr)
+ if (pr == NULL)
goto tryharder;
if (pr->type != XCB_ATOM_CARDINAL) {
free(pr);
pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_STRING,
0, SWM_PROPLEN);
pr = xcb_get_property_reply(conn, pc, NULL);
- if (!pr)
+ if (pr == NULL)
return (0);
if (pr->type != apid) {
free(pr);
xcb_get_property(conn, 0, id, a_swm_ws,
XCB_ATOM_STRING, 0, SWM_PROPLEN),
NULL);
- if (!gpr)
+ if (gpr == NULL)
return (-1);
if (gpr->type) {
proplen = xcb_get_property_value_length(gpr);
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_icccm_get_wm_protocols_reply_t wpr;
+ xcb_get_geometry_reply_t *gr;
if ((win = find_window(id)) != NULL) {
DNPRINTF(SWM_D_MISC, "manage_window: win 0x%x already "
DNPRINTF(SWM_D_MISC, "manage_window: win 0x%x is new.\n", id);
}
+ /* Try to get initial window geometry. */
+ gr = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, id), NULL);
+ if (gr == NULL) {
+ DNPRINTF(SWM_D_MISC, "manage_window: get geometry failed.\n");
+ return (NULL);
+ }
+
/* Create and initialize ws_win object. */
if ((win = calloc(1, sizeof(struct ws_win))) == NULL)
err(1, "manage_window: calloc: failed to allocate memory for "
win->id = id;
- /* Get window geometry. */
- win->wa = xcb_get_geometry_reply(conn,
- xcb_get_geometry(conn, win->id),
- NULL);
-
- /* Figure out which region the window belongs to. */
- r = root_to_region(win->wa->root, SWM_CK_ALL);
+ /* Figureout which region the window belongs to. */
+ r = root_to_region(gr->root, SWM_CK_ALL);
/* Ignore window border if there is one. */
- WIDTH(win) = win->wa->width;
- HEIGHT(win) = win->wa->height;
- X(win) = win->wa->x + win->wa->border_width - border_width;
- Y(win) = win->wa->y + win->wa->border_width - border_width;
+ WIDTH(win) = gr->width;
+ HEIGHT(win) = gr->height;
+ X(win) = gr->x + gr->border_width - border_width;
+ Y(win) = gr->y + gr->border_width - border_width;
win->bordered = 1;
win->mapped = mapped;
win->floatmaxed = 0;
win->ewmh_flags = 0;
win->s = r->s; /* this never changes */
- store_float_geom(win, r);
+ 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,
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);
ws_idx_str);
}
+ /* WS must already be set for this to work. */
+ store_float_geom(win);
+
/* Handle EWMH */
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) &&
- !strcmp(win->ch.instance_name, qp->name)) {
- 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;
/* Make sure window is positioned inside its region, if its active. */
if (win->ws->r) {
- constrain_window(win, win->ws->r, 0);
+ region_containment(win, r, SWM_CW_ALLSIDES |
+ SWM_CW_HARDBOUNDARY);
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)))
TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry);
- if (win->wa)
- free(win->wa);
-
xcb_icccm_get_wm_class_reply_wipe(&win->ch);
kill_refs(win);
xcb_get_geometry_reply_t *wa;
wa = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, w), NULL);
-
- if (!wa) {
+ if (wa == NULL) {
DNPRINTF(SWM_D_MISC, "print_win_geom: window not found: 0x%x\n",
w);
return;
unmanage_window(win);
stack();
- if (focus_mode != SWM_FOCUS_FOLLOW) {
+ if (focus_mode != SWM_FOCUS_FOLLOW && WS_FOCUSED(win->ws)) {
if (win->ws->focus_pending) {
focus_win(win->ws->focus_pending);
win->ws->focus_pending = NULL;
- } else if (win == win->ws->focus && win->ws->r) {
+ } else if (win == win->ws->focus) {
xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
win->ws->r->id, XCB_CURRENT_TIME);
}
DNPRINTF(SWM_D_EVENT, "mapnotify: window: 0x%x\n", e->window);
- if ((win = find_window(e->window)) == NULL)
- win = manage_window(e->window, 1);
+ if ((win = manage_window(e->window, 1)) == NULL)
+ return;
win->mapped = 1;
set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL);
- if (focus_mode != SWM_FOCUS_FOLLOW) {
+ if (focus_mode != SWM_FOCUS_FOLLOW && WS_FOCUSED(win->ws)) {
if (win->ws->focus_pending == win) {
focus_win(win);
win->ws->focus_pending = NULL;
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
win = manage_window(e->window,
(war->map_state == XCB_MAP_STATE_VIEWABLE));
+ if (win == NULL)
+ goto out;
/* 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) {
if (w == win || !w->mapped)
continue;
- if (!strcmp(w->ch.class_name,
- win->ch.class_name) &&
- !strcmp(w->ch.instance_name,
- win->ch.instance_name))
+ if (w->ch.class_name &&
+ win->ch.class_name &&
+ strcmp(w->ch.class_name,
+ win->ch.class_name) == 0 &&
+ w->ch.instance_name &&
+ win->ch.instance_name &&
+ strcmp(w->ch.instance_name,
+ win->ch.instance_name) == 0)
break;
}
}
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.
if (ws->r) {
stack();
- if (focus_mode != SWM_FOCUS_FOLLOW) {
+ if (focus_mode != SWM_FOCUS_FOLLOW &&
+ WS_FOCUSED(ws)) {
if (ws->focus_pending) {
focus_win(ws->focus_pending);
ws->focus_pending = NULL;
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 == a_state) {
/* State just changed, make sure it gets focused if mapped. */
if (e->state == XCB_PROPERTY_NEW_VALUE) {
- if (focus_mode != SWM_FOCUS_FOLLOW) {
+ if (focus_mode != SWM_FOCUS_FOLLOW && WS_FOCUSED(ws)) {
if (win->mapped &&
ws->focus_pending == win) {
focus_win(ws->focus_pending);
} 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);
if (ws->r)
stack();
- if (focus_mode == SWM_FOCUS_FOLLOW) {
- if (ws->r)
+ if (WS_FOCUSED(ws)) {
+ if (focus_mode == SWM_FOCUS_FOLLOW) {
focus_win(get_pointer_win(ws->r->s->root));
- } else if (ws->focus_pending) {
- focus_win(ws->focus_pending);
- ws->focus_pending = NULL;
- } else if (ws->focus == NULL && ws->r) {
- xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
- ws->r->id, XCB_CURRENT_TIME);
+ } else if (ws->focus_pending) {
+ focus_win(ws->focus_pending);
+ ws->focus_pending = NULL;
+ } else if (ws->focus == NULL) {
+ xcb_set_input_focus(conn, XCB_INPUT_FOCUS_PARENT,
+ ws->r->id, XCB_CURRENT_TIME);
+ }
}
}
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)
{
- struct ws_win *win;
+ struct ws_win *win;
xcb_map_request_event_t mre;
#ifdef SWM_DEBUG
char *name;
if (e->type == ewmh[_NET_ACTIVE_WINDOW].atom) {
DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_ACTIVE_WINDOW\n");
- focus_win(win);
+ if (WS_FOCUSED(win->ws))
+ focus_win(win);
+ else
+ win->ws->focus_pending = win;
}
if (e->type == ewmh[_NET_CLOSE_WINDOW].atom) {
DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_CLOSE_WINDOW\n");
for (i = 0; i < num_screens; i++) {
qtc = xcb_query_tree(conn, screens[i].root);
qtr = xcb_query_tree_reply(conn, qtc, NULL);
- if (!qtr)
+ if (qtr == NULL)
continue;
wins = xcb_query_tree_children(qtr);
no = xcb_query_tree_children_length(qtr);
gac = xcb_get_window_attributes(conn, wins[j]);
gar = xcb_get_window_attributes_reply(conn, gac, NULL);
- if (!gar) {
+ if (gar == NULL) {
DNPRINTF(SWM_D_INIT, "grab_windows: skip %#x; "
"doesn't exist.\n", wins[j]);
continue;
for (j = 0; j < no; j++) {
gac = xcb_get_window_attributes(conn, wins[j]);
gar = xcb_get_window_attributes_reply(conn, gac, NULL);
- if (!gar) {
+ if (gar == NULL) {
DNPRINTF(SWM_D_INIT, "grab_windows: skip %#x; "
"doesn't exist.\n", wins[j]);
continue;
void
setup_screens(void)
{
- int i, j, k, num_screens;
- struct workspace *ws;
- uint32_t gcv[1], wa[1];
- const xcb_query_extension_reply_t *qep;
+ int i, j, k, num_screens;
+ struct workspace *ws;
+ uint32_t gcv[1], wa[1];
+ const xcb_query_extension_reply_t *qep;
xcb_screen_t *screen;
xcb_randr_query_version_cookie_t c;
xcb_randr_query_version_reply_t *r;
a_prot = get_atom_from_string("WM_PROTOCOLS");
a_delete = get_atom_from_string("WM_DELETE_WINDOW");
a_takefocus = get_atom_from_string("WM_TAKE_FOCUS");
- a_wmname = get_atom_from_string("WM_NAME");
- a_netwmname = get_atom_from_string("_NET_WM_NAME");
a_utf8_string = get_atom_from_string("UTF8_STRING");
- a_string = get_atom_from_string("STRING");
a_swm_iconic = get_atom_from_string("_SWM_ICONIC");
a_swm_ws = get_atom_from_string("_SWM_WS");
}
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win,
netwmcheck, XCB_ATOM_WINDOW, 32, 1, &win);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win,
- a_netwmname, a_utf8_string, 8, strlen("LG3D"), "LG3D");
+ ewmh[_NET_WM_NAME].atom, a_utf8_string, 8, strlen("LG3D"),
+ "LG3D");
}
}
num_screens = get_screen_count();
for (i = 0; i < num_screens; ++i) {
- if (screens[i].bar_gc != 0)
+ if (screens[i].bar_gc != XCB_NONE)
xcb_free_gc(conn, screens[i].bar_gc);
if (!bar_font_legacy)
XftColorFree(display, DefaultVisual(display, i),
/*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)
int xfd, i, num_screens, startup = 1;
struct sigaction sact;
xcb_generic_event_t *evt;
- struct timeval tv;
+ struct timeval tv;
fd_set rd;
int rd_max;
int stdin_ready = 0;
start_argv = argv;
warnx("Welcome to spectrwm V%s Build: %s", SPECTRWM_VERSION, buildstr);
- if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, ""))
+ if (setlocale(LC_CTYPE, "") == NULL || setlocale(LC_TIME, "") == NULL)
warnx("no locale support");
/* handle some signals */
sact.sa_flags = SA_NOCLDSTOP;
sigaction(SIGCHLD, &sact, NULL);
- if (!(display = XOpenDisplay(0)))
+ if ((display = XOpenDisplay(0)) == NULL)
errx(1, "can not open display");
conn = XGetXCBConnection(display);
free(evt);
}
- if (enable_wm() != 0)
+ if (enable_wm())
errx(1, "another window manager is currently running");
/* Load Xcursors and/or cursorfont glyph cursors. */