void hide_desktop(desktop_t *d)
{
if (!visible)
return;
for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
window_hide(n->client->window);
}
void set_visibility(monitor_t *m, desktop_t *d, node_t *n, bool visible)
{
PRINTF("set visibilty %X: %s\n", n->client->window, BOOLSTR(visible));
if (!n->client->floating) {
n->vacant = !visible;
update_vacant_state(n->parent);
if (visible)
rotate_brother(n);
else
unrotate_brother(n);
}
if (visible) {
if (m->desk == d)
window_show(n->client->window);
if (d->focus == NULL) {
if (mon->desk == d)
focus_node(m, d, n);
else
pseudo_focus(d, n);
}
} else {
if (m->desk == d || n->client->sticky)
window_hide(n->client->window);
if (d->focus == n) {
node_t *f = history_get_node(d, n);
if (f == NULL)
f = closest_visible(d, n);
if (mon->desk == d)
focus_node(m, d, f);
else
pseudo_focus(d, f);
}
}
}
void select_desktop(desktop_t *d)
{
if (d == NULL || d == mon->desk)
return;
PRINTF("select desktop %s\n", d->name);
if (visible) {
node_t *n = first_extrema(d->root);
while (n != NULL) {
window_show(n->client->window);
n = next_leaf(n);
}
n = first_extrema(mon->desk->root);
while (n != NULL) {
window_hide(n->client->window);
n = next_leaf(n);
}
}
mon->last_desk = mon->desk;
mon->desk = d;
update_current();
ewmh_update_current_desktop();
put_status();
}
void transfer_node(monitor_t *ms, desktop_t *ds, monitor_t *md, desktop_t *dd, node_t *n)
{
if (n == NULL || ds == NULL || dd == NULL || ms == NULL || md == NULL || (ms == md && dd == ds))
return;
PRINTF("transfer node %X\n", n->client->window);
unlink_node(ds, n);
insert_node(md, dd, n);
ewmh_set_wm_desktop(n, dd);
if (ds == ms->desk && dd != md->desk) {
window_hide(n->client->window);
}
fit_monitor(md, n->client);
if (n->client->fullscreen)
window_move_resize(n->client->window, md->rectangle.x, md->rectangle.y, md->rectangle.width, md->rectangle.height);
if (ds != ms->desk && dd == md->desk) {
window_show(n->client->window);
focus_node(md, dd, n, true);
} else {
focus_node(md, dd, n, false);
}
if (ds == ms->desk || dd == md->desk)
update_current();
}
void hide_presel_feedbacks(monitor_t *m, desktop_t *d, node_t *n)
{
if (n == NULL) {
return;
} else {
if (n->presel != NULL) {
window_hide(n->presel->feedback);
}
hide_presel_feedbacks(m, d, n->first_child);
hide_presel_feedbacks(m, d, n->second_child);
}
}
static void status_icon_pushed(object_t * status, event_t * event)
{
if(is_shown)
{
window_hide(w);
is_shown = FALSE;
}
else
{
window_show(w);
is_shown = TRUE;
}
}
void parse_pushed(object_t *obj, event_t *evt)
{
object_t *window = NULL;
bounds_t *b;
object_t *lelex = NULL;
size_t len;
int type;
lelex = (object_t *)store_get("lelex", &len, &type);
assert(len == sizeof(textbox_widget_t) && type == TYPE_TEXTBOX && "invalid object in store for lelex");
// first kill the old window if it is still around
window = store_take("display.window", &len, &type);
if(window) {
window_hide(window);
event_send(window, "destroy", "");
}
b = new_bounds(0,0,0,0);
*b = store_get_bounds_t("window.bounds");
window = window_widget_create(NULL, b, 0);
window_set_title(window, "Layout Display");
object_addhandler(window, "destroy", window_destroy_handle);
object_addhandler(window, "moved", window_moved_handle);
object_addhandler(window, "resized", window_moved_handle);
if(!make_layout(window, b, textarea_get_text(lelex))) {
event_send(window, "destroy", "");
printf("FAILED TO PARSE");
} else {
store_put("display.window", window, sizeof(window_widget_t), TYPE_WINDOW);
window_show( window );
window_focus( window );
}
}
void update_colors_in(node_t *n, desktop_t *d, monitor_t *m)
{
if (n == NULL) {
return;
} else {
if (n->presel != NULL) {
uint32_t pxl = get_color_pixel(presel_feedback_color);
xcb_change_window_attributes(dpy, n->presel->feedback, XCB_CW_BACK_PIXEL, &pxl);
if (d == m->desk) {
/* hack to induce back pixel refresh */
window_hide(n->presel->feedback);
window_show(n->presel->feedback);
}
}
if (n == d->focus) {
draw_border(n, true, (m == mon));
} else if (n->client != NULL) {
draw_border(n, false, (m == mon));
} else {
update_colors_in(n->first_child, d, m);
update_colors_in(n->second_child, d, m);
}
}
}
void manage_window(xcb_window_t win, rule_consequence_t *csq, int fd)
{
monitor_t *m = mon;
desktop_t *d = mon->desk;
node_t *f = mon->desk->focus;
parse_rule_consequence(fd, csq);
if (!csq->manage) {
free(csq->layer);
free(csq->state);
window_show(win);
return;
}
if (csq->node_desc[0] != '\0') {
coordinates_t ref = {m, d, f};
coordinates_t trg = {NULL, NULL, NULL};
if (node_from_desc(csq->node_desc, &ref, &trg)) {
m = trg.monitor;
d = trg.desktop;
f = trg.node;
}
} else if (csq->desktop_desc[0] != '\0') {
coordinates_t ref = {m, d, NULL};
coordinates_t trg = {NULL, NULL, NULL};
if (desktop_from_desc(csq->desktop_desc, &ref, &trg)) {
m = trg.monitor;
d = trg.desktop;
f = trg.desktop->focus;
}
} else if (csq->monitor_desc[0] != '\0') {
coordinates_t ref = {m, NULL, NULL};
coordinates_t trg = {NULL, NULL, NULL};
if (monitor_from_desc(csq->monitor_desc, &ref, &trg)) {
m = trg.monitor;
d = trg.monitor->desk;
f = trg.monitor->desk->focus;
}
}
if (csq->sticky) {
m = mon;
d = mon->desk;
f = mon->desk->focus;
}
if (csq->split_dir[0] != '\0' && f != NULL) {
direction_t dir;
if (parse_direction(csq->split_dir, &dir)) {
presel_dir(m, d, f, dir);
}
}
if (csq->split_ratio != 0 && f != NULL) {
presel_ratio(m, d, f, csq->split_ratio);
}
node_t *n = make_node(win);
client_t *c = make_client();
c->border_width = csq->border ? d->border_width : 0;
n->client = c;
initialize_client(n);
update_floating_rectangle(n);
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;
c->max_height = csq->max_height;
monitor_t *mm = monitor_from_client(c);
embrace_client(mm, c);
adapt_geometry(&mm->rectangle, &m->rectangle, n);
if (csq->center) {
window_center(m, c);
}
snprintf(c->class_name, sizeof(c->class_name), "%s", csq->class_name);
snprintf(c->instance_name, sizeof(c->instance_name), "%s", csq->instance_name);
f = insert_node(m, d, n, f);
clients_count++;
put_status(SBSC_MASK_NODE_MANAGE, "node_manage %s %s 0x%X 0x%X\n", m->name, d->name, win, f!=NULL?f->id:0);
if (f != NULL && f->client != NULL && csq->state != NULL && *(csq->state) == STATE_FLOATING) {
c->last_layer = c->layer = f->client->layer;
}
if (csq->layer != NULL) {
c->last_layer = c->layer = *(csq->layer);
}
if (csq->state != NULL) {
set_state(m, d, n, *(csq->state));
c->last_state = c->state;
}
set_locked(m, d, n, csq->locked);
set_sticky(m, d, n, csq->sticky);
set_private(m, d, n, csq->private);
arrange(m, d);
bool give_focus = (csq->focus && (d == mon->desk || csq->follow));
if (give_focus) {
focus_node(m, d, n);
} else if (csq->focus) {
activate_node(m, d, n);
} else {
stack(d, n, false);
}
uint32_t values[] = {CLIENT_EVENT_MASK | (focus_follows_pointer ? XCB_EVENT_MASK_ENTER_WINDOW : 0)};
xcb_change_window_attributes(dpy, win, XCB_CW_EVENT_MASK, values);
if (d == m->desk) {
window_show(n->id);
} else {
window_hide(n->id);
}
/* the same function is already called in `focus_node` but has no effects on unmapped windows */
if (give_focus) {
xcb_set_input_focus(dpy, XCB_INPUT_FOCUS_POINTER_ROOT, win, XCB_CURRENT_TIME);
}
ewmh_set_wm_desktop(n, d);
ewmh_update_client_list(false);
free(csq->layer);
free(csq->state);
}
void disable_motion_recorder(void)
{
window_hide(motion_recorder);
}
