Variables | |
| constexpr QLatin1StringView | SetEngineMode {"setEngineMode"} |
| constexpr QLatin1StringView | SetSnappingLayout {"setSnappingLayout"} |
| constexpr QLatin1StringView | SetTilingAlgorithm {"setTilingAlgorithm"} |
| constexpr QLatin1StringView | SetScrollingTemplate {"setScrollingTemplate"} |
| Scrolling-mode template for the matched context: a NATIVE ScrollingTemplate id (its own picker kind, scrollingTemplate, with its own name resolution — not a manual layout). | |
| constexpr QLatin1StringView | DisableEngine {"disableEngine"} |
| constexpr QLatin1StringView | LockContext {"lockContext"} |
| Lock the active layout for the matched screen/desktop/activity context so it can't be switched — the rule-driven equivalent of the manual ToggleLayoutLock shortcut. | |
| constexpr QLatin1StringView | DefaultLayoutAssignment {"defaultLayoutAssignment"} |
| Per-context override of the global "suppress default layout assignment" setting for the matched screen/desktop/activity context. | |
| constexpr QLatin1StringView | SetOsdEnabled {"setOsdEnabled"} |
| Per-context override of the OSD toggles for the matched screen/desktop/ activity context. | |
| constexpr QLatin1StringView | SetDragSelectorEnabled {"setDragSelectorEnabled"} |
| Per-context override of the drag selector popup — the edge-triggered zone / strip picker offered while a window is dragged — for the matched screen/desktop/activity context. | |
| constexpr QLatin1StringView | Exclude {"exclude"} |
| constexpr QLatin1StringView | ExcludePlacement {"excludePlacement"} |
| Exclude a matched window from the placement engines ONLY — snapping, autotile and scrolling all treat it as unmanaged (open path, drag gate, keyboard navigation), so it stays floating — while decorations and animations still apply. | |
| constexpr QLatin1StringView | Float {"float"} |
| constexpr QLatin1StringView | SnapToZone {"snapToZone"} |
| Snap a matched window into one or more zones on open. | |
| constexpr QLatin1StringView | RouteToScreen {"routeToScreen"} |
| Route a matched window to a specific monitor on open. | |
| constexpr QLatin1StringView | RouteToDesktop {"routeToDesktop"} |
| Route a matched window to a specific virtual desktop on open. | |
| constexpr QLatin1StringView | RouteToWorkspace {"routeToWorkspace"} |
| Route a matched window to a NAMED dynamic workspace on open. | |
| constexpr QLatin1StringView | OverrideAnimationShader {"overrideAnimationShader"} |
| constexpr QLatin1StringView | OverrideDecorationChain {"overrideDecorationChain"} |
| Per-window override of the decoration surface-pack chain (border-sweep / glow / frosted-glass, ...). | |
| constexpr QLatin1StringView | OverrideAnimationTiming {"overrideAnimationTiming"} |
| constexpr QLatin1StringView | OverrideAnimationCurve {"overrideAnimationCurve"} |
| Curve-only animation override — separate slot from timing so a user can override the easing/spring curve for an event without committing to a duration (and vice versa). | |
| constexpr QLatin1StringView | SetOpacity {"setOpacity"} |
| constexpr QLatin1StringView | OverrideOverlayShader {"overrideOverlayShader"} |
| Context-domain override of one node of the zone-overlay shader tree, the overlay analogue of OverrideAnimationShader. | |
| constexpr QLatin1StringView | OverrideOverlayStyle {"overrideOverlayStyle"} |
| constexpr QLatin1StringView | SetOverlayHighlightColor {"setOverlayHighlightColor"} |
| Context-domain overrides of the active layout's zone-overlay APPEARANCE — the colours, opacities, border dimensions and zone-number visibility that the global Snapping.Zones.
| |
| constexpr QLatin1StringView | SetOverlayInactiveColor {"setOverlayInactiveColor"} |
| constexpr QLatin1StringView | SetOverlayBorderColor {"setOverlayBorderColor"} |
| constexpr QLatin1StringView | SetOverlayActiveOpacity {"setOverlayActiveOpacity"} |
| constexpr QLatin1StringView | SetOverlayInactiveOpacity {"setOverlayInactiveOpacity"} |
| constexpr QLatin1StringView | SetOverlayBorderWidth {"setOverlayBorderWidth"} |
| constexpr QLatin1StringView | SetOverlayBorderRadius {"setOverlayBorderRadius"} |
| constexpr QLatin1StringView | SetOverlayShowZoneNumbers {"setOverlayShowZoneNumbers"} |
| constexpr QLatin1StringView | ExcludeAnimations {"excludeAnimations"} |
| Disable every animation override on a matched window. | |
| constexpr QLatin1StringView | ExcludeDecorations {"excludeDecorations"} |
| Disable window decorations (the border + surface-pack chain) on a matched window — the decoration mirror of ExcludeAnimations. | |
| constexpr QLatin1StringView | RestorePosition {"restorePosition"} |
| Per-window override for floated-position restore on login. | |
| constexpr QLatin1StringView | SetRestoreToZoneOnLogin {"setRestoreToZoneOnLogin"} |
| Per-window override for the "restore snapped windows to their zone on login" setting. | |
| constexpr QLatin1StringView | SetRestoreSizeOnUnsnap {"setRestoreSizeOnUnsnap"} |
| Per-window override for the "restore original size when unsnapped" setting. | |
| constexpr QLatin1StringView | SetUnfloatFallbackToZone {"setUnfloatFallbackToZone"} |
| Per-window override of the "unfloat falls back to a zone" setting. | |
| constexpr QLatin1StringView | SetWindowLayer {"setWindowLayer"} |
| Per-window stacking-layer override. | |
| constexpr QLatin1StringView | SetHideTitleBar {"setHideTitleBar"} |
| constexpr QLatin1StringView | SetBorderVisible {"setBorderVisible"} |
| constexpr QLatin1StringView | SetBorderWidth {"setBorderWidth"} |
| constexpr QLatin1StringView | SetBorderRadius {"setBorderRadius"} |
| constexpr QLatin1StringView | SetBorderColorActive {"setBorderColorActive"} |
| constexpr QLatin1StringView | SetBorderColorInactive {"setBorderColorInactive"} |
| constexpr QLatin1StringView | SetOpacityTintVisible {"setOpacityTintVisible"} |
| constexpr QLatin1StringView | SetTintStrength {"setTintStrength"} |
| constexpr QLatin1StringView | SetTintColor {"setTintColor"} |
| constexpr QLatin1StringView | SetInnerGap {"setInnerGap"} |
| constexpr QLatin1StringView | SetOuterGap {"setOuterGap"} |
| constexpr QLatin1StringView | SetUsePerSideOuterGap {"setUsePerSideOuterGap"} |
| constexpr QLatin1StringView | SetOuterGapTop {"setOuterGapTop"} |
| constexpr QLatin1StringView | SetOuterGapBottom {"setOuterGapBottom"} |
| constexpr QLatin1StringView | SetOuterGapLeft {"setOuterGapLeft"} |
| constexpr QLatin1StringView | SetOuterGapRight {"setOuterGapRight"} |
| constexpr QLatin1StringView | SetMaxWindows {"setMaxWindows"} |
| constexpr QLatin1StringView | SetSplitRatio {"setSplitRatio"} |
| constexpr QLatin1StringView | SetMasterCount {"setMasterCount"} |
| constexpr QLatin1StringView | SetInsertPosition {"setInsertPosition"} |
| Where a newly-opened window is inserted into the autotile stack. | |
| constexpr QLatin1StringView | SetOverflowBehavior {"setOverflowBehavior"} |
| How the autotile stack handles windows beyond the max: float the overflow, or go unlimited (ignore the cap). | |
| constexpr QLatin1StringView | SetDragBehavior {"setDragBehavior"} |
| How dragging a tiled window behaves: float it out, or reorder it within the stack (Krohnkite-style drag-to-swap). | |
| constexpr QLatin1StringView | SetAlgorithmParam {"setAlgorithmParam"} |
| Override an autotile algorithm's custom (Luau-declared) parameters for the matched context. | |
| constexpr QLatin1StringView | SetScrollDefaultColumnWidth {"setScrollDefaultColumnWidth"} |
| Width a newly-opened column takes, as a fraction of the work area. | |
| constexpr QLatin1StringView | SetCenterFocusedColumn {"setCenterFocusedColumn"} |
| When the scroll viewport re-centres on the focused column. | |
| constexpr QLatin1StringView | SetScrollDefaultColumnDisplay {"setScrollDefaultColumnDisplay"} |
| How a newly-opened column displays its windows: side by side, or stacked as tabs. | |
| constexpr QLatin1StringView | SetScrollInsertPosition {"setScrollInsertPosition"} |
| Where a fresh-opened window's new column enters the strip. | |
| constexpr QLatin1StringView | SetScrollDefaultWindowHeight {"setScrollDefaultWindowHeight"} |
| Height a newly-opened window takes inside its column, as a fraction of the work-area height (numeric ActionParam::Value, edited as a percent; committed as a fixed pixel intent against the live work area). | |
| constexpr QLatin1StringView | SetScrollAlwaysCenterSingleColumn {"setScrollAlwaysCenterSingleColumn"} |
| Whether a lone column centres on the strip regardless of the centering policy. | |
| constexpr QLatin1StringView | SetScrollCenterShortColumns {"setScrollCenterShortColumns"} |
| Whether a column whose windows do not fill the work area is centred on the cross axis instead of hugging the start edge. | |
| constexpr QLatin1StringView | SetScrollRespectMinimumSize {"setScrollRespectMinimumSize"} |
| Whether the strip honours each window's declared minimum size when sizing its column. | |
| constexpr QLatin1StringView | SetScrollCropStraddlers {"setScrollCropStraddlers"} |
| Whether a column straddling the screen edge is clipped at the boundary (its true rect is kept, only the drawing is cropped). | |
| constexpr QLatin1StringView | SetScrollFocusNewWindows {"setScrollFocusNewWindows"} |
| Whether a window opening on the matched context takes focus. | |
| constexpr QLatin1StringView | SetScrollSmartGaps {"setScrollSmartGaps"} |
| Whether a lone column drops the outer gaps (niri's smart gaps). | |
| constexpr QLatin1StringView | SetScrollFocusFollowsMouse {"setScrollFocusFollowsMouse"} |
| Whether moving the pointer over a column focuses it on the matched context. | |
| constexpr QLatin1StringView | SetScrollFocusFollowsMouseMaxScroll {"setScrollFocusFollowsMouseMaxScroll"} |
| Numeric ActionParam::Value in [MinFocusFollowsMouseMaxScrollRatio, MaxFocusFollowsMouseMaxScrollRatio], the furthest focus-follows-mouse may scroll the strip to reveal the window under the pointer, as a fraction of the viewport's extent along it. | |
| constexpr QLatin1StringView | SetScrollStickyWindowHandling {"setScrollStickyWindowHandling"} |
| How the strip treats windows shown on all desktops. | |
| constexpr QLatin1StringView | SetScrollStripAxis {"setScrollStripAxis"} |
| Which way the matched context's strip runs. | |
| constexpr QLatin1StringView | SetTabIndicatorEnabled {"setTabIndicatorEnabled"} |
| Whether tabbed columns show an indicator at all. Boolean ActionParam::Value. | |
| constexpr QLatin1StringView | SetTabIndicatorStyle {"setTabIndicatorStyle"} |
| Title chips or a segment bar. | |
| constexpr QLatin1StringView | SetTabIndicatorPosition {"setTabIndicatorPosition"} |
| Which column edge the indicator runs along. | |
| constexpr QLatin1StringView | SetTabIndicatorHideWhenSingleTab {"setTabIndicatorHideWhenSingleTab"} |
| Hide the indicator on a single-window tabbed column. Boolean ActionParam::Value. | |
| constexpr QLatin1StringView | SetTabIndicatorPlaceWithinColumn {"setTabIndicatorPlaceWithinColumn"} |
| Reserve the indicator out of the column instead of drawing beside it. | |
| constexpr QLatin1StringView | SetTabIndicatorGap {"setTabIndicatorGap"} |
| Gap between indicator and window in px. | |
| constexpr QLatin1StringView | SetTabIndicatorWidth {"setTabIndicatorWidth"} |
| Indicator thickness in px. Numeric ActionParam::Value. | |
| constexpr QLatin1StringView | SetTabIndicatorLength {"setTabIndicatorLength"} |
| Indicator length as a fraction of the column extent. | |
| constexpr QLatin1StringView | SetTabIndicatorGapsBetweenTabs {"setTabIndicatorGapsBetweenTabs"} |
| Gap between individual tabs in px. Numeric ActionParam::Value. | |
| constexpr QLatin1StringView | SetTabIndicatorCornerRadius {"setTabIndicatorCornerRadius"} |
| Per-tab corner radius in px. | |
| constexpr QLatin1StringView | SetTabIndicatorActiveColor {"setTabIndicatorActiveColor"} |
| Tab colours. Hex ActionParam::Value, same shapes as the border colours. | |
| constexpr QLatin1StringView | SetTabIndicatorInactiveColor {"setTabIndicatorInactiveColor"} |
| constexpr QLatin1StringView | SetTabIndicatorUrgentColor {"setTabIndicatorUrgentColor"} |
| constexpr QLatin1StringView | SetTabIndicatorFontFamily {"setTabIndicatorFontFamily"} |
| Tab label font family. | |
| constexpr QLatin1StringView | SetTabIndicatorFontWeight {"setTabIndicatorFontWeight"} |
| Tab label font weight on the CSS scale. | |
| constexpr QLatin1StringView | SetTabIndicatorFontItalic {"setTabIndicatorFontItalic"} |
| Tab label font style flags. | |
| constexpr QLatin1StringView | SetTabIndicatorFontUnderline {"setTabIndicatorFontUnderline"} |
| constexpr QLatin1StringView | SetTabIndicatorFontStrikeout {"setTabIndicatorFontStrikeout"} |
| constexpr QLatin1StringView | SetDropIndicatorEnabled {"setDropIndicatorEnabled"} |
| Whether the drop indicator is painted at all. Boolean ActionParam::Value. | |
| constexpr QLatin1StringView | SetDropIndicatorColor {"setDropIndicatorColor"} |
| Fill and border colours. | |
| constexpr QLatin1StringView | SetDropIndicatorBorderColor {"setDropIndicatorBorderColor"} |
| constexpr QLatin1StringView | SetDropIndicatorOpacity {"setDropIndicatorOpacity"} |
| Fill opacity, 0.0-1.0. | |
| constexpr QLatin1StringView | SetDropIndicatorBorderWidth {"setDropIndicatorBorderWidth"} |
| Border thickness in px. | |
| constexpr QLatin1StringView | SetDropIndicatorBorderRadius {"setDropIndicatorBorderRadius"} |
| Corner radius in px. | |
| constexpr QLatin1StringView | OpenColumnWidth {"openColumnWidth"} |
| Width the opening window's column takes, as a fraction of the work area. | |
| constexpr QLatin1StringView | OpenTabbed {"openTabbed"} |
| Whether the opening window's column starts tabbed. Boolean ActionParam::Value. | |
| constexpr QLatin1StringView | TabColorActive {"tabColorActive"} |
| Per-window tab colours — niri's tab-indicator WINDOW rule, which recolours only the matched window's own tab. | |
| constexpr QLatin1StringView | TabColorInactive {"tabColorInactive"} |
| constexpr QLatin1StringView | TabColorUrgent {"tabColorUrgent"} |
| constexpr QLatin1StringView | DropIndicatorColor {"dropIndicatorColor"} |
| Per-window drop-indicator colours, keyed on the DRAGGED window. | |
| constexpr QLatin1StringView | DropIndicatorBorderColor {"dropIndicatorBorderColor"} |
| constexpr QLatin1StringView | OpenColumnPlacement {"openColumnPlacement"} |
| Whether the opening window starts its own column or is consumed into the focused one. | |
| constexpr QLatin1StringView | OpenWindowHeight {"openWindowHeight"} |
| Height the opening window takes inside its column, as a fraction of the work-area height. | |
| constexpr QLatin1StringView | OpenMaximized {"openMaximized"} |
| Whether the opening window's column starts maximized (full work-area width) — niri's open-maximized. | |
| constexpr QLatin1StringView | OpenFocused {"openFocused"} |
| Per-window override of the "focus new windows" scrolling setting — niri's open-focused. | |
| constexpr QLatin1StringView | OpenTabGroup {"openTabGroup"} |
| Open the window as a tab of a NAMED group. | |
| constexpr QLatin1StringView | OpenFullscreen {"openFullscreen"} |
| Fullscreen at open — niri's open-fullscreen. | |
| constexpr QLatin1StringView | ScrollFactor {"scrollFactor"} |
| Per-window scroll-speed multiplier — niri's scroll-factor window rule. | |
|
inlineconstexpr |
Per-context override of the global "suppress default layout assignment" setting for the matched screen/desktop/activity context.
Context domain (matches only context fields); mode-agnostic (the override governs the synthesized default for BOTH the snapping and tiling engines, since the level-1 default is a single mode-carrying AssignmentEntry). Boolean value: false SUPPRESSES the synthesized default for this context (no engine activates until the user explicitly assigns one), true ALLOWS it (forces the global default through even when the global suppress setting is on). With no such rule, the context follows the global setting. Carries no SetEngineMode action, so it is NOT a cascade-winning assignment rule — the daemon reads it as a per-slot overlay at cascade-miss via LayoutRegistry::resolveContextDefaultAssignment, mirroring LockContext.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Per-window drop-indicator colours, keyed on the DRAGGED window.
The only per-window slice of the drop indicator that has a coherent referent: while a drag is in flight exactly one window is being dragged, so "show this colour when dragging Firefox" resolves unambiguously at drag start. The remaining four properties stay context-only — a per-window opacity or border width would name the same slot the context rule already describes with no added meaning. These outrank the per-context colours, which outrank the config, which falls back to the theme: the tab colours' exact order. Hex ActionParam::Value.
|
inlineconstexpr |
|
inlineconstexpr |
Disable every animation override on a matched window.
The opposite of the OverrideAnimation* family — the effect's shouldAnimateWindow gate surfaces this as "no animation for this window, regardless of other rules". Distinct from the generic Exclude action (which marks the window unmanaged by snap/tile/etc); a user can have Exclude without ExcludeAnimations and vice versa. Migrated from the legacy animationExcludedApplications / animationExcludedWindowClasses settings lists by the v3→v4 chain.
|
inlineconstexpr |
Disable window decorations (the border + surface-pack chain) on a matched window — the decoration mirror of ExcludeAnimations.
The KWin effect's shouldDecorateWindow gate binds the decoration-exclusion slice (ExclusionRules::excludeDecorationsRulesFrom, Exclude ∪ ExcludeDecorations), so the blanket Exclude keeps stripping decorations while this action strips ONLY decorations — placement and animations are untouched (full-store evaluators enforce this by scoping which terminal actions they honour, see RuleEvaluator::setTerminalActionScope, so a mixed rule carrying this action cannot cancel placement or animation resolution). Like ExcludeAnimations it deliberately omits Tag::Effect: carrying it would admit the rule into the effect's animation rule set, whose "any match force-animates" opt-in gate must not fire for a decoration opt-out. Carries Tag::Border as classification only — no in-tree tag reader consumes it, and blanket Exclude's decoration effect flows exclusively through the slicer, never through tags. Terminal.
|
inlineconstexpr |
Exclude a matched window from the placement engines ONLY — snapping, autotile and scrolling all treat it as unmanaged (open path, drag gate, keyboard navigation), so it stays floating — while decorations and animations still apply.
The scoped sibling of the blanket Exclude, which additionally strips decorations. Terminal like Exclude, and sliced into the same placement-exclusion set consumers bind (ExclusionRules::excludePlacementRulesFrom returns Exclude ∪ ExcludePlacement rules). Distinct from Float, which is an open-path placement verdict on a MANAGED window (a floated window can still be dragged into a zone; an excluded one cannot).
Scope enforcement: evaluators bound to the FULL store declare a terminal-action scope (RuleEvaluator::setTerminalActionScope) so this action terminates only placement-policy walks — on a mixed rule, its presence does not cancel animation/appearance or context resolution. Carries no tags, deliberately: no in-tree tag reader consumes the exclusion family, and its placement effect flows exclusively through the slicer.
|
inlineconstexpr |
|
inlineconstexpr |
Lock the active layout for the matched screen/desktop/activity context so it can't be switched — the rule-driven equivalent of the manual ToggleLayoutLock shortcut.
Context domain (matches only context fields); mode-agnostic (a true lock applies to both the snapping and tiling engines). The daemon resolves it LIVE on the context-lock path and never persists it, so rule locks and manual toggles never overwrite each other.
|
inlineconstexpr |
Whether the opening window starts its own column or is consumed into the focused one.
Closed enum token (ActionParam::Value, ColumnPlacementToken).
|
inlineconstexpr |
Width the opening window's column takes, as a fraction of the work area.
Numeric ActionParam::Value (stored fraction, edited as a percent). Ignored when OpenColumnPlacement resolves to "consume" on a non-empty strip, because the arrival joins the host column and keeps its width.
|
inlineconstexpr |
Per-window override of the "focus new windows" scrolling setting — niri's open-focused.
Boolean ActionParam::Value: true activates the window on open even when the global setting is off, false keeps focus (and the strip's active column) where it was. Read on the same open path as the other Open* slots and layered over IScrollSettings::scrollingFocusNewWindows.
|
inlineconstexpr |
Fullscreen at open — niri's open-fullscreen.
Boolean ActionParam::Value: true puts the opening window into real KWin fullscreen, false vetoes the app's OWN fullscreen request at open (apps that start fullscreen by default). Unlike the rest of the Open* family this is EFFECT-consumed (Tag::EffectVerdict, so an ExcludeAnimations rule cannot cancel it — see the tag's doc): only the compositor side can flip KWin's fullscreen state, and the flip happens at windowAdded, before the window is announced to the daemon. One-shot open verdict — a rule edit mid-session does not yank an already-open window into or out of fullscreen. Applies on every screen and engine mode, not just scrolling.
|
inlineconstexpr |
Whether the opening window's column starts maximized (full work-area width) — niri's open-maximized.
Boolean ActionParam::Value. Wins over OpenColumnWidth when both match (a maximized open IS a width verdict, the stronger one). There is no stored "maximized" state in the scroll engine — full width is simply ColumnWidth::makeProportion(1.0) — so a later un-maximize takes the default-width fallback, matching the manual verb.
|
inlineconstexpr |
Whether the opening window's column starts tabbed. Boolean ActionParam::Value.
|
inlineconstexpr |
Open the window as a tab of a NAMED group.
String ActionParam::Value, non-empty: the group name. On open, the scrolling engine looks for a column that already holds a window whose own rules resolve to the same group name and joins it as a tab, turning that column tabbed if needed; no such column means a column of its own. The name is what ties windows together, so a rule matching a title, a class or anything else groups every window it matches with every other window resolving to that name, across applications. Outranks the app-keyed IScrollSettings::scrollingGroupSameAppAsTabs default: a window with a group name never falls back to same-app grouping. An OpenColumnPlacement consume rule on the same window outranks it, the way every explicit placement outranks a grouping verdict.
Names compare exactly after trimming, case included ("Work" and "work" are two groups). Membership is resolved LIVE: on every open the engine re-evaluates each existing tile's rules against that tile's current metadata, so a group keyed on a title condition follows the live title, and a tile can enter or leave a group between two opens without moving. Nothing is remembered per window.
|
inlineconstexpr |
Height the opening window takes inside its column, as a fraction of the work-area height.
Numeric ActionParam::Value (stored fraction, edited as a percent). Applies after every insert path, outranking remembered and default heights the way OpenColumnWidth outranks the width defaults.
|
inlineconstexpr |
Curve-only animation override — separate slot from timing so a user can override the easing/spring curve for an event without committing to a duration (and vice versa).
OverrideAnimationTiming still carries both for backward compatibility with legacy rules; resolveAnimationMotionProfile checks the curve slot first.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Per-window override of the decoration surface-pack chain (border-sweep / glow / frosted-glass, ...).
Carries an ordered pack-id array (ActionParam::Chain) plus an optional per-pack parameter map (ActionParam::Params, shape {packId: {paramId: value}}). An EMPTY chain array is the "no decoration" sentinel, blocking the tree-resolved chain for matched windows — the decoration analogue of OverrideAnimationShader's empty effectId. The reserved rule-owned "border" pack id is ignored if present (SetBorderVisible governs it). Effect-consumed in updateWindowDecoration, replacing the DecorationProfileTree user packs; one un-scoped slot, so the highest priority matching rule wins outright. Domain Window.
|
inlineconstexpr |
Context-domain override of one node of the zone-overlay shader tree, the overlay analogue of OverrideAnimationShader.
Carries the node (ActionParam::LayoutId: a layout UUID, or absent / empty for the tree's global default), the shader (ActionParam::EffectId) and optional uniform overrides (ActionParam::Params). For the matched context (screen / desktop / activity) the rule replaces what the tree would have resolved at that node: a layout node applies only while that layout is the context's active one, the global node applies to every layout there. An engaged EMPTY effectId is the "no shader" sentinel, blocking the tree's answer for that node just as the animation action's does. Resolved daemon-side via LayoutRegistry::resolveContextOverlay, slot overlay-shader:<node>.
|
inlineconstexpr |
|
inlineconstexpr |
Per-window override for floated-position restore on login.
A boolean value action: true forces the window's previous floated position (and original monitor) to be restored, false suppresses it. Engine-neutral — overrides the per-engine snappingRestoreFloatedWindowsOnLogin / autotileRestoreFloatedWindowsOnLogin / scrollingRestoreFloatedWindowsOnLogin settings for matched windows. Resolved by the daemon-injected restore-position predicate, which all THREE placement engines take: consulted inside SnapEngine::resolveWindowRestore, AutotileEngine::insertWindow and the scroll engine's floating-reopen branch. Domain Window (matches window properties).
|
inlineconstexpr |
Route a matched window to a specific virtual desktop on open.
Carries the 1-based desktop number (ActionParam::TargetDesktop). Composes with the other open-path placement actions. Sticky (on-all-desktops) windows are left alone. Daemon-consumed on the open path. Domain Window.
|
inlineconstexpr |
Route a matched window to a specific monitor on open.
Carries the canonical target screen id (ActionParam::TargetScreenId, the EDID Manuf:Model:Serial form the settings screen-picker and the runtime both use — physical OR virtual screen id). Composes with SnapToZone (snap into a zone ON the target screen) and with autotile (insert the window into the target screen's tiling state); on its own it just moves the window to that monitor. Restores the per-monitor pinning the retired per-layout Layout::appRules targetScreen field carried. Daemon-consumed on the open path. Domain Window.
|
inlineconstexpr |
Route a matched window to a NAMED dynamic workspace on open.
Carries the declaration's persistent entry id (ActionParam::TargetWorkspaceId) and the name it had when the rule was written (ActionParam::TargetWorkspaceName, required; a rule written before ids existed carries the name alone). The daemon resolves the id against the live named-workspace declarations, falls back to the name when no declaration carries the id, and moves the window to whichever desktop, and onto whichever monitor, currently realizes it. A no-op when neither resolves or dynamic workspaces are off. Sticky (on-all-desktops) windows are left alone, as with RouteToDesktop. Distinct from RouteToDesktop's positional number: the id survives a rename, renumbering, pinning changes and monitor moves.
Precedence over the other two routes is by ACTION, not by rule priority, because each route fills its own slot (ActionSlot::RouteWorkspace). When a cascade carries this route and its target is declared, it decides the desktop even if the RouteToDesktop came from a higher-priority rule: a realized workspace places the window there, and one that is declared but momentarily unresolvable leaves the window on its spawn desktop rather than applying the number. When the workspace realizes, it also decides the monitor, and a RouteToScreen in the same cascade is skipped. Only an undeclared target (or workspaces off) lets the other two routes apply. Daemon-consumed on the open path. Domain Window.
|
inlineconstexpr |
Per-window scroll-speed multiplier — niri's scroll-factor window rule.
Numeric ActionParam::Value in [MinScrollFactor, MaxScrollFactor], multiplying every wheel / touchpad scroll delta delivered to the matched window while the pointer is over it (below 1 slows scrolling, above 1 speeds it up). The wire value is the multiplier itself, a fraction below 1, so the editor shows it as a percent (schema kind percent, scale 0.01) the way the other fraction-valued actions do. EFFECT-consumed (Tag::EffectVerdict, so an ExcludeAnimations rule cannot cancel it — see the tag's doc): the KWin effect's input filter rescales the axis event in place before the forwarding filter hands it to the client. Wayland sessions only — on X11 the input filter chain is not the client delivery path, so the rule is inert there.
|
inlineconstexpr |
Override an autotile algorithm's custom (Luau-declared) parameters for the matched context.
Carries the target algorithm token (ActionParam::Algorithm) and a free-form nested params object (ActionParam::Params) of the custom parameter values — the same shape OverrideOverlayShader uses for shader uniforms. Applied only when the target algorithm is the screen's effective algorithm; layered over the global per-algorithm config. Context domain.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
When the scroll viewport re-centres on the focused column.
Closed enum token (ActionParam::Value, CenterFocusedColumnToken).
|
inlineconstexpr |
How dragging a tiled window behaves: float it out, or reorder it within the stack (Krohnkite-style drag-to-swap).
Closed enum token (DragBehaviorToken). Context domain; consumed by the drag adaptor (NOT the tile-engine override map) — it resolves the effective behavior for the drag's screen.
|
inlineconstexpr |
Per-context override of the drag selector popup — the edge-triggered zone / strip picker offered while a window is dragged — for the matched screen/desktop/activity context.
Context domain; boolean value: false SUPPRESSES the popup for the context, true FORCES it past the global selector toggle. With no such rule the context follows the global toggle for whichever variant the screen hosts (the classic zone selector, or the scrolling strip selector). The rule governs only whether the popup is OFFERED, so it never turns an engine off, and it never overrides the gates that exist because a pick could not be committed (an excluded dragged window, a layout-suppressed or disabled context, an engine-owned screen without the strip capability). Live-resolved daemon-side via LayoutRegistry::resolveContextDragSelectorEnabled and consumed by TWO load-bearing gates — WindowDragAdaptor::checkZoneSelectorTrigger (and its edge-activation sibling) and OverlayService::selectorEnabledForScreen — mirroring SetOsdEnabled.
|
inlineconstexpr |
|
inlineconstexpr |
Corner radius in px.
Numeric ActionParam::Value. UNSIGNED, unlike the tab indicator's: there is no pill sentinel here, 0 means square.
|
inlineconstexpr |
Border thickness in px.
Numeric ActionParam::Value. Zero is legal and means a fill with no edge, so this floors at 0 rather than at 1.
|
inlineconstexpr |
Fill and border colours.
Hex ActionParam::Value. EMPTY is not expressible as a rule value — a rule that does not set the colour simply leaves the setting (and through it the "follow the colour scheme" sentinel) in place.
|
inlineconstexpr |
Whether the drop indicator is painted at all. Boolean ActionParam::Value.
|
inlineconstexpr |
Fill opacity, 0.0-1.0.
Numeric ActionParam::Value (stored fraction, edited as a percent). The border is always opaque, so this is the fill's alone — see ScrollDropIndicatorContent.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Where a newly-opened window is inserted into the autotile stack.
Carries a closed enum token (ActionParam::Value, InsertPositionToken). Context domain; layered onto the per-screen override map like the other tiling params.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Per-context override of the OSD toggles for the matched screen/desktop/ activity context.
Context domain; boolean value: false SUPPRESSES every on-screen display for the context, true FORCES them past the per-trigger global toggles (but never past the OsdStyle::None kill switch, which returns before a rendering style is chosen). With no such rule the context follows the global toggles. Live-resolved daemon-side via LayoutRegistry::resolveContextOsdEnabled, mirroring LockContext.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
How the autotile stack handles windows beyond the max: float the overflow, or go unlimited (ignore the cap).
Closed enum token (OverflowBehaviorToken). Context domain; layered onto the per-screen override map like the other params.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Context-domain overrides of the active layout's zone-overlay APPEARANCE — the colours, opacities, border dimensions and zone-number visibility that the global Snapping.Zones.
* config sets. Each is its own slot so independent rules cascade per-property, mirroring the per-window border family. A matched context rule (screen / desktop / activity) overrides the corresponding global setting for that context's overlay; an unset property falls through to the global config value (config stays authoritative — these only layer on top). Resolved daemon-side via LayoutRegistry::resolveContextOverlay and consumed by the overlay service. Colours carry a #AARRGGBB hex (ActionParam::Value); opacities a [0,1] double; widths/radii a number; show-zone-numbers a bool. Unlike the border colour actions there is NO accent sentinel — the overlay consumer resolves no token, so the value is always a concrete hex.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Per-window override for the "restore original size when unsnapped" setting.
A boolean value: false suppresses the pre-snap size restore for the matched window (it keeps the zone size after unsnap), true forces it on even when the global restoreOriginalSizeOnUnsnap setting is off. Consulted daemon-side on the drag-out / drop / cursor-left-zones unsnap paths. Domain Window.
|
inlineconstexpr |
Per-window override for the "restore snapped windows to their zone on login" setting.
A boolean value: false suppresses zone restore for the matched window (it reopens wherever the session put it), true forces it on even when the global restoreWindowsToZonesOnLogin setting is off. Resolved by the daemon-injected managed-restore predicate. Domain Window. The snapped-to-zone analogue of RestorePosition (which covers FLOATED windows).
|
inlineconstexpr |
Whether a lone column centres on the strip regardless of the centering policy.
Boolean ActionParam::Value. Rides the per-screen override map to ScrollLayoutParams::alwaysCenterSingleColumn, beside CenterFocusedColumn.
|
inlineconstexpr |
Whether a column whose windows do not fill the work area is centred on the cross axis instead of hugging the start edge.
Boolean ActionParam::Value. Rides the per-screen override map to ScrollLayoutParams::centerShortColumns, beside AlwaysCenterSingleColumn.
|
inlineconstexpr |
Whether a column straddling the screen edge is clipped at the boundary (its true rect is kept, only the drawing is cropped).
Boolean ActionParam::Value. Read by BOTH the engine's straddler clamp and the compositor's paint clip, so the daemon pushes the resolved per-screen set to the effect as well as onto the engine's override map.
|
inlineconstexpr |
How a newly-opened column displays its windows: side by side, or stacked as tabs.
Closed enum token (ActionParam::Value, ColumnDisplayToken).
|
inlineconstexpr |
Width a newly-opened column takes, as a fraction of the work area.
Carries a numeric ActionParam::Value (the stored wire value is the fraction; the editor shows a percent).
|
inlineconstexpr |
Height a newly-opened window takes inside its column, as a fraction of the work-area height (numeric ActionParam::Value, edited as a percent; committed as a fixed pixel intent against the live work area).
|
inlineconstexpr |
Whether moving the pointer over a column focuses it on the matched context.
Boolean ActionParam::Value. EFFECT-consumed: focus-follows-mouse lives entirely in the compositor, so the daemon resolves this per screen and pushes the resolved set over org.phosphor_works.Placement.Scrolling rather than onto the engine's override map. It governs the SCROLLING half of the per-mode focus-follows-mouse split only — a snapping or tiling screen keeps reading the global setting.
|
inlineconstexpr |
Numeric ActionParam::Value in [MinFocusFollowsMouseMaxScrollRatio, MaxFocusFollowsMouseMaxScrollRatio], the furthest focus-follows-mouse may scroll the strip to reveal the window under the pointer, as a fraction of the viewport's extent along it.
1.0 is no cap. Editors show a percent.
|
inlineconstexpr |
Whether a window opening on the matched context takes focus.
Boolean ActionParam::Value. The per-window OpenFocused rule outranks this, and this outranks the global focus-new-windows setting.
|
inlineconstexpr |
Scrolling-mode template for the matched context: a NATIVE ScrollingTemplate id (its own picker kind, scrollingTemplate, with its own name resolution — not a manual layout).
It shares the LayoutId wire KEY with SetSnappingLayout but the two id namespaces are disjoint, and it fills its own cascade slot — the lossless mode-toggle contract stores it BESIDE the snapping layout in one rule, and sharing the layout slot would shadow one of the pair.
|
inlineconstexpr |
Where a fresh-opened window's new column enters the strip.
Closed enum token (ActionParam::Value, ScrollInsertPositionToken).
|
inlineconstexpr |
Whether the strip honours each window's declared minimum size when sizing its column.
Boolean ActionParam::Value. Off lets a column go narrower than the client asked for, which the compositor then clamps on commit.
|
inlineconstexpr |
Whether a lone column drops the outer gaps (niri's smart gaps).
Boolean ActionParam::Value. The CONFIG value forwards from the tiling toggle (the gap model is shared), but the rule slot is scrolling-only — a tiling screen keeps reading its own config.
|
inlineconstexpr |
How the strip treats windows shown on all desktops.
Closed enum token (ActionParam::Value, StickyWindowHandlingToken). The scrolling engine collapses both non-normal values to "float it", matching its single consumption site.
|
inlineconstexpr |
Which way the matched context's strip runs.
Closed enum token (ActionParam::Value, StripAxisToken — auto / horizontal / vertical, the same intent space as the Scrolling.StripAxis config key, where auto resolves from the work-area shape). Layered onto the engine's per-screen override map like its siblings; the daemon's axis membership publish to the KWin effect happens downstream of that map, so the effect follows without a channel of its own.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Tab colours. Hex ActionParam::Value, same shapes as the border colours.
|
inlineconstexpr |
Per-tab corner radius in px.
Numeric ActionParam::Value, signed like the gap: -1 is the "fully rounded" sentinel the config layer uses.
|
inlineconstexpr |
Whether tabbed columns show an indicator at all. Boolean ActionParam::Value.
|
inlineconstexpr |
Tab label font family.
Free string ActionParam::Value; EMPTY is a real value here, not an unset one — it means "use the system font" and is how a rule takes a screen back to the default after a global family was chosen.
|
inlineconstexpr |
Tab label font style flags.
Boolean ActionParam::Value each, one action per flag so a rule that italicises leaves underline and strikeout alone. There is deliberately no font SIZE action to pair with these: the painter auto-fits the label to the pill thickness, so a size would have nothing to change.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Tab label font weight on the CSS scale.
Numeric ActionParam::Value, 100..900.
|
inlineconstexpr |
Gap between indicator and window in px.
Numeric ActionParam::Value, and the one numeric action here whose range is SIGNED — a negative gap draws the indicator over the window, which is niri's behaviour.
|
inlineconstexpr |
Gap between individual tabs in px. Numeric ActionParam::Value.
|
inlineconstexpr |
Hide the indicator on a single-window tabbed column. Boolean ActionParam::Value.
|
inlineconstexpr |
|
inlineconstexpr |
Indicator length as a fraction of the column extent.
Numeric ActionParam::Value (stored fraction, edited as a percent).
|
inlineconstexpr |
Reserve the indicator out of the column instead of drawing beside it.
Boolean ActionParam::Value.
|
inlineconstexpr |
Which column edge the indicator runs along.
Closed enum token (ActionParam::Value, TabIndicatorPositionToken).
|
inlineconstexpr |
Title chips or a segment bar.
Closed enum token (ActionParam::Value, TabIndicatorStyleToken).
|
inlineconstexpr |
|
inlineconstexpr |
Indicator thickness in px. Numeric ActionParam::Value.
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Per-window override of the "unfloat falls back to a zone" setting.
A boolean value: true places a matched window into a zone when it is unfloated WITHOUT a remembered pre-float zone (last-used, else first empty, else first zone), even when the global snapUnfloatFallbackToZone setting is off; false suppresses the fallback so the window stays floating. Resolved mid-session by the daemon-injected unfloat-fallback predicate inside SnapEngine::resolveFallbackUnfloatGeometry, covering the live unfloat and the SnapAdaptor restore-calculation twin. Domain Window.
|
inlineconstexpr |
|
inlineconstexpr |
Per-window stacking-layer override.
Carries a closed enum token (ActionParam::Value, WindowLayerToken): above keeps the matched window above normal windows, below keeps it below, normal pins both flags off. Effect-consumed (reconcileRuleWindowLayer): the token maps onto KWin's keepAbove/keepBelow pair, BOTH flags are always written from the token (so a layer flip can never leave a stale opposite flag), the window's pre-rule flags are snapshotted on first application, and they are restored when no rule owns the layer any more. Combined with the IsFloating / IsTiled match fields this yields Krohnkite-style window layers ("floating windows above tiled windows"). Domain Window.
|
inlineconstexpr |
Snap a matched window into one or more zones on open.
Carries a list of 1-based zone ordinals (ActionParam::Zones) and/or a list of zone names (ActionParam::ZoneNames), at least one entry between them; a single target snaps to that zone, multiple targets snap to their unioned bounding rect (zone spanning). Both forms are layout-agnostic — an ordinal addresses "zone N of whatever layout is active on the window's screen" (matching the snapToZone1..9 shortcuts) and a name addresses "the zone called X in that layout", which lets one rule follow a zone across layouts that number it differently. Daemon-consumed (placement) on the SnapEngine open path; supersedes the retired per-layout Layout::appRules. Domain Window.
|
inlineconstexpr |
Per-window tab colours — niri's tab-indicator WINDOW rule, which recolours only the matched window's own tab.
These outrank the per-context colours above, which in turn outrank the config, which falls back to the theme: niri's exact resolution order. Hex ActionParam::Value.
|
inlineconstexpr |
|
inlineconstexpr |