pub struct Inspector<V: Binding<bool>> { /* private fields */ }Expand description
Window content beside a trailing inspector panel, visibility bound to visible
(docs/inspector.md).
ⓘ
let show = Signal::global(false);
inspector(show, editor(), || form((section((/* property rows */,)),)))panel is a builder rather than a piece because the panel can be re-homed: on a compact
window the composed form presents it inside a fullscreen sheet instead of a side pane, and
each home builds it fresh in its own scope.
Implementations§
Source§impl<V: Binding<bool>> Inspector<V>
impl<V: Binding<bool>> Inspector<V>
Sourcepub fn width(self, width: f64) -> Self
pub fn width(self, width: f64) -> Self
The panel’s preferred width in points (default INSPECTOR_WIDTH). Where the native
pane has a user-draggable divider this is the initial width, not a limit.
Sourcepub fn not_scrollable(self) -> Self
pub fn not_scrollable(self) -> Self
Do not wrap the panel in a scroll view (it is wrapped by default): for a panel that owns a recycling list or its own scroller, so it receives a bounded viewport.
Sourcepub fn sheet_done<M>(self, t: impl IntoText<M>) -> Self
pub fn sheet_done<M>(self, t: impl IntoText<M>) -> Self
The label of the compact sheet’s dismiss button (default ✕). Pass a localized
“Done”; the sheet is the one home where the panel needs its own way out.
Sourcepub fn edge(self, edge: PaneEdge) -> Self
pub fn edge(self, edge: PaneEdge) -> Self
Put the pane on the leading side of the content, for a layer panel rather than a
properties inspector (docs/tree.md). Default PaneEdge::Trailing.
Sourcepub fn half_sheet(self) -> Self
pub fn half_sheet(self) -> Self
On a compact window, present the panel as a half-height sheet rising from the bottom
edge rather than a fullscreen one, so the content it describes stays on show (and, on
iOS, interactive) while it is open: Cover::half_sheet.
Default: the fullscreen sheet.
Trait Implementations§
Source§impl<V: Binding<bool>> InspectorBuilder for Inspector<V>
impl<V: Binding<bool>> InspectorBuilder for Inspector<V>
Source§fn width(self, width: f64) -> Self
fn width(self, width: f64) -> Self
The panel’s preferred width in points (default
INSPECTOR_WIDTH). Where the native
pane has a user-draggable divider this is the initial width, not a limit.Source§fn not_scrollable(self) -> Self
fn not_scrollable(self) -> Self
Do not wrap the panel in a scroll view (it is wrapped by default): for a panel that owns
a recycling list or its own scroller, so it receives a bounded viewport.
Source§fn sheet_done<M>(self, t: impl IntoText<M>) -> Self
fn sheet_done<M>(self, t: impl IntoText<M>) -> Self
The label of the compact sheet’s dismiss button (default
✕). Pass a localized
“Done”; the sheet is the one home where the panel needs its own way out.Source§fn edge(self, edge: PaneEdge) -> Self
fn edge(self, edge: PaneEdge) -> Self
Put the pane on the leading side of the content, for a layer panel rather than a
properties inspector (docs/tree.md). Default
PaneEdge::Trailing.Source§fn half_sheet(self) -> Self
fn half_sheet(self) -> Self
On a compact window, present the panel as a half-height sheet rising from the bottom
edge rather than a fullscreen one, so the content it describes stays on show (and, on
iOS, interactive) while it is open:
Cover::half_sheet.
Default: the fullscreen sheet.Auto Trait Implementations§
impl<V> !RefUnwindSafe for Inspector<V>
impl<V> !Send for Inspector<V>
impl<V> !Sync for Inspector<V>
impl<V> !UnwindSafe for Inspector<V>
impl<V> Freeze for Inspector<V>where
V: Freeze,
impl<V> Unpin for Inspector<V>where
V: Unpin,
impl<V> UnsafeUnpin for Inspector<V>where
V: UnsafeUnpin,
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<P> Decorate for Pwhere
P: Piece,
impl<P> Decorate for Pwhere
P: Piece,
Source§fn id(self, id: ElementId) -> Decorated<Self>
fn id(self, id: ElementId) -> Decorated<Self>
Stable element identifier: a11y identifier + dayscript locator + lint uniqueness (§5.5). Read more
Source§fn wrapper_id(self, id: ElementId) -> Decorated<Self>
fn wrapper_id(self, id: ElementId) -> Decorated<Self>
Name the node that is outermost at this point in the chain: the padding box, the frame,
the background, whichever wrapper the modifiers before it built. For a dayscript frame
assertion on the wrapper rather than on the piece. Ordered, unlike
id.Source§fn apply_if(
self,
cond: bool,
f: impl FnOnce(Decorated<Self>) -> Decorated<Self>,
) -> Decorated<Self>
fn apply_if( self, cond: bool, f: impl FnOnce(Decorated<Self>) -> Decorated<Self>, ) -> Decorated<Self>
Apply
f to the chain when cond holds, else continue unchanged
(see Decorated::apply_if): nav(sel).apply_if(!primary, |n| n.local()). The
closure receives the decorated piece, so forwarded builder methods and modifiers both
chain inside it.Source§fn apply_some<T>(
self,
value: Option<T>,
f: impl FnOnce(Decorated<Self>, T) -> Decorated<Self>,
) -> Decorated<Self>
fn apply_some<T>( self, value: Option<T>, f: impl FnOnce(Decorated<Self>, T) -> Decorated<Self>, ) -> Decorated<Self>
Apply
f with the value when there is one, else continue unchanged
(see Decorated::apply_some): canvas(draw).apply_some(id, |c, id| c.id(id)).Source§fn id_of(self, id: impl Fn() -> ElementId + 'static) -> Decorated<Self>
fn id_of(self, id: impl Fn() -> ElementId + 'static) -> Decorated<Self>
Reactive element id: the id for rows inside a recycling
list. A plain
id is assigned once at build, but a recycled cell rebinds to different
items over its life (and drag-to-reorder rebinds eagerly), so a static item-derived id
keeps naming the first-bound item. This variant re-registers whenever the closure’s
value changes; read your ItemSlot inside it:
.id_of(move || day_core::id!(row_remove, slot.key())).Source§fn tweak(self, f: impl FnOnce(RNode) + 'static) -> Decorated<Self>
fn tweak(self, f: impl FnOnce(RNode) + 'static) -> Decorated<Self>
Apply a tweak:
f runs once at mount, after the native widget exists, with the
realized node (docs/tweaks.md). Reach the typed native handle through the compiled
backend’s ext accessor (day_appkit::with_native, day_gtk::with_native, …), or apply
a packaged day-tweak-* crate’s modifier instead of calling this directly. If the native
change affects the widget’s intrinsic size, follow it with
day_core::invalidate_size. Day may overwrite managed properties (title, value,
enabled, frame, a11y) on its next patch; unmanaged properties are stable. Read moreSource§fn selectable(self) -> Decorated<Self>
fn selectable(self) -> Decorated<Self>
Source§fn cursor<M>(self, cursor: impl IntoReactive<Cursor, M>) -> Decorated<Self>
fn cursor<M>(self, cursor: impl IntoReactive<Cursor, M>) -> Decorated<Self>
Shape the pointer while it is over this piece and its descendants (docs/cursor.md): a
Cursor constant, a Signal<Cursor>, or a closure, so a canvas tool or a busy state
moves the shape without rebuilding the piece. The nearest ancestor’s cursor wins, and
Cursor::Default releases the piece back to the platform. capability(Cap::Cursor)
says whether this toolkit draws the requested shapes, a nearest neighbor, or nothing;
a touch-only host never shows one, which is correct rather than a failure.Source§fn window_drag_region(self) -> Decorated<Self>
fn window_drag_region(self) -> Decorated<Self>
Let the user move the window by dragging this piece, as a title bar does
(docs/window-chrome.md): what a custom title bar in a
WindowChrome::Overlay or
WindowChrome::Frameless window needs. The piece’s own background starts the drag,
with the platform’s snapping and tiling; buttons and fields inside it keep their clicks;
a double click does what the user’s title-bar setting says (zoom, minimize, nothing).
capability(Cap::DragRegion); on a phone the piece is an ordinary view.Source§fn native_ref(self, r: &NativeRef) -> Decorated<Self>
fn native_ref(self, r: &NativeRef) -> Decorated<Self>
Capture a
NativeRef to this piece’s realized node for later imperative access
(docs/tweaks.md). The ref clears automatically when the piece’s scope is disposed.fn padding(self, insets: impl IntoInsets) -> Decorated<Self>
Source§fn max_width(self, max: f64) -> Decorated<Self>
fn max_width(self, max: f64) -> Decorated<Self>
Cap this piece’s width at
max points: the child is never PROPOSED more, so text
wraps inside the cap (chat bubbles, readable columns) while narrower content hugs.Source§fn reserving(self, sample: impl Into<String>) -> Decorated<Self>
fn reserving(self, sample: impl Into<String>) -> Decorated<Self>
Reserve at least the space
sample needs, so this piece’s size stops changing with its
content. Read morefn frame(self, width: f64, height: f64) -> Decorated<Self>
Source§fn width(self, width: f64) -> Decorated<Self>
fn width(self, width: f64) -> Decorated<Self>
Fix this piece’s width to
width points while its height stays flexible (hugging its
content or filling on the cross axis). The single-axis complement to Self::frame, e.g.
a fixed-width sidebar pane in a row whose height fills the window.Source§fn height(self, height: f64) -> Decorated<Self>
fn height(self, height: f64) -> Decorated<Self>
Fix this piece’s height to
height points while its width stays flexible. The single-axis
complement to Self::frame, e.g. a fixed-height header/toolbar bar that fills its width.fn a11y( self, f: impl FnOnce(A11yBuilder) -> A11yBuilder + 'static, ) -> Decorated<Self>
Source§fn on_tap(self, f: impl Fn() + 'static) -> Decorated<Self>
fn on_tap(self, f: impl Fn() + 'static) -> Decorated<Self>
Fire when this piece is tapped (bounding-box; shapes override with path-precise testing). Read more
Source§fn focused<M>(self, binding: impl IntoFocusBinding<M>) -> Decorated<Self>
fn focused<M>(self, binding: impl IntoFocusBinding<M>) -> Decorated<Self>
Bind this control’s keyboard focus to a signal (docs/focus.md), two-way like every other
binding: native focus changes write the signal; writing the signal moves focus. Takes a
Signal<bool> for one control, or (Signal<Option<K>>, K::Variant) binding one control
of a group; writing false/None resigns focus (dismissing the soft keyboard on
mobile). Focus applies asynchronously: a write is a request, resolved on the next turn,
and the signal always ends up reflecting what the platform actually did.Source§fn on_key(self, f: impl Fn(&KeyEvent) + 'static) -> Decorated<Self>
fn on_key(self, f: impl Fn(&KeyEvent) + 'static) -> Decorated<Self>
Handle the non-text keys (the arrows) that reach this piece while it has focus
(docs/menus.md). Keys follow focus, so pair it with
Decorate::focused or with a
piece the user can click into: a canvas takes focus on a press, and only the focused
piece hears the keys, so a nudge handler can never fire while a text field, a list or a
sidebar is the one being typed into. Read moreSource§fn toolbar<M>(self, content: impl ToolbarContent<M>) -> Decorated<Self>
fn toolbar<M>(self, content: impl ToolbarContent<M>) -> Decorated<Self>
Declare toolbar items on the chrome this piece sits under (docs/toolbars.md). Read more
Source§fn searchable(self, search: Search) -> Decorated<Self>
fn searchable(self, search: Search) -> Decorated<Self>
A search field for this navigation page (docs/search.md, “Page search”), drawn where the
platform puts a page’s search: the window toolbar on a desktop, the page’s navigation bar
on iOS (a
UISearchController), its app bar on Android. It shows while this page does, and
its text is the app’s query both ways. For a search the server runs, act on
crate::Search::on_submit; for a local filter, read the query. Declare it on a
nav_stack destination, as .toolbar(…) is declared; a whole navigation surface takes
crate::Nav::searchable instead.Source§fn focusable(self) -> Decorated<Self>
fn focusable(self) -> Decorated<Self>
Opt this piece into the platform’s focus system (docs/focus.md): the canvas contract
for anything composed: it joins the key loop, takes focus on a press, reports through
.focused(…), and hears the arrows through .on_key(…) while focused. A composed
list column is the motivating case (docs/navigation.md). On a backend without the
set_focusable duty the piece renders normally and never takes focus.Source§fn drag_source(
self,
source: impl Fn(Point) -> Option<Offer> + 'static,
) -> Decorated<Self>
fn drag_source( self, source: impl Fn(Point) -> Option<Offer> + 'static, ) -> Decorated<Self>
Attach a context menu, shown with the platform’s native affordance on secondary-click (desktop)
or long-press (mobile). Items are built with
menu_item/sub_menu/menu_role/
menu_separator. Passing an empty Vec removes any menu.fn drop_target(self, target: Target) -> Decorated<Self>
A context menu (docs/menus.md): shown on secondary-click / long-press, built from the
same
menu_item/sub_menu entries as everywhere else. Takes a fixed list, or a closure
built when the menu is summoned (“Dynamic context menus”): with no argument, or with the
summon point in this piece’s own coordinates, so a canvas can select what is under the
pointer and offer commands for that selection. An empty result shows nothing. Read morefn on_drag(self, f: impl Fn(Drag) + 'static) -> Decorated<Self>
Source§fn on_pinch(self, f: impl Fn(Pinch) + 'static) -> Decorated<Self>
fn on_pinch(self, f: impl Fn(Pinch) + 'static) -> Decorated<Self>
Fire on each phase of a pinch/magnify over this piece (docs/canvas.md “Zoom and
pan”). Only backends with a native recognizer wired emit it; pair a zoom with
visible controls.
Source§fn on_pan(self, f: impl Fn(Pan) + 'static) -> Decorated<Self>
fn on_pan(self, f: impl Fn(Pan) + 'static) -> Decorated<Self>
Fire on each viewport-pan event over this piece (docs/canvas.md “Zoom and pan”):
trackpad two-finger scroll, two-finger touch pan.
delta is incremental; apply it
as it arrives.Source§fn on_hover(self, f: impl Fn(Option<Point>) + 'static) -> Decorated<Self>
fn on_hover(self, f: impl Fn(Option<Point>) + 'static) -> Decorated<Self>
The pointer moving over this piece:
Some(point) in its own coordinates while inside,
None when it leaves (docs/canvas.md “Interaction”). Pointer-only; wire on_tap_at
alongside it so a touch-only device can reach the same thing.Source§fn card(self) -> Decorated<Self>
fn card(self) -> Decorated<Self>
Fill the piece’s bounds with a solid color painted behind it: a message-bubble / card /
badge surface. Accepts a constant
Color, a Signal<Color>, or a Fn() -> Color; a
reactive color repaints the surface when its source changes. Wraps the piece in a native
container that carries the fill, so it composes with Self::corner_radius for a rounded
colored surface and with Self::padding for interior inset.
The platform’s card around this piece: the grouped-content surface with rounded
corners and a Space::M inset (see Decorated::card).fn background<M>(self, color: impl IntoReactive<Color, M>) -> Decorated<Self>
Source§fn corner_radius(self, radius: f64) -> Decorated<Self>
fn corner_radius(self, radius: f64) -> Decorated<Self>
Round the piece’s corners to
radius points, clipping its background and content to the
rounded rectangle. Compose after Self::background for a rounded colored surface, or use
alone to round a clipped child (e.g. an avatar image).Source§fn opacity<M>(self, opacity: impl IntoReactive<f64, M>) -> Decorated<Self>
fn opacity<M>(self, opacity: impl IntoReactive<f64, M>) -> Decorated<Self>
Animate/set the piece’s opacity (
0.0 transparent … 1.0 opaque). Wrapped in a native
layer so it composes with .background; the change animates when made inside
with_animation or under a .animation ancestor (§8.4).Source§fn transform<M>(self, t: impl IntoReactive<Transform, M>) -> Decorated<Self>
fn transform<M>(self, t: impl IntoReactive<Transform, M>) -> Decorated<Self>
Apply an animatable
Transform (translate/scale/rotate about the center): the cheap
movement/scaling channel that never triggers relayout (§8.4). Prefer this over .offset
for animated motion.Source§fn scale<M>(self, factor: impl IntoReactive<f64, M>) -> Decorated<Self>
fn scale<M>(self, factor: impl IntoReactive<f64, M>) -> Decorated<Self>
Uniformly scale the piece by
factor about its center (animatable). Convenience over
Self::transform.Source§fn rotation<M>(self, degrees: impl IntoReactive<f64, M>) -> Decorated<Self>
fn rotation<M>(self, degrees: impl IntoReactive<f64, M>) -> Decorated<Self>
Rotate the piece by
degrees clockwise about its center (animatable).Source§fn translation<Mx, My>(
self,
x: impl IntoReactive<f64, Mx>,
y: impl IntoReactive<f64, My>,
) -> Decorated<Self>
fn translation<Mx, My>( self, x: impl IntoReactive<f64, Mx>, y: impl IntoReactive<f64, My>, ) -> Decorated<Self>
Translate the piece by (
x, y) points without relayout (animatable): the
animation-friendly sibling of .offset.Source§fn animation(self, anim: AnimSpec) -> Decorated<Self>
fn animation(self, anim: AnimSpec) -> Decorated<Self>
Attach an implicit animation (§8.4): changes to this piece’s (and its descendants’)
animatable properties animate with
anim even outside a with_animation. SwiftUI’s
.animation. The ambient with_animation takes precedence when both apply.Source§fn overlay(self, over: impl Piece) -> Decorated<Self>
fn overlay(self, over: impl Piece) -> Decorated<Self>
Draw
over on top of this piece, centered, without affecting layout size: a badge /
annotation overlay. self is the sizing content (bottom of the z-order); over is proposed
self’s size and drawn on top. For an explicit alignment use Self::overlay_aligned; for
a stack that sizes to the union of its children use zstack.Source§fn overlay_aligned(self, align: Alignment, over: impl Piece) -> Decorated<Self>
fn overlay_aligned(self, align: Alignment, over: impl Piece) -> Decorated<Self>
Self::overlay with an explicit Alignment for the annotation (e.g. a corner badge with
Alignment::TopTrailing).Source§fn aspect_ratio(self, ratio: f64) -> Decorated<Self>
fn aspect_ratio(self, ratio: f64) -> Decorated<Self>
Constrain this piece to a
width / height ratio: the largest box of that shape which
fits whatever the parent offers (SwiftUI’s .aspectRatio(_:contentMode: .fit)). Read moreSource§fn grow(self) -> Decorated<Self>
fn grow(self) -> Decorated<Self>
Expand to fill the available space on both axes (a filling pane / card that stretches to
its container). Wraps the piece in a layout-only node carrying grow
Flex: the stack
offers it the space and it fills; no native backing, so this is a pure layout change.Source§fn grid_align(self, a: Alignment) -> Decorated<Self>
fn grid_align(self, a: Alignment) -> Decorated<Self>
Override this cell’s alignment within its cell rect of the enclosing
grid
(docs/grid.md). Apply last (outermost), like Decorated::grid_span.Source§fn defers_system_gestures(self, edges: Edges) -> Decorated<Self>
fn defers_system_gestures(self, edges: Edges) -> Decorated<Self>
While this subtree is mounted, ask the OS to require a second swipe for its edge
gestures on
edges (docs/cover.md), the SwiftUI defersSystemGestures(on:)
analogue. Put it on a game or drawing surface whose touches run to the screen edge,
so a swipe up from the bottom doesn’t leave the app. iOS defers the chosen edges’
system gestures; Android enters swipe-to-reveal immersive mode while any subtree
requests deferral; desktop backends no-op.While this subtree is mounted and
hidden is true, hide the system status bar, the
SwiftUI statusBarHidden(_:) analogue (docs/cover.md). hidden is a constant, a
Signal, or a closure, so a setting can turn it on and off in place. Put it on a page
that wants the whole screen (a reader, a game, a photo viewer); the bar returns when
the page unmounts. Any mounted request that answers true hides the bar. iOS, Android and
HarmonyOS hide it (Cap::StatusBarHidden); desktop and web have none and ignore it.Source§fn interactive_dismiss_disabled(self) -> Decorated<Self>
fn interactive_dismiss_disabled(self) -> Decorated<Self>
While this subtree is mounted, the enclosing
cover (or other modal surface) must
not be dismissed interactively, the SwiftUI interactiveDismissDisabled() analogue
(docs/cover.md). System back / sheet gestures are ignored; only programmatic writes
(an explicit close control) dismiss it.impl<T> ErasedDestructor for Twhere
T: 'static,
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more