Skip to content

feat(keyboard): multiple bindings per action and standardised navigation - #139

Merged
PapyElGringo merged 7 commits into
mainfrom
feat/navigation-and-bindings
Oct 14, 2026
Merged

PapyElGringo merged 7 commits into
mainfrom
feat/navigation-and-bindings

Conversation

@PapyElGringo

@PapyElGringo PapyElGringo commented Oct 14, 2026 •

Copy link
Copy Markdown
Contributor

Summary

Two related changes that unblock context-driven navigation (and, later, gamepad
support).

Several bindings per action (fixes #133)

keyboard.hotkeys is now action -> [chord], so one action can be reached
from several keys (Super+W and Super+Up). The settings UI reuses the
shared list editor with a key-capture field; the schema, defaults and the
legacy single-string form are handled. Malformed/empty entries are dropped
instead of becoming an activator (an empty LogicalKeySet matches every key).
The shipped defaults now include both the WASD family and the arrow keys.

Move a tileable between rows (fixes #134)

Super+Shift+W/S sends the selected tileable to the workspace above/below and
follows it there, so an individual tileable can move between rows.
Super+Shift+A/D still reorders within the workspace. Reordering the workspace
itself, and moving tileables/workspaces across screens, is tracked in #141.

Standardised navigation + framework integration

  • Navigation is contextual: the Screen owns the vertical axis, the Workspace
    the horizontal one, and the overview the result list; each forwards the
    directions it does not own via Actions.maybeInvoke.
  • Activate/dismiss reuse Flutter's ActivateIntent / DismissIntent, so the
    shell's hotkeys drive the focused framework widgets (buttons, list tiles) and
    overlays (dialogs, menus). Escape closes the topmost overlay before the
    overview hides.
  • Directional movement stays a shell NavigateIntent — text fields register
    their own handler for DirectionalFocusIntent, which would shadow the
    workspace/tileable handlers while the launcher search field has focus — but
    focus-based contexts delegate to FocusNode.focusInDirection, so the
    traversal itself is the framework's.
  • The overview becomes a combobox: Super+Down enters the result list and
    Super+Up returns to the field; each result row owns a focus node (roving
    tab index) so assistive technology follows the selection. The row fill is a
    focus effect, so it clears when the keyboard leaves the list. The Helm groups
    each column for traversal. Backspace goes up a directory in Files, and
    left/right no longer mean parent/activate. Super+Tab / Super+Shift+Tab
    cycles the search mode.

Specs: new docs/specifications/navigation.md, plus updates to keyboard.md
and overview.md.

Testing

  • flutter test — 473 passed
  • flutter analyze — 0 errors
  • dart format --set-exit-if-changed — clean
  • cargo check — finished (pre-existing warnings only)

Veshell release bot added 7 commits October 14, 2026 12:53
- `keyboard.hotkeys` is now an action -> list of chords, so one action can be
  reached from several keys (`Super+W` and `Super+Up`); the legacy
  single-string form still parses, malformed entries are dropped, and the
  defaults ship both WASD and arrows (#133).
- Navigation is standardised and contextual: the Screen owns the vertical
  axis, the Workspace the horizontal one, the overview the result list; each
  forwards the directions it does not own.
- Activate/dismiss reuse Flutter's `ActivateIntent`/`DismissIntent`, so the
  shell's hotkeys drive the focused framework widgets and overlays (buttons,
  list tiles, dialogs, menus). Escape closes the topmost overlay first.
- The overview is focus-driven: a combobox (`Super+Down` enters the list,
  `Super+Up` returns to the field), per-row focus nodes (roving tab index),
  and a focusable Helm with traversal groups. `Backspace` goes to the parent
  directory in Files.
- Renamed navigation action ids fall back to their legacy key so existing
  overrides survive.

Verified with `flutter test` (467), `flutter analyze`, `dart format` and
`cargo check`.
…move

`MoveIntent` left/right still reorders the tileable inside its workspace, but
up/down now sends the selected tile to the workspace above/below instead of
reordering the workspaces themselves. The tile is appended and selected in the
destination; the source workspace keeps focus. The move lives on `ScreenState`
(`moveSelectedTileableToWorkspace`) and reuses the destination's `insertWindow`,
so it shares the transfer logic with drag-and-drop between workspaces.
Drop the redundant "in the current context" filler from the navigation
hotkey descriptions across every catalog.
Replace the "Move the selection …" phrasing with the localized "Navigate"
direction verb in every catalog.
Moving the selected tile to the workspace above/below now navigates to that
workspace as well, so the tile (selected in its new home) stays in view instead
of disappearing off-screen.
The result rows were tinted from the selection index, so navigating the
keyboard out of the list (for example `Super+Right` to the content pane) left
the last row painted with no feedback that focus had moved. The fill now
follows the row's focus (a filled-button look for the focused row) and clears
as soon as the keyboard leaves it; a shared `FocusHighlight` wrapper rebuilds
the row when its node gains or loses focus.
`SingleActivator(meta: true)` only matches `meta`/`metaLeft`/`metaRight`, not
the `superKey` the engine reports for the Super key, so the cycle binding never
fired. Build the chord from the key set and cover both spellings, as the global
hotkeys do.
@PapyElGringo
PapyElGringo merged commit b80cb92 into main Oct 14, 2026
2 checks passed
@PapyElGringo
PapyElGringo deleted the feat/navigation-and-bindings branch October 14, 2026 16:51
PapyElGringo pushed a commit that referenced this pull request Oct 15, 2026
`MaterialApp` installs `DefaultTextEditingShortcuts`, which maps `Enter` to a
do-nothing intent handled by the focused `EditableText`. `VeshellShortcutManager`
wraps `MaterialApp` (see `main.dart`), so its global `navigation.activate`
binding — and the framework's own `Enter` binding — sit above those text-editing
shortcuts and never see the key while the search field is focused. Since #139
replaced the search pane's local `CallbackShortcuts` with the global binding,
`Enter` after a search has therefore been swallowed: nothing was activated.

Bind `Enter`/`NumpadEnter` to `ActivateIntent` in the search pane again, close
enough to win over `DefaultTextEditingShortcuts`. `Space` stays unbound so the
field keeps typing spaces; a focused client surface is a sibling of the pane and
still receives `Enter` (its `SurfaceFocus` shadows it).

The regression test mirrors the real tree (`VeshellShortcutManager` above
`MaterialApp`); it fails without this binding.
PapyElGringo added a commit that referenced this pull request Oct 15, 2026
`MaterialApp` installs `DefaultTextEditingShortcuts`, which maps `Enter` to a
do-nothing intent handled by the focused `EditableText`. `VeshellShortcutManager`
wraps `MaterialApp` (see `main.dart`), so its global `navigation.activate`
binding — and the framework's own `Enter` binding — sit above those text-editing
shortcuts and never see the key while the search field is focused. Since #139
replaced the search pane's local `CallbackShortcuts` with the global binding,
`Enter` after a search has therefore been swallowed: nothing was activated.

Bind `Enter`/`NumpadEnter` to `ActivateIntent` in the search pane again, close
enough to win over `DefaultTextEditingShortcuts`. `Space` stays unbound so the
field keeps typing spaces; a focused client surface is a sibling of the pane and
still receives `Enter` (its `SurfaceFocus` shadows it).

The regression test mirrors the real tree (`VeshellShortcutManager` above
`MaterialApp`); it fails without this binding.

Co-authored-by: Veshell release bot <releases@veshell.invalid>
PapyElGringo added a commit that referenced this pull request Oct 16, 2026
* fix(overview): activate the search result with Enter again

`MaterialApp` installs `DefaultTextEditingShortcuts`, which maps `Enter` to a
do-nothing intent handled by the focused `EditableText`. `VeshellShortcutManager`
wraps `MaterialApp` (see `main.dart`), so its global `navigation.activate`
binding — and the framework's own `Enter` binding — sit above those text-editing
shortcuts and never see the key while the search field is focused. Since #139
replaced the search pane's local `CallbackShortcuts` with the global binding,
`Enter` after a search has therefore been swallowed: nothing was activated.

Bind `Enter`/`NumpadEnter` to `ActivateIntent` in the search pane again, close
enough to win over `DefaultTextEditingShortcuts`. `Space` stays unbound so the
field keeps typing spaces; a focused client surface is a sibling of the pane and
still receives `Enter` (its `SurfaceFocus` shadows it).

The regression test mirrors the real tree (`VeshellShortcutManager` above
`MaterialApp`); it fails without this binding.

* feat(window): present tile dialogs as a tabbed, frosted dialog area

Rework how a tile shows its dialogs. Instead of floating each dialog over a
dark scrim (which gave no way to navigate between several open dialogs, and no
extract affordance for client-side-decorated ones), a tile now hosts a dialog
area:

- `WindowDialogArea` wraps the tile (persistent and ephemeral) and lists its
  dialogs plus the trusted file chooser as tabs. Only the selected entry is
  shown, filling a panel that overlays the tile; the window behind it is
  blurred (`ImageFiltered`, the overview's recipe) and made non-interactive.
- Actions for the selected entry float on the right: extract and close for a
  dialog (extract now covers CSD dialogs), cancel for the chooser.
- Selection lives per tile (`SelectedDialogForWindow`); the newest dialog, or a
  newly arrived chooser, takes it, and a vanished selection falls back.
- The tile's single focus node drives activation of the selected dialog via
  `WindowWidget.activationTarget`, keeping the old "focused tile raises the
  topmost dialog" behaviour without a second focus node.
- Dialog meta windows report `MetaWindowDisplayMode.maximized`, matching how
  they are rendered.

`WindowWidget` no longer carries dialogs (`dialogMetaWindowList` removed);
`WindowDialogs` is gone. The dialog-only extract button is removed from the
shell titlebar (its close stays for the floating main window). The overview's
panel tab and search-mode button are extracted to `shared/widget` so the dialog
area reuses the exact look.

* refactor(window): put dialog actions in the pills and scale the panel margin

Follow-up on the dialog area:

- Drop the panel's `Material` background: the tabs and the dialog surface now
  sit directly on the frosted tile instead of a translucent card.
- Replace the fixed panel inset with a ratio of the tile's shortest side, so
  the frosted margin shrinks on a small tile instead of swallowing the panel.
- Move extract and close out of the floating right-hand action strip and into
  each dialog's pill (the chooser pill keeps cancel only); the strip is gone
  and the body fills the panel width.

* fix(window): keep the dialog area on whole logical pixels

The proportional panel margin could land on a decimal, and the body region
could inherit one, giving the hosted Wayland surface a fractional size and
origin. Flutter then samples the external texture bilinearly, which reads as
an always-blurry dialog — the same trap the overview split and the floating
window's origin already avoid.

Round the margin to whole logical pixels, and floor the dialog body to a
whole-pixel size pinned to the top-left so its origin stays whole too.

* feat(window): round the dialog surface corners

The panel no longer draws a Material, so the dialog body lost the rounded
corners its clipBehavior provided. Clip the whole-pixel box with the shell's
surface radius; ClipRRect leaves the size and origin untouched, so the
whole-pixel contract still holds.

* feat(window): offer extract only for a regular toplevel dialog

Extract makes sense for a top-level window that merely attached to the tile as
a dialog, not for a genuine dialog. Gate it on `isExtractableDialog`: the
native window declares no client parent and is not modal, so real modal and
portal/child dialogs lose the pill's Extract action while keeping Close.

Extract also stays off when the dialog's meta window is gone.

* feat(theme): add a reusable FrostedSurface and use it for the glass

Blur alone reads as "out of focus", not glass. Add `FrostedSurface`, which
combines the ingredients that sell the effect:

- optional blur (clamped `ImageFilter` so edges do not bleed inward) and a
  saturation lift — "vibrancy" — applied to the frosted content;
- a translucent wash, a hairline frame and a soft top sheen;
- an optional fine grain to break the banding a flat wash shows.

Two layering modes: the wash sits behind the content (a background for
transparent UI) or above it (`tintOverContent`, a veil that dims what it
frosts).

Wire it in:
- the tile dialog backdrop now blurs *and* lifts vibrancy, dimmed by a black
  veil; it keeps the cheaper `ImageFiltered`-on-the-child recipe instead of a
  per-frame `BackdropFilter`;
- the overview search pane and content pane swap their ad-hoc `withAlpha(200)`
  decoration for the same surface (wash + frame + grain), so the shell reads as
  one material.

* fix(theme): stop the frosted glass from swallowing clicks

The glass layer draws a `ColoredBox` for its tint above the content, and
`ColoredBox` is hit-test opaque — even at alpha 0. With no dialog open the
veil is fully transparent but still absorbed every pointer, so the tile's
WindowWidget became unclickable.

Wrap the glass in `IgnorePointer`: it is decorative and must never take a
pointer. Covered by a widget test that taps a tile with no dialog open.

* feat(theme): tint the glass with the theme hue, dim with the scrim

Keep the frost neutral-but-on-brand instead of hand-picked colours:

- panes use `frostedGlassTint`, a low-alpha blend of the scheme's `primary`
  over `surfaceContainerHigh`, dialable through `glassTintPrimaryAlpha`
  (0 = pure surface tone, 24 = painted). Derived from scheme roles so it flips
  with the brightness;
- the dialog veil uses `colorScheme.scrim` instead of `Colors.black`, so it
  recedes neutrally under the panel.

* fix(overview): keep the content pane plain, not frosted

The content pane hosts the Helm, previews and live window surfaces; it was
never meant to carry the frosted decoration (hue tint, frame, grain). Restore
its plain translucent `Material` background.

The search pane and the dialog backdrop keep the frosted treatment.

* fix(overview): revert the search pane; frost the overview background instead

Neither overview pane was meant to be frosted — they host UI (search fields,
results, the Helm, previews, live surfaces) and keep their plain translucent
surfaces. The frost belongs to the overview *background*:

- `OverviewBlurTarget` uses `FrostedSurface` for the blurred screen, so the
  backdrop reads as glass (vibrancy lift) rather than merely out of focus;
- the overview wash (`_OverviewScrim`) uses the theme glass tint and a grain
  instead of flat white.

The dialog area keeps its frost.

* fix(overview): absorb clicks behind the overview and brighten its wash

Two regressions from moving the frost to the overview background:

- the new wash no longer absorbed pointers (the original `ColoredBox` was
  hit-test opaque), so clicks in the gaps between panes reached the desktop
  behind. `FrostedSurface` gains `absorbPointers` (default off, since the
  dialog veil must stay click-through); the overview background opts in.
- the wash used `surfaceContainerHigh`, which is dark in dark mode and made
  the overview darker than the original white. Blend the primary hue over
  white, so the wash lifts the blurred backdrop and keeps the contrast with
  the content pane.

* feat(window): frost the dialog backdrop like the overview

The dialog veil used `colorScheme.scrim`, a dark wash that only dims. Over a
dark window (a terminal) it stayed black. Use the same bright, theme-hued
`frostedGlassTint` wash as the overview, so the window behind the dialog is
lifted and the panel keeps reading as the foreground.

* tune(window): soften the dialog backdrop wash

The bright wash at full strength (alpha 70) was too strong over the window
behind the dialog — it reads much heavier than the overview's, whose wash sits
behind the panes. Cap it at 40 (near the overview's ~41) and name the knob
`dialogAreaWashAlpha`; also match the overview's 0.20 saturation bump.

* tune(theme): one shared frost wash strength

Bring the dialog backdrop and the overview background onto a single dial,
`frostedWashAlpha` (currently 20), so both washes read at the same strength.
The overview wash no longer derives its alpha from `overviewBlurSigma`; the
blur sigma and the wash strength are independent.

* feat(theme): richer frost — relative blur, baked grain, sheen, theme-aware wash

Four improvements to the frosted effect:

- blur sigma now scales with the frosted region (`frostSigmaFor`, factor 0.02,
  clamped 8..28) instead of a fixed 16, so a small tile is not over-blurred;
  both the dialog backdrop and `OverviewBlurTarget` use it, and the two sigma
  constants are gone;
- the grain is baked once into a 64px tileable image (synchronous
  `toImageSync`) and drawn as a repeated shader instead of a per-paint loop of
  thousands of rects, and it is enabled on the dialog too;
- the sheen runs diagonally (top-left light source) with a wider falloff
  instead of a flat vertical fade;
- the wash is theme-aware: white on a dark scheme (lift the dim desktop), black
  on a light one (settle the bright desktop), so light mode no longer washes
  out.

* fix(theme): stop the grain over the dialog, match the original density, cache the blur

Three fixes on top of the richer frost:

- the dialog no longer draws grain, and its wash is `null` while closed, so
  the glass is skipped entirely when there is nothing to frost instead of
  painting a transparent veil (and its grain) over the window;
- the baked grain was ~40x denser than the old per-paint dots (1 per 8px vs 1
  per 350px), which is why it suddenly read as texture — match the old density;
- `FrostedSurface` gains `frame` (so a tile backdrop drops the hairline
  without a transparent-border paint), and the dialog backdrop and
  `OverviewBlurTarget` wrap their frosted result in a `RepaintBoundary` so the
  blur is reused while the panel/overview is interacted with.

* feat(window): keep the grain on the dialog backdrop

The grain only paints while a dialog is open (the wash is null when closed),
so it no longer covers the window in the idle state. Enable it on the dialog
again to match the overview.

* fix(theme): only draw the grain over a blurred surface

Grain over a sharp image reads as a dirty screen. `FrostedSurface` now drops
the grain below a small sigma threshold, and the overview's grain moved from
the scrim (which does not blur) onto `OverviewBlurTarget` (which does), so it
is gated the same way as the dialog's.

* feat(window): centre the dialog content under the tab bar

The tab bar is a header, so the body was pushed below the tile's centre by its
own height. Reduce the panel's top margin by the tab bar's height instead, so
the dialog — the content — is what ends up centred (clamped at zero so the
panel never runs past the tile edge).

The tab bar's height is intrinsic (theme, text scale), so it is measured after
the first layout; until then the margin stays symmetric for one frame.

* fix(window): pre-compute the dialog tab bar height

Measuring the tab bar's intrinsic height after the first layout made the
content jump one frame. Use a constant (`_dialogTabBarHeight = 56`, from
`PanelTab`: a 40px action button plus 8px vertical padding each side) so the
top margin is right on the first frame.

* feat(file_chooser): let the portal chooser fill the dialog area

The chooser capped itself at 720x620 and the dialog area centred it, so it
floated small inside the panel. Move the cap to `FileChooserModal` (the
monitor overlay fallback, which does need a bounded size) and let the chooser
fill its body region in the dialog area, like a native dialog does.

* feat(window): float modal and fixed-size dialogs instead of tiling them

The tabbed, frosted dialog area stretches the selected surface to fill the
panel, which distorts a fixed-size dialog and wastes the space for a modal one.
Neither is ever extractable, so the tabbed area adds nothing for them. They keep
the tile's previous presentation instead: a dim scrim over the tile with the
dialog floating at its natural size (capped at 90%), rendered above the panel.

- `isFloatingDialog` (modal or fixed-size) partitions a tile's dialogs; the
  rest, plus the file chooser, stay in the tabbed area.
- `WindowDialogs` is restored for the floating stack.
- A floating dialog is not a tab, but it sits on top, so the tile's activation
  target prefers the newest floating dialog over the selected tab.
- `isExtractableDialog` also rejects fixed-size dialogs, matching the absence
  of a tab (and therefore of an extract affordance) for them.

* feat(gaming): frost the paused game instead of dimming it

The pause overlay covered the game with a flat `black38` scrim. Use the shared
frosted effect instead, matching the overview background and the dialog area:
the game blurs behind the instructions, with the theme-hued wash, lifted
saturation and grain animating in over the same 300ms as the instructions'
fade.

The scrim's box was also the tap target, so the pause gesture detector is now
explicitly `HitTestBehavior.opaque` to keep the whole tile tappable.

* feat(window): give floating modal/fixed-size dialogs a shell frame

A modal or fixed-size dialog now floats over the dimmed tile, but a client that
draws no decoration of its own read as a flat rectangle pasted on the dim. Draw
a bare shell frame around it: the same rounded corners and drop shadow
`MetaSurfaceDecoration` uses for server-side decoration, minus the title bar.

- `windowFrameDecoration` is shared by `MetaSurfaceDecoration` and the new
  `ServerSideFrame` so every shell-drawn window edge matches.
- `FloatableWindow.frame` opts in; `WindowDialogs` sets it for the floating
  modal/fixed-size stack, while the floating main window keeps its bare surface.
- A client that asked for server-side decoration already carries the frame (title
  bar included), so it is skipped to avoid doubling the shadow.

* fix(window): frame only a bare floating dialog, never a decorated one

The floating modal/fixed-size frame clipped the surface to the window geometry,
which sliced off the CSD margins a self-decorating client draws its shadow and
rounded corners in -- leaving the shell's narrow shadow sitting flush on the
geometry edge.

Only frame a surface that draws no decoration of its own: one whose buffer
equals the window geometry. A buffer larger than the geometry means the client
decorates itself, so it is drawn as-is, neither framed nor cropped. The buffer
is compared in logical pixels, `geometry` being logical and the texture size
physical.

* fix(wayland): remap a re-bound subsurface on commit

A subsurface is mapped when it has a texture and has committed. commit()
only set `committed` and relied on the texture-change listener to
recompute `mapped`, so the flag was only ever recomputed when the texture
changed. When a client re-binds an existing surface as the subsurface of a
new parent and commits the same buffer, the texture is unchanged, the
listener never fires, and `mapped` stays false: the surface renders blank.

Firefox does exactly this, reusing its menu panel surface for every
xdg_popup, so its hamburger menu could be opened once but never reopened.
Recompute `mapped` in commit() so the commit half of the predicate is
honored on its own.

* fix(matching): return a settled relation window to its empty tile

A window opened after the launch burst settled, carrying an owner relation
(tracked provenance, activation or process sibling), was always turned into a
dialog of the owner tile. When that tile owns no native window there is no
displayed surface for the dialog to belong to, so the application's own window
was buried in its empty tile's dialog area.

Sweet Home 3D hits this: it maps a transient "win0", the burst settles on it,
the window is closed, and the real window opens afterwards. Provenance resolves
the (now empty) launch tile, and the main window became a dialog of it.

Attach such a window to the owner tile as its displayed window instead. A
fixed-size splash still becomes a dialog, and a fullscreen-like window is still
extracted to its own tile before this rule applies.

* fix(matching): treat desktop-entry aliases as one application

Two .desktop entries for the same program (e.g. org.gnome.SystemMonitor and the
KDE-only gnome-system-monitor-kde) resolved to different ids, so the matcher
rejected tracked-launch provenance as an "identity conflict" and created a
second tile for one application.

Applications now compare by desktop-entry identity: the same entry id, or two
entries that share a non-empty StartupWMClass. The executable is deliberately
not used: Exec/TryExec basenames are shared by unrelated entries
(gnome-control-center has 28, flatpak 11), so matching on them would merge those
applications.

The same predicate widens the ordinary candidate, sibling and placeholder
gates, and entry resolution now lives in one shared helper used by both the
matcher and LocalizedDesktopEntryForId.

* fix(app-drawer): honour OnlyShowIn/NotShowIn

The app drawer listed every non-hidden entry, including desktop-specific ones
such as the OnlyShowIn=KDE gnome-system-monitor-kde duplicate. Filter by the
running session's desktop names (XDG_CURRENT_DESKTOP/XDG_SESSION_DESKTOP/
DESKTOP_SESSION) so the canonical entry is the one offered.

* perf(frost): shorten and even out the frost transitions

The frost ran a 200ms controller through an `Interval(0, 0.6)` with no
`reverseCurve`, so the motion took 120ms while the remaining 80ms only kept
rasterizing blurred frames -- and opening finished 80ms early while closing
started 80ms late, holding the frost at full over a panel that had already
vanished.

- `frostDuration` (160ms) and `frostCurve` (easeInOut, no interval) are shared
  by the dialog backdrop, the overview backdrop and the overview scrim: the
  ramp is fully used and both directions start on the first frame.
- The dialog area now owns a single controller. The panel fades with the frost
  and stays mounted (ignoring pointers) until the ramp finishes, instead of
  being unmounted the frame the dialog closes. Fade only -- scaling it would
  resample the live Wayland surface it hosts.
- A surface mounted while already open (a tile built with a dialog open, a
  screen subtree rebuilt with the overview up, a game tile that starts paused)
  comes up frosted instead of blurring in from nothing.
- The gaming pause frost keeps its 300ms (route-synced) but is eased now, and
  the instructions' fade shares that curve.
- `FrostedSurface.noiseOpacity` ramps the grain, so it fades with the wash
  instead of popping the moment the blur crosses its floor.

The overview scrim keeps its two-interval stagger: there the clamped ends sit
behind the other layer's motion instead of being visible as a hold.

---------

Co-authored-by: Veshell release bot <releases@veshell.invalid>
@PapyElGringo PapyElGringo mentioned this pull request Oct 16, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

[FEATURE] Allow moving individual tileables up and down [FEATURE] Map multiple keybindings to the same action

1 participant