X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcon.c;h=aefe756ccddd831dc7c59a39393491e32d382ff5;hb=884214f14fdbd0a4a368d2a36d5e50324fa1d52a;hp=14948cc6c2155eb40874f1b494cf0fd3b7540913;hpb=2e4a2d4f303d38909e59501cc54a708b82406f8d;p=i3%2Fi3

diff --git a/src/con.c b/src/con.c
index 14948cc6..aefe756c 100644
--- a/src/con.c
+++ b/src/con.c
@@ -4,7 +4,7 @@
  * vim:ts=4:sw=4:expandtab
  *
  * i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
  *
  * con.c: Functions which deal with containers directly (creating containers,
  *        searching containers, getting specific properties from containers,
@@ -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) {
@@ -60,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));
@@ -91,20 +70,10 @@ Con *con_new(Con *parent, i3Window *window) {
     return new;
 }
 
-/*
- * Attaches the given container to the given parent. This happens when moving
- * a container or when inserting a new container at a specific place in the
- * tree.
- *
- * ignore_focus is to just insert the Con at the end (useful when creating a
- * new split container *around* some containers, that is, detaching and
- * attaching them in order without wanting to mess with the focus in between).
- *
- */
-void con_attach(Con *con, Con *parent, bool ignore_focus) {
+static void _con_attach(Con *con, Con *parent, Con *previous, bool ignore_focus) {
     con->parent = parent;
     Con *loop;
-    Con *current = NULL;
+    Con *current = previous;
     struct nodes_head *nodes_head = &(parent->nodes_head);
     struct focus_head *focus_head = &(parent->focus_head);
 
@@ -130,7 +99,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;
@@ -175,10 +145,10 @@ void con_attach(Con *con, Con *parent, bool ignore_focus) {
         /* Insert the container after the tiling container, if found.
          * When adding to a CT_OUTPUT, just append one after another. */
         if (current && parent->type != CT_OUTPUT) {
-            DLOG("Inserting con = %p after last focused tiling con %p\n",
-                 con, current);
+            DLOG("Inserting con = %p after 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:
@@ -189,6 +159,20 @@ add_to_focus_head:
     con_force_split_parents_redraw(con);
 }
 
+/*
+ * Attaches the given container to the given parent. This happens when moving
+ * a container or when inserting a new container at a specific place in the
+ * tree.
+ *
+ * ignore_focus is to just insert the Con at the end (useful when creating a
+ * new split container *around* some containers, that is, detaching and
+ * attaching them in order without wanting to mess with the focus in between).
+ *
+ */
+void con_attach(Con *con, Con *parent, bool ignore_focus) {
+    _con_attach(con, parent, NULL, ignore_focus);
+}
+
 /*
  * Detaches the given container from its current parent
  *
@@ -230,6 +214,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);
     }
 }
 
@@ -246,10 +231,7 @@ bool con_is_leaf(Con *con) {
  * 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);
+    return (con != NULL && con->window != NULL && con->window->id != XCB_WINDOW_NONE && con_get_workspace(con) != NULL);
 }
 
 /**
@@ -463,8 +445,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;
 }
 
@@ -476,8 +458,23 @@ 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)
+    if (con->frame == frame)
+        return con;
+    return NULL;
+}
+
+/*
+ * Returns the container with the given mark or NULL if no such container
+ * exists.
+ *
+ */
+Con *con_by_mark(const char *mark) {
+    Con *con;
+    TAILQ_FOREACH(con, &all_cons, all_cons) {
+        if (con->mark != NULL && strcmp(con->mark, mark) == 0)
             return con;
+    }
+
     return NULL;
 }
 
@@ -530,7 +527,7 @@ int con_num_children(Con *con) {
     int children = 0;
 
     TAILQ_FOREACH(child, &(con->nodes_head), nodes)
-        children++;
+    children++;
 
     return children;
 }
@@ -563,7 +560,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);
             }
         }
     }
@@ -572,10 +570,10 @@ 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;
     }
 }
 
@@ -586,37 +584,27 @@ void con_fix_percent(Con *con) {
  *
  */
 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);
 
@@ -640,27 +628,86 @@ void con_toggle_fullscreen(Con *con, int fullscreen_mode) {
 }
 
 /*
- * Moves the given container to the currently focused container on the given
- * workspace.
+ * Enables fullscreen mode for the given container, if necessary.
  *
- * The fix_coordinates flag will translate the current coordinates (offset from
- * the monitor position basically) to appropriate coordinates on the
- * destination workspace.
- * Not enabling this behaviour comes in handy when this function gets called by
- * floating_maybe_reassign_ws, which will only "move" a floating window when it
- * *already* changed its coordinates to a different output.
+ * 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.
  *
- * The dont_warp flag disables pointer warping and will be set when this
- * function is called while dragging a floating window.
+ * Other fullscreen containers will be disabled first, if they hide the new
+ * one.
  *
- * TODO: is there a better place for this function?
+ */
+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_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp) {
+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);
+}
+
+static bool _con_move_to_con(Con *con, Con *target, bool behind_focused, bool fix_coordinates, bool dont_warp) {
+    Con *orig_target = target;
+
     /* Prevent moving if this would violate the fullscreen focus restrictions. */
-    if (!con_fullscreen_permits_focusing(workspace)) {
+    Con *target_ws = con_get_workspace(target);
+    if (!con_fullscreen_permits_focusing(target_ws)) {
         LOG("Cannot move out of a fullscreen container");
-        return;
+        return false;
     }
 
     if (con_is_floating(con)) {
@@ -669,63 +716,59 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
     }
 
     Con *source_ws = con_get_workspace(con);
-    if (workspace == source_ws) {
-        DLOG("Not moving, already there\n");
-        return;
-    }
 
     if (con->type == CT_WORKSPACE) {
         /* Re-parent all of the old workspace's floating windows. */
         Con *child;
         while (!TAILQ_EMPTY(&(source_ws->floating_head))) {
             child = TAILQ_FIRST(&(source_ws->floating_head));
-            con_move_to_workspace(child, workspace, true, true);
+            con_move_to_workspace(child, target_ws, true, true);
         }
 
         /* If there are no non-floating children, ignore the workspace. */
         if (con_is_leaf(con))
-            return;
+            return false;
 
         con = workspace_encapsulate(con);
         if (con == NULL) {
             ELOG("Workspace failed to move its contents into a container!\n");
-            return;
+            return false;
         }
     }
 
+    /* Save the urgency state so that we can restore it. */
+    bool urgent = con->urgent;
+
     /* Save the current workspace. So we can call workspace_show() by the end
      * of this function. */
     Con *current_ws = con_get_workspace(focused);
 
     Con *source_output = con_get_output(con),
-        *dest_output = con_get_output(workspace);
+        *dest_output = con_get_output(target_ws);
 
     /* 1: save the container which is going to be focused after the current
      * container is moved away */
     Con *focus_next = con_next_focused(con);
 
-    /* 2: get the focused container of this workspace */
-    Con *next = con_descend_focused(workspace);
-
-    /* 3: we go up one level, but only when next is a normal container */
-    if (next->type != CT_WORKSPACE) {
-        DLOG("next originally = %p / %s / type %d\n", next, next->name, next->type);
-        next = next->parent;
+    /* 2: we go up one level, but only when target is a normal container */
+    if (target->type != CT_WORKSPACE) {
+        DLOG("target originally = %p / %s / type %d\n", target, target->name, target->type);
+        target = target->parent;
     }
 
-    /* 4: if the target container is floating, we get the workspace instead.
+    /* 3: if the target container is floating, we get the workspace instead.
      * Only tiling windows need to get inserted next to the current container.
      * */
-    Con *floatingcon = con_inside_floating(next);
+    Con *floatingcon = con_inside_floating(target);
     if (floatingcon != NULL) {
         DLOG("floatingcon, going up even further\n");
-        next = floatingcon->parent;
+        target = floatingcon->parent;
     }
 
     if (con->type == CT_FLOATING_CON) {
-        Con *ws = con_get_workspace(next);
+        Con *ws = con_get_workspace(target);
         DLOG("This is a floating window, using workspace %p / %s\n", ws, ws->name);
-        next = ws;
+        target = ws;
     }
 
     if (source_output != dest_output) {
@@ -733,13 +776,14 @@ 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
          * if focused container is in its area. */
-        if (workspace_is_visible(workspace)) {
-            workspace_show(workspace);
+        if (workspace_is_visible(target_ws)) {
+            workspace_show(target_ws);
 
             /* Don’t warp if told so (when dragging floating windows with the
              * mouse for example) */
@@ -752,29 +796,29 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
 
     /* If moving a fullscreen container and the destination already has a
      * fullscreen window on it, un-fullscreen the target's fullscreen con. */
-    Con *fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT);
+    Con *fullscreen = con_get_fullscreen_con(target_ws, CF_OUTPUT);
     if (con->fullscreen_mode != CF_NONE && fullscreen != NULL) {
         con_toggle_fullscreen(fullscreen, CF_OUTPUT);
         fullscreen = NULL;
     }
 
-    DLOG("Re-attaching container to %p / %s\n", next, next->name);
-    /* 5: re-attach the con to the parent of this focused container */
+    DLOG("Re-attaching container to %p / %s\n", target, target->name);
+    /* 4: re-attach the con to the parent of this focused container */
     Con *parent = con->parent;
     con_detach(con);
-    con_attach(con, next, false);
+    _con_attach(con, target, behind_focused ? NULL : orig_target, !behind_focused);
 
-    /* 6: fix the percentages */
+    /* 5: fix the percentages */
     con_fix_percent(parent);
     con->percent = 0.0;
-    con_fix_percent(next);
+    con_fix_percent(target);
 
-    /* 7: focus the con on the target workspace, but only within that
+    /* 6: focus the con on the target workspace, but only within that
      * workspace, that is, don’t move focus away if the target workspace is
      * invisible.
      * We don’t focus the con for i3 pseudo workspaces like __i3_scratch and
      * we don’t focus when there is a fullscreen con on that workspace. */
-    if (!con_is_internal(workspace) && !fullscreen) {
+    if (!con_is_internal(target_ws) && !fullscreen) {
         /* We need to save the focused workspace on the output in case the
          * new workspace is hidden and it's necessary to immediately switch
          * back to the originally-focused workspace. */
@@ -786,7 +830,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
             con_focus(old_focus);
     }
 
-    /* 8: when moving to another workspace, we leave the focus on the current
+    /* 7: when moving to another workspace, we leave the focus on the current
      * workspace. (see also #809) */
 
     /* Descend focus stack in case focus_next is a workspace which can
@@ -797,9 +841,9 @@ 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,
+    /* 8. If anything within the container is associated with a startup sequence,
      * delete it so child windows won't be created on the old workspace. */
     struct Startup_Sequence *sequence;
     xcb_get_property_cookie_t cookie;
@@ -812,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);
@@ -823,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);
@@ -832,6 +876,79 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool
     }
 
     CALL(parent, on_remove_child);
+
+    /* 9. If the container was marked urgent, move the urgency hint. */
+    if (urgent) {
+        workspace_update_urgent_flag(source_ws);
+        con_set_urgency(con, true);
+    }
+
+    ipc_send_window_event("move", con);
+    return true;
+}
+
+/*
+ * Moves the given container to the given mark.
+ *
+ */
+bool con_move_to_mark(Con *con, const char *mark) {
+    Con *target = con_by_mark(mark);
+    if (target == NULL) {
+        DLOG("found no container with mark \"%s\"\n", mark);
+        return false;
+    }
+
+    /* For floating target containers, we just send the window to the same workspace. */
+    if (con_is_floating(target)) {
+        DLOG("target container is floating, moving container to target's workspace.\n");
+        con_move_to_workspace(con, con_get_workspace(target), true, false);
+        return true;
+    }
+
+    /* For split containers, we use the currently focused container within it.
+     * This allows setting marks on, e.g., tabbed containers which will move
+     * con to a new tab behind the focused tab. */
+    if (con_is_split(target)) {
+        DLOG("target is a split container, descending to the currently focused child.\n");
+        target = TAILQ_FIRST(&(target->focus_head));
+    }
+
+    if (con == target) {
+        DLOG("cannot move the container to itself, aborting.\n");
+        return false;
+    }
+
+    return _con_move_to_con(con, target, false, true, false);
+}
+
+/*
+ * Moves the given container to the currently focused container on the given
+ * workspace.
+ *
+ * The fix_coordinates flag will translate the current coordinates (offset from
+ * the monitor position basically) to appropriate coordinates on the
+ * destination workspace.
+ * Not enabling this behaviour comes in handy when this function gets called by
+ * floating_maybe_reassign_ws, which will only "move" a floating window when it
+ * *already* changed its coordinates to a different output.
+ *
+ * The dont_warp flag disables pointer warping and will be set when this
+ * function is called while dragging a floating window.
+ *
+ * TODO: is there a better place for this function?
+ *
+ */
+void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp) {
+    assert(workspace->type == CT_WORKSPACE);
+
+    Con *source_ws = con_get_workspace(con);
+    if (workspace == source_ws) {
+        DLOG("Not moving, already there\n");
+        return;
+    }
+
+    Con *target = con_descend_focused(workspace);
+    _con_move_to_con(con, target, true, fix_coordinates, dont_warp);
 }
 
 /*
@@ -1032,7 +1149,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
@@ -1056,7 +1174,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
@@ -1101,10 +1220,10 @@ Rect con_border_style_rect(Con *con) {
     /* 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)};
     }
@@ -1112,7 +1231,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;
@@ -1129,7 +1248,6 @@ Rect con_border_style_rect(Con *con) {
         result.height += border_width;
     }
     return result;
-
 }
 
 /*
@@ -1262,9 +1380,15 @@ void con_set_layout(Con *con, layout_t 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");
@@ -1293,11 +1417,7 @@ void con_set_layout(Con *con, layout_t layout) {
          * with an orientation). Since we switched to splith/splitv layouts,
          * using the "default" layout (which "only" should happen when using
          * legacy configs) is using the last split layout (either splith or
-         * splitv) in order to still do the same thing.
-         *
-         * Starting from v4.6 though, we will nag users about using "layout
-         * default", and in v4.9 we will remove it entirely (with an
-         * appropriate i3-migrate-config mechanism). */
+         * splitv) in order to still do the same thing. */
         con->layout = con->last_split_layout;
         /* In case last_split_layout was not initialized… */
         if (con->layout == L_DEFAULT)
@@ -1333,7 +1453,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)
@@ -1341,7 +1462,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
@@ -1349,7 +1471,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);
             }
@@ -1380,8 +1503,15 @@ 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;
     }
@@ -1410,7 +1540,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) {
@@ -1430,7 +1560,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)
@@ -1450,7 +1580,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",
@@ -1506,7 +1636,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
@@ -1593,14 +1723,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);
+    }
 }
 
 /*
@@ -1652,7 +1784,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;
     }