Merge pull request #2040 from Airblader/bug-2034

[i3/i3] / src / con.c

diff --git a/src/con.c b/src/con.c
index 7a8ccd5830f9a0ad519c85b9498f7c937fadecca..bd002d35ca245517372ef7f5f38ec1c7973a60ef 100644 (file)
--- a/src/con.c
+++ b/src/con.c
@@ -55,6 +55,7 @@ Con *con_new_skeleton(Con *parent, i3Window *window) {
     TAILQ_INIT(&(new->nodes_head));
     TAILQ_INIT(&(new->focus_head));
     TAILQ_INIT(&(new->swallow_head));
+    TAILQ_INIT(&(new->marks_head));
 
     if (parent != NULL)
         con_attach(new, parent, false);
@@ -447,6 +448,20 @@ bool con_is_floating(Con *con) {
     return (con->floating >= FLOATING_AUTO_ON);
 }
 
+/*
+ * Returns true if the container is a docked container.
+ *
+ */
+bool con_is_docked(Con *con) {
+    if (con->parent == NULL)
+        return false;
+
+    if (con->parent->type == CT_DOCKAREA)
+        return true;
+
+    return con_is_docked(con->parent);
+}
+
 /*
  * Checks if the given container is either floating or inside some floating
  * container. It returns the FLOATING_CON container.
@@ -512,13 +527,121 @@ Con *con_by_frame_id(xcb_window_t frame) {
 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)
+        if (con_has_mark(con, mark))
             return con;
     }
 
     return NULL;
 }
 
+/*
+ * Returns true if and only if the given containers holds the mark.
+ *
+ */
+bool con_has_mark(Con *con, const char *mark) {
+    mark_t *current;
+    TAILQ_FOREACH(current, &(con->marks_head), marks) {
+        if (strcmp(current->name, mark) == 0)
+            return true;
+    }
+
+    return false;
+}
+
+/*
+ * Toggles the mark on a container.
+ * If the container already has this mark, the mark is removed.
+ * Otherwise, the mark is assigned to the container.
+ *
+ */
+void con_mark_toggle(Con *con, const char *mark, mark_mode_t mode) {
+    assert(con != NULL);
+    DLOG("Toggling mark \"%s\" on con = %p.\n", mark, con);
+
+    if (con_has_mark(con, mark)) {
+        con_unmark(con, mark);
+    } else {
+        con_mark(con, mark, mode);
+    }
+}
+
+/*
+ * Assigns a mark to the container.
+ *
+ */
+void con_mark(Con *con, const char *mark, mark_mode_t mode) {
+    assert(con != NULL);
+    DLOG("Setting mark \"%s\" on con = %p.\n", mark, con);
+
+    con_unmark(NULL, mark);
+    if (mode == MM_REPLACE) {
+        DLOG("Removing all existing marks on con = %p.\n", con);
+
+        mark_t *current;
+        TAILQ_FOREACH(current, &(con->marks_head), marks) {
+            con_unmark(con, current->name);
+        }
+    }
+
+    mark_t *new = scalloc(1, sizeof(mark_t));
+    new->name = sstrdup(mark);
+    TAILQ_INSERT_TAIL(&(con->marks_head), new, marks);
+
+    con->mark_changed = true;
+}
+
+/*
+ * Removes marks from containers.
+ * If con is NULL, all containers are considered.
+ * If name is NULL, this removes all existing marks.
+ * Otherwise, it will only remove the given mark (if it is present).
+ *
+ */
+void con_unmark(Con *con, const char *name) {
+    Con *current;
+    if (name == NULL) {
+        DLOG("Unmarking all containers.\n");
+        TAILQ_FOREACH(current, &all_cons, all_cons) {
+            if (con != NULL && current != con)
+                continue;
+
+            if (TAILQ_EMPTY(&(current->marks_head)))
+                continue;
+
+            mark_t *mark;
+            while (!TAILQ_EMPTY(&(current->marks_head))) {
+                mark = TAILQ_FIRST(&(current->marks_head));
+                FREE(mark->name);
+                TAILQ_REMOVE(&(current->marks_head), mark, marks);
+                FREE(mark);
+            }
+
+            current->mark_changed = true;
+        }
+    } else {
+        DLOG("Removing mark \"%s\".\n", name);
+        current = (con == NULL) ? con_by_mark(name) : con;
+        if (current == NULL) {
+            DLOG("No container found with this mark, so there is nothing to do.\n");
+            return;
+        }
+
+        DLOG("Found mark on con = %p. Removing it now.\n", current);
+        current->mark_changed = true;
+
+        mark_t *mark;
+        TAILQ_FOREACH(mark, &(current->marks_head), marks) {
+            if (strcmp(mark->name, name) != 0)
+                continue;
+
+            FREE(mark->name);
+            TAILQ_REMOVE(&(current->marks_head), mark, marks);
+            FREE(mark);
+            break;
+        }
+    }
+}
+
 /*
  * Returns the first container below 'con' which wants to swallow this window
  * TODO: priority
@@ -658,14 +781,13 @@ static void con_set_fullscreen_mode(Con *con, fullscreen_mode_t fullscreen_mode)
     if (con->window == NULL)
         return;
 
-    uint32_t values[1];
-    unsigned int num = 0;
-
-    if (con->fullscreen_mode != CF_NONE)
-        values[num++] = A__NET_WM_STATE_FULLSCREEN;
-
-    xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->window->id,
-                        A__NET_WM_STATE, XCB_ATOM_ATOM, 32, num, values);
+    if (con->fullscreen_mode != CF_NONE) {
+        DLOG("Setting _NET_WM_STATE_FULLSCREEN for con = %p / window = %d.\n", con, con->window->id);
+        xcb_add_property_atom(conn, con->window->id, A__NET_WM_STATE, A__NET_WM_STATE_FULLSCREEN);
+    } else {
+        DLOG("Removing _NET_WM_STATE_FULLSCREEN for con = %p / window = %d.\n", con, con->window->id);
+        xcb_remove_property_atom(conn, con->window->id, A__NET_WM_STATE, A__NET_WM_STATE_FULLSCREEN);
+    }
 }
 
 /*
@@ -948,6 +1070,12 @@ bool con_move_to_mark(Con *con, const char *mark) {
         return true;
     }
 
+    if (con->type == CT_WORKSPACE) {
+        DLOG("target container is a workspace, simply moving the container there.\n");
+        con_move_to_workspace(con, target, true, false, 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. */
@@ -956,8 +1084,8 @@ bool con_move_to_mark(Con *con, const char *mark) {
         target = TAILQ_FIRST(&(target->focus_head));
     }
 
-    if (con == target) {
-        DLOG("cannot move the container to itself, aborting.\n");
+    if (con == target || con == target->parent) {
+        DLOG("cannot move the container to or inside itself, aborting.\n");
         return false;
     }