83987718cf
* Open the scratchpad with the default agent already in it on_created_empty fires when the special workspace is created empty, so the agent starts the first time the console drops down instead of at boot, and comes back on the next open if you close it. The exec rule pins the workspace rather than trusting the spawn to inherit it: Hyprland only tags a process with its origin workspace while misc.initial_workspace_tracking is on, and we turn that off. Nothing to guard for a missing default agent. Omarchy picks none for you, and omarchy-agent exits without opening a window when none is set, so the scratchpad just opens empty until one is chosen. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * Move the console into its own file and size it to half the screen The scratchpad's presentation was scattered through looknfeel: a dim in the decoration block, a workspace rule below it, two animation leaves further down again. Gathered into qconsole.lua, where the whole console is one readable thing. Sized to half the screen while it moved. A window rule cannot do that: its size expressions resolve once, when the window maps, so rescaling the monitor afterwards leaves a console that is no longer half of anything. Gaps are re-applied by the layout, so the console is sized by the gap left underneath it, recomputed from the monitor whenever the layout changes. Monitor dimensions come back in physical pixels while gaps are logical, so the scale comes out before the reserved area comes off. That arithmetic is the whole trick, and the test pins it at 1x, 2x and 1.5x. The test runs lua with an explicit "-". Bare `lua <<EOF` reads stdin as a REPL and exits 0 even after an error, which would leave its assertions unable to fail. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * Only rewrite the console rule when its size actually changes Refitting replaces the rule in place rather than stacking a new one, so there was no leak, but each write still schedules a monitor and window state refresh and monitor.focused fires on every hop between screens. Remember what was last written and skip the write when the number has not moved. Also say out loud that the scale guard is what keeps the arithmetic below it safe: a monitor handle that has outlived its output answers nil to every field, and a layout change is exactly when that happens. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * Drop the active window border inside the console The gradient border marks which window has focus, which the console does not need: it is only ever focused while it is open, and the dimmed workspace behind it already sets it apart. On a single agent terminal the highlight just reads as a frame around the panel. no_border on the workspace rule pins the border to 0 at workspace-rule priority, so it applies to whatever ends up in there without touching the global border. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Omabot <david@hey.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
91 lines
4.1 KiB
Bash
Executable File
91 lines
4.1 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
source "$(dirname "${BASH_SOURCE[0]}")/base-test.sh"
|
|
|
|
require_command lua
|
|
|
|
# The console is sized by the gap underneath it, recomputed from the monitor,
|
|
# because a window rule's size would freeze at whatever the screen measured when
|
|
# the console first opened. The arithmetic is what keeps it half a screen on a
|
|
# scaled display, so it is worth pinning down.
|
|
# base-test.sh does not set -e, so the assertions have to fail the file
|
|
# themselves rather than leaving the pass below to run regardless.
|
|
OMARCHY_PATH="$ROOT" lua - <<'LUA' || fail "the console covers half the work area at any monitor scale"
|
|
local rules, handlers = {}, {}
|
|
local monitor = nil
|
|
|
|
hl = {
|
|
config = function() end,
|
|
animation = function() end,
|
|
workspace_rule = function(rule) table.insert(rules, rule) end,
|
|
on = function(event, callback) handlers[event] = callback end,
|
|
get_active_monitor = function() return monitor end,
|
|
}
|
|
|
|
dofile(os.getenv("OMARCHY_PATH") .. "/default/hypr/bootstrap.lua")
|
|
require("default.hypr.qconsole")
|
|
|
|
local function current()
|
|
return rules[#rules]
|
|
end
|
|
|
|
-- Config loads before the outputs are up, so the first pass has no monitor to
|
|
-- read. It still has to leave a rule behind, or the console would open unseeded.
|
|
assert(#rules > 0, "console is ruled even before a monitor can be read")
|
|
assert(current().on_created_empty:find("omarchy%-agent"), "console is seeded with the default agent")
|
|
assert(current().on_created_empty:find("^%[workspace special:scratchpad silent%]"),
|
|
"the seed is pinned to the console rather than trusting the spawn to inherit it")
|
|
assert(current().workspace == "special:scratchpad")
|
|
|
|
local function rescale(height, scale, bar)
|
|
monitor = { height = height, scale = scale, reserved = { top = bar, bottom = 0, left = 0, right = 0 } }
|
|
handlers["monitor.layout_changed"]()
|
|
return current().gaps_out.bottom
|
|
end
|
|
|
|
-- Same panel, same logical size, different scale: the console must not care.
|
|
assert(rescale(1080, 1, 40) == 520, "half of a 1080p work area, unscaled")
|
|
assert(rescale(2160, 2, 40) == 520, "the same half once the monitor is scaled 2x")
|
|
assert(rescale(2160, 1.5, 40) == 700, "and at a fractional scale")
|
|
|
|
-- The bar is already out of the work area; counting it twice would push the
|
|
-- console short.
|
|
assert(rescale(1440, 1, 0) == 720, "a monitor with nothing reserved")
|
|
|
|
-- The console stays flush with the top and the sides, the way a Quake console
|
|
-- drops in, and keeps its seed across every refit.
|
|
local final = current()
|
|
assert(final.gaps_out.top == 0 and final.gaps_out.left == 0 and final.gaps_out.right == 0,
|
|
"the console is flush to the top and sides")
|
|
assert(final.on_created_empty:find("omarchy%-agent"), "refitting keeps the console seeded")
|
|
assert(final.no_border == true, "the console drops the active window border")
|
|
|
|
-- A monitor that cannot be read must not wipe the last good rule.
|
|
local before = current().gaps_out.bottom
|
|
monitor = nil
|
|
handlers["monitor.layout_changed"]()
|
|
assert(current().gaps_out.bottom == before, "an absent monitor leaves the console as it was")
|
|
|
|
-- A monitor handle outliving its output answers nil to everything, which is
|
|
-- what a layout change looks like mid-flight. Reading height or reserved off
|
|
-- that would throw, so the scale guard has to catch it first.
|
|
monitor = setmetatable({}, { __index = function() return nil end })
|
|
handlers["monitor.layout_changed"]()
|
|
assert(current().gaps_out.bottom == before, "an expired monitor handle is not read to pieces")
|
|
|
|
-- Refitting to the size it already is would still cost a state refresh, and
|
|
-- monitor.focused fires on every hop between screens.
|
|
monitor = { height = 1440, scale = 1, reserved = { top = 0, bottom = 0, left = 0, right = 0 } }
|
|
handlers["monitor.layout_changed"]()
|
|
local written = #rules
|
|
handlers["monitor.focused"]()
|
|
handlers["monitor.layout_changed"]()
|
|
assert(#rules == written, "refitting to the same size does not rewrite the rule")
|
|
|
|
monitor.scale = 2
|
|
handlers["monitor.layout_changed"]()
|
|
assert(#rules == written + 1, "a real change still rewrites it")
|
|
assert(current().gaps_out.bottom == 360, "and lands on half the rescaled screen")
|
|
LUA
|
|
pass "the console covers half the work area at any monitor scale"
|