Struct FloatConfig 

pub struct FloatConfig {
    pub anchor: FloatAnchor,
    pub anchor_point: (Align, Align),
    pub self_point: (Align, Align),
    pub offset: Vec2Offset,
    pub fit: bool,
    pub clip: bool,
}

Takes a node out of flex flow: it doesn’t consume space in its parent, sizes Grow/Percent against its anchor, is positioned by attach points, and escapes ancestor clips unless FloatConfig::clip keeps it in its parent’s. It paints as a layer of its own — above the in-flow tree and every float that opened before it, under every one that opened after — and takes input in the same order (docs/adr/0023-layers-stack-in-the-order-they-open.md).

Fields

anchor: FloatAnchor

anchor_point: (Align, Align)

Attach point on the anchor rect (horizontal, vertical).

self_point: (Align, Align)

Attach point on the floating node itself.

offset: Vec2Offset

Extra offset applied after attaching, logical px.

fit: bool

Keep the float on screen: if the attached placement leaves the viewport on an axis, mirror the attachment across the anchor on that axis (below ↔ above, after ↔ before) when that fits better, then clamp whatever still overflows. Tooltips/menus want this.

This is the in-window approximation of an OS popup, and it is the one to reach for first: a float costs one tree, one hit list and one draw call. What it cannot do is leave the window — a dropdown taller than the viewport, or a menu with nowhere in-window to go, gets clamped rather than placed. Those want a popup window — which this release does not have: it is docs/adr/0004-multi-window.md’s step 4, and the ADR’s Consequences say so. So fit plus a modal float (docs/adr/0003-modal-surfaces.md) is not merely the first thing to reach for today, it is the only thing.

clip: bool

Take the parent’s clip, as a child does, instead of escaping every ancestor’s: a node on a clip canvas panned past the canvas’s edge is cut there, and its hit region with it, rather than drawn over and clicked through the toolbar beside it (backlog F90). Only a FloatAnchor::Parent float reads it — a viewport or node anchor is placed against something other than the parent, and escapes with it set or not. Paint order is unchanged: the float is still a layer of its own above its in-flow siblings, only cut. A line or polygon anchored in its parent’s box has it set by the core (ADR 0010, decision 5, as amended).

Implementations

impl FloatConfig

pub fn parent() -> FloatConfig

pub fn viewport() -> FloatConfig

pub fn below() -> FloatConfig

Tooltip-style: hang below the parent, centered.

pub fn above() -> FloatConfig

Tooltip-style: hover above the parent, centered.

pub fn at(self, x: Align, y: Align) -> FloatConfig

pub fn self_at(self, x: Align, y: Align) -> FloatConfig

pub fn inside(self, x: Align, y: Align) -> FloatConfig

Self::at and Self::self_at at the same point: the float sits inside the anchor against that edge or corner — (End, End) is a toast in the viewport’s bottom-right, (Center, Center) a dialog.

pub fn offset(self, x: f32, y: f32) -> FloatConfig

pub fn fit(self) -> FloatConfig

Flip across the anchor / clamp as needed to stay in the viewport; see FloatConfig::fit for where that stops being enough.

pub fn clipped(self) -> FloatConfig

Cut by the parent’s clip instead of escaping it; see FloatConfig::clip for which anchors read it.

pub fn clipped_by_parent(&self) -> bool

Whether this float takes its parent’s clip: FloatConfig::clip declared on a parent-anchored float. The one reading both paint passes and the hit regions share.

pub fn preset_at(i: usize) -> Option<FloatConfig>

A preset by its wire index — its position in FLOAT_PRESETS, which is what the binary protocol carries and what KUI_FLOAT_* counts from. None for an index no preset claims.

pub fn preset(name: &str) -> Option<FloatConfig>

A preset by name. Every binding that spells a float as a word — float="below", float = "above", kui_spec_float_preset — resolves it here, so “below” cannot mean one thing in JS and another in Lua.

pub fn build( base: FloatConfig, anchor_at: Option<(Align, Align)>, self_at: Option<(Align, Align)>, dx: Option<f32>, dy: Option<f32>, fit: bool, clip: bool, ) -> FloatConfig

One config from the pieces a binding can extract without deciding anything: a base preset (from FloatConfig::preset or FloatConfig::preset_at) and the overrides that were actually declared. None leaves the base’s own value — that is what lets float="below" keep its 6px gap while { anchor: "below", dx: 2 } moves it sideways without flattening the gap to zero. fit and clip are ORed in: no preset sets either.

Trait Implementations

impl Clone for FloatConfig

fn clone(&self) -> FloatConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for FloatConfig

impl Debug for FloatConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for FloatConfig

fn default() -> FloatConfig

Returns the “default value” for a type.

impl PartialEq for FloatConfig

fn eq(&self, other: &FloatConfig) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for FloatConfig