git.sur5r.net Git - i3/i3/blob - src/handlers.c

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * i3 - an improved dynamic tiling window manager
   5  * © 2009-2010 Michael Stapelberg and contributors (see also: LICENSE)
   6  *
   7  */
   8 #include <time.h>
   9
  10 #include <xcb/xcb_atom.h>
  11 #include <xcb/randr.h>
  12
  13 #include <X11/XKBlib.h>
  14
  15 #include "all.h"
  16
  17 /* After mapping/unmapping windows, a notify event is generated. However, we don’t want it,
  18    since it’d trigger an infinite loop of switching between the different windows when
  19    changing workspaces */
  20 static SLIST_HEAD(ignore_head, Ignore_Event) ignore_events;
  21
  22 void add_ignore_event(const int sequence) {
  23     struct Ignore_Event *event = smalloc(sizeof(struct Ignore_Event));
  24
  25     event->sequence = sequence;
  26     event->added = time(NULL);
  27
  28     SLIST_INSERT_HEAD(&ignore_events, event, ignore_events);
  29 }
  30
  31 /*
  32  * Checks if the given sequence is ignored and returns true if so.
  33  *
  34  */
  35 static bool event_is_ignored(const int sequence) {
  36     struct Ignore_Event *event;
  37     time_t now = time(NULL);
  38     for (event = SLIST_FIRST(&ignore_events); event != SLIST_END(&ignore_events);) {
  39         if ((now - event->added) > 5) {
  40             struct Ignore_Event *save = event;
  41             event = SLIST_NEXT(event, ignore_events);
  42             SLIST_REMOVE(&ignore_events, save, Ignore_Event, ignore_events);
  43             free(save);
  44         } else event = SLIST_NEXT(event, ignore_events);
  45     }
  46
  47     SLIST_FOREACH(event, &ignore_events, ignore_events) {
  48         if (event->sequence != sequence)
  49             continue;
  50
  51         /* instead of removing a sequence number we better wait until it gets
  52          * garbage collected. it may generate multiple events (there are multiple
  53          * enter_notifies for one configure_request, for example). */
  54         //SLIST_REMOVE(&ignore_events, event, Ignore_Event, ignore_events);
  55         //free(event);
  56         return true;
  57     }
  58
  59     return false;
  60 }
  61
  62 /*
  63  * There was a key press. We compare this key code with our bindings table and pass
  64  * the bound action to parse_command().
  65  *
  66  */
  67 int handle_key_press(void *ignored, xcb_connection_t *conn, xcb_key_press_event_t *event) {
  68     DLOG("Keypress %d, state raw = %d\n", event->detail, event->state);
  69
  70     /* Remove the numlock bit, all other bits are modifiers we can bind to */
  71     uint16_t state_filtered = event->state & ~(xcb_numlock_mask | XCB_MOD_MASK_LOCK);
  72     DLOG("(removed numlock, state = %d)\n", state_filtered);
  73     /* Only use the lower 8 bits of the state (modifier masks) so that mouse
  74      * button masks are filtered out */
  75     state_filtered &= 0xFF;
  76     DLOG("(removed upper 8 bits, state = %d)\n", state_filtered);
  77
  78     if (xkb_current_group == XkbGroup2Index)
  79         state_filtered |= BIND_MODE_SWITCH;
  80
  81     DLOG("(checked mode_switch, state %d)\n", state_filtered);
  82
  83     /* Find the binding */
  84     Binding *bind = get_binding(state_filtered, event->detail);
  85
  86     /* No match? Then the user has Mode_switch enabled but does not have a
  87      * specific keybinding. Fall back to the default keybindings (without
  88      * Mode_switch). Makes it much more convenient for users of a hybrid
  89      * layout (like us, ru). */
  90     if (bind == NULL) {
  91         state_filtered &= ~(BIND_MODE_SWITCH);
  92         DLOG("no match, new state_filtered = %d\n", state_filtered);
  93         if ((bind = get_binding(state_filtered, event->detail)) == NULL) {
  94             ELOG("Could not lookup key binding (modifiers %d, keycode %d)\n",
  95                  state_filtered, event->detail);
  96             return 1;
  97         }
  98     }
  99
 100     parse_cmd(bind->command);
 101     tree_render();
 102     return 1;
 103 }
 104
 105 #if 0
 106
 107 /*
 108  * Called with coordinates of an enter_notify event or motion_notify event
 109  * to check if the user crossed virtual screen boundaries and adjust the
 110  * current workspace, if so.
 111  *
 112  */
 113 static void check_crossing_screen_boundary(uint32_t x, uint32_t y) {
 114         Output *output;
 115
 116         if ((output = get_output_containing(x, y)) == NULL) {
 117                 ELOG("ERROR: No such screen\n");
 118                 return;
 119         }
 120         if (output == c_ws->output)
 121                 return;
 122
 123         c_ws->current_row = current_row;
 124         c_ws->current_col = current_col;
 125         c_ws = output->current_workspace;
 126         current_row = c_ws->current_row;
 127         current_col = c_ws->current_col;
 128         DLOG("We're now on output %p\n", output);
 129
 130         /* While usually this function is only called when the user switches
 131          * to a different output using his mouse (and thus the output is
 132          * empty), it may be that the following race condition occurs:
 133          * 1) the user actives a new output (say VGA1).
 134          * 2) the cursor is sent to the first pixel of the new VGA1, thus
 135          *    generating an enter_notify for the screen (the enter_notify
 136          *    is not yet received by i3).
 137          * 3) i3 requeries screen configuration and maps a workspace onto the
 138          *    new output.
 139          * 4) the enter_notify event arrives and c_ws is set to the new
 140          *    workspace but the existing windows on the new workspace are not
 141          *    focused.
 142          *
 143          * Therefore, we re-set the focus here to be sure it’s correct. */
 144         Client *first_client = SLIST_FIRST(&(c_ws->focus_stack));
 145         if (first_client != NULL)
 146                 set_focus(global_conn, first_client, true);
 147 }
 148 #endif
 149
 150 /*
 151  * When the user moves the mouse pointer onto a window, this callback gets called.
 152  *
 153  */
 154 int handle_enter_notify(void *ignored, xcb_connection_t *conn,
 155                         xcb_enter_notify_event_t *event) {
 156     Con *con;
 157
 158     DLOG("enter_notify for %08x, mode = %d, detail %d, serial %d\n",
 159          event->event, event->mode, event->detail, event->sequence);
 160     DLOG("coordinates %d, %d\n", event->event_x, event->event_y);
 161     if (event->mode != XCB_NOTIFY_MODE_NORMAL) {
 162         DLOG("This was not a normal notify, ignoring\n");
 163         return 1;
 164     }
 165     /* Some events are not interesting, because they were not generated
 166      * actively by the user, but by reconfiguration of windows */
 167     if (event_is_ignored(event->sequence))
 168         return 1;
 169
 170     bool enter_child = false;
 171     /* Get container by frame or by child window */
 172     if ((con = con_by_frame_id(event->event)) == NULL) {
 173         con = con_by_window_id(event->event);
 174         enter_child = true;
 175     }
 176
 177     /* If not, then the user moved his cursor to the root window. In that case, we adjust c_ws */
 178     if (con == NULL) {
 179         DLOG("Getting screen at %d x %d\n", event->root_x, event->root_y);
 180         //check_crossing_screen_boundary(event->root_x, event->root_y);
 181         return 1;
 182     }
 183
 184     if (con->parent->type == CT_DOCKAREA) {
 185         DLOG("Ignoring, this is a dock client\n");
 186         return 1;
 187     }
 188
 189     /* see if the user entered the window on a certain window decoration */
 190     int layout = (enter_child ? con->parent->layout : con->layout);
 191     Con *child;
 192     TAILQ_FOREACH(child, &(con->nodes_head), nodes)
 193         if (rect_contains(child->deco_rect, event->event_x, event->event_y)) {
 194             LOG("using child %p / %s instead!\n", child, child->name);
 195             con = child;
 196             break;
 197         }
 198
 199     /* for stacked/tabbed layout we do not want to change focus when the user
 200      * enters the window at the decoration of any child window. */
 201     if (layout == L_STACKED || layout == L_TABBED) {
 202         con = TAILQ_FIRST(&(con->parent->focus_head));
 203         LOG("using focused %p / %s instead\n", con, con->name);
 204     }
 205
 206 #if 0
 207     if (client->workspace != c_ws && client->workspace->output == c_ws->output) {
 208             /* This can happen when a client gets assigned to a different workspace than
 209              * the current one (see src/mainx.c:reparent_window). Shortly after it was created,
 210              * an enter_notify will follow. */
 211             DLOG("enter_notify for a client on a different workspace but the same screen, ignoring\n");
 212             return 1;
 213     }
 214 #endif
 215
 216     if (config.disable_focus_follows_mouse)
 217         return 1;
 218
 219     con_focus(con_descend_focused(con));
 220     x_push_changes(croot);
 221
 222     return 1;
 223 }
 224
 225 /*
 226  * When the user moves the mouse but does not change the active window
 227  * (e.g. when having no windows opened but moving mouse on the root screen
 228  * and crossing virtual screen boundaries), this callback gets called.
 229  *
 230  */
 231 int handle_motion_notify(void *ignored, xcb_connection_t *conn, xcb_motion_notify_event_t *event) {
 232     /* Skip events where the pointer was over a child window, we are only
 233      * interested in events on the root window. */
 234     if (event->child != 0)
 235         return 1;
 236
 237     Con *con;
 238     if ((con = con_by_frame_id(event->event)) == NULL) {
 239         /* TODO; handle root window: */
 240         //check_crossing_screen_boundary(event->root_x, event->root_y);
 241         return 1;
 242     }
 243
 244     if (config.disable_focus_follows_mouse)
 245         return 1;
 246
 247     if (con->layout != L_DEFAULT)
 248         return 1;
 249
 250     /* see over which rect the user is */
 251     Con *current;
 252     TAILQ_FOREACH(current, &(con->nodes_head), nodes) {
 253         if (!rect_contains(current->deco_rect, event->event_x, event->event_y))
 254             continue;
 255
 256         /* We found the rect, let’s see if this window is focused */
 257         if (TAILQ_FIRST(&(con->focus_head)) == current)
 258             return 1;
 259
 260         con_focus(current);
 261         x_push_changes(croot);
 262         return 1;
 263     }
 264
 265     return 1;
 266 }
 267
 268 #if 0
 269 /*
 270  * Called when the keyboard mapping changes (for example by using Xmodmap),
 271  * we need to update our key bindings then (re-translate symbols).
 272  *
 273  */
 274 int handle_mapping_notify(void *ignored, xcb_connection_t *conn, xcb_mapping_notify_event_t *event) {
 275         if (event->request != XCB_MAPPING_KEYBOARD &&
 276             event->request != XCB_MAPPING_MODIFIER)
 277                 return 0;
 278
 279         DLOG("Received mapping_notify for keyboard or modifier mapping, re-grabbing keys\n");
 280         xcb_refresh_keyboard_mapping(keysyms, event);
 281
 282         xcb_get_numlock_mask(conn);
 283
 284         ungrab_all_keys(conn);
 285         translate_keysyms();
 286         grab_all_keys(conn, false);
 287
 288         return 0;
 289 }
 290
 291 #endif
 292 /*
 293  * A new window appeared on the screen (=was mapped), so let’s manage it.
 294  *
 295  */
 296 int handle_map_request(void *prophs, xcb_connection_t *conn, xcb_map_request_event_t *event) {
 297     xcb_get_window_attributes_cookie_t cookie;
 298
 299     cookie = xcb_get_window_attributes_unchecked(conn, event->window);
 300
 301     DLOG("window = 0x%08x, serial is %d.\n", event->window, event->sequence);
 302     add_ignore_event(event->sequence);
 303
 304     manage_window(event->window, cookie, false);
 305     x_push_changes(croot);
 306     return 1;
 307 }
 308
 309 /*
 310  * Configure requests are received when the application wants to resize windows on their own.
 311  *
 312  * We generate a synthethic configure notify event to signalize the client its "new" position.
 313  *
 314  */
 315 int handle_configure_request(void *prophs, xcb_connection_t *conn, xcb_configure_request_event_t *event) {
 316     Con *con;
 317
 318     DLOG("window 0x%08x wants to be at %dx%d with %dx%d\n",
 319         event->window, event->x, event->y, event->width, event->height);
 320
 321     /* For unmanaged windows, we just execute the configure request. As soon as
 322      * it gets mapped, we will take over anyways. */
 323     if ((con = con_by_window_id(event->window)) == NULL) {
 324         DLOG("Configure request for unmanaged window, can do that.\n");
 325
 326         uint32_t mask = 0;
 327         uint32_t values[7];
 328         int c = 0;
 329 #define COPY_MASK_MEMBER(mask_member, event_member) do { \
 330         if (event->value_mask & mask_member) { \
 331             mask |= mask_member; \
 332             values[c++] = event->event_member; \
 333         } \
 334 } while (0)
 335
 336         COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_X, x);
 337         COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_Y, y);
 338         COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_WIDTH, width);
 339         COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_HEIGHT, height);
 340         COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_BORDER_WIDTH, border_width);
 341         COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_SIBLING, sibling);
 342         COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_STACK_MODE, stack_mode);
 343
 344         xcb_configure_window(conn, event->window, mask, values);
 345         xcb_flush(conn);
 346
 347         return 1;
 348     }
 349
 350     DLOG("Configure request!\n");
 351     if (con_is_floating(con) && con_is_leaf(con)) {
 352         /* find the height for the decorations */
 353         i3Font *font = load_font(conn, config.font);
 354         int deco_height = font->height + 5;
 355         /* we actually need to apply the size/position changes to the *parent*
 356          * container */
 357         Rect bsr = con_border_style_rect(con);
 358         if (con->border_style == BS_NORMAL) {
 359             bsr.y += deco_height;
 360             bsr.height -= deco_height;
 361         }
 362         con = con->parent;
 363         DLOG("Container is a floating leaf node, will do that.\n");
 364         if (event->value_mask & XCB_CONFIG_WINDOW_X) {
 365             con->rect.x = event->x + (-1) * bsr.x;
 366             DLOG("proposed x = %d, new x is %d\n", event->x, con->rect.x);
 367         }
 368         if (event->value_mask & XCB_CONFIG_WINDOW_Y) {
 369             con->rect.y = event->y + (-1) * bsr.y;
 370             DLOG("proposed y = %d, new y is %d\n", event->y, con->rect.y);
 371         }
 372         if (event->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
 373             con->rect.width = event->width + (-1) * bsr.width;
 374             DLOG("proposed width = %d, new width is %d\n", event->width, con->rect.width);
 375         }
 376         if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
 377             con->rect.height = event->height + (-1) * bsr.height;
 378             DLOG("proposed height = %d, new height is %d\n", event->height, con->rect.height);
 379         }
 380         tree_render();
 381     }
 382
 383     fake_absolute_configure_notify(con);
 384
 385     return 1;
 386 #if 0
 387         /* Dock clients can be reconfigured in their height */
 388         if (client->dock) {
 389                 DLOG("Reconfiguring height of this dock client\n");
 390
 391                 if (!(event->value_mask & XCB_CONFIG_WINDOW_HEIGHT)) {
 392                         DLOG("Ignoring configure request, no height given\n");
 393                         return 1;
 394                 }
 395
 396                 client->desired_height = event->height;
 397                 render_workspace(conn, c_ws->output, c_ws);
 398                 xcb_flush(conn);
 399
 400                 return 1;
 401         }
 402
 403         if (client->fullscreen) {
 404                 DLOG("Client is in fullscreen mode\n");
 405
 406                 Rect child_rect = client->container->workspace->rect;
 407                 child_rect.x = child_rect.y = 0;
 408                 fake_configure_notify(conn, child_rect, client->child);
 409
 410                 return 1;
 411         }
 412
 413         fake_absolute_configure_notify(conn, client);
 414
 415         return 1;
 416 #endif
 417 }
 418 #if 0
 419
 420 /*
 421  * Configuration notifies are only handled because we need to set up ignore for
 422  * the following enter notify events.
 423  *
 424  */
 425 int handle_configure_event(void *prophs, xcb_connection_t *conn, xcb_configure_notify_event_t *event) {
 426     DLOG("configure_event, sequence %d\n", event->sequence);
 427         /* We ignore this sequence twice because events for child and frame should be ignored */
 428         add_ignore_event(event->sequence);
 429         add_ignore_event(event->sequence);
 430
 431         return 1;
 432 }
 433 #endif
 434
 435 /*
 436  * Gets triggered upon a RandR screen change event, that is when the user
 437  * changes the screen configuration in any way (mode, position, …)
 438  *
 439  */
 440 int handle_screen_change(void *prophs, xcb_connection_t *conn,
 441                          xcb_generic_event_t *e) {
 442     DLOG("RandR screen change\n");
 443
 444     randr_query_outputs();
 445
 446     ipc_send_event("output", I3_IPC_EVENT_OUTPUT, "{\"change\":\"unspecified\"}");
 447
 448     return 1;
 449 }
 450
 451 /*
 452  * Our window decorations were unmapped. That means, the window will be killed
 453  * now, so we better clean up before.
 454  *
 455  */
 456 int handle_unmap_notify_event(void *data, xcb_connection_t *conn, xcb_unmap_notify_event_t *event) {
 457
 458     /* FIXME: we cannot ignore this sequence because more UnmapNotifys with the same sequence
 459      * numbers but different window IDs may follow */
 460     /* we need to ignore EnterNotify events which will be generated because a
 461      * different window is visible now */
 462     //add_ignore_event(event->sequence);
 463
 464     DLOG("UnmapNotify for 0x%08x (received from 0x%08x), serial %d\n", event->window, event->event, event->sequence);
 465     Con *con = con_by_window_id(event->window);
 466     if (con == NULL) {
 467         /* This could also be an UnmapNotify for the frame. We need to
 468          * decrement the ignore_unmap counter. */
 469         con = con_by_frame_id(event->window);
 470         if (con == NULL) {
 471             LOG("Not a managed window, ignoring UnmapNotify event\n");
 472             return 1;
 473         }
 474         if (con->ignore_unmap > 0)
 475             con->ignore_unmap--;
 476         DLOG("ignore_unmap = %d for frame of container %p\n", con->ignore_unmap, con);
 477         return 1;
 478     }
 479
 480     if (con->ignore_unmap > 0) {
 481         DLOG("ignore_unmap = %d, dec\n", con->ignore_unmap);
 482         con->ignore_unmap--;
 483         return 1;
 484     }
 485
 486     tree_close(con, false, false);
 487     tree_render();
 488     x_push_changes(croot);
 489     return 1;
 490
 491 #if 0
 492         if (client == NULL) {
 493                 DLOG("not a managed window. Ignoring.\n");
 494
 495                 /* This was most likely the destroyed frame of a client which is
 496                  * currently being unmapped, so we add this sequence (again!) to
 497                  * the ignore list (enter_notify events will get sent for both,
 498                  * the child and its frame). */
 499                 add_ignore_event(event->sequence);
 500
 501                 return 0;
 502         }
 503 #endif
 504
 505
 506 #if 0
 507         /* Let’s see how many clients there are left on the workspace to delete it if it’s empty */
 508         bool workspace_empty = SLIST_EMPTY(&(client->workspace->focus_stack));
 509         bool workspace_focused = (c_ws == client->workspace);
 510         Client *to_focus = (!workspace_empty ? SLIST_FIRST(&(client->workspace->focus_stack)) : NULL);
 511
 512         /* If this workspace is currently visible, we don’t delete it */
 513         if (workspace_is_visible(client->workspace))
 514                 workspace_empty = false;
 515
 516         if (workspace_empty) {
 517                 client->workspace->output = NULL;
 518                 ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"empty\"}");
 519         }
 520
 521         /* Remove the urgency flag if set */
 522         client->urgent = false;
 523         workspace_update_urgent_flag(client->workspace);
 524
 525         render_layout(conn);
 526 #endif
 527
 528         return 1;
 529 }
 530
 531 /*
 532  * A destroy notify event is sent when the window is not unmapped, but
 533  * immediately destroyed (for example when starting a window and immediately
 534  * killing the program which started it).
 535  *
 536  * We just pass on the event to the unmap notify handler (by copying the
 537  * important fields in the event data structure).
 538  *
 539  */
 540 int handle_destroy_notify_event(void *data, xcb_connection_t *conn, xcb_destroy_notify_event_t *event) {
 541     DLOG("destroy notify for 0x%08x, 0x%08x\n", event->event, event->window);
 542
 543     xcb_unmap_notify_event_t unmap;
 544     unmap.sequence = event->sequence;
 545     unmap.event = event->event;
 546     unmap.window = event->window;
 547
 548     return handle_unmap_notify_event(NULL, conn, &unmap);
 549 }
 550
 551 /*
 552  * Called when a window changes its title
 553  *
 554  */
 555 int handle_windowname_change(void *data, xcb_connection_t *conn, uint8_t state,
 556                                 xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
 557     Con *con;
 558     if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
 559         return 1;
 560
 561     window_update_name(con->window, prop);
 562
 563     x_push_changes(croot);
 564
 565     return 1;
 566 }
 567
 568 /*
 569  * Handles legacy window name updates (WM_NAME), see also src/window.c,
 570  * window_update_name_legacy().
 571  *
 572  */
 573 int handle_windowname_change_legacy(void *data, xcb_connection_t *conn, uint8_t state,
 574                                 xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
 575     Con *con;
 576     if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
 577         return 1;
 578
 579     window_update_name_legacy(con->window, prop);
 580
 581     x_push_changes(croot);
 582
 583     return 1;
 584 }
 585
 586 /*
 587  * Updates the client’s WM_CLASS property
 588  *
 589  */
 590 int handle_windowclass_change(void *data, xcb_connection_t *conn, uint8_t state,
 591                              xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
 592     Con *con;
 593     if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
 594         return 1;
 595
 596     window_update_class(con->window, prop);
 597
 598     return 0;
 599 }
 600
 601 /*
 602  * Expose event means we should redraw our windows (= title bar)
 603  *
 604  */
 605 int handle_expose_event(void *data, xcb_connection_t *conn, xcb_expose_event_t *event) {
 606     Con *parent, *con;
 607
 608     /* event->count is the number of minimum remaining expose events for this
 609      * window, so we skip all events but the last one */
 610     if (event->count != 0)
 611         return 1;
 612
 613     DLOG("window = %08x\n", event->window);
 614
 615     if ((parent = con_by_frame_id(event->window)) == NULL) {
 616         LOG("expose event for unknown window, ignoring\n");
 617         return 1;
 618     }
 619
 620     if (parent->window)
 621         x_draw_decoration(parent);
 622
 623     TAILQ_FOREACH(con, &(parent->nodes_head), nodes) {
 624         DLOG("expose for con %p / %s\n", con, con->name);
 625         if (con->window)
 626             x_draw_decoration(con);
 627     }
 628
 629     /* We also need to render the decorations of other Cons nearby the Con
 630      * itself to not get overlapping decorations */
 631     TAILQ_FOREACH(con, &(parent->parent->nodes_head), nodes) {
 632         DLOG("expose for con %p / %s\n", con, con->name);
 633         if (con->window)
 634             x_draw_decoration(con);
 635     }
 636     xcb_flush(conn);
 637
 638     return 1;
 639 }
 640
 641 /*
 642  * Handle client messages (EWMH)
 643  *
 644  */
 645 int handle_client_message(void *data, xcb_connection_t *conn, xcb_client_message_event_t *event) {
 646     LOG("ClientMessage for window 0x%08x\n", event->window);
 647     if (event->type == atoms[_NET_WM_STATE]) {
 648         if (event->format != 32 || event->data.data32[1] != atoms[_NET_WM_STATE_FULLSCREEN]) {
 649             DLOG("atom in clientmessage is %d, fullscreen is %d\n",
 650                     event->data.data32[1], atoms[_NET_WM_STATE_FULLSCREEN]);
 651             DLOG("not about fullscreen atom\n");
 652             return 0;
 653         }
 654
 655         Con *con = con_by_window_id(event->window);
 656         if (con == NULL) {
 657             DLOG("Could not get window for client message\n");
 658             return 0;
 659         }
 660
 661         /* Check if the fullscreen state should be toggled */
 662         if ((con->fullscreen_mode != CF_NONE &&
 663              (event->data.data32[0] == _NET_WM_STATE_REMOVE ||
 664               event->data.data32[0] == _NET_WM_STATE_TOGGLE)) ||
 665             (con->fullscreen_mode == CF_NONE &&
 666              (event->data.data32[0] == _NET_WM_STATE_ADD ||
 667               event->data.data32[0] == _NET_WM_STATE_TOGGLE))) {
 668             DLOG("toggling fullscreen\n");
 669             con_toggle_fullscreen(con);
 670         }
 671
 672         tree_render();
 673         x_push_changes(croot);
 674     } else {
 675         ELOG("unhandled clientmessage\n");
 676         return 0;
 677     }
 678
 679     return 1;
 680 }
 681
 682 #if 0
 683 int handle_window_type(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
 684                         xcb_atom_t atom, xcb_get_property_reply_t *property) {
 685         /* TODO: Implement this one. To do this, implement a little test program which sleep(1)s
 686          before changing this property. */
 687         ELOG("_NET_WM_WINDOW_TYPE changed, this is not yet implemented.\n");
 688         return 0;
 689 }
 690 #endif
 691
 692 /*
 693  * Handles the size hints set by a window, but currently only the part necessary for displaying
 694  * clients proportionally inside their frames (mplayer for example)
 695  *
 696  * See ICCCM 4.1.2.3 for more details
 697  *
 698  */
 699 int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
 700                         xcb_atom_t name, xcb_get_property_reply_t *reply) {
 701     Con *con = con_by_window_id(window);
 702     if (con == NULL) {
 703         DLOG("Received WM_NORMAL_HINTS for unknown client\n");
 704         return 1;
 705     }
 706
 707     xcb_size_hints_t size_hints;
 708
 709         //CLIENT_LOG(client);
 710
 711     /* If the hints were already in this event, use them, if not, request them */
 712     if (reply != NULL)
 713         xcb_get_wm_size_hints_from_reply(&size_hints, reply);
 714     else
 715         xcb_get_wm_normal_hints_reply(conn, xcb_get_wm_normal_hints_unchecked(conn, con->window->id), &size_hints, NULL);
 716
 717     if ((size_hints.flags & XCB_SIZE_HINT_P_MIN_SIZE)) {
 718         // TODO: Minimum size is not yet implemented
 719         DLOG("Minimum size: %d (width) x %d (height)\n", size_hints.min_width, size_hints.min_height);
 720     }
 721
 722     bool changed = false;
 723     if ((size_hints.flags & XCB_SIZE_HINT_P_RESIZE_INC)) {
 724         if (size_hints.width_inc > 0 && size_hints.width_inc < 0xFFFF)
 725             if (con->width_increment != size_hints.width_inc) {
 726                 con->width_increment = size_hints.width_inc;
 727                 changed = true;
 728             }
 729         if (size_hints.height_inc > 0 && size_hints.height_inc < 0xFFFF)
 730             if (con->height_increment != size_hints.height_inc) {
 731                 con->height_increment = size_hints.height_inc;
 732                 changed = true;
 733             }
 734
 735         if (changed)
 736             DLOG("resize increments changed\n");
 737     }
 738
 739     int base_width = 0, base_height = 0;
 740
 741     /* base_width/height are the desired size of the window.
 742        We check if either the program-specified size or the program-specified
 743        min-size is available */
 744     if (size_hints.flags & XCB_SIZE_HINT_BASE_SIZE) {
 745         base_width = size_hints.base_width;
 746         base_height = size_hints.base_height;
 747     } else if (size_hints.flags & XCB_SIZE_HINT_P_MIN_SIZE) {
 748         /* TODO: is this right? icccm says not */
 749         base_width = size_hints.min_width;
 750         base_height = size_hints.min_height;
 751     }
 752
 753     if (base_width != con->base_width ||
 754         base_height != con->base_height) {
 755         con->base_width = base_width;
 756         con->base_height = base_height;
 757         DLOG("client's base_height changed to %d\n", base_height);
 758         DLOG("client's base_width changed to %d\n", base_width);
 759     }
 760
 761     /* If no aspect ratio was set or if it was invalid, we ignore the hints */
 762     if (!(size_hints.flags & XCB_SIZE_HINT_P_ASPECT) ||
 763         (size_hints.min_aspect_num <= 0) ||
 764         (size_hints.min_aspect_den <= 0)) {
 765         goto render_and_return;
 766     }
 767
 768     /* XXX: do we really use rect here, not window_rect? */
 769     double width = con->rect.width - base_width;
 770     double height = con->rect.height - base_height;
 771     /* Convert numerator/denominator to a double */
 772     double min_aspect = (double)size_hints.min_aspect_num / size_hints.min_aspect_den;
 773     double max_aspect = (double)size_hints.max_aspect_num / size_hints.min_aspect_den;
 774
 775     DLOG("Aspect ratio set: minimum %f, maximum %f\n", min_aspect, max_aspect);
 776     DLOG("width = %f, height = %f\n", width, height);
 777
 778     /* Sanity checks, this is user-input, in a way */
 779     if (max_aspect <= 0 || min_aspect <= 0 || height == 0 || (width / height) <= 0)
 780         goto render_and_return;
 781
 782     /* Check if we need to set proportional_* variables using the correct ratio */
 783     if ((width / height) < min_aspect) {
 784         con->proportional_width = width;
 785         con->proportional_height = width / min_aspect;
 786     } else if ((width / height) > max_aspect) {
 787         con->proportional_width = width;
 788         con->proportional_height = width / max_aspect;
 789     } else goto render_and_return;
 790
 791 render_and_return:
 792     tree_render();
 793     return 1;
 794 }
 795
 796 /*
 797  * Handles the WM_HINTS property for extracting the urgency state of the window.
 798  *
 799  */
 800 int handle_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
 801                   xcb_atom_t name, xcb_get_property_reply_t *reply) {
 802     Con *con = con_by_window_id(window);
 803     if (con == NULL) {
 804         DLOG("Received WM_HINTS for unknown client\n");
 805         return 1;
 806     }
 807
 808     xcb_wm_hints_t hints;
 809
 810     if (reply != NULL) {
 811         if (!xcb_get_wm_hints_from_reply(&hints, reply))
 812             return 1;
 813     } else {
 814         if (!xcb_get_wm_hints_reply(conn, xcb_get_wm_hints_unchecked(conn, con->window->id), &hints, NULL))
 815             return 1;
 816     }
 817
 818     if (!con->urgent && focused == con) {
 819         DLOG("Ignoring urgency flag for current client\n");
 820         return 1;
 821     }
 822
 823     /* Update the flag on the client directly */
 824     con->urgent = (xcb_wm_hints_get_urgency(&hints) != 0);
 825     //CLIENT_LOG(con);
 826     LOG("Urgency flag changed to %d\n", con->urgent);
 827
 828     workspace_update_urgent_flag(con_get_workspace(con));
 829
 830 #if 0
 831     /* If the workspace this client is on is not visible, we need to redraw
 832      * the workspace bar */
 833     if (!workspace_is_visible(client->workspace)) {
 834             Output *output = client->workspace->output;
 835             render_workspace(conn, output, output->current_workspace);
 836             xcb_flush(conn);
 837     }
 838 #endif
 839
 840     return 1;
 841 }
 842
 843 /*
 844  * Handles the transient for hints set by a window, signalizing that this window is a popup window
 845  * for some other window.
 846  *
 847  * See ICCCM 4.1.2.6 for more details
 848  *
 849  */
 850 int handle_transient_for(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
 851                          xcb_atom_t name, xcb_get_property_reply_t *prop) {
 852     Con *con;
 853
 854     if ((con = con_by_window_id(window)) == NULL || con->window == NULL) {
 855         DLOG("No such window\n");
 856         return 1;
 857     }
 858
 859     if (prop == NULL) {
 860         prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
 861                                 false, window, WM_TRANSIENT_FOR, WINDOW, 0, 32), NULL);
 862         if (prop == NULL)
 863             return 1;
 864     }
 865
 866     window_update_transient_for(con->window, prop);
 867
 868     // TODO: put window in floating mode if con->window->transient_for != XCB_NONE:
 869 #if 0
 870     if (client->floating == FLOATING_AUTO_OFF) {
 871         DLOG("This is a popup window, putting into floating\n");
 872         toggle_floating_mode(conn, client, true);
 873     }
 874 #endif
 875
 876     return 1;
 877 }
 878
 879 /*
 880  * Handles changes of the WM_CLIENT_LEADER atom which specifies if this is a
 881  * toolwindow (or similar) and to which window it belongs (logical parent).
 882  *
 883  */
 884 int handle_clientleader_change(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
 885                         xcb_atom_t name, xcb_get_property_reply_t *prop) {
 886     Con *con;
 887     if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
 888         return 1;
 889
 890     if (prop == NULL) {
 891         prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
 892                                 false, window, WM_CLIENT_LEADER, WINDOW, 0, 32), NULL);
 893         if (prop == NULL)
 894             return 1;
 895     }
 896
 897     window_update_leader(con->window, prop);
 898
 899     return 1;
 900 }