X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcon.c;h=b610b0c60c1c9cfb792d107a7ff6d05acdc27487;hb=56f420c3ddc12e9c4bf8c8cca324a8d2da0fb475;hp=79872f9251d64fa7cd4aabd07b8a1be2a4d55bb5;hpb=70d28bc7afb013de718969371d3a3671de4a9bfc;p=i3%2Fi3

diff --git a/src/con.c b/src/con.c
index 79872f92..b610b0c6 100644
--- a/src/con.c
+++ b/src/con.c
@@ -12,19 +12,7 @@
  *
  */
 #include "all.h"
-
-char *colors[] = {
-    "#ff0000",
-    "#00FF00",
-    "#0000FF",
-    "#ff00ff",
-    "#00ffff",
-    "#ffff00",
-    "#aa0000",
-    "#00aa00",
-    "#0000aa",
-    "#aa00aa"
-};
+#include "yajl_utils.h"
 
 static void con_on_remove_child(Con *con);
 
@@ -32,7 +20,7 @@ static void con_on_remove_child(Con *con);
  * force parent split containers to be redrawn
  *
  */
-static void con_force_split_parents_redraw(Con *con) {
+void con_force_split_parents_redraw(Con *con) {
     Con *parent = con;
 
     while (parent && parent->type != CT_WORKSPACE && parent->type != CT_DOCKAREA) {
@@ -51,6 +39,7 @@ Con *con_new_skeleton(Con *parent, i3Window *window) {
     Con *new = scalloc(sizeof(Con));
     new->on_remove_child = con_on_remove_child;
     TAILQ_INSERT_TAIL(&all_cons, new, all_cons);
+    new->aspect_ratio = 0.0;
     new->type = CT_CON;
     new->window = window;
     new->border_style = config.default_border;
@@ -59,16 +48,7 @@ Con *con_new_skeleton(Con *parent, i3Window *window) {
         new->depth = window->depth;
     else
         new->depth = XCB_COPY_FROM_PARENT;
-    static int cnt = 0;
-    DLOG("opening window %d\n", cnt);
-
-    /* TODO: remove window coloring after test-phase */
-    DLOG("color %s\n", colors[cnt]);
-    new->name = strdup(colors[cnt]);
-    //uint32_t cp = get_colorpixel(colors[cnt]);
-    cnt++;
-    if ((cnt % (sizeof(colors) / sizeof(char*))) == 0)
-        cnt = 0;
+    DLOG("opening window\n");
 
     TAILQ_INIT(&(new->floating_head));
     TAILQ_INIT(&(new->nodes_head));
@@ -129,7 +109,8 @@ void con_attach(Con *con, Con *parent, bool ignore_focus) {
                 /* we need to insert con after current, if current is not NULL */
                 if (current)
                     TAILQ_INSERT_BEFORE(current, con, nodes);
-                else TAILQ_INSERT_TAIL(nodes_head, con, nodes);
+                else
+                    TAILQ_INSERT_TAIL(nodes_head, con, nodes);
             }
         }
         goto add_to_focus_head;
@@ -177,7 +158,8 @@ void con_attach(Con *con, Con *parent, bool ignore_focus) {
             DLOG("Inserting con = %p after last focused tiling con %p\n",
                  con, current);
             TAILQ_INSERT_AFTER(nodes_head, current, con, nodes);
-        } else TAILQ_INSERT_TAIL(nodes_head, con, nodes);
+        } else
+            TAILQ_INSERT_TAIL(nodes_head, con, nodes);
     }
 
 add_to_focus_head:
@@ -229,6 +211,7 @@ void con_focus(Con *con) {
         con->urgent = false;
         con_update_parents_urgency(con);
         workspace_update_urgent_flag(con_get_workspace(con));
+        ipc_send_window_event("urgent", con);
     }
 }
 
@@ -240,6 +223,14 @@ bool con_is_leaf(Con *con) {
     return TAILQ_EMPTY(&(con->nodes_head));
 }
 
+/*
+ * Returns true when this con is a leaf node with a managed X11 window (e.g.,
+ * excluding dock containers)
+ */
+bool con_has_managed_window(Con *con) {
+    return (con != NULL && con->window != NULL && con->window->id != XCB_WINDOW_NONE && con_get_workspace(con) != NULL);
+}
+
 /**
  * Returns true if this node has regular or floating children.
  *
@@ -352,7 +343,7 @@ struct bfs_entry {
  * Returns the first fullscreen node below this node.
  *
  */
-Con *con_get_fullscreen_con(Con *con, int fullscreen_mode) {
+Con *con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode) {
     Con *current, *child;
 
     /* TODO: is breadth-first-search really appropriate? (check as soon as
@@ -451,8 +442,8 @@ bool con_inside_focused(Con *con) {
 Con *con_by_window_id(xcb_window_t window) {
     Con *con;
     TAILQ_FOREACH(con, &all_cons, all_cons)
-        if (con->window != NULL && con->window->id == window)
-            return con;
+    if (con->window != NULL && con->window->id == window)
+        return con;
     return NULL;
 }
 
@@ -464,8 +455,8 @@ Con *con_by_window_id(xcb_window_t window) {
 Con *con_by_frame_id(xcb_window_t frame) {
     Con *con;
     TAILQ_FOREACH(con, &all_cons, all_cons)
-        if (con->frame == frame)
-            return con;
+    if (con->frame == frame)
+        return con;
     return NULL;
 }
 
@@ -518,7 +509,7 @@ int con_num_children(Con *con) {
     int children = 0;
 
     TAILQ_FOREACH(child, &(con->nodes_head), nodes)
-        children++;
+    children++;
 
     return children;
 }
@@ -551,7 +542,8 @@ void con_fix_percent(Con *con) {
             if (child->percent <= 0.0) {
                 if (children_with_percent == 0)
                     total += (child->percent = 1.0);
-                else total += (child->percent = total / children_with_percent);
+                else
+                    total += (child->percent = total / children_with_percent);
             }
         }
     }
@@ -560,53 +552,47 @@ void con_fix_percent(Con *con) {
     // distribute according to the proportions we got
     if (total == 0.0) {
         TAILQ_FOREACH(child, &(con->nodes_head), nodes)
-            child->percent = 1.0 / children;
+        child->percent = 1.0 / children;
     } else if (total != 1.0) {
         TAILQ_FOREACH(child, &(con->nodes_head), nodes)
-            child->percent /= total;
+        child->percent /= total;
     }
 }
 
 /*
- * Toggles fullscreen mode for the given container. Fullscreen mode will not be
- * entered when there already is a fullscreen container on this workspace.
+ * Toggles fullscreen mode for the given container. If there already is a
+ * fullscreen container on this workspace, fullscreen will be disabled and then
+ * enabled for the container the user wants to have in fullscreen mode.
  *
  */
 void con_toggle_fullscreen(Con *con, int fullscreen_mode) {
-    Con *workspace, *fullscreen;
-
     if (con->type == CT_WORKSPACE) {
         DLOG("You cannot make a workspace fullscreen.\n");
         return;
     }
 
     DLOG("toggling fullscreen for %p / %s\n", con, con->name);
-    if (con->fullscreen_mode == CF_NONE) {
-        /* 1: check if there already is a fullscreen con */
-        if (fullscreen_mode == CF_GLOBAL)
-            fullscreen = con_get_fullscreen_con(croot, CF_GLOBAL);
-        else {
-            workspace = con_get_workspace(con);
-            fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT);
-        }
-        if (fullscreen != NULL) {
-            /* Disable fullscreen for the currently fullscreened
-             * container and enable it for the one the user wants
-             * to have in fullscreen mode. */
-            LOG("Disabling fullscreen for (%p/%s) upon user request\n",
-                fullscreen, fullscreen->name);
-            fullscreen->fullscreen_mode = CF_NONE;
-        }
 
-        /* 2: enable fullscreen */
-        con->fullscreen_mode = fullscreen_mode;
-    } else {
-        /* 1: disable fullscreen */
-        con->fullscreen_mode = CF_NONE;
-    }
+    if (con->fullscreen_mode == CF_NONE)
+        con_enable_fullscreen(con, fullscreen_mode);
+    else
+        con_disable_fullscreen(con);
+}
+
+/*
+ * Sets the specified fullscreen mode for the given container, sends the
+ * “fullscreen_mode” event and changes the XCB fullscreen property of the
+ * container’s window, if any.
+ *
+ */
+static void con_set_fullscreen_mode(Con *con, fullscreen_mode_t fullscreen_mode) {
+    con->fullscreen_mode = fullscreen_mode;
 
     DLOG("mode now: %d\n", con->fullscreen_mode);
 
+    /* Send an ipc window "fullscreen_mode" event */
+    ipc_send_window_event("fullscreen_mode", con);
+
     /* update _NET_WM_STATE if this container has a window */
     /* TODO: when a window is assigned to a container which is already
      * fullscreened, this state needs to be pushed to the client, too */
@@ -623,6 +609,79 @@ void con_toggle_fullscreen(Con *con, int fullscreen_mode) {
                         A__NET_WM_STATE, XCB_ATOM_ATOM, 32, num, values);
 }
 
+/*
+ * Enables fullscreen mode for the given container, if necessary.
+ *
+ * If the container’s mode is already CF_OUTPUT or CF_GLOBAL, the container is
+ * kept fullscreen but its mode is set to CF_GLOBAL and CF_OUTPUT,
+ * respectively.
+ *
+ * Other fullscreen containers will be disabled first, if they hide the new
+ * one.
+ *
+ */
+void con_enable_fullscreen(Con *con, fullscreen_mode_t fullscreen_mode) {
+    if (con->type == CT_WORKSPACE) {
+        DLOG("You cannot make a workspace fullscreen.\n");
+        return;
+    }
+
+    assert(fullscreen_mode == CF_GLOBAL || fullscreen_mode == CF_OUTPUT);
+
+    if (fullscreen_mode == CF_GLOBAL)
+        DLOG("enabling global fullscreen for %p / %s\n", con, con->name);
+    else
+        DLOG("enabling fullscreen for %p / %s\n", con, con->name);
+
+    if (con->fullscreen_mode == fullscreen_mode) {
+        DLOG("fullscreen already enabled for %p / %s\n", con, con->name);
+        return;
+    }
+
+    Con *con_ws = con_get_workspace(con);
+
+    /* Disable any fullscreen container that would conflict the new one. */
+    Con *fullscreen = con_get_fullscreen_con(croot, CF_GLOBAL);
+    if (fullscreen == NULL)
+        fullscreen = con_get_fullscreen_con(con_ws, CF_OUTPUT);
+    if (fullscreen != NULL)
+        con_disable_fullscreen(fullscreen);
+
+    /* Set focus to new fullscreen container. Unless in global fullscreen mode
+     * and on another workspace restore focus afterwards.
+     * Switch to the container’s workspace if mode is global. */
+    Con *cur_ws = con_get_workspace(focused);
+    Con *old_focused = focused;
+    if (fullscreen_mode == CF_GLOBAL && cur_ws != con_ws)
+        workspace_show(con_ws);
+    con_focus(con);
+    if (fullscreen_mode != CF_GLOBAL && cur_ws != con_ws)
+        con_focus(old_focused);
+
+    con_set_fullscreen_mode(con, fullscreen_mode);
+}
+
+/*
+ * Disables fullscreen mode for the given container regardless of the mode, if
+ * necessary.
+ *
+ */
+void con_disable_fullscreen(Con *con) {
+    if (con->type == CT_WORKSPACE) {
+        DLOG("You cannot make a workspace fullscreen.\n");
+        return;
+    }
+
+    DLOG("disabling fullscreen for %p / %s\n", con, con->name);
+
+    if (con->fullscreen_mode == CF_NONE) {
+        DLOG("fullscreen already disabled for %p / %s\n", con, con->name);
+        return;
+    }
+
+    con_set_fullscreen_mode(con, CF_NONE);
+}
+
 /*
  * Moves the given container to the currently focused container on the given
  * workspace.
@@ -717,7 +776,8 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
          * to the coordinate space of the correct output */
         if (fix_coordinates && con->type == CT_FLOATING_CON) {
             floating_fix_coordinates(con, &(source_output->rect), &(dest_output->rect));
-        } else DLOG("Not fixing coordinates, fix_coordinates flag = %d\n", fix_coordinates);
+        } else
+            DLOG("Not fixing coordinates, fix_coordinates flag = %d\n", fix_coordinates);
 
         /* If moving to a visible workspace, call show so it can be considered
          * focused. Must do before attaching because workspace_show checks to see
@@ -781,7 +841,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
     /* Set focus only if con was on current workspace before moving.
      * Otherwise we would give focus to some window on different workspace. */
     if (source_ws == current_ws)
-            con_focus(con_descend_focused(focus_next));
+        con_focus(con_descend_focused(focus_next));
 
     /* If anything within the container is associated with a startup sequence,
      * delete it so child windows won't be created on the old workspace. */
@@ -796,7 +856,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
                 continue;
 
             cookie = xcb_get_property(conn, false, child->window->id,
-                A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512);
+                                      A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512);
             startup_id_reply = xcb_get_property_reply(conn, cookie, NULL);
 
             sequence = startup_sequence_get(child->window, startup_id_reply, true);
@@ -807,7 +867,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
 
     if (con->window) {
         cookie = xcb_get_property(conn, false, con->window->id,
-            A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512);
+                                  A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512);
         startup_id_reply = xcb_get_property_reply(conn, cookie, NULL);
 
         sequence = startup_sequence_get(con->window, startup_id_reply, true);
@@ -816,6 +876,8 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
     }
 
     CALL(parent, on_remove_child);
+
+    ipc_send_window_event("move", con);
 }
 
 /*
@@ -824,7 +886,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
  * container).
  *
  */
-int con_orientation(Con *con) {
+orientation_t con_orientation(Con *con) {
     switch (con->layout) {
         case L_SPLITV:
         /* stacking containers behave like they are in vertical orientation */
@@ -1016,7 +1078,8 @@ Con *con_descend_direction(Con *con, direction_t direction) {
              * (D_RIGHT) or the last con (D_LEFT) */
             if (direction == D_RIGHT)
                 most = TAILQ_FIRST(&(con->nodes_head));
-            else most = TAILQ_LAST(&(con->nodes_head), nodes_head);
+            else
+                most = TAILQ_LAST(&(con->nodes_head), nodes_head);
         } else if (orientation == VERT) {
             /* Wrong orientation. We use the last focused con. Within that con,
              * we recurse to chose the left/right con or at least the last
@@ -1040,7 +1103,8 @@ Con *con_descend_direction(Con *con, direction_t direction) {
              * (D_DOWN) or the last con (D_UP) */
             if (direction == D_UP)
                 most = TAILQ_LAST(&(con->nodes_head), nodes_head);
-            else most = TAILQ_FIRST(&(con->nodes_head));
+            else
+                most = TAILQ_FIRST(&(con->nodes_head));
         } else if (orientation == HORIZ) {
             /* Wrong orientation. We use the last focused con. Within that con,
              * we recurse to chose the top/bottom con or at least the last
@@ -1074,16 +1138,21 @@ Rect con_border_style_rect(Con *con) {
     int border_width = con->current_border_width;
     DLOG("The border width for con is set to: %d\n", con->current_border_width);
     Rect result;
-    if (con->current_border_width < 0)
-        border_width = config.default_border_width;
+    if (con->current_border_width < 0) {
+        if (con_is_floating(con)) {
+            border_width = config.default_floating_border_width;
+        } else {
+            border_width = config.default_border_width;
+        }
+    }
     DLOG("Effective border width is set to: %d\n", border_width);
     /* Shortcut to avoid calling con_adjacent_borders() on dock containers. */
     int border_style = con_border_style(con);
     if (border_style == BS_NONE)
-        return (Rect){ 0, 0, 0, 0 };
+        return (Rect){0, 0, 0, 0};
     borders_to_hide = con_adjacent_borders(con) & config.hide_edge_borders;
     if (border_style == BS_NORMAL) {
-        result = (Rect){border_width, 0 , -(2 * border_width), -(border_width)};
+        result = (Rect){border_width, 0, -(2 * border_width), -(border_width)};
     } else {
         result = (Rect){border_width, border_width, -(2 * border_width), -(2 * border_width)};
     }
@@ -1091,7 +1160,7 @@ Rect con_border_style_rect(Con *con) {
     /* Floating windows are never adjacent to any other window, so
        don’t hide their border(s). This prevents bug #998. */
     if (con_is_floating(con))
-      return result;
+        return result;
 
     if (borders_to_hide & ADJ_LEFT_SCREEN_EDGE) {
         result.x -= border_width;
@@ -1108,7 +1177,6 @@ Rect con_border_style_rect(Con *con) {
         result.height += border_width;
     }
     return result;
-
 }
 
 /*
@@ -1173,34 +1241,30 @@ void con_set_border_style(Con *con, int border_style, int border_width) {
 
     /* For floating containers, we want to keep the position/size of the
      * *window* itself. We first add the border pixels to con->rect to make
-     * con->rect represent the absolute position of the window. Then, we change
-     * the border and subtract the new border pixels. Afterwards, we update
-     * parent->rect to contain con. */
+     * con->rect represent the absolute position of the window (same for
+     * parent). Then, we change the border style and subtract the new border
+     * pixels. For the parent, we do the same also for the decoration. */
     DLOG("This is a floating container\n");
 
+    Con *parent = con->parent;
     Rect bsr = con_border_style_rect(con);
-    con->rect.x += bsr.x;
-    con->rect.y += bsr.y;
-    con->rect.width += bsr.width;
-    con->rect.height += bsr.height;
+    int deco_height = (con->border_style == BS_NORMAL ? render_deco_height() : 0);
+
+    con->rect = rect_add(con->rect, bsr);
+    parent->rect = rect_add(parent->rect, bsr);
+    parent->rect.y += deco_height;
+    parent->rect.height -= deco_height;
 
     /* Change the border style, get new border/decoration values. */
     con->border_style = border_style;
     con->current_border_width = border_width;
     bsr = con_border_style_rect(con);
-    int deco_height =
-        (con->border_style == BS_NORMAL ? render_deco_height() : 0);
-
-    con->rect.x -= bsr.x;
-    con->rect.y -= bsr.y;
-    con->rect.width -= bsr.width;
-    con->rect.height -= bsr.height;
+    deco_height = (con->border_style == BS_NORMAL ? render_deco_height() : 0);
 
-    Con *parent = con->parent;
-    parent->rect.x = con->rect.x;
-    parent->rect.y = con->rect.y - deco_height;
-    parent->rect.width = con->rect.width;
-    parent->rect.height = con->rect.height + deco_height;
+    con->rect = rect_sub(con->rect, bsr);
+    parent->rect = rect_sub(parent->rect, bsr);
+    parent->rect.y -= deco_height;
+    parent->rect.height += deco_height;
 }
 
 /*
@@ -1209,7 +1273,7 @@ void con_set_border_style(Con *con, int border_style, int border_width) {
  * new split container before).
  *
  */
-void con_set_layout(Con *con, int layout) {
+void con_set_layout(Con *con, layout_t layout) {
     DLOG("con_set_layout(%p, %d), con->type = %d\n",
          con, layout, con->type);
 
@@ -1245,9 +1309,15 @@ void con_set_layout(Con *con, int layout) {
             new->layout = layout;
             new->last_split_layout = con->last_split_layout;
 
+            /* Save the container that was focused before we move containers
+             * around, but only if the container is visible (otherwise focus
+             * will be restored properly automatically when switching). */
             Con *old_focused = TAILQ_FIRST(&(con->focus_head));
             if (old_focused == TAILQ_END(&(con->focus_head)))
                 old_focused = NULL;
+            if (old_focused != NULL &&
+                !workspace_is_visible(con_get_workspace(old_focused)))
+                old_focused = NULL;
 
             /* 3: move the existing cons of this workspace below the new con */
             DLOG("Moving cons\n");
@@ -1316,7 +1386,8 @@ void con_toggle_layout(Con *con, const char *toggle_mode) {
         else {
             if (parent->layout == L_SPLITH)
                 con_set_layout(con, L_SPLITV);
-            else con_set_layout(con, L_SPLITH);
+            else
+                con_set_layout(con, L_SPLITH);
         }
     } else {
         if (parent->layout == L_STACKED)
@@ -1324,7 +1395,8 @@ void con_toggle_layout(Con *con, const char *toggle_mode) {
         else if (parent->layout == L_TABBED) {
             if (strcmp(toggle_mode, "all") == 0)
                 con_set_layout(con, L_SPLITH);
-            else con_set_layout(con, parent->last_split_layout);
+            else
+                con_set_layout(con, parent->last_split_layout);
         } else if (parent->layout == L_SPLITH || parent->layout == L_SPLITV) {
             if (strcmp(toggle_mode, "all") == 0) {
                 /* When toggling through all modes, we toggle between
@@ -1332,7 +1404,8 @@ void con_toggle_layout(Con *con, const char *toggle_mode) {
                  * stacked. */
                 if (parent->layout == L_SPLITH)
                     con_set_layout(con, L_SPLITV);
-                else con_set_layout(con, L_STACKED);
+                else
+                    con_set_layout(con, L_STACKED);
             } else {
                 con_set_layout(con, L_STACKED);
             }
@@ -1353,8 +1426,9 @@ static void con_on_remove_child(Con *con) {
      * not be closed when the last child was removed */
     if (con->type == CT_OUTPUT ||
         con->type == CT_ROOT ||
-        con->type == CT_DOCKAREA) {
-        DLOG("not handling, type = %d\n", con->type);
+        con->type == CT_DOCKAREA ||
+        (con->parent != NULL && con->parent->type == CT_OUTPUT)) {
+        DLOG("not handling, type = %d, name = %s\n", con->type, con->name);
         return;
     }
 
@@ -1362,13 +1436,22 @@ static void con_on_remove_child(Con *con) {
     if (con->type == CT_WORKSPACE) {
         if (TAILQ_EMPTY(&(con->focus_head)) && !workspace_is_visible(con)) {
             LOG("Closing old workspace (%p / %s), it is empty\n", con, con->name);
+            yajl_gen gen = ipc_marshal_workspace_event("empty", con, NULL);
             tree_close(con, DONT_KILL_WINDOW, false, false);
-            ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"empty\"}");
+
+            const unsigned char *payload;
+            ylength length;
+            y(get_buf, &payload, &length);
+            ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, (const char *)payload);
+
+            y(free);
         }
         return;
     }
 
     con_force_split_parents_redraw(con);
+    con->urgent = con_has_urgent_child(con);
+    con_update_parents_urgency(con);
 
     /* TODO: check if this container would swallow any other client and
      * don’t close it automatically. */
@@ -1390,7 +1473,7 @@ Rect con_minimum_size(Con *con) {
 
     if (con_is_leaf(con)) {
         DLOG("leaf node, returning 75x50\n");
-        return (Rect){ 0, 0, 75, 50 };
+        return (Rect){0, 0, 75, 50};
     }
 
     if (con->type == CT_FLOATING_CON) {
@@ -1410,7 +1493,7 @@ Rect con_minimum_size(Con *con) {
         }
         DLOG("stacked/tabbed now, returning %d x %d + deco_rect = %d\n",
              max_width, max_height, deco_height);
-        return (Rect){ 0, 0, max_width, max_height + deco_height };
+        return (Rect){0, 0, max_width, max_height + deco_height};
     }
 
     /* For horizontal/vertical split containers we sum up the width (h-split)
@@ -1430,7 +1513,7 @@ Rect con_minimum_size(Con *con) {
             }
         }
         DLOG("split container, returning width = %d x height = %d\n", width, height);
-        return (Rect){ 0, 0, width, height };
+        return (Rect){0, 0, width, height};
     }
 
     ELOG("Unhandled case, type = %d, layout = %d, split = %d\n",
@@ -1486,7 +1569,7 @@ bool con_fullscreen_permits_focusing(Con *con) {
      * sufficient to guarantee that change won't leave fullscreen in bad shape. */
     if (fs->fullscreen_mode == CF_OUTPUT &&
         con_get_workspace(con) != con_get_workspace(fs)) {
-            return true;
+        return true;
     }
 
     /* Allow it only if the container to be focused is contained within the
@@ -1573,14 +1656,16 @@ void con_set_urgency(Con *con, bool urgent) {
 
     con_update_parents_urgency(con);
 
-    if (con->urgent == urgent)
-        LOG("Urgency flag changed to %d\n", con->urgent);
-
     Con *ws;
     /* Set the urgency flag on the workspace, if a workspace could be found
      * (for dock clients, that is not the case). */
     if ((ws = con_get_workspace(con)) != NULL)
         workspace_update_urgent_flag(ws);
+
+    if (con->urgent == urgent) {
+        LOG("Urgency flag changed to %d\n", con->urgent);
+        ipc_send_window_event("urgent", con);
+    }
 }
 
 /*
@@ -1632,7 +1717,7 @@ char *con_get_tree_representation(Con *con) {
 
         char *tmp_buf;
         sasprintf(&tmp_buf, "%s%s%s", buf,
-                (TAILQ_FIRST(&(con->nodes_head)) == child ? "" : " "), child_txt);
+                  (TAILQ_FIRST(&(con->nodes_head)) == child ? "" : " "), child_txt);
         free(buf);
         buf = tmp_buf;
     }