add tilingHEADmaster

1 files changed, 989 insertions, 0 deletions

diff --git a/openbox/tiling.c b/openbox/tiling.c
new file mode 100644
index 00000000..ec24b0df
--- /dev/null
+++ b/openbox/tiling.c
@@ -0,0 +1,989 @@
+#include "tiling.h"
+#include "client.h"
+#include "config.h"
+#include "event.h"
+#include "focus.h"
+#include "frame.h"
+#include "moveresize.h"
+#include "openbox.h"
+#include "popup.h"
+#include "screen.h"
+#include "stacking.h"
+#include "window.h"
+#include "obt/display.h"
+#include "obt/prop.h"
+#include "obrender/render.h"
+
+#define MAX_TILES 32
+#define DROP_EDGE_PERCENT 10
+#define OUTLINE_WIDTH 3
+#define SHARE_SCALE 10000
+
+typedef struct _TileLayout TileLayout;
+
+typedef struct {
+    ObClient *client;
+    TileLayout *layout;
+    guint stack;
+    guint row;
+    gdouble height_weight;
+    Rect saved;
+    Rect pre_max;
+    gboolean max_horz;
+    gboolean max_vert;
+    gboolean snapped_left;
+    gboolean snapped_right;
+} Tile;
+
+struct _TileLayout {
+    guint monitor;
+    guint desktop;
+    gboolean enabled;
+    gboolean main_right;
+    guint main_share;
+    guint count[2];
+    Tile *slots[2][MAX_TILES];
+};
+
+static GList *layouts;
+static GList *tiles;
+static ObClient *keys[12];
+static ObInternalWindow outline[4];
+static guint pending;
+static gboolean arranging;
+static ObClient *preview_client;
+static gint preview_x;
+static gint preview_y;
+static ObClient *resize_client;
+static guint resize_share;
+static gint resize_client_width;
+static gint resize_column_width;
+static gint resize_client_height;
+static gint resize_client_y;
+static guint resize_count;
+static Tile *resize_members[MAX_TILES];
+static gdouble resize_weights[MAX_TILES];
+static gint resize_heights[MAX_TILES];
+static ObPopup *notification;
+static guint notification_timer;
+static gchar *notification_text;
+
+static gboolean hide_notification(gpointer data)
+{
+    popup_hide(notification);
+    notification_timer = 0;
+    return FALSE;
+}
+
+static void show_notification(guint monitor, const gchar *text)
+{
+    const Rect *area;
+
+    if (!config_desktop_popup_time || monitor >= screen_num_monitors)
+        return;
+    if (!notification) {
+        notification = popup_new();
+        popup_height(notification, POPUP_HEIGHT);
+        popup_set_text_align(notification, RR_JUSTIFY_CENTER);
+    }
+    if (notification_timer)
+        g_source_remove(notification_timer);
+    g_free(notification_text);
+    notification_text = g_strdup(text);
+    area = screen_physical_area_monitor(monitor);
+    popup_position(notification, CenterGravity,
+                    area->x + area->width / 2, area->y + area->height / 2);
+    popup_max_width(notification, MIN(area->width,
+                                      MAX(area->width / 3, POPUP_WIDTH)));
+    OBT_PROP_SETS(notification->bg, NET_WM_NAME, notification_text);
+    popup_show(notification, notification_text);
+    notification_timer = g_timeout_add(config_desktop_popup_time,
+                                       hide_notification, NULL);
+}
+
+static Tile *find_tile(ObClient *client)
+{
+    GList *it;
+
+    for (it = tiles; it; it = it->next) {
+        Tile *tile = it->data;
+        if (tile->client == client)
+            return tile;
+    }
+    return NULL;
+}
+
+static TileLayout *find_layout(guint monitor, guint desktop, gboolean create)
+{
+    GList *it;
+    TileLayout *layout;
+
+    if (monitor >= screen_num_monitors || desktop >= screen_num_desktops)
+        return NULL;
+    for (it = layouts; it; it = it->next) {
+        layout = it->data;
+        if (layout->monitor == monitor && layout->desktop == desktop)
+            return layout;
+    }
+    if (!create)
+        return NULL;
+    layout = g_new0(TileLayout, 1);
+    layout->monitor = monitor;
+    layout->desktop = desktop;
+    layout->main_share = SHARE_SCALE * 3 / 5;
+    layout->count[0] = layout->count[1] = 1;
+    layouts = g_list_append(layouts, layout);
+    return layout;
+}
+
+static gboolean eligible(ObClient *client)
+{
+    return client && client->managed && client->frame &&
+        client->type == OB_CLIENT_TYPE_NORMAL && !client->transient &&
+        !client->above && !client->fullscreen && !client->iconic &&
+        !client->shaded && client->desktop != DESKTOP_ALL &&
+        (client->functions & OB_CLIENT_FUNC_MOVE) &&
+        (client->functions & OB_CLIENT_FUNC_RESIZE);
+}
+
+static Rect slot_area_for_count(TileLayout *layout, guint stack, guint row,
+                                guint count)
+{
+    Rect *work = screen_area(layout->desktop, layout->monitor, NULL);
+    Rect result = *work;
+    gint split = ((gint64)work->width * layout->main_share + SHARE_SCALE / 2) /
+        SHARE_SCALE;
+    gdouble total = 0, before = 0, through = 0;
+    guint i;
+    gint top, bottom;
+
+    for (i = 0; i < count; ++i) {
+        Tile *tile = layout->slots[stack][i];
+        gdouble weight = tile ? tile->height_weight : 1.0;
+
+        total += weight;
+        if (i < row)
+            before += weight;
+        if (i <= row)
+            through += weight;
+    }
+    top = work->height * before / total;
+    bottom = row + 1 == count ? work->height : work->height * through / total;
+
+    if (layout->main_right) {
+        if (stack == 0) {
+            result.x += work->width - split;
+            result.width = split;
+        } else
+            result.width = work->width - split;
+    } else {
+        if (stack == 0)
+            result.width = split;
+        else {
+            result.x += split;
+            result.width -= split;
+        }
+    }
+    result.y += top;
+    result.height = bottom - top;
+    g_slice_free(Rect, work);
+    return result;
+}
+
+static Rect slot_area(TileLayout *layout, guint stack, guint row)
+{
+    return slot_area_for_count(layout, stack, row, layout->count[stack]);
+}
+
+static void hide_outline(void)
+{
+    guint i;
+    gulong serial;
+
+    if (!outline[0].window)
+        return;
+    serial = event_start_ignore_all_enters();
+
+    for (i = 0; i < G_N_ELEMENTS(outline); ++i)
+        if (outline[i].window)
+            XUnmapWindow(obt_display, outline[i].window);
+    event_end_ignore_all_enters(serial);
+}
+
+static void show_outline(const Rect *area)
+{
+    guint i;
+    Rect edges[4];
+    XSetWindowAttributes attr;
+    gulong serial = event_start_ignore_all_enters();
+    gint border = MIN(OUTLINE_WIDTH, MIN(area->width, area->height));
+
+    RECT_SET(edges[0], area->x, area->y, area->width, border);
+    RECT_SET(edges[1], area->x, area->y, border, area->height);
+    RECT_SET(edges[2], area->x + area->width - border, area->y,
+             border, area->height);
+    RECT_SET(edges[3], area->x, area->y + area->height - border,
+             area->width, border);
+    attr.override_redirect = True;
+    attr.background_pixel = WhitePixel(obt_display, ob_screen);
+    for (i = 0; i < G_N_ELEMENTS(outline); ++i) {
+        if (!outline[i].window) {
+            outline[i].type = OB_WINDOW_CLASS_INTERNAL;
+            outline[i].window = XCreateWindow(
+                obt_display, obt_root(ob_screen), 0, 0, 1, 1, 0,
+                CopyFromParent, InputOutput, CopyFromParent,
+                CWOverrideRedirect | CWBackPixel, &attr);
+            stacking_add(INTERNAL_AS_WINDOW(&outline[i]));
+        }
+        XMoveResizeWindow(obt_display, outline[i].window,
+                          edges[i].x, edges[i].y,
+                          edges[i].width, edges[i].height);
+        XMapWindow(obt_display, outline[i].window);
+        stacking_raise(INTERNAL_AS_WINDOW(&outline[i]));
+    }
+    event_end_ignore_all_enters(serial);
+}
+
+static void remove_tile(Tile *tile, gboolean restore)
+{
+    ObClient *client = tile->client;
+
+    tile->layout->slots[tile->stack][tile->row] = NULL;
+    tiles = g_list_remove(tiles, tile);
+    if (restore && client->managed) {
+        if (client->fullscreen) {
+            client->pre_fullscreen_area = tile->saved;
+            client->pre_fullscreen_max_horz = tile->max_horz;
+            client->pre_fullscreen_max_vert = tile->max_vert;
+            if (tile->max_horz) {
+                client->pre_fullscreen_area.x = tile->pre_max.x;
+                client->pre_fullscreen_area.width = tile->pre_max.width;
+            }
+            if (tile->max_vert) {
+                client->pre_fullscreen_area.y = tile->pre_max.y;
+                client->pre_fullscreen_area.height = tile->pre_max.height;
+            }
+        } else {
+            client_configure(client, tile->saved.x, tile->saved.y,
+                             tile->saved.width, tile->saved.height,
+                             TRUE, TRUE, FALSE);
+            if (tile->max_horz)
+                client_maximize(client, TRUE, 1);
+            if (tile->max_vert)
+                client_maximize(client, TRUE, 2);
+        }
+        client->pre_max_area = tile->pre_max;
+        client->snapped_left = tile->snapped_left;
+        client->snapped_right = tile->snapped_right;
+    }
+    g_free(tile);
+}
+
+static gboolean place_tile(Tile *tile)
+{
+    ObClient *client = tile->client;
+    Rect area = slot_area(tile->layout, tile->stack, tile->row);
+    gint x = area.x;
+    gint y = area.y;
+    gint width = MAX(1, area.width - client->frame->size.left -
+                      client->frame->size.right);
+    gint height = MAX(1, area.height - client->frame->size.top -
+                       client->frame->size.bottom);
+    gint logical_width, logical_height;
+
+    frame_frame_gravity(client->frame, &x, &y);
+    client_try_configure(client, &x, &y, &width, &height,
+                         &logical_width, &logical_height, TRUE);
+    if (width + client->frame->size.left + client->frame->size.right >
+        area.width ||
+        height + client->frame->size.top + client->frame->size.bottom >
+        area.height)
+        return FALSE;
+    client_configure(client, x, y, width, height, TRUE, TRUE, FALSE);
+    return TRUE;
+}
+
+static void compact_stack(TileLayout *layout, guint stack)
+{
+    guint row, next = 0;
+
+    for (row = 0; row < layout->count[stack]; ++row) {
+        Tile *tile = layout->slots[stack][row];
+
+        layout->slots[stack][row] = NULL;
+        if (tile) {
+            tile->row = next;
+            layout->slots[stack][next++] = tile;
+        }
+    }
+    layout->count[stack] = MAX(1, next);
+}
+
+static void queue_arrange(void);
+
+static gboolean arrange(gpointer data)
+{
+    GList *it, *next;
+    gboolean retry = FALSE;
+
+    pending = 0;
+    arranging = TRUE;
+    for (it = tiles; it; it = next) {
+        Tile *tile = it->data;
+        ObClient *client = tile->client;
+        TileLayout *layout = tile->layout;
+        next = it->next;
+
+        if (moveresize_in_progress && moveresize_client == client)
+            continue;
+        if (!layout->enabled || layout->monitor >= screen_num_monitors ||
+            layout->desktop >= screen_num_desktops) {
+            remove_tile(tile, TRUE);
+            continue;
+        }
+        if (client->above) {
+            remove_tile(tile, TRUE);
+            continue;
+        }
+        if (client->desktop != layout->desktop) {
+            remove_tile(tile, TRUE);
+            continue;
+        }
+        if (client->iconic || client->fullscreen || client->shaded)
+            continue;
+        if (!eligible(client) || client_monitor(client) != layout->monitor ||
+            client->max_horz || client->max_vert) {
+            remove_tile(tile, FALSE);
+            continue;
+        }
+    }
+    for (it = layouts; it; it = it->next) {
+        TileLayout *layout = it->data;
+
+        if (layout->enabled) {
+            compact_stack(layout, 0);
+            compact_stack(layout, 1);
+        }
+    }
+    for (it = tiles; it; it = next) {
+        Tile *tile = it->data;
+        next = it->next;
+
+        if (!eligible(tile->client) ||
+            (moveresize_in_progress && moveresize_client == tile->client))
+            continue;
+        if (!place_tile(tile)) {
+            remove_tile(tile, TRUE);
+            retry = TRUE;
+        }
+    }
+    arranging = FALSE;
+    if (retry)
+        queue_arrange();
+    return FALSE;
+}
+
+static void queue_arrange(void)
+{
+    if (!arranging && !pending && layouts)
+        pending = g_idle_add(arrange, NULL);
+}
+
+static Tile *add_tile(ObClient *client, TileLayout *layout,
+                      guint stack, guint row)
+{
+    Tile *tile = g_new0(Tile, 1);
+
+    tile->client = client;
+    tile->layout = layout;
+    tile->stack = stack;
+    tile->row = row;
+    tile->height_weight = 1.0;
+    tile->saved = client->area;
+    tile->pre_max = client->pre_max_area;
+    tile->max_horz = client->max_horz;
+    tile->max_vert = client->max_vert;
+    tile->snapped_left = client->snapped_left;
+    tile->snapped_right = client->snapped_right;
+    client->snapped_left = client->snapped_right = FALSE;
+    if (client->max_horz || client->max_vert)
+        client_maximize(client, FALSE, 0);
+    layout->slots[stack][row] = tile;
+    tiles = g_list_append(tiles, tile);
+    return tile;
+}
+
+static void put_client(ObClient *client, TileLayout *layout,
+                       guint stack, guint row)
+{
+    Tile *tile = find_tile(client);
+    Tile *displaced = layout->slots[stack][row];
+
+    if (tile == displaced && tile) {
+        stacking_raise(CLIENT_AS_WINDOW(client));
+        return;
+    }
+    if (displaced && (displaced->client->fullscreen ||
+                      displaced->client->iconic || displaced->client->shaded)) {
+        remove_tile(displaced, TRUE);
+        displaced = NULL;
+    }
+    if (tile) {
+        TileLayout *old = tile->layout;
+        guint old_stack = tile->stack;
+        guint old_row = tile->row;
+
+        old->slots[old_stack][old_row] = displaced;
+        if (displaced) {
+            displaced->layout = old;
+            displaced->stack = old_stack;
+            displaced->row = old_row;
+            if (place_tile(displaced))
+                stacking_raise(CLIENT_AS_WINDOW(displaced->client));
+        }
+        tile->layout = layout;
+        tile->stack = stack;
+        tile->row = row;
+        layout->slots[stack][row] = tile;
+    } else {
+        if (displaced)
+            remove_tile(displaced, TRUE);
+        tile = add_tile(client, layout, stack, row);
+    }
+    if (place_tile(tile))
+        stacking_raise(CLIENT_AS_WINDOW(client));
+    queue_arrange();
+}
+
+static guint stack_members(TileLayout *layout, guint stack, Tile *exclude)
+{
+    guint row, count = 0;
+
+    for (row = 0; row < layout->count[stack]; ++row)
+        if (layout->slots[stack][row] && layout->slots[stack][row] != exclude)
+            ++count;
+    return count;
+}
+
+static void append_client(ObClient *client, TileLayout *layout, guint stack)
+{
+    Tile *tile = find_tile(client);
+    guint row, next = 0;
+    guint count = stack_members(layout, stack, tile);
+
+    if (count == MAX_TILES)
+        return;
+    if (tile)
+        tile->layout->slots[tile->stack][tile->row] = NULL;
+    for (row = 0; row < layout->count[stack]; ++row) {
+        Tile *member = layout->slots[stack][row];
+
+        layout->slots[stack][row] = NULL;
+        if (member) {
+            member->row = next;
+            layout->slots[stack][next++] = member;
+        }
+    }
+    layout->count[stack] = count + 1;
+    if (tile) {
+        tile->layout = layout;
+        tile->stack = stack;
+        tile->row = count;
+        layout->slots[stack][count] = tile;
+    } else
+        tile = add_tile(client, layout, stack, count);
+    if (place_tile(tile))
+        stacking_raise(CLIENT_AS_WINDOW(client));
+    queue_arrange();
+}
+
+static ObClient *next_floating(TileLayout *layout)
+{
+    GList *it;
+
+    if (eligible(focus_client) && !find_tile(focus_client) &&
+        focus_client->desktop == layout->desktop &&
+        client_monitor(focus_client) == layout->monitor)
+        return focus_client;
+    for (it = client_list; it; it = it->next) {
+        ObClient *client = it->data;
+        if (eligible(client) && !find_tile(client) &&
+            client->desktop == layout->desktop &&
+            client_monitor(client) == layout->monitor)
+            return client;
+    }
+    return NULL;
+}
+
+void tiling_toggle(guint monitor)
+{
+    TileLayout *layout = find_layout(monitor, screen_desktop, TRUE);
+    guint stack, row;
+
+    if (!layout || moveresize_in_progress)
+        return;
+    layout->enabled = !layout->enabled;
+    for (stack = 0; stack < 2; ++stack)
+        for (row = 0; row < layout->count[stack]; ++row) {
+            if (!layout->enabled) {
+                if (layout->slots[stack][row])
+                    remove_tile(layout->slots[stack][row], TRUE);
+            } else {
+                ObClient *client = next_floating(layout);
+                if (client)
+                    put_client(client, layout, stack, row);
+            }
+        }
+    queue_arrange();
+    hide_outline();
+    show_notification(monitor, layout->enabled ? "tiling: on" : "tiling: off");
+}
+
+void tiling_flip(guint monitor)
+{
+    TileLayout *layout = find_layout(monitor, screen_desktop, TRUE);
+
+    if (layout && !moveresize_in_progress) {
+        layout->main_right = !layout->main_right;
+        queue_arrange();
+    }
+}
+
+void tiling_change_count(guint monitor, gboolean main_stack, gint delta)
+{
+    TileLayout *layout = find_layout(monitor, screen_desktop, TRUE);
+    guint stack = main_stack ? 0 : 1;
+    guint old, count, row;
+    gchar *message;
+
+    if (!layout || moveresize_in_progress)
+        return;
+    old = layout->count[stack];
+    count = CLAMP((gint)old + CLAMP(delta, -MAX_TILES, MAX_TILES), 1, MAX_TILES);
+    for (row = count; row < old; ++row)
+        if (layout->slots[stack][row])
+            remove_tile(layout->slots[stack][row], TRUE);
+    layout->count[stack] = count;
+    if (layout->enabled)
+        for (row = old; row < count; ++row) {
+            ObClient *client = next_floating(layout);
+            if (client)
+                put_client(client, layout, stack, row);
+        }
+    queue_arrange();
+    if (layout->enabled) {
+        compact_stack(layout, 0);
+        compact_stack(layout, 1);
+    }
+    message = g_strdup_printf("main: %u | side: %u",
+                              layout->count[0], layout->count[1]);
+    show_notification(monitor, message);
+    g_free(message);
+}
+
+void tiling_promote(ObClient *client)
+{
+    TileLayout *layout;
+
+    if (!eligible(client) || moveresize_in_progress)
+        return;
+    layout = find_layout(client_monitor(client), client->desktop, FALSE);
+    if (layout && layout->enabled)
+        put_client(client, layout, 0, 0);
+}
+
+guint tiling_key(ObClient *client)
+{
+    guint i;
+
+    for (i = 0; i < G_N_ELEMENTS(keys); ++i)
+        if (keys[i] == client)
+            return i + 1;
+    return 0;
+}
+
+void tiling_assign(ObClient *client, guint key)
+{
+    guint old;
+    ObClient *previous;
+    gchar *message;
+
+    if (!client || !client->managed || key > G_N_ELEMENTS(keys))
+        return;
+    old = tiling_key(client);
+    if (old)
+        keys[old - 1] = NULL;
+    previous = key ? keys[key - 1] : NULL;
+    if (key)
+        keys[key - 1] = client;
+    if (previous && previous != client)
+        client_update_title(previous);
+    client_update_title(client);
+    message = key ? g_strdup_printf("[F%u] -> %s", key, client->original_title) :
+        g_strdup("window key cleared");
+    show_notification(client_monitor(client), message);
+    g_free(message);
+}
+
+void tiling_recall(guint key)
+{
+    ObClient *client;
+
+    if (!key || key > G_N_ELEMENTS(keys) || moveresize_in_progress)
+        return;
+    client = keys[key - 1];
+    if (client) {
+        client_activate(client, TRUE, FALSE, TRUE, TRUE, TRUE);
+        tiling_promote(client);
+    }
+}
+
+static TileLayout *drop_target(ObClient *client, gint x, gint y,
+                               guint *stack, guint *row, Rect *area)
+{
+    TileLayout *layout;
+    guint monitor;
+    const Rect *physical;
+    gint edge;
+    gboolean right;
+    TileLayout preview;
+    Tile incoming;
+    Tile *moving_tile;
+    guint i, next = 0;
+
+    if (!eligible(client))
+        return NULL;
+    monitor = screen_find_monitor_point(x, y);
+    layout = find_layout(monitor, client->desktop, FALSE);
+    if (!layout || !layout->enabled)
+        return NULL;
+    physical = screen_physical_area_monitor(monitor);
+    if (!RECT_CONTAINS(*physical, x, y))
+        return NULL;
+    edge = MAX(1, physical->width * DROP_EDGE_PERCENT / 100);
+    right = x >= physical->x + physical->width - edge;
+    if (!right && x >= physical->x + edge)
+        return NULL;
+    *stack = right == layout->main_right ? 0 : 1;
+    *row = stack_members(layout, *stack, find_tile(client));
+    if (*row == MAX_TILES)
+        return NULL;
+    preview = *layout;
+    moving_tile = find_tile(client);
+    for (i = 0; i < MAX_TILES; ++i)
+        preview.slots[*stack][i] = NULL;
+    for (i = 0; i < layout->count[*stack]; ++i) {
+        Tile *member = layout->slots[*stack][i];
+
+        if (member && member != moving_tile)
+            preview.slots[*stack][next++] = member;
+    }
+    incoming.height_weight = moving_tile ? moving_tile->height_weight : 1.0;
+    preview.slots[*stack][*row] = &incoming;
+    preview.count[*stack] = *row + 1;
+    *area = slot_area(&preview, *stack, *row);
+    return layout;
+}
+
+gboolean tiling_move_preview(ObClient *client, gint x, gint y)
+{
+    guint stack, row;
+    Rect area;
+    TileLayout *layout = find_layout(screen_find_monitor_point(x, y),
+                                      client->desktop, FALSE);
+
+    preview_client = client;
+    preview_x = x;
+    preview_y = y;
+    if (drop_target(client, x, y, &stack, &row, &area))
+        show_outline(&area);
+    else
+        hide_outline();
+    return find_tile(client) || (layout && layout->enabled);
+}
+
+void tiling_move_end(ObClient *client, gboolean cancel)
+{
+    guint stack, row;
+    Rect area;
+    TileLayout *layout;
+    Tile *tile;
+
+    hide_outline();
+    if (cancel || preview_client != client) {
+        preview_client = NULL;
+        tile = find_tile(client);
+        if (tile)
+            place_tile(tile);
+        return;
+    }
+    layout = drop_target(client, preview_x, preview_y, &stack, &row, &area);
+    preview_client = NULL;
+    if (layout)
+        append_client(client, layout, stack);
+    else {
+        tile = find_tile(client);
+        if (tile)
+            remove_tile(tile, FALSE);
+    }
+    queue_arrange();
+}
+
+void tiling_action_moved(ObClient *client)
+{
+    TileLayout *layout;
+    Tile *tile;
+    Rect *work;
+    gint left, right, edge;
+    guint stack;
+
+    if (!eligible(client) || client->max_horz || client->max_vert ||
+        moveresize_in_progress)
+        return;
+    tile = find_tile(client);
+    layout = find_layout(client_monitor(client), client->desktop, FALSE);
+    if (!layout || !layout->enabled) {
+        if (tile)
+            remove_tile(tile, FALSE);
+        queue_arrange();
+        return;
+    }
+    work = screen_area(layout->desktop, layout->monitor, NULL);
+    left = ABS(client->frame->area.x - work->x);
+    right = ABS(RECT_RIGHT(client->frame->area) - RECT_RIGHT(*work));
+    edge = MAX(1, work->width * DROP_EDGE_PERCENT / 100);
+    g_slice_free(Rect, work);
+    if (MIN(left, right) > edge) {
+        if (tile)
+            remove_tile(tile, FALSE);
+        queue_arrange();
+        return;
+    }
+    stack = (right < left) == layout->main_right ? 0 : 1;
+    if (tile && tile->layout == layout && tile->stack == stack) {
+        stacking_raise(CLIENT_AS_WINDOW(client));
+        queue_arrange();
+    } else
+        append_client(client, layout, stack);
+}
+
+void tiling_resize_begin(ObClient *client)
+{
+    Tile *tile = find_tile(client);
+    guint row;
+
+    resize_client = NULL;
+    if (tile) {
+        Rect area = slot_area(tile->layout, tile->stack, tile->row);
+
+        resize_client = client;
+        resize_share = tile->layout->main_share;
+        resize_client_width = client->area.width;
+        resize_column_width = area.width;
+        resize_client_height = client->area.height;
+        resize_client_y = client->area.y;
+        resize_count = tile->layout->count[tile->stack];
+        for (row = 0; row < resize_count; ++row) {
+            Tile *member = tile->layout->slots[tile->stack][row];
+            Rect slot = slot_area(tile->layout, tile->stack, row);
+
+            resize_members[row] = member;
+            resize_weights[row] = member ? member->height_weight : 1.0;
+            resize_heights[row] = slot.height;
+        }
+    }
+}
+
+static gint stack_min_width(TileLayout *layout, guint stack)
+{
+    guint row;
+    gint width = 1;
+
+    for (row = 0; row < layout->count[stack]; ++row) {
+        Tile *tile = layout->slots[stack][row];
+
+        if (tile) {
+            ObClient *client = tile->client;
+            width = MAX(width, client->min_size.width +
+                        client->frame->size.left + client->frame->size.right);
+        }
+    }
+    return width;
+}
+
+static void restore_resize_weights(Tile *tile)
+{
+    guint row, old;
+
+    for (row = 0; row < tile->layout->count[tile->stack]; ++row) {
+        Tile *member = tile->layout->slots[tile->stack][row];
+
+        if (member)
+            for (old = 0; old < resize_count; ++old)
+                if (member == resize_members[old]) {
+                    member->height_weight = resize_weights[old];
+                    break;
+                }
+    }
+}
+
+static gint tile_min_height(Tile *tile)
+{
+    ObClient *client = tile->client;
+
+    return MAX(1, client->min_size.height) + client->frame->size.top +
+        client->frame->size.bottom;
+}
+
+static void resize_vertical(Tile *tile, gint y, gint height)
+{
+    guint row, neighbor;
+    Tile *other;
+    gint pair_height, minimum, maximum, requested;
+    gdouble pair_weight;
+
+    if (resize_count != tile->layout->count[tile->stack])
+        return;
+    for (row = 0; row < resize_count; ++row)
+        if (tile->layout->slots[tile->stack][row] != resize_members[row])
+            return;
+    restore_resize_weights(tile);
+    if (y != resize_client_y) {
+        if (!tile->row)
+            return;
+        neighbor = tile->row - 1;
+    } else {
+        if (tile->row + 1 == resize_count)
+            return;
+        neighbor = tile->row + 1;
+    }
+    other = tile->layout->slots[tile->stack][neighbor];
+    if (!other)
+        return;
+    pair_height = resize_heights[tile->row] + resize_heights[neighbor];
+    /* Keep rounding from violating either window's minimum height. */
+    minimum = tile_min_height(tile) + 1;
+    maximum = pair_height - tile_min_height(other) - 1;
+    if (minimum > maximum || height == resize_client_height)
+        return;
+    requested = CLAMP(resize_heights[tile->row] + height - resize_client_height,
+                       minimum, maximum);
+    pair_weight = resize_weights[tile->row] + resize_weights[neighbor];
+    tile->height_weight = pair_weight * requested / pair_height;
+    other->height_weight = pair_weight - tile->height_weight;
+}
+
+void tiling_resize_adjust(ObClient *client, gint *x, gint *y,
+                           gint *width, gint *height)
+{
+    Tile *tile = find_tile(client);
+    TileLayout *layout;
+    Rect *work, area;
+    gint column_width, minimum, maximum;
+
+    if (client != resize_client || !tile)
+        return;
+    layout = tile->layout;
+    work = screen_area(layout->desktop, layout->monitor, NULL);
+    minimum = stack_min_width(layout, 0);
+    maximum = work->width - stack_min_width(layout, 1);
+    if (tile->stack == 0 && minimum <= maximum && work->width > 0) {
+        column_width = CLAMP(resize_column_width + *width - resize_client_width,
+                             minimum, maximum);
+        layout->main_share = CLAMP(
+            ((gint64)column_width * SHARE_SCALE + work->width / 2) / work->width,
+            1, SHARE_SCALE - 1);
+    }
+    g_slice_free(Rect, work);
+    resize_vertical(tile, *y, *height);
+    area = slot_area(layout, tile->stack, tile->row);
+    *x = area.x;
+    *y = area.y;
+    *width = MAX(1, area.width - client->frame->size.left - client->frame->size.right);
+    *height = MAX(1, area.height - client->frame->size.top - client->frame->size.bottom);
+    frame_frame_gravity(client->frame, x, y);
+    queue_arrange();
+}
+
+void tiling_resize_end(ObClient *client, gboolean cancel)
+{
+    Tile *tile = find_tile(client);
+
+    if (resize_client == client && tile && cancel) {
+        tile->layout->main_share = resize_share;
+        restore_resize_weights(tile);
+    }
+    resize_client = NULL;
+    queue_arrange();
+}
+
+void tiling_forget(ObClient *client)
+{
+    Tile *tile = find_tile(client);
+    guint key = tiling_key(client);
+
+    if (key)
+        keys[key - 1] = NULL;
+    if (resize_client == client)
+        resize_client = NULL;
+    if (preview_client == client) {
+        preview_client = NULL;
+        hide_outline();
+    }
+    if (tile)
+        remove_tile(tile, FALSE);
+    queue_arrange();
+}
+
+void tiling_client_changed(ObClient *client)
+{
+    if (find_tile(client))
+        queue_arrange();
+}
+
+void tiling_screen_changed(void)
+{
+    hide_outline();
+    queue_arrange();
+}
+
+void tiling_shutdown(gboolean reconfigure)
+{
+    guint i;
+
+    if (notification_timer) {
+        g_source_remove(notification_timer);
+        notification_timer = 0;
+    }
+    popup_free(notification);
+    notification = NULL;
+    g_free(notification_text);
+    notification_text = NULL;
+    if (reconfigure)
+        return;
+
+    if (pending) {
+        g_source_remove(pending);
+        pending = 0;
+    }
+    arranging = TRUE;
+    while (tiles)
+        remove_tile(tiles->data, TRUE);
+    arranging = FALSE;
+    while (layouts) {
+        g_free(layouts->data);
+        layouts = g_list_delete_link(layouts, layouts);
+    }
+    for (i = 0; i < G_N_ELEMENTS(keys); ++i) {
+        ObClient *client = keys[i];
+        keys[i] = NULL;
+        if (client)
+            client_update_title(client);
+    }
+    for (i = 0; i < G_N_ELEMENTS(outline); ++i)
+        if (outline[i].window) {
+            stacking_remove(INTERNAL_AS_WINDOW(&outline[i]));
+            XDestroyWindow(obt_display, outline[i].window);
+            outline[i].window = None;
+        }
+}