oxwm

const std = @import("std");

const client_mod = @import("../client.zig");

const monitor_mod = @import("../monitor.zig");

const tiling = @import("tiling.zig");

const Client = client_mod.Client;

const Monitor = monitor_mod.Monitor;

pub const layout = monitor_mod.Layout{

    .symbol = "[#]",

    .arrange_fn = grid,

};

pub fn grid(monitor: *Monitor) void {

    var client_count: u32 = 0;

    var current = client_mod.next_tiled(monitor.clients);

    while (current) |_| : (current = client_mod.next_tiled(current.?.next)) {

        client_count += 1;

    }

    if (client_count == 0) return;

    const gap_outer_h = monitor.gap_outer_h;

    const gap_outer_v = monitor.gap_outer_v;

    const gap_inner_h = monitor.gap_inner_h;

    const gap_inner_v = monitor.gap_inner_v;

    if (client_count == 1) {

        const client = client_mod.next_tiled(monitor.clients).?;

        tiling.resize(

            client,

            monitor.win_x + gap_outer_v,

            monitor.win_y + gap_outer_h,

            monitor.win_w - 2 * gap_outer_v - 2 * client.border_width,

            monitor.win_h - 2 * gap_outer_h - 2 * client.border_width,

            false,

        );

        return;

    }

    const cols: u32 = @intFromFloat(@ceil(@sqrt(@as(f64, @floatFromInt(client_count)))));

    const rows: u32 = @intFromFloat(@ceil(@as(f64, @floatFromInt(client_count)) / @as(f64, @floatFromInt(cols))));

    const total_horizontal_gaps = 2 * gap_outer_v + gap_inner_v * @as(i32, @intCast(cols - 1));

    const total_vertical_gaps = 2 * gap_outer_h + gap_inner_h * @as(i32, @intCast(rows - 1));

    const available_width = monitor.win_w - total_horizontal_gaps;

    const available_height = monitor.win_h - total_vertical_gaps;

    const cell_width: i32 = @divTrunc(available_width, @as(i32, @intCast(cols)));

    const cell_height: i32 = @divTrunc(available_height, @as(i32, @intCast(rows)));

    var index: u32 = 0;

    current = client_mod.next_tiled(monitor.clients);

    while (current) |client| : (current = client_mod.next_tiled(client.next)) {

        const row = index / cols;

        const col = index % cols;

        const is_last_row = row == rows - 1;

        const windows_in_last_row = client_count - (rows - 1) * cols;

        var x: i32 = undefined;

        var y: i32 = undefined;

        var width: i32 = undefined;

        var height: i32 = undefined;

        if (is_last_row and windows_in_last_row < cols) {

            const last_row_col = index % cols;

            const last_row_gaps = 2 * gap_outer_v + gap_inner_v * @as(i32, @intCast(windows_in_last_row - 1));

            const last_row_available = monitor.win_w - last_row_gaps;

            const last_row_cell_width = @divTrunc(last_row_available, @as(i32, @intCast(windows_in_last_row)));

            x = monitor.win_x + gap_outer_v + @as(i32, @intCast(last_row_col)) * (last_row_cell_width + gap_inner_v);

            y = monitor.win_y + gap_outer_h + @as(i32, @intCast(row)) * (cell_height + gap_inner_h);

            width = last_row_cell_width - 2 * client.border_width;

            height = cell_height - 2 * client.border_width;

        } else {

            x = monitor.win_x + gap_outer_v + @as(i32, @intCast(col)) * (cell_width + gap_inner_v);

            y = monitor.win_y + gap_outer_h + @as(i32, @intCast(row)) * (cell_height + gap_inner_h);

            width = cell_width - 2 * client.border_width;

            height = cell_height - 2 * client.border_width;

        }

        tiling.resize(client, x, y, width, height, false);

        index += 1;

    }

}