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

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  */
   4
   5 #include "all.h"
   6 #include "cmdparse.tab.h"
   7
   8 typedef enum { BEFORE, AFTER } position_t;
   9
  10 /*
  11  * This function detaches 'con' from its parent and inserts it either before or
  12  * after 'target'.
  13  *
  14  */
  15 static void insert_con_into(Con *con, Con *target, position_t position) {
  16     Con *parent = target->parent;
  17     /* We need to preserve the old con->parent. While it might still be used to
  18      * insert the entry before/after it, we call the on_remove_child callback
  19      * afterwards which might then close the con if it is empty. */
  20     Con *old_parent = con->parent;
  21
  22     con_detach(con);
  23     con_fix_percent(con->parent);
  24
  25     con->parent = parent;
  26
  27     if (position == BEFORE) {
  28         TAILQ_INSERT_BEFORE(target, con, nodes);
  29         TAILQ_INSERT_HEAD(&(parent->focus_head), con, focused);
  30     } else if (position == AFTER) {
  31         TAILQ_INSERT_AFTER(&(parent->nodes_head), target, con, nodes);
  32         TAILQ_INSERT_HEAD(&(parent->focus_head), con, focused);
  33     }
  34
  35     /* Pretend the con was just opened with regards to size percent values.
  36      * Since the con is moved to a completely different con, the old value
  37      * does not make sense anyways. */
  38     con->percent = 0.0;
  39     con_fix_percent(parent);
  40
  41     CALL(old_parent, on_remove_child);
  42 }
  43
  44 /*
  45  * This function detaches 'con' from its parent and inserts it at the given
  46  * workspace.
  47  *
  48  */
  49 static void attach_to_workspace(Con *con, Con *ws) {
  50     con_detach(con);
  51     con_fix_percent(con->parent);
  52
  53     CALL(con->parent, on_remove_child);
  54
  55     con->parent = ws;
  56
  57     TAILQ_INSERT_TAIL(&(ws->nodes_head), con, nodes);
  58     TAILQ_INSERT_TAIL(&(ws->focus_head), con, focused);
  59
  60     /* Pretend the con was just opened with regards to size percent values.
  61      * Since the con is moved to a completely different con, the old value
  62      * does not make sense anyways. */
  63     con->percent = 0.0;
  64     con_fix_percent(ws);
  65 }
  66
  67 /*
  68  * Moves the current container in the given direction (TOK_LEFT, TOK_RIGHT,
  69  * TOK_UP, TOK_DOWN from cmdparse.l)
  70  *
  71  */
  72 void tree_move(int direction) {
  73     DLOG("Moving in direction %d\n", direction);
  74     /* 1: get the first parent with the same orientation */
  75     Con *con = focused;
  76
  77     if (con->type == CT_WORKSPACE) {
  78         DLOG("Not moving workspace\n");
  79         return;
  80     }
  81
  82     if (con->parent->type == CT_WORKSPACE && con_num_children(con->parent) == 1) {
  83         DLOG("This is the only con on this workspace, not doing anything\n");
  84         return;
  85     }
  86
  87     orientation_t o = (direction == TOK_LEFT || direction == TOK_RIGHT ? HORIZ : VERT);
  88
  89     Con *same_orientation = con_parent_with_orientation(con, o);
  90     /* There is no parent container with the same orientation */
  91     if (!same_orientation) {
  92         if (con_is_floating(con)) {
  93             /* this is a floating con, we just disable floating */
  94             floating_disable(con, true);
  95             return;
  96         }
  97         if (con_inside_floating(con)) {
  98             /* 'con' should be moved out of a floating container */
  99             DLOG("Inside floating, moving to workspace\n");
 100             attach_to_workspace(con, con_get_workspace(con));
 101             goto end;
 102         }
 103         DLOG("Force-changing orientation\n");
 104         ws_force_orientation(con_get_workspace(con), o);
 105         same_orientation = con_parent_with_orientation(con, o);
 106     }
 107
 108     /* easy case: the move is within this container */
 109     if (same_orientation == con->parent) {
 110         DLOG("We are in the same container\n");
 111         Con *swap;
 112         if (!(swap = (direction == TOK_LEFT || direction == TOK_UP ?
 113                       TAILQ_PREV(con, nodes_head, nodes) :
 114                       TAILQ_NEXT(con, nodes))))
 115             return;
 116
 117         if (!con_is_leaf(swap)) {
 118             insert_con_into(con, con_descend_focused(swap), AFTER);
 119             goto end;
 120         }
 121         if (direction == TOK_LEFT || direction == TOK_UP)
 122             TAILQ_SWAP(swap, con, &(swap->parent->nodes_head), nodes);
 123         else TAILQ_SWAP(con, swap, &(swap->parent->nodes_head), nodes);
 124
 125         TAILQ_REMOVE(&(con->parent->focus_head), con, focused);
 126         TAILQ_INSERT_HEAD(&(swap->parent->focus_head), con, focused);
 127
 128         DLOG("Swapped.\n");
 129         return;
 130     }
 131
 132     /* this time, we have to move to another container */
 133     /* This is the container *above* 'con' which is inside 'same_orientation' */
 134     Con *above = con;
 135     while (above->parent != same_orientation)
 136         above = above->parent;
 137
 138     DLOG("above = %p\n", above);
 139     Con *next;
 140     position_t position;
 141     if (direction == TOK_UP || direction == TOK_LEFT) {
 142         position = BEFORE;
 143         next = TAILQ_PREV(above, nodes_head, nodes);
 144     } else if (direction == TOK_DOWN || direction == TOK_RIGHT) {
 145         position = AFTER;
 146         next = TAILQ_NEXT(above, nodes);
 147     }
 148
 149     /* special case: there is a split container in the direction we are moving
 150      * to, so descend and append */
 151     if (next && !con_is_leaf(next))
 152         insert_con_into(con, con_descend_focused(next), AFTER);
 153     else
 154         insert_con_into(con, above, position);
 155
 156 end:
 157     /* We need to call con_focus() to fix the focus stack "above" the container
 158      * we just inserted the focused container into (otherwise, the parent
 159      * container(s) would still point to the old container(s)). */
 160     con_focus(con);
 161
 162     tree_flatten(croot);
 163 }