init.lua

---@diagnostic disable: undefined-global
-- hyprview: float-grid workspace overview for Hyprland 0.55+ (Lua config).
-- Plugin-free workaround for the 0.55 plugin-dispatcher gap (`hyprexpo:expo`
-- and friends aren't invokable from the Lua bridge). On toggle: every tiled
-- window on the active workspace is floated into a grid; on second toggle,
-- they're unfloated in original column order so the scrolling layout puts
-- them back where they were.

local M = {}

local _state = { active = false, addrs = {} }

local _defaults = {
    bind = "SUPER + Tab",
    padding = 30,
    -- Grid sizing. cols(n) returns the number of columns for n windows.
    -- Default: roughly square (ceil(sqrt(n))).
    cols = function(n)
        return math.ceil(math.sqrt(n))
    end,
    -- On exit, center the focused column in the scrolling viewport. Useful
    -- with narrow `column_width` setups where the focused column would
    -- otherwise be left/right of center. Implemented by briefly swapping
    -- `scrolling.focus_fit_method` from 1 (fit) to 0 (center), re-focusing
    -- the window, then restoring via timer.
    center_on_exit = false,
    -- focus_fit_method to restore to after re-centering. Set to your normal
    -- value (Hyprland default is 1 = fit). Ignored unless center_on_exit.
    restore_focus_fit_method = 1,
    -- Delay before restoring focus_fit_method (ms). Short enough not to
    -- affect subsequent focus changes, long enough for the centering pass
    -- to land.
    restore_delay_ms = 80,
}

local function shallow_merge(base, over)
    local out = {}
    for k, v in pairs(base) do
        out[k] = v
    end
    if over then
        for k, v in pairs(over) do
            out[k] = v
        end
    end
    return out
end

local _opts = _defaults

local function enter()
    local mon = hl.get_active_monitor()
    local ws = hl.get_active_workspace()
    if not mon or not ws then
        return
    end
    -- Hyprland reports unrotated w/h even for rotated monitors; swap on
    -- 90°/270° transforms (1, 3, 5, 7 are the odd values).
    local mw, mh = mon.width, mon.height
    if (mon.transform or 0) % 2 == 1 then
        mw, mh = mh, mw
    end

    local tiled = {}
    for _, w in ipairs(hl.get_workspace_windows(ws.id) or {}) do
        if not w.floating then
            table.insert(tiled, w)
        end
    end
    local n = #tiled
    if n == 0 then
        return
    end

    local cols = _opts.cols(n)
    if cols < 1 then
        cols = 1
    end
    local rows = math.ceil(n / cols)
    local pad = _opts.padding
    local cw = math.floor((mw - (cols + 1) * pad) / cols)
    local ch = math.floor((mh - (rows + 1) * pad) / rows)

    _state.addrs = {}
    for i, w in ipairs(tiled) do
        local row = math.floor((i - 1) / cols)
        local col = (i - 1) % cols
        local x = mon.position.x + pad + col * (cw + pad)
        local y = mon.position.y + pad + row * (ch + pad)
        table.insert(_state.addrs, w.address)
        hl.dispatch(hl.dsp.window.float({ action = "set", window = w, value = true }))
        hl.dispatch(hl.dsp.window.resize({ window = w, x = cw, y = ch }))
        hl.dispatch(hl.dsp.window.move({ window = w, x = x, y = y }))
    end
    _state.active = true
end

local function exit()
    -- Remember whichever window the user had focused. Could be the one
    -- they were originally on, or one they clicked while in overview.
    local focused = hl.get_active_window()
    -- Unfloat in original column order, anchoring each insertion next to
    -- the previously-unfloated window so the scrolling layout puts them
    -- back in left-to-right (or top-to-bottom on rotated) order.
    local by_addr = {}
    for _, w in ipairs(hl.get_windows() or {}) do
        by_addr[w.address] = w
    end
    local anchor
    for _, addr in ipairs(_state.addrs) do
        local w = by_addr[addr]
        if w and w.floating then
            if anchor then
                hl.dispatch(hl.dsp.focus({ window = anchor }))
            end
            hl.dispatch(hl.dsp.window.float({ action = "toggle", window = w }))
            anchor = w
        end
    end
    -- Restore focus to whatever the user was looking at, optionally
    -- centering it in the scrolling viewport.
    if focused then
        if _opts.center_on_exit then
            hl.config({ scrolling = { focus_fit_method = 0 } })
            hl.dispatch(hl.dsp.focus({ window = focused }))
            hl.timer(function()
                hl.config({ scrolling = { focus_fit_method = _opts.restore_focus_fit_method } })
            end, { timeout = _opts.restore_delay_ms, type = "oneshot" })
        else
            hl.dispatch(hl.dsp.focus({ window = focused }))
        end
    end
    _state.active = false
    _state.addrs = {}
end

function M.toggle()
    if _state.active then
        exit()
    else
        enter()
    end
end

function M.enter()
    enter()
end
function M.exit()
    exit()
end

function M.is_active()
    return _state.active
end

function M.setup(opts)
    _opts = shallow_merge(_defaults, opts)
    if _opts.bind then
        hl.bind(_opts.bind, M.toggle)
    end
end

return M