Skip to content

Add a floating bar option (bar.floating) - #13569

Open
AbaddonTataken wants to merge 2 commits into
omacom:quattrofrom
AbaddonTataken:bar-floating
Open

AbaddonTataken wants to merge 2 commits into
omacom:quattrofrom
AbaddonTataken:bar-floating

Conversation

@AbaddonTataken

Copy link
Copy Markdown

What

omarchy bar floating true (or "floating": true under bar in ~/.config/omarchy/shell.json) lifts the bar off its screen edge:

  • The bar becomes a card inset by one Hyprland gaps_out from the edge and both sides, so it lines up with window edges.
  • Its corners take decoration:rounding, the same radius windows get. With Omarchy's default rounding of 0 the card is square; themes or users that round windows get a matching rounded bar.
  • Toggling window gaps (Super + Shift + Backspace) tucks it back flush against the edge together with the windows, and floats it again when gaps come back. The inset and radius animate on the default Hyprland windows curve (easeOutQuint, 379 ms).
  • Works for all four bar positions, with transparency, and with hiding (Super + Shift + Space).

floating defaults to false; the docked bar is unchanged.

How

  • The layer window now always spans the full floating footprint (windowExtent), and a barSurface rectangle inside it carries the background, inset and radius. Only the card moves when the gap changes; the layer surface is never resized. Resizing a layer surface to animate can show one stale, stretched frame, which is what a naive implementation (animating the window height) looked like during the gaps toggle.
  • Reserved space is set explicitly (ExclusionMode.Normal + exclusiveZone: barExtent), so windows reflow to the new gap immediately with their own animation while the card follows.
  • mask: Region { item: barSurface } keeps the floating gap click-through.
  • Style only re-polls general:gaps_out / decoration:rounding 200 ms after Hyprland reloads, which made the bar snap after the windows had already moved. The bar watches the window-no-gaps toggle flag itself (the same directory-watch + probe pattern as bar-off) and holds the last real gap and radius until Style catches up.
  • Transparent text-colour sampling now covers the full extent (barExtent) so a floating transparent bar samples what is actually behind it.

Also

  • omarchy bar floating <true|false|toggle> in bin/omarchy-bar, mirroring transparent.
  • Docs: manual/05-the-top-bar.md (new "Floating the bar" section, command and config example), docs/omarchy-shell.md, shell/plugins/bar/README.md.

Tests

  • test/shell.d/bar-test.sh: the existing hidden-bar assertions now match the explicit exclusion zone and windowExtent; new assertions cover the gap derivation, reserved space, fixed window size across a gap change, the click-through mask, the gaps-toggle watch and reading bar.floating.
  • test/shell.d/config-test.sh: omarchy bar floating true, toggle, and rejection of invalid values.
  • ./test/all: 4086 passing (11 new), no new failures. The 8 failures on my machine fail identically on unmodified quattro (environment: omasnap not installed, no omarchy-iso checkout, kernel headers, browser launcher, VS Code theme, cache cleanup, network portal fixture, a pre_remove hook).

Visual verification

Verified on a running session (Hyprland gaps_out = 10, rounding = 12): floating, gaps toggled off, gaps back on, and the layer surface stayed 1920×47 throughout while the reserved zone switched 47 → 37 → 47.

Screenshots (floating, and with window gaps toggled off) are attached below.

Possible follow-ups

  • A Style → Menu Bar entry for floating next to position and transparency.

🤖 Generated with Claude Code

`bar.floating` (and `omarchy bar floating <true|false|toggle>`) insets the
bar from its screen edge by one Hyprland gaps_out, with the window corner
radius, so it lines up with windows. The layer window keeps a fixed size
and only the card inside it moves, so toggling window gaps animates the
bar with the windows instead of resizing the surface (which can show a
stretched frame). The bar watches the window-gaps flag itself rather than
waiting for Style to re-poll Hyprland.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@llstrk

llstrk commented Sep 29, 2026

Copy link
Copy Markdown

Automated AI review

Community review: Independent automated community review, unaffiliated with the Omarchy team, intended to help prepare PRs for their review.

Outcome: Toasts overlap a floating top/right bar; the first gaps toggle mishandles the inset.

Toasts overlap the floating bar

notifications/Service.qml clears barSize + Style.gapsOut (31 px, stock top bar); the floating card reaches barSize + Style.gapsOut * 2 (36 px). Overlay-layer toasts cover its inner 5 px.

Suggested change: Clear shell.bar.barExtent when provided, else barSize (replacement bars).

Reproducer (fails at 9d878b0)

Reproducer: notification toasts overlap a floating top or right bar (reproduced as geometry)

Reviewed head: 9d878b0.

Toasts are placed from shell.bar.barSize + Style.gapsOut (shell/plugins/notifications/Service.qml, liveBarSize and barClearance), which the PR leaves unchanged. A floating bar's card now reaches Style.gapsOut * 2 + barSize from its edge (floatGap in Bar.qml). The toast window is on the Overlay layer, above the bar, so with stock sizes (bar 26 px horizontal and 28 px vertical, Style.gapsOut 5 from gaps_out = 10) a toast covers the inner 5 px of a floating top bar at its right end, or of a floating right bar at its top. With window gaps toggled off the card is flush again and there is no overlap.

This is a geometric check with the repository's own NotificationLogic.popupPlacement and the two formulas above, written in the node style of test/shell.d/notifications-test.sh. It is not a screenshot; nothing is rendered.

Run from an Omarchy checkout at the PR head (needs node):

bash toast-overlap-repro.sh "$PWD"

toast-overlap-repro.sh:

#!/bin/bash
# Reproducer: with bar.floating, notification toasts start inside a floating
# top or right bar. Uses the repository's own placement helper and the
# clearance formula in notifications/Service.qml.
# Usage: bash toast-overlap-repro.sh <omarchy-checkout>
set -euo pipefail
source "$1/test/shell.d/base-test.sh"

run_node_test <<'JS'
const fs = require('fs')
const notifications = requireFromRoot('shell/plugins/notifications/NotificationLogic.js')
const service = fs.readFileSync(root + '/shell/plugins/notifications/Service.qml', 'utf8')
const bar = fs.readFileSync(root + '/shell/plugins/bar/Bar.qml', 'utf8')

// Stock sizes: Style.bar.sizeHorizontal 26, sizeVertical 28, and
// Style.gapsOut 5 (half of Hyprland's default gaps_out 10).
const gapsOut = 5
assert(/floatGap: floating && !windowGapsOff \? \(Style\.gapsOut > 0 \? Style\.gapsOut \* 2 : lastGap\) : 0/.test(bar),
  'a floating bar card sits Style.gapsOut * 2 from its edge')
assert(/liveBarSize: [^\n]*shell\.bar\.barSize\)/.test(service) && /barClearance: liveBarSize \+ Style\.gapsOut/.test(service),
  'toasts clear shell.bar.barSize + Style.gapsOut')

const rows = [['top', 26, 'top'], ['right', 28, 'right']].map(([position, barSize, margin]) => {
  const cardInnerEdge = gapsOut * 2 + barSize
  const toastEdge = notifications.popupPlacement(position, barSize + gapsOut, gapsOut).margins[margin]
  console.log(`# ${position} bar: toast starts ${toastEdge}px from the edge; the floating bar reaches ${cardInnerEdge}px`)
  return { position, cardInnerEdge, toastEdge }
})
for (const row of rows) {
  assert(row.toastEdge >= row.cardInnerEdge, `a toast clears a floating ${row.position} bar`,
    `overlap: ${row.cardInnerEdge - row.toastEdge}px`)
}
JS

Actual output at 9d878b0 (exit 1):

ok - a floating bar card sits Style.gapsOut * 2 from its edge
ok - toasts clear shell.bar.barSize + Style.gapsOut
# top bar: toast starts 31px from the edge; the floating bar reaches 36px
# right bar: toast starts 33px from the edge; the floating bar reaches 38px
overlap: 5px
not ok - a toast clears a floating top bar

The script stops at the first failed assertion; both rows are printed before it: the top case overlaps by 5 px (31 against 36) and the right case by 5 px (33 against 38).

First gaps toggle resizes the bar

Stock gaps_out = 10 polls as Style's starting value, so onGapsOutChanged never assigns the bound lastGap. The first toggle pulls it to 0: the window resizes, and on return the card stays flush until Style re-polls. Once set, it also masks a later real gaps_out of 0.

Suggested change: Assign lastGap/lastRadius in the existing Component.onCompleted instead of binding, and guard onGapsOutChanged with Style.gapsOut > 0 || !root.windowGapsOff.

Reproducer (fails at 9d878b0)

Reproducer: the floating bar's window-gaps bookkeeping on stock Omarchy (reproduced)

Reviewed head: 9d878b0.

Stock Omarchy ships gaps_out = 10 (default/hypr/looknfeel.lua), which Style polls as gapsOut = 5. That is also Style.gapsOut's starting value, so no change signal fires at startup and property int lastGap: Style.gapsOut * 2 stays a live binding. On the first window-gaps toggle, Style re-polls 0 and the binding drags lastGap to 0: the bar window shrinks to the flush size, and when gaps come back the card stays flush until Style re-polls, because floatGap falls back to that 0. After one full cycle onGapsOutChanged has assigned lastGap and later cycles behave as designed. Separately, a gaps_out that really is 0 while the shell runs (no toggle flag) keeps the old inset, because every 0 falls back to lastGap.

The script copies the PR's floating block out of shell/plugins/bar/Bar.qml byte for byte (from property bool floating: false to the end of the Connections { target: Style } block) into a qmltestrunner harness with a stub Style singleton that has Style.qml's starting values, then steps through the toggle in the order the bar sees it (its own flag probe first, then Style's re-poll). Needs Qt 6 qmltestrunner at /usr/lib/qt6/bin/qmltestrunner. It does not start the shell or a compositor.

Run from an Omarchy checkout at the PR head:

bash floating-gaps-repro.sh "$PWD" "$(mktemp -d)"

floating-gaps-repro.sh:

#!/bin/bash
# Reproducer: the floating bar's lastGap follows Style.gapsOut to 0 on the first
# window-gaps toggle. Copies the PR's floating property block out of Bar.qml
# verbatim into a qmltestrunner harness with a stub Style singleton.
# Usage: bash floating-gaps-repro.sh <omarchy-checkout> <empty-scratch-dir>
set -euo pipefail
src="$1"; work="$2/lastgap"
rm -rf "$work"; mkdir -p "$work/qs/Commons" "$work/tests"

style="$src/shell/Commons/Style.qml"
bar="$src/shell/plugins/bar/Bar.qml"
start_gaps=$(sed -n 's/^  property int gapsOut: \([0-9][0-9]*\)$/\1/p' "$style")
start_radius=$(sed -n 's/^  property int cornerRadius: \([0-9][0-9]*\)$/\1/p' "$style")
[[ -n $start_gaps && -n $start_radius ]] || { echo "could not read Style.qml starting values" >&2; exit 2; }

printf 'module qs.Commons\nsingleton Style 1.0 Style.qml\n' >"$work/qs/Commons/qmldir"
cat >"$work/qs/Commons/Style.qml" <<QML
pragma Singleton
import QtQuick
// Stub with the starting values of shell/Commons/Style.qml.
QtObject {
  property int cornerRadius: $start_radius
  property int gapsOut: $start_gaps
}
QML

# Everything from 'property bool floating: false' through the end of the
# 'Connections { target: Style ... }' block, byte for byte.
awk '/^  property bool floating: false$/ { on = 1 }
     on { print }
     on && /^  Connections \{$/ { conn = 1 }
     conn && /^  \}$/ { exit }' "$bar" >"$work/block.txt"
grep -q 'function onGapsOutChanged' "$work/block.txt" || { echo "floating block not found in Bar.qml" >&2; exit 2; }

{
  cat <<'QML'
import QtQuick
import QtTest
import qs.Commons

Item {
  id: harness
  width: 100
  height: 100

  Component {
    id: barComponent

    Item {
      id: root
      // Bar.qml: vertical ? Style.bar.sizeVertical : Style.bar.sizeHorizontal (26 for a top bar)
      property int barSize: 26
QML
  cat "$work/block.txt"
  cat <<QML
    }
  }

  TestCase {
    name: "FloatingBarWindowGaps"

    // Creates the bar the way the shell does: Style still holds its starting
    // values, then its startup hyprctl poll lands.
    function makeBar(polledGapsOut, polledRadius) {
      Style.gapsOut = $start_gaps
      Style.cornerRadius = $start_radius
      var bar = createTemporaryObject(barComponent, harness)
      Style.gapsOut = polledGapsOut
      Style.cornerRadius = polledRadius
      bar.floating = true
      return bar
    }

    // omarchy toggle window-gaps: the bar's own probe sees the flag first,
    // then Style re-polls Hyprland (200 ms later) and reads 0.
    function gapsOff(bar) {
      bar.windowGapsOff = true
      Style.gapsOut = 0
      Style.cornerRadius = 0
    }

    // Stock Omarchy: gaps_out = 10, so Style.gapsOut polls as 5, its starting value.
    function test_stock_windowKeepsFloatingSizeWithGapsOff() {
      var bar = makeBar(5, 0)
      compare(bar.floatGap, 10, "floating gap before the toggle")
      compare(bar.windowExtent, 36, "window extent before the toggle")
      gapsOff(bar)
      compare(bar.floatGap, 0, "gaps off tucks the card")
      compare(bar.windowExtent, 36, "the window keeps its floating size while gaps are off")
    }

    function test_stock_floatsAgainBeforeStyleRepolls() {
      var bar = makeBar(5, 0)
      gapsOff(bar)
      // Toggle back: the probe sees the flag go before Style re-polls.
      bar.windowGapsOff = false
      compare(bar.floatGap, 10, "the card floats again before Style re-polls")
    }

    // After one full off/on cycle the handler has assigned lastGap, so the
    // binding is gone and later cycles behave as designed.
    function test_stock_secondCycle() {
      var bar = makeBar(5, 0)
      gapsOff(bar)
      bar.windowGapsOff = false
      Style.gapsOut = 5
      gapsOff(bar)
      compare(bar.windowExtent, 36, "second cycle: the window keeps its floating size")
      bar.windowGapsOff = false
      compare(bar.floatGap, 10, "second cycle: the card floats again before Style re-polls")
    }

    // A gaps_out that really is 0 (no toggle flag) must not float the card.
    function test_realZeroGapsAtStartup() {
      var bar = makeBar(0, 0)
      compare(bar.floatGap, 0, "gaps_out 0 at startup: no inset")
    }

    function test_realZeroGapsWhileRunning() {
      var bar = makeBar(10, 0)
      Style.gapsOut = 0
      compare(bar.floatGap, 0, "gaps_out set to 0 while running, flag absent: no inset")
    }

    // Control: gaps_out = 20, so Style.gapsOut changes from 5 to 10 at startup.
    function test_gapsOut20() {
      var bar = makeBar(10, 0)
      gapsOff(bar)
      compare(bar.windowExtent, 46, "the window keeps its floating size while gaps are off")
      bar.windowGapsOff = false
      compare(bar.floatGap, 20, "the card floats again before Style re-polls")
    }
  }
}
QML
} >"$work/tests/tst_floating_gaps.qml"

runner=/usr/lib/qt6/bin/qmltestrunner
QT_QPA_PLATFORM=offscreen QT_QUICK_BACKEND=software "$runner" -import "$work" -input "$work/tests" -o -,txt

Actual output at 9d878b0 (qmltestrunner exits 3, one per failed case):

One run-environment setup line and its one-line output are omitted, and the scratch directory in Loc: is shown as <scratch>. The output is otherwise unchanged.

********* Start testing of qmltestrunner *********
Config: Using QtTest library 6.11.2, Qt 6.11.2 (x86_64-little_endian-lp64 shared (dynamic) release build; by GCC 16.2.1 20260810), omarchy 4.0.4
PASS   : qmltestrunner::FloatingBarWindowGaps::initTestCase()
PASS   : qmltestrunner::FloatingBarWindowGaps::test_gapsOut20()
PASS   : qmltestrunner::FloatingBarWindowGaps::test_realZeroGapsAtStartup()
FAIL!  : qmltestrunner::FloatingBarWindowGaps::test_realZeroGapsWhileRunning() gaps_out set to 0 while running, flag absent: no inset
   Actual   (): 20
   Expected (): 0
   Loc: [<scratch>/lastgap/tests/tst_floating_gaps.qml(110)]
FAIL!  : qmltestrunner::FloatingBarWindowGaps::test_stock_floatsAgainBeforeStyleRepolls() the card floats again before Style re-polls
   Actual   (): 0
   Expected (): 10
   Loc: [<scratch>/lastgap/tests/tst_floating_gaps.qml(85)]
PASS   : qmltestrunner::FloatingBarWindowGaps::test_stock_secondCycle()
FAIL!  : qmltestrunner::FloatingBarWindowGaps::test_stock_windowKeepsFloatingSizeWithGapsOff() the window keeps its floating size while gaps are off
   Actual   (): 26
   Expected (): 36
   Loc: [<scratch>/lastgap/tests/tst_floating_gaps.qml(77)]
PASS   : qmltestrunner::FloatingBarWindowGaps::cleanupTestCase()
Totals: 5 passed, 3 failed, 0 skipped, 0 blacklisted, 3ms
********* Finished testing of qmltestrunner *********

The two stock failures are the first-cycle problem; test_stock_secondCycle passes. test_realZeroGapsWhileRunning is the second problem. test_gapsOut20 (control) and test_realZeroGapsAtStartup pass.

Diagnostic check (disposable copy of the extracted block, not a PR change): with lastGap and lastRadius seeded once in Component.onCompleted instead of bound, and onGapsOutChanged guarded the way onCornerRadiusChanged already is (if (Style.gapsOut > 0 || !root.windowGapsOff)), all six cases pass (Totals: 8 passed, 0 failed). Seeding alone, without the guard, fixes the stock cases but fails both real-zero cases (Totals: 6 passed, 2 failed).

Details

Related open PRs

Optional notes

  • Current quattro (b18ab49) routes bar animations through Style.duration(...) for the new no-animations mode; the two new duration: 379 animations would keep animating there. Style.duration(379) matches.
  • With positive decoration:rounding, mask: Region { item: barSurface } is still a rectangle: Quickshell's Region only rounds from its own radius, so the transparent card corners take clicks. Region { item: barSurface; radius: barSurface.radius } would match the painted shape; Region.radius needs Quickshell 0.3.0 or later (source-level, not tested on screen).
  • The new bar-test.sh assertions match source text, so they pass with the lastGap issue present.

Verified

  • omarchy bar floating true|false|toggle validates input, persists a JSON boolean and reaches the running bar through reloadConfig.
  • The docked bar keeps the same window size and reserved zone (exclusiveZone = barSize, as Auto computed).
  • The click-through mask follows the animated card; the watched flag path matches omarchy-hyprland-toggle window-no-gaps.
  • bar-test.sh passes at head; the new config-test.sh floating cases pass.

Review information

Test scope: Source and sandbox tests only, at 9d878b01; not checked on screen.

AI process: Opus 5.5 Medium coordination and synthesis, Opus 5.5 Xhigh technical review and final fact check, GPT 6 Sol Xhigh search for related issues, Opus 5.5 Medium editorial check.

Opt out: To stop receiving these reviews, reply to this comment saying so.

@cristian-fleischer

Copy link
Copy Markdown

Hi @AbaddonTataken, #13138 adds the same bar.floating key and omarchy bar floating command. It floats the bar inside Hyprland's gaps_out, so windows don't move, and already covers toasts and popouts. Maybe it's worth comparing the two so the maintainers don't have to pick blind. Context for the whole set: #13136.

Toasts cleared barSize + gapsOut while a floating card reaches
barSize + 2 * gapsOut, so they covered its inner 5 px. They now clear
the bar's barExtent when it is larger.

lastGap and lastRadius were bound at creation, before Style had polled
Hyprland, so the first window-gaps toggle could start from a wrong
inset and resize the bar. They are now captured in Component.onCompleted,
and a gaps_out of 0 is remembered only when the toggle flag is off.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
@AbaddonTataken

Copy link
Copy Markdown
Author

Thanks @cristian-fleischer, and thanks @llstrk for the review.

Both review findings are fixed in fcd6580: toasts now clear the bar's full barExtent, and lastGap/lastRadius are captured at startup so the first window-gaps toggle starts from the live inset.

On #13138: it uses the same bar.floating key and omarchy bar floating command, so only one of the two should land. #13138 is the broader one (windows don't move, popouts and toasts follow, theme margin/radius). What this PR adds on top is the animated inset/radius on the gaps toggle and the click-through mask for the gap. I'm happy to rebase those two onto #13138 once it is in, if the maintainers prefer that one.

@greptile-apps

greptile-apps Bot commented Oct 8, 2026 •

Copy link
Copy Markdown
Contributor

RetriggerConfidence Score: 4/5

[Medium risk] Adds a floating bar positioning mode to the shell UI.

The PR appears safe to merge, with non-blocking fixes needed for gap toggles and panel spacing.

Findings

  1. P2 Bar misses gap toggles ▶
  2. P2 Bar keeps old gaps ▶
  3. P2 Panels keep an extra gap ▶

Summary

Adds bar.floating, a CLI command, and an inset bar card that follows window-gap toggles.

  • Keeps the layer window fixed while the card moves.
  • Updates notification clearance, documentation, and tests.
  • Three non-blocking issues remain: missed toggles, stale zero-value caches, and panel spacing.
Diagram
%%{init: {'theme': 'neutral'}}%%
flowchart LR
  Config["bar.floating"] --> Bar["Bar.qml"]
  Flag["Window-gap flag"] --> Probe["windowGapsProbe"]
  Probe --> Bar
  Style["Style gaps and rounding"] --> Cache["Remembered gap and radius"]
  Cache --> Bar
  Bar --> Card["Animated barSurface"]
  Bar --> Window["Fixed windowExtent"]
  Bar --> Space["Reserved barExtent"]
  Window --> Panels["KeyboardPanel placement"]
Loading

Reviews (1) · Last reviewed commit: "Fix toast overlap and first gaps toggle ..." · Reviewed by Greptile

Comment thread shell/plugins/bar/Bar.qml
Comment on lines +1226 to +1230
FileView {
path: root.home + "/.local/state/omarchy/toggles/hypr"
watchChanges: true
printErrors: false
onFileChanged: windowGapsProbe.running = true

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Bar misses gap toggles

The new directory watch has no recovery path if it misses a gap toggle. The existing bar-off watch documents this failure and uses syncHidden() to recover, but windowGapsProbe only runs at startup and on directory events. After quick toggles, windowGapsOff can stay stale even after Style refreshes, leaving the floating bar docked or inset incorrectly until the shell restarts. Add a refresh call from the toggle command or another way to re-read the flag.

Comment thread shell/plugins/bar/Bar.qml
Comment on lines +69 to +70
readonly property int floatGap: floating && !windowGapsOff ? (Style.gapsOut > 0 ? Style.gapsOut * 2 : lastGap) : 0
readonly property int floatRadius: floating && !windowGapsOff ? (Style.cornerRadius > 0 ? Style.cornerRadius : lastRadius) : 0

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Bar keeps old gaps

Cached gaps and rounding never expire when the restored value stays zero. For example, start with rounding 12, turn gaps off, change the configured rounding to 0, then turn gaps back on. Style.cornerRadius stays 0, so onCornerRadiusChanged() never runs again and floatRadius keeps using 12. The same problem affects a gap changed to zero while gaps are off. Refresh the cached values after the restore poll completes, even when the values did not change.

Comment thread shell/plugins/bar/Bar.qml
// stretched frame), so a floating bar's window always spans the floating
// footprint and only its reserved space and card inset change.
readonly property int barExtent: barSize + floatGap
readonly property int windowExtent: barSize + (floating ? Math.max(lastGap, floatGap) : 0)

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Panels keep an extra gap

Keeping the layer window larger than the docked card breaks the spacing used by KeyboardPanel. It places panels using anchorWindow.height or anchorWindow.width, not the visible card edge. With a floating top bar and a remembered gap of 10, turning gaps off leaves the clock and weather panels 10 pixels below the flush bar even though gap is now zero. Update panel placement to use the visible bar edge rather than the fixed window size.

Knowledge Base Used: Shell UI and desktop interactions

@cristian-fleischer

Copy link
Copy Markdown

Thanks @AbaddonTataken, sounds good. Upstream reworked the bar since (#15517, #14991), so I'm porting #13138 onto it now. Once that's up, your animated inset and the click-through mask would fit nicely on top.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

enhancement New feature or request

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants