oxwm

const std = @import("std");

const xlib = @import("x11/xlib.zig");

const Monitor = @import("monitor.zig").Monitor;

pub const Client = struct {

    name: [256]u8 = std.mem.zeroes([256]u8),

    min_aspect: f32 = 0,

    max_aspect: f32 = 0,

    x: i32 = 0,

    y: i32 = 0,

    width: i32 = 0,

    height: i32 = 0,

    old_x: i32 = 0,

    old_y: i32 = 0,

    old_width: i32 = 0,

    old_height: i32 = 0,

    base_width: i32 = 0,

    base_height: i32 = 0,

    increment_width: i32 = 0,

    increment_height: i32 = 0,

    max_width: i32 = 0,

    max_height: i32 = 0,

    min_width: i32 = 0,

    min_height: i32 = 0,

    hints_valid: bool = false,

    border_width: i32 = 0,

    old_border_width: i32 = 0,

    tags: u32 = 0,

    is_fixed: bool = false,

    is_floating: bool = false,

    is_urgent: bool = false,

    never_focus: bool = false,

    old_state: bool = false,

    is_fullscreen: bool = false,

    next: ?*Client = null,

    stack_next: ?*Client = null,

    monitor: ?*Monitor = null,

    window: xlib.Window = 0,

};

var allocator: std.mem.Allocator = undefined;

pub fn init(alloc: std.mem.Allocator) void {

    allocator = alloc;

}

pub fn create(window: xlib.Window) ?*Client {

    const client = allocator.create(Client) catch return null;

    client.* = Client{ .window = window };

    return client;

}

pub fn destroy(client: *Client) void {

    allocator.destroy(client);

}

pub fn attach(client: *Client) void {

    if (client.monitor) |monitor| {

        client.next = monitor.clients;

        monitor.clients = client;

    }

}

pub fn detach(client: *Client) void {

    if (client.monitor) |monitor| {

        var current_ptr: *?*Client = &monitor.clients;

        while (current_ptr.*) |current| {

            if (current == client) {

                current_ptr.* = client.next;

                return;

            }

            current_ptr = &current.next;

        }

    }

}

pub fn attach_stack(client: *Client) void {

    if (client.monitor) |monitor| {

        client.stack_next = monitor.stack;

        monitor.stack = client;

    }

}

pub fn detach_stack(client: *Client) void {

    if (client.monitor) |monitor| {

        var current_ptr: *?*Client = &monitor.stack;

        while (current_ptr.*) |current| {

            if (current == client) {

                current_ptr.* = client.stack_next;

                return;

            }

            current_ptr = &current.stack_next;

        }

    }

}

pub fn window_to_client(window: xlib.Window) ?*Client {

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

    var current_monitor = monitor_mod.monitors;

    while (current_monitor) |monitor| {

        var current_client = monitor.clients;

        while (current_client) |client| {

            if (client.window == window) {

                return client;

            }

            current_client = client.next;

        }

        current_monitor = monitor.next;

    }

    return null;

}

pub fn next_tiled(client: ?*Client) ?*Client {

    var current = client;

    while (current) |iter| {

        if (!iter.is_floating and is_visible(iter)) {

            return iter;

        }

        current = iter.next;

    }

    return null;

}

pub fn is_visible(client: *Client) bool {

    if (client.monitor) |monitor| {

        return (client.tags & monitor.tagset[monitor.sel_tags]) != 0;

    }

    return false;

}

pub fn is_visible_on_tag(client: *Client, tags: u32) bool {

    return (client.tags & tags) != 0;

}

pub fn next_tagged(client: *Client) ?*Client {

    const monitor = client.monitor orelse return null;

    var walked = monitor.clients;

    while (walked) |iter| {

        if (!iter.is_floating and is_visible_on_tag(iter, client.tags)) {

            return iter;

        }

        walked = iter.next;

    }

    return null;

}

pub fn attach_aside(client: *Client) void {

    const at = next_tagged(client);

    if (at == null) {

        attach(client);

        return;

    }

    client.next = at.?.next;

    at.?.next = client;

}

pub fn count_tiled(monitor: *Monitor) u32 {

    var count: u32 = 0;

    var current = next_tiled(monitor.clients);

    while (current) |client| {

        count += 1;

        current = next_tiled(client.next);

    }

    return count;

}

pub fn tiled_window_at(exclude: *Client, monitor: *Monitor, point_x: i32, point_y: i32) ?*Client {

    const tags = monitor.tagset[monitor.sel_tags];

    var current = monitor.clients;

    while (current) |client| {

        if (client != exclude and !client.is_floating and (client.tags & tags) != 0) {

            const client_x = client.x;

            const client_y = client.y;

            const client_w = client.width + client.border_width * 2;

            const client_h = client.height + client.border_width * 2;

            if (point_x >= client_x and point_x < client_x + client_w and

                point_y >= client_y and point_y < client_y + client_h)

            {

                return client;

            }

        }

        current = client.next;

    }

    return null;

}

pub fn insert_before(client: *Client, target: *Client) void {

    const monitor = target.monitor orelse return;

    if (client.monitor != monitor) return;

    detach(client);

    if (monitor.clients == target) {

        client.next = target;

        monitor.clients = client;

        return;

    }

    var current = monitor.clients;

    while (current) |iter| {

        if (iter.next == target) {

            client.next = target;

            iter.next = client;

            return;

        }

        current = iter.next;

    }

}

pub fn swap_clients(client_a: *Client, client_b: *Client) void {

    const monitor = client_a.monitor orelse return;

    if (client_b.monitor != monitor) return;

    var prev_a: ?*Client = null;

    var prev_b: ?*Client = null;

    var iter = monitor.clients;

    while (iter) |client| {

        if (client.next == client_a) prev_a = client;

        if (client.next == client_b) prev_b = client;

        iter = client.next;

    }

    const next_a = client_a.next;

    const next_b = client_b.next;

    if (next_a == client_b) {

        client_a.next = next_b;

        client_b.next = client_a;

        if (prev_a) |prev| {

            prev.next = client_b;

        } else {

            monitor.clients = client_b;

        }

    } else if (next_b == client_a) {

        client_b.next = next_a;

        client_a.next = client_b;

        if (prev_b) |prev| {

            prev.next = client_a;

        } else {

            monitor.clients = client_a;

        }

    } else {

        client_a.next = next_b;

        client_b.next = next_a;

        if (prev_a) |prev| {

            prev.next = client_b;

        } else {

            monitor.clients = client_b;

        }

        if (prev_b) |prev| {

            prev.next = client_a;

        } else {

            monitor.clients = client_a;

        }

    }

}