bspc.o: bspc.c common.h helpers.h
bspwm.o: bspwm.c bspwm.h common.h desktop.h events.h ewmh.h helpers.h history.h messages.h monitor.h rule.h settings.h stack.h subscribe.h types.h window.h
desktop.o: desktop.c bspwm.h desktop.h ewmh.h helpers.h history.h monitor.h query.h settings.h subscribe.h tree.h types.h window.h
-events.o: events.c bspwm.h events.h ewmh.h helpers.h monitor.h query.h settings.h tree.h types.h window.h
+events.o: events.c bspwm.h events.h ewmh.h helpers.h monitor.h query.h settings.h subscribe.h tree.h types.h window.h
ewmh.o: ewmh.c bspwm.h ewmh.h helpers.h settings.h tree.h types.h
helpers.o: helpers.c bspwm.h helpers.h types.h
history.o: history.c bspwm.h helpers.h query.h types.h
messages.o: messages.c bspwm.h common.h desktop.h ewmh.h helpers.h history.h messages.h monitor.h pointer.h query.h restore.h rule.h settings.h subscribe.h tree.h types.h window.h
monitor.o: monitor.c bspwm.h desktop.h ewmh.h helpers.h history.h monitor.h query.h settings.h subscribe.h tree.h types.h window.h
-pointer.o: pointer.c bspwm.h helpers.h monitor.h pointer.h query.h settings.h stack.h tree.h types.h window.h
+pointer.o: pointer.c bspwm.h helpers.h monitor.h pointer.h query.h settings.h stack.h subscribe.h tree.h types.h window.h
query.o: query.c bspwm.h desktop.h helpers.h history.h messages.h monitor.h query.h subscribe.h tree.h types.h
restore.o: restore.c bspwm.h desktop.h ewmh.h helpers.h history.h monitor.h query.h restore.h settings.h stack.h tree.h types.h
rule.o: rule.c bspwm.h ewmh.h helpers.h messages.h rule.h settings.h subscribe.h types.h window.h
for (int i = 0; i < n; i++) {
xcb_xinerama_screen_info_t info = xsi[i];
xcb_rectangle_t rect = (xcb_rectangle_t) {info.x_org, info.y_org, info.width, info.height};
- monitor_t *m = add_monitor(rect);
+ monitor_t *m = make_monitor(rect);
+ add_monitor(m);
add_desktop(m, make_desktop(NULL));
}
free(xsq);
} else {
warn("Xinerama is inactive.\n");
xcb_rectangle_t rect = (xcb_rectangle_t) {0, 0, screen_width, screen_height};
- monitor_t *m = add_monitor(rect);
+ monitor_t *m = make_monitor(rect);
+ add_monitor(m);
add_desktop(m, make_desktop(NULL));
}
}
if (d == mon->desk)
return;
- PRINTF("focus desktop %s\n", d->name);
put_status(SBSC_MASK_DESKTOP_FOCUS, "desktop_focus %s %s\n", m->name, d->name);
show_desktop(d);
void transfer_desktop(monitor_t *ms, monitor_t *md, desktop_t *d)
{
- if (ms == md)
+ if (ms == md) {
return;
+ }
put_status(SBSC_MASK_DESKTOP_TRANSFER, "desktop_transfer %s %s %s\n", ms->name, d->name, md->name);
return d;
}
-void rename_desktop(desktop_t *d, const char *name)
+void rename_desktop(monitor_t *m, desktop_t *d, const char *name)
{
+
+ put_status(SBSC_MASK_DESKTOP_RENAME, "desktop_rename %s %s %s\n", m->name, d->name, name);
+
snprintf(d->name, sizeof(d->name), "%s", name);
+
+ put_status(SBSC_MASK_REPORT);
ewmh_update_desktop_names();
}
void add_desktop(monitor_t *m, desktop_t *d)
{
- PRINTF("add desktop %s\n", d->name);
put_status(SBSC_MASK_DESKTOP_ADD, "desktop_add %s %s\n", m->name, d->name);
insert_desktop(m, d);
void remove_desktop(monitor_t *m, desktop_t *d)
{
- PRINTF("remove desktop %s\n", d->name);
- put_status(SBSC_MASK_DESKTOP_REMOVE, "desktop_remove %s\n", d->name);
+ put_status(SBSC_MASK_DESKTOP_REMOVE, "desktop_remove %s %s\n", m->name, d->name);
unlink_desktop(m, d);
history_remove(d, NULL);
void swap_desktops(monitor_t *m1, desktop_t *d1, monitor_t *m2, desktop_t *d2)
{
- if (d1 == NULL || d2 == NULL || d1 == d2)
+ if (d1 == NULL || d2 == NULL || d1 == d2) {
return;
+ }
- PRINTF("swap desktops %s %s\n", d1->name, d2->name);
put_status(SBSC_MASK_DESKTOP_SWAP, "desktop_swap %s %s %s %s\n", m1->name, d1->name, m2->name, d2->name);
bool d1_focused = (m1->desk == d1);
void change_layout(monitor_t *m, desktop_t *d, layout_t l);
void transfer_desktop(monitor_t *ms, monitor_t *md, desktop_t *d);
desktop_t *make_desktop(const char *name);
-void rename_desktop(desktop_t *d, const char *name);
+void rename_desktop(monitor_t *m, desktop_t *d, const char *name);
void initialize_desktop(desktop_t *d);
void insert_desktop(monitor_t *m, desktop_t *d);
void add_desktop(monitor_t *m, desktop_t *d);
## Coding Style
-I follow the [Linux Coding Style][4].
+I follow the [Linux Coding Style][4] with the following variations:
+- [Ident with tabs, align with spaces][5].
+- Always use braces with if/else.
## Browsing the Code
[2]: http://www.x.org/releases/X11R7.5/doc/libxcb/tutorial/
[3]: http://git-scm.com/documentation
[4]: http://www.kernel.org/doc/Documentation/CodingStyle
+[5]: http://lea.verou.me/2012/01/why-tabs-are-clearly-superior/
.\" Title: bspwm
.\" Author: [see the "Author" section]
.\" Generator: DocBook XSL Stylesheets v1.78.1 <http://docbook.sf.net/>
-.\" Date: 11/07/2015
+.\" Date: 11/09/2015
.\" Manual: Bspwm Manual
.\" Source: Bspwm 0.9
.\" Language: English
.\"
-.TH "BSPWM" "1" "11/07/2015" "Bspwm 0\&.9" "Bspwm Manual"
+.TH "BSPWM" "1" "11/09/2015" "Bspwm 0\&.9" "Bspwm Manual"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.PP
\fB\-\-subscribe\fR (all|report|monitor|desktop|window|\&...)*
.RS 4
-Continuously print status information\&.
+Continuously print status information\&. See the
+\fBEVENTS\fR
+section for the detailed description of each event\&.
.RE
.PP
\fB\-\-get\-status\fR
.RS 4
Size of the gap that separates windows\&.
.RE
-.SH "STATUS FORMAT"
+.SH "EVENTS"
+.PP
+\fIreport\fR
+.RS 4
+See the next section for the description of the format\&.
+.RE
+.PP
+\fImonitor_add <monitor_name> <monitor_id> <monitor_geometry>\fR
+.RS 4
+A monitor is added\&.
+.RE
+.PP
+\fImonitor_rename <old_name> <new_name>\fR
+.RS 4
+A monitor is renamed\&.
+.RE
+.PP
+\fImonitor_remove <monitor_name>\fR
+.RS 4
+A monitor is removed\&.
+.RE
+.PP
+\fImonitor_focus <monitor_name>\fR
+.RS 4
+A monitor is focused\&.
+.RE
+.PP
+\fImonitor_geometry <monitor_name> <monitor_geometry>\fR
+.RS 4
+The geometry of a monitor changed\&.
+.RE
+.PP
+\fIdesktop_add <monitor_name> <desktop_name>\fR
+.RS 4
+A desktop is added\&.
+.RE
+.PP
+\fIdesktop_rename <monitor_name> <old_name> <new_name>\fR
+.RS 4
+A desktop is renamed\&.
+.RE
+.PP
+\fIdesktop_remove <monitor_name> <desktop_name>\fR
+.RS 4
+A desktop is removed\&.
+.RE
+.PP
+\fIdesktop_swap <src_monitor_name> <src_desktop_name> <dst_monitor_name> <dst_desktop_name>\fR
+.RS 4
+A desktop is swapped\&.
+.RE
+.PP
+\fIdesktop_transfer <src_monitor_name> <src_desktop_name> <dst_monitor_name>\fR
+.RS 4
+A desktop is transferred\&.
+.RE
+.PP
+\fIdesktop_focus <monitor_name> <desktop_name>\fR
+.RS 4
+A desktop is focused\&.
+.RE
+.PP
+\fIdesktop_layout <monitor_name> <desktop_name> tiled|monocle\fR
+.RS 4
+The layout of a desktop changed\&.
+.RE
+.PP
+\fIwindow_manage <monitor_name> <desktop_name> <window_id> <ip_id>\fR
+.RS 4
+A window is managed\&.
+.RE
+.PP
+\fIwindow_manage <monitor_name> <desktop_name> <window_id> <ip_id>\fR
+.RS 4
+A window is managed\&.
+.RE
+.PP
+\fIwindow_unmanage <monitor_name> <desktop_name> <window_id>\fR
+.RS 4
+A window is unmanaged\&.
+.RE
+.PP
+\fIwindow_swap <src_monitor_name> <src_desktop_name> <src_window_id> <dst_monitor_name> <dst_desktop_name> <dst_window_id>\fR
+.RS 4
+A window is swapped\&.
+.RE
+.PP
+\fIwindow_transfer <src_monitor_name> <src_desktop_name> <src_window_id> <dst_monitor_name> <dst_desktop_name> <dst_window_id>\fR
+.RS 4
+A window is transferred\&.
+.RE
+.PP
+\fIwindow_focus <monitor_name> <desktop_name> <window_id>\fR
+.RS 4
+A window is focused\&.
+.RE
+.PP
+\fIwindow_activate <monitor_name> <desktop_name> <window_id>\fR
+.RS 4
+A window is activated\&.
+.RE
+.PP
+\fIwindow_geometry <monitor_name> <desktop_name> <window_id> <window_geometry>\fR
+.RS 4
+The geometry of a window changed\&.
+.RE
+.PP
+\fIwindow_state <monitor_name> <desktop_name> <window_id> tiled|pseudo_tiled|floating|fullscreen on|off\fR
+.RS 4
+The state of a window changed\&.
+.RE
+.PP
+\fIwindow_flag <monitor_name> <desktop_name> <window_id> sticky|private|locked|urgent on|off\fR
+.RS 4
+One of the flags of a window changed\&.
+.RE
+.PP
+\fIwindow_layer <monitor_name> <desktop_name> <window_id> below|normal|above\fR
+.RS 4
+The layer of a window changed\&.
+.RE
+.sp
+Please note that \fBbspwm\fR initializes monitors before it reads messages on its socket, therefore the initial monitor events can\(cqt be received\&.
+.SH "REPORT FORMAT"
.sp
-Status information is composed of items separated by colons\&.
+Each report event message is composed of items separated by colons\&.
.sp
Each item has the form \fI<type><value>\fR where \fI<type>\fR is the first character of the item\&.
.PP
Enable or disable the recording of window focus history.
*--subscribe* (all|report|monitor|desktop|window|...)*::
- Continuously print status information.
+ Continuously print status information. See the *EVENTS* section for the detailed description of each event.
*--get-status*::
Print the current status information.
Size of the gap that separates windows.
-Status Format
+Events
+------
+
+'report'::
+ See the next section for the description of the format.
+
+'monitor_add <monitor_name> <monitor_id> <monitor_geometry>'::
+ A monitor is added.
+
+'monitor_rename <old_name> <new_name>'::
+ A monitor is renamed.
+
+'monitor_remove <monitor_name>'::
+ A monitor is removed.
+
+'monitor_focus <monitor_name>'::
+ A monitor is focused.
+
+'monitor_geometry <monitor_name> <monitor_geometry>'::
+ The geometry of a monitor changed.
+
+'desktop_add <monitor_name> <desktop_name>'::
+ A desktop is added.
+
+'desktop_rename <monitor_name> <old_name> <new_name>'::
+ A desktop is renamed.
+
+'desktop_remove <monitor_name> <desktop_name>'::
+ A desktop is removed.
+
+'desktop_swap <src_monitor_name> <src_desktop_name> <dst_monitor_name> <dst_desktop_name>'::
+ A desktop is swapped.
+
+'desktop_transfer <src_monitor_name> <src_desktop_name> <dst_monitor_name>'::
+ A desktop is transferred.
+
+'desktop_focus <monitor_name> <desktop_name>'::
+ A desktop is focused.
+
+'desktop_layout <monitor_name> <desktop_name> tiled|monocle'::
+ The layout of a desktop changed.
+
+'window_manage <monitor_name> <desktop_name> <window_id> <ip_id>'::
+ A window is managed.
+
+'window_manage <monitor_name> <desktop_name> <window_id> <ip_id>'::
+ A window is managed.
+
+'window_unmanage <monitor_name> <desktop_name> <window_id>'::
+ A window is unmanaged.
+
+'window_swap <src_monitor_name> <src_desktop_name> <src_window_id> <dst_monitor_name> <dst_desktop_name> <dst_window_id>'::
+ A window is swapped.
+
+'window_transfer <src_monitor_name> <src_desktop_name> <src_window_id> <dst_monitor_name> <dst_desktop_name> <dst_window_id>'::
+ A window is transferred.
+
+'window_focus <monitor_name> <desktop_name> <window_id>'::
+ A window is focused.
+
+'window_activate <monitor_name> <desktop_name> <window_id>'::
+ A window is activated.
+
+'window_geometry <monitor_name> <desktop_name> <window_id> <window_geometry>'::
+ The geometry of a window changed.
+
+'window_state <monitor_name> <desktop_name> <window_id> tiled|pseudo_tiled|floating|fullscreen on|off'::
+ The state of a window changed.
+
+'window_flag <monitor_name> <desktop_name> <window_id> sticky|private|locked|urgent on|off'::
+ One of the flags of a window changed.
+
+'window_layer <monitor_name> <desktop_name> <window_id> below|normal|above'::
+ The layer of a window changed.
+
+Please note that *bspwm* initializes monitors before it reads messages on its socket, therefore the initial monitor events can't be received.
+
+Report Format
-------------
-Status information is composed of items separated by colons.
+Each report event message is composed of items separated by colons.
Each item has the form '<type><value>' where '<type>' is the first character of the item.
#include "monitor.h"
#include "query.h"
#include "settings.h"
+#include "subscribe.h"
#include "tree.h"
#include "window.h"
#include "events.h"
{
xcb_map_request_event_t *e = (xcb_map_request_event_t *) evt;
- PRINTF("map request %X\n", e->window);
-
schedule_window(e->window);
}
{
xcb_configure_request_event_t *e = (xcb_configure_request_event_t *) evt;
- PRINTF("configure request %X\n", e->window);
-
coordinates_t loc;
bool is_managed = locate_window(e->window, &loc);
client_t *c = (is_managed ? loc.node->client : NULL);
}
xcb_configure_window(dpy, e->window, mask, values);
+
+ if (is_managed && (mask & XCB_CONFIG_WINDOW_X_Y_WIDTH_HEIGHT)) {
+ xcb_rectangle_t r = c->floating_rectangle;
+ put_status(SBSC_MASK_WINDOW_GEOMETRY, "window_geometry %s %s 0x%X %ux%u+%i+%i\n", loc.monitor->name, loc.desktop->name, c->window, r.width, r.height, r.x, r.y);
+ }
}
if (is_managed) {
{
xcb_destroy_notify_event_t *e = (xcb_destroy_notify_event_t *) evt;
- PRINTF("destroy notify %X\n", e->window);
-
unmanage_window(e->window);
}
{
xcb_unmap_notify_event_t *e = (xcb_unmap_notify_event_t *) evt;
- PRINTF("unmap notify %X\n", e->window);
-
unmanage_window(e->window);
}
{
xcb_property_notify_event_t *e = (xcb_property_notify_event_t *) evt;
- /* PRINTF("property notify %X\n", e->window); */
-
- if (e->atom != XCB_ATOM_WM_HINTS && e->atom != XCB_ATOM_WM_NORMAL_HINTS)
+ if (e->atom != XCB_ATOM_WM_HINTS && e->atom != XCB_ATOM_WM_NORMAL_HINTS) {
return;
+ }
coordinates_t loc;
if (!locate_window(e->window, &loc))
{
xcb_client_message_event_t *e = (xcb_client_message_event_t *) evt;
- PRINTF("client message %X %u\n", e->window, e->type);
-
if (e->type == ewmh->_NET_CURRENT_DESKTOP) {
coordinates_t loc;
if (ewmh_locate_desktop(e->data.data32[0], &loc))
{
xcb_focus_in_event_t *e = (xcb_focus_in_event_t *) evt;
- /* PRINTF("focus in %X %d %d\n", e->event, e->mode, e->detail); */
-
if (e->mode == XCB_NOTIFY_MODE_GRAB ||
e->mode == XCB_NOTIFY_MODE_UNGRAB)
return;
xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *) evt;
xcb_window_t win = e->event;
- PRINTF("enter notify %X %d %d\n", win, e->mode, e->detail);
-
if (e->mode != XCB_NOTIFY_MODE_NORMAL ||
(mon->desk->focus != NULL &&
mon->desk->focus->client->window == win)) {
{
xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t *) evt;
- PRINTF("motion notify %X %i %i\n", e->event, e->root_x, e->root_y);
-
int dtime = e->time - last_motion_time;
if (dtime > 1000) {
last_motion_time = e->time;
#define streq(s1, s2) (strcmp((s1), (s2)) == 0)
-#ifdef DEBUG
-# define PUTS(x) puts(x)
-# define PRINTF(x,...) printf(x, __VA_ARGS__)
-#else
-# define PUTS(x) ((void)0)
-# define PRINTF(x,...) ((void)0)
-#endif
-
void warn(char *fmt, ...);
void err(char *fmt, ...);
bool get_color(char *col, xcb_window_t win, uint32_t *pxl);
if (dst.desktop == mon->desk) {
return MSG_FAILURE;
}
- activate(dst.monitor, dst.desktop, dst.node);
+ activate_node(dst.monitor, dst.desktop, dst.node);
} else if (streq("-d", *args) || streq("--to-desktop", *args)) {
num--, args++;
coordinates_t dst;
num--, args++;
if (num < 1)
return MSG_SYNTAX;
- put_status(SBSC_MASK_DESKTOP_RENAME, "desktop_rename %s %s %s\n", trg.monitor->name, trg.desktop->name, *args);
- rename_desktop(trg.desktop, *args);
- put_status(SBSC_MASK_REPORT);
+ rename_desktop(trg.monitor, trg.desktop, *args);
} else if (streq("-r", *args) || streq("--remove", *args)) {
if (trg.desktop->root == NULL &&
trg.monitor->desk_head != trg.monitor->desk_tail) {
return MSG_SYNTAX;
desktop_t *d = trg.monitor->desk_head;
while (num > 0 && d != NULL) {
- put_status(SBSC_MASK_DESKTOP_RENAME, "desktop_rename %s %s %s\n", trg.monitor->name, d->name, *args);
- rename_desktop(d, *args);
+ rename_desktop(trg.monitor, d, *args);
initialize_desktop(d);
arrange(trg.monitor, d);
d = d->next;
}
} else if (streq("-n", *args) || streq("--rename", *args)) {
num--, args++;
- if (num < 1)
+ if (num < 1) {
return MSG_SYNTAX;
- put_status(SBSC_MASK_MONITOR_RENAME, "monitor_rename %s %s\n", trg.monitor->name, *args);
- snprintf(trg.monitor->name, sizeof(trg.monitor->name), "%s", *args);
- put_status(SBSC_MASK_REPORT);
+ }
+ rename_monitor(trg.monitor, *args);
} else if (streq("-s", *args) || streq("--swap", *args)) {
num--, args++;
if (num < 1)
*mask = SBSC_MASK_MONITOR_REMOVE;
} else if (streq("monitor_focus", s)) {
*mask = SBSC_MASK_MONITOR_FOCUS;
- } else if (streq("monitor_resize", s)) {
- *mask = SBSC_MASK_MONITOR_RESIZE;
+ } else if (streq("monitor_geometry", s)) {
+ *mask = SBSC_MASK_MONITOR_GEOMETRY;
} else if (streq("report", s)) {
*mask = SBSC_MASK_REPORT;
} else {
return m;
}
+void rename_monitor(monitor_t *m, const char *name)
+{
+ put_status(SBSC_MASK_MONITOR_RENAME, "monitor_rename %s %s\n", m->name, name);
+
+ snprintf(m->name, sizeof(m->name), "%s", name);
+
+ put_status(SBSC_MASK_REPORT);
+}
+
monitor_t *find_monitor(char *name)
{
for (monitor_t *m = mon_head; m != NULL; m = m->next)
void update_root(monitor_t *m)
{
- xcb_rectangle_t rect = m->rectangle;
- window_move_resize(m->root, rect.x, rect.y, rect.width, rect.height);
+ xcb_rectangle_t r = m->rectangle;
+ window_move_resize(m->root, r.x, r.y, r.width, r.height);
+ put_status(SBSC_MASK_MONITOR_GEOMETRY, "monitor_geometry %s %ux%u+%i+%i\n", m->name, r.width, r.height, r.x, r.y);
}
void focus_monitor(monitor_t *m)
if (mon == m)
return;
- PRINTF("focus monitor %s\n", m->name);
put_status(SBSC_MASK_MONITOR_FOCUS, "monitor_focus %s\n", m->name);
mon = m;
- if (pointer_follows_monitor)
+ if (pointer_follows_monitor) {
center_pointer(m->rectangle);
+ }
ewmh_update_current_desktop();
put_status(SBSC_MASK_REPORT);
}
-monitor_t *add_monitor(xcb_rectangle_t rect)
+void add_monitor(monitor_t *m)
{
- monitor_t *m = make_monitor(rect);
- put_status(SBSC_MASK_MONITOR_ADD, "monitor_add %s\n", m->name);
+ xcb_rectangle_t r = m->rectangle;
+
+ put_status(SBSC_MASK_MONITOR_ADD, "monitor_add %s 0x%X %ux%u+%i+%i\n", m->name, m->id, r.width, r.height, r.x, r.y);
if (mon == NULL) {
mon = m;
}
num_monitors++;
- return m;
}
void remove_monitor(monitor_t *m)
{
- PRINTF("remove monitor %s (0x%X)\n", m->name, m->id);
put_status(SBSC_MASK_MONITOR_REMOVE, "monitor_remove %s\n", m->name);
while (m->desk_head != NULL) {
return;
}
- PRINTF("merge %s into %s\n", ms->name, md->name);
-
desktop_t *d = ms->desk_head;
while (d != NULL) {
desktop_t *next = d->next;
monitor_t *monitor_from_point(xcb_point_t pt)
{
- for (monitor_t *m = mon_head; m != NULL; m = m->next)
- if (is_inside_monitor(m, pt))
+ for (monitor_t *m = mon_head; m != NULL; m = m->next) {
+ if (is_inside_monitor(m, pt)) {
return m;
+ }
+ }
return NULL;
}
bool update_monitors(void)
{
- PUTS("update monitors");
xcb_randr_get_screen_resources_current_reply_t *sres = xcb_randr_get_screen_resources_current_reply(dpy, xcb_randr_get_screen_resources_current(dpy, root), NULL);
if (sres == NULL)
return false;
if (mm != NULL) {
mm->rectangle = rect;
update_root(mm);
- for (desktop_t *d = mm->desk_head; d != NULL; d = d->next)
- for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
+ for (desktop_t *d = mm->desk_head; d != NULL; d = d->next) {
+ for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {
translate_client(mm, mm, n->client);
+ }
+ }
arrange(mm, mm->desk);
mm->wired = true;
- PRINTF("update monitor %s (0x%X)\n", mm->name, mm->id);
} else {
- mm = add_monitor(rect);
+ mm = make_monitor(rect);
char *name = (char *)xcb_randr_get_output_info_name(info);
size_t name_len = MIN(sizeof(mm->name), (size_t)xcb_randr_get_output_info_name_length(info) + 1);
snprintf(mm->name, name_len, "%s", name);
mm->id = outputs[i];
- PRINTF("add monitor %s (0x%X)\n", mm->name, mm->id);
+ add_monitor(mm);
}
}
free(cir);
#define DEFAULT_MON_NAME "MONITOR"
monitor_t *make_monitor(xcb_rectangle_t rect);
+void rename_monitor(monitor_t *m, const char *name);
monitor_t *find_monitor(char *name);
monitor_t *get_monitor_by_id(xcb_randr_output_t id);
void embrace_client(monitor_t *m, client_t *c);
void translate_client(monitor_t *ms, monitor_t *md, client_t *c);
void update_root(monitor_t *m);
void focus_monitor(monitor_t *m);
-monitor_t *add_monitor(xcb_rectangle_t rect);
+void add_monitor(monitor_t *m);
void remove_monitor(monitor_t *m);
void merge_monitors(monitor_t *ms, monitor_t *md);
void swap_monitors(monitor_t *m1, monitor_t *m2);
#include "stack.h"
#include "tree.h"
#include "monitor.h"
+#include "subscribe.h"
#include "window.h"
#include "pointer.h"
void grab_pointer(pointer_action_t pac)
{
- PRINTF("grab pointer %u\n", pac);
-
xcb_window_t win = XCB_NONE;
xcb_point_t pos;
void ungrab_pointer(void)
{
+ if (frozen_pointer->action != ACTION_NONE) {
+ xcb_rectangle_t r = get_rectangle(frozen_pointer->monitor, frozen_pointer->client);
+ put_status(SBSC_MASK_WINDOW_GEOMETRY, "window_geometry %s %s 0x%X %ux%u+%i+%i\n", frozen_pointer->monitor->name, frozen_pointer->desktop->name, frozen_pointer->window, r.width, r.height, r.x, r.y);
+ }
frozen_pointer->action = ACTION_NONE;
}
return;
}
- PUTS("restore tree");
-
char line[MAXLEN];
char name[MAXLEN];
coordinates_t loc;
return;
}
- PUTS("restore history");
-
char line[MAXLEN];
char mnm[SMALEN];
char dnm[SMALEN];
return;
}
- PUTS("restore stack");
-
char line[MAXLEN];
xcb_window_t win;
{
if (pr == NULL)
return;
- PRINTF("add pending rule %i\n", pr->fd);
if (pending_rule_head == NULL) {
pending_rule_head = pending_rule_tail = pr;
} else {
{
if (pr == NULL)
return;
- PRINTF("remove pending rule %i\n", pr->fd);
pending_rule_t *a = pr->prev;
pending_rule_t *b = pr->next;
if (a != NULL)
return;
}
- PRINTF("stack %X\n", n->client->window);
-
if (stack_head == NULL) {
stack_insert_after(NULL, n);
} else {
SBSC_MASK_MONITOR_RENAME = 1 << 2,
SBSC_MASK_MONITOR_REMOVE = 1 << 3,
SBSC_MASK_MONITOR_FOCUS = 1 << 4,
- SBSC_MASK_MONITOR_RESIZE = 1 << 5,
+ SBSC_MASK_MONITOR_GEOMETRY = 1 << 5,
SBSC_MASK_DESKTOP_ADD = 1 << 6,
SBSC_MASK_DESKTOP_RENAME = 1 << 7,
SBSC_MASK_DESKTOP_REMOVE = 1 << 8,
if (d->root == NULL)
return;
- PRINTF("arrange %s %s\n", m->name, d->name);
-
layout_t set_layout = d->layout;
if (leaf_monocle && tiled_count(d) == 1) {
d->layout = LAYOUT_MONOCLE;
window_border_width(n->client->window, bw);
window_draw_border(n, d->focus == n, m == mon);
+ if (frozen_pointer->action == ACTION_NONE) {
+ put_status(SBSC_MASK_WINDOW_GEOMETRY, "window_geometry %s %s 0x%X %ux%u+%i+%i\n", m->name, d->name, n->client->window, r.width, r.height, r.x, r.y);
+ }
+
if (pointer_follows_focus && mon->desk->focus == n && frozen_pointer->action == ACTION_NONE) {
center_pointer(r);
}
if (d == NULL || n == NULL)
return;
- PRINTF("insert node %X\n", n->client->window);
-
/* n: new leaf node */
/* c: new container node */
/* f: focus or insertion anchor */
put_status(SBSC_MASK_REPORT);
}
-void activate(monitor_t *m, desktop_t *d, node_t *n)
+void activate_node(monitor_t *m, desktop_t *d, node_t *n)
{
if (n != NULL) {
if (d->focus != NULL && n != d->focus && stack_cmp(n->client, d->focus->client) < 0) {
}
}
d->focus = n;
- put_status(SBSC_MASK_WINDOW_ACTIVATE, "window_activate 0x%X\n", n->client->window);
+ put_status(SBSC_MASK_WINDOW_ACTIVATE, "window_activate %s %s 0x%X\n", m->name, d->name, n->client->window);
}
void focus_node(monitor_t *m, desktop_t *d, node_t *n)
stack(n, true);
}
- PRINTF("focus node %X\n", n->client->window);
- put_status(SBSC_MASK_WINDOW_FOCUS, "window_focus 0x%X\n", n->client->window);
+ put_status(SBSC_MASK_WINDOW_FOCUS, "window_focus %s %s 0x%X\n", m->name, d->name, n->client->window);
history_add(m, d, n);
set_input_focus(n);
if (d == NULL || n == NULL)
return;
- PRINTF("unlink node %X\n", n->client->window);
-
node_t *p = n->parent;
if (p == NULL) {
if (n == NULL)
return;
- PRINTF("remove node %X\n", n->client->window);
-
bool focused = (n == mon->desk->focus);
+
unlink_node(m, d, n);
history_remove(d, n);
remove_stack_node(n);
bool swap_nodes(monitor_t *m1, desktop_t *d1, node_t *n1, monitor_t *m2, desktop_t *d2, node_t *n2)
{
- if (n1 == NULL || n2 == NULL ||n1 == n2 ||
- (d1 != d2 && (n1->client->sticky || n2->client->sticky)))
+ if (n1 == NULL || n2 == NULL || n1 == n2
+ || (d1 != d2 && (n1->client->sticky || n2->client->sticky))) {
return false;
+ }
- PRINTF("swap nodes %X %X\n", n1->client->window, n2->client->window);
+ put_status(SBSC_MASK_WINDOW_SWAP, "window_swap %s %s 0x%X %s %s 0x%X\n", m1->name, d1->name, n1->client->window, m2->name, d2->name, n2->client->window);
node_t *pn1 = n1->parent;
node_t *pn2 = n2->parent;
return false;
}
- PRINTF("transfer node %X\n", ns->client->window);
put_status(SBSC_MASK_WINDOW_TRANSFER, "window_transfer %s %s 0x%X %s %s 0x%X\n", ms->name, ds->name, ns->client->window, md->name, dd->name, nd!=NULL?nd->client->window:0);
bool focused = (ns == mon->desk->focus);
if (focused) {
focus_node(md, dd, ns);
} else if (active) {
- activate(md, dd, ns);
+ activate_node(md, dd, ns);
}
} else {
if (focused) {
if (n == NULL)
return;
- PUTS("update vacant state");
-
/* n is not a leaf */
node_t *p = n;
void arrange(monitor_t *m, desktop_t *d);
void apply_layout(monitor_t *m, desktop_t *d, node_t *n, xcb_rectangle_t rect, xcb_rectangle_t root_rect);
void insert_node(monitor_t *m, desktop_t *d, node_t *n, node_t *f);
-void activate(monitor_t *m, desktop_t *d, node_t *n);
+void activate_node(monitor_t *m, desktop_t *d, node_t *n);
void focus_node(monitor_t *m, desktop_t *d, node_t *n);
void update_current(void);
node_t *make_node(void);
return;
}
- PRINTF("manage %X\n", win);
-
if (csq->node_desc[0] != '\0') {
coordinates_t ref = {m, d, f};
coordinates_t trg = {NULL, NULL, NULL};
client_t *c = make_client(win, csq->border ? d->border_width : 0);
update_floating_rectangle(c);
- if (c->floating_rectangle.x == 0 && c->floating_rectangle.y == 0)
+ if (c->floating_rectangle.x == 0 && c->floating_rectangle.y == 0) {
csq->center = true;
+ }
c->min_width = csq->min_width;
c->max_width = csq->max_width;
c->min_height = csq->min_height;
node_t *n = make_node();
n->client = c;
- put_status(SBSC_MASK_WINDOW_MANAGE, "window_manage %s %s 0x%X 0x%X\n", m->name, d->name, f!=NULL?f->client->window:0, win);
+ put_status(SBSC_MASK_WINDOW_MANAGE, "window_manage %s %s 0x%X 0x%X\n", m->name, d->name, win, f!=NULL?f->client->window:0);
insert_node(m, d, n, f);
if (f != NULL && f->client != NULL && csq->state != NULL && *(csq->state) == STATE_FLOATING) {
if (give_focus) {
focus_node(m, d, n);
} else if (csq->focus) {
- activate(m, d, n);
+ activate_node(m, d, n);
} else {
stack(n, false);
}
{
coordinates_t loc;
if (locate_window(win, &loc)) {
- PRINTF("unmanage %X\n", win);
- put_status(SBSC_MASK_WINDOW_UNMANAGE, "window_unmanage 0x%X\n", win);
+ put_status(SBSC_MASK_WINDOW_UNMANAGE, "window_unmanage %s %s 0x%X\n", loc.monitor, loc.desktop, win);
remove_node(loc.monitor, loc.desktop, loc.node);
if (frozen_pointer->window == win)
frozen_pointer->action = ACTION_NONE;
if (qtr == NULL)
return;
- PUTS("adopt orphans");
-
int len = xcb_query_tree_children_length(qtr);
xcb_window_t *wins = xcb_query_tree_children(qtr);
for (int i = 0; i < len; i++) {
if (n == NULL || n->client->locked)
return;
- PRINTF("close window %X\n", n->client->window);
-
send_client_message(n->client->window, ewmh->WM_PROTOCOLS, WM_DELETE_WINDOW);
}
return;
xcb_window_t win = n->client->window;
- PRINTF("kill window %X\n", win);
xcb_kill_client(dpy, win);
remove_node(m, d, n);
c->layer = l;
- put_status(SBSC_MASK_WINDOW_LAYER, "window_layer %s 0x%X\n", LAYERSTR(l), c->window);
+ put_status(SBSC_MASK_WINDOW_LAYER, "window_layer %s %s 0x%X %s\n", m->name, d->name, c->window, LAYERSTR(l));
if (d->focus == n) {
neutralize_obscuring_windows(m, d, n);
break;
}
- put_status(SBSC_MASK_WINDOW_STATE, "window_state %s off 0x%X\n", STATESTR(c->last_state), c->window);
+ put_status(SBSC_MASK_WINDOW_STATE, "window_state %s %s 0x%X %s off\n", m->name, d->name, c->window, STATESTR(c->last_state));
switch (c->state) {
case STATE_TILED:
break;
}
- put_status(SBSC_MASK_WINDOW_STATE, "window_state %s on 0x%X\n", STATESTR(c->state), c->window);
+ put_status(SBSC_MASK_WINDOW_STATE, "window_state %s %s 0x%X %s on\n", m->name, d->name, c->window, STATESTR(c->state));
}
void set_floating(monitor_t *m, desktop_t *d, node_t *n, bool value)
client_t *c = n->client;
- put_status(SBSC_MASK_WINDOW_FLAG, "window_flag locked %s 0x%X\n", ONOFFSTR(value), c->window);
+ put_status(SBSC_MASK_WINDOW_FLAG, "window_flag %s %s 0x%X locked %s\n", m->name, d->name, c->window, ONOFFSTR(value));
c->locked = value;
window_draw_border(n, d->focus == n, m == mon);
client_t *c = n->client;
- put_status(SBSC_MASK_WINDOW_FLAG, "window_flag sticky %s 0x%X\n", ONOFFSTR(value), c->window);
+ put_status(SBSC_MASK_WINDOW_FLAG, "window_flag %s %s 0x%X sticky %s\n", m->name, d->name, c->window, ONOFFSTR(value));
if (d != m->desk)
transfer_node(m, d, n, m, m->desk, m->desk->focus);
client_t *c = n->client;
- put_status(SBSC_MASK_WINDOW_FLAG, "window_flag private %s 0x%X\n", ONOFFSTR(value), c->window);
+ put_status(SBSC_MASK_WINDOW_FLAG, "window_flag %s %s 0x%X private %s\n", m->name, d->name, c->window, ONOFFSTR(value));
c->private = value;
update_privacy_level(n, value);
n->client->urgent = value;
window_draw_border(n, d->focus == n, m == mon);
- put_status(SBSC_MASK_WINDOW_FLAG, "window_flag urgent %s 0x%X\n", ONOFFSTR(value), n->client->window);
+ put_status(SBSC_MASK_WINDOW_FLAG, "window_flag %s %s 0x%X urgent %s\n", m->name, d->name, n->client->window, ONOFFSTR(value));
put_status(SBSC_MASK_REPORT);
}
void window_hide(xcb_window_t win)
{
- PRINTF("window hide %X\n", win);
window_set_visibility(win, false);
}
void window_show(xcb_window_t win)
{
- PRINTF("window show %X\n", win);
window_set_visibility(win, true);
}
void enable_motion_recorder(void)
{
- PUTS("motion recorder on");
window_raise(motion_recorder);
window_show(motion_recorder);
}
void disable_motion_recorder(void)
{
- PUTS("motion recorder off");
window_hide(motion_recorder);
}
if (geo != NULL) {
window_resize(motion_recorder, geo->width, geo->height);
- PRINTF("update motion recorder size: %ux%u\n", geo->width, geo->height);
}
free(geo);
projects / bspwm.git / commitdiff