Struct View 

pub struct View { /* private fields */ }

A SwiftUI view with chainable modifiers.

Implementations

impl View

pub fn a11y_hint(self, hint: &str) -> Self

.accessibilityHint(_:) — what happens if the user activates this.

Examples found in repository

examples/inbox.rs (line 100)

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

examples/settings.rs (line 80)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

pub fn a11y_value(self, value: &str) -> Self

.accessibilityValue(_:) — what the control currently reads as, for one whose value is not its label.

Examples found in repository

examples/dashboard.rs (line 51)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

examples/todo.rs (line 80)

fn row(i: usize, it: &Item) -> View {
    hstack_spacing(
        &[
            // The checkmark is the button, so the whole symbol is the target.
            button_labelled(
                system_image(if it.done { "checkmark.circle.fill" } else { "circle" })
                    .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                    .view()
                    .fg_system(if it.done { SystemColor::Green } else { SystemColor::Gray }),
                move || toggle(i),
            )
            .button_style(views::ButtonStyle::Bordered),
            text(&it.title)
                .strikethrough_styled(it.done, LinePattern::Solid, None)
                .fg_system(if it.done { SystemColor::Gray } else { SystemColor::Primary }),
            spacer(),
        ],
        10.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(6.0))
    .a11y_label(&it.title)
    .a11y_value(if it.done { "Done" } else { "Not done" })
}

pub fn a11y_identifier(self, id: &str) -> Self

.accessibilityIdentifier(_:) — the name a UI test finds this by, not something VoiceOver speaks.

pub fn a11y_add_traits(self, traits: &[AccessibilityTrait]) -> Self

.accessibilityAddTraits(_:)

pub fn a11y_remove_traits(self, traits: &[AccessibilityTrait]) -> Self

.accessibilityRemoveTraits(_:)

pub fn a11y_heading(self, level: HeadingLevel) -> Self

.accessibilityHeading(_:) — which heading level this is, so VoiceOver can navigate by them.

pub fn a11y_sort_priority(self, priority: f64) -> Self

.accessibilitySortPriority(_:) — higher is read first.

pub fn a11y_input_labels(self, labels: &[&str]) -> Self

.accessibilityInputLabels(_:) — the phrases Voice Control accepts for this, when the visible label is awkward to say.

pub fn a11y_responds_to_interaction(self, responds: bool) -> Self

.accessibilityRespondsToUserInteraction(_:)

pub fn a11y_text_content_type(self, kind: TextContentType) -> Self

.accessibilityTextContentType(_:) — what kind of text this is, which changes how VoiceOver reads it.

pub fn a11y_action(self, kind: ActionKind, action: impl Fn() + 'static) -> Self

.accessibilityAction(_:_:) — an action VoiceOver can perform without a visible control for it.

pub fn a11y_actions(self, category: ActionCategory, content: View) -> Self

.accessibilityActions(category:content:) — several, as a group.

pub fn a11y_adjustable_action(self, action: impl Fn(i64) + 'static) -> Self

.accessibilityAdjustableAction(_:) — what a swipe up or down does, which is how VoiceOver drives a slider or stepper.

pub fn a11y_scroll_action(self, action: impl Fn(i64) + 'static) -> Self

.accessibilityScrollAction(_:)

pub fn a11y_zoom_action(self, action: impl Fn() + 'static) -> Self

.accessibilityZoomAction(_:)

pub fn a11y_element(self, children: AccessibilityChildBehavior) -> Self

.accessibilityElement(children:) — whether descendants are merged into one element, kept as a container, or dropped.

Examples found in repository

examples/dashboard.rs (line 49)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

pub fn a11y_children(self, children: View) -> Self

.accessibilityChildren(children:) — a different subtree for VoiceOver than the one on screen.

pub fn a11y_representation(self, representation: View) -> Self

.accessibilityRepresentation(representation:) — stand in for this view with a description of a standard control.

pub fn a11y_labeled_pair( self, role: LabeledPairRole, id: HashableValue<'_>, ) -> Self

.accessibilityLabeledPair(role:id:) — tie a label to the thing it labels, so they are read together.

pub fn a11y_linked_group<'h>(self, id: impl IntoHashable<'h>) -> Self

.accessibilityLinkedGroup(id:)

pub fn a11y_custom_content( self, key_label: &str, id: &str, value: &str, importance: CustomContentImportance, ) -> Self

.accessibilityCustomContent(_:_:importance:) — extra detail VoiceOver reads on request rather than always.

pub fn a11y_activation_point(self, x: f64, y: f64) -> Self

.accessibilityActivationPoint(_:) — where a VoiceOver double-tap lands, for a control whose centre is not where it should be pressed.

pub fn a11y_drag_point(self, x: f64, y: f64, description: &str) -> Self

.accessibilityDragPoint(_:description:)

pub fn a11y_drop_point(self, x: f64, y: f64, description: &str) -> Self

.accessibilityDropPoint(_:description:)

pub fn a11y_direct_touch( self, enabled: bool, options: &[DirectTouchOption], ) -> Self

.accessibilityDirectTouch(_:options:) — for a view that handles raw touches itself, like an instrument or a drawing canvas.

pub fn a11y_scroll_status(self, status: &str) -> Self

.accessibilityScrollStatus(_:) — what to announce after a scroll.

pub fn a11y_shows_large_content_viewer(self) -> Self

.accessibilityShowsLargeContentViewer()

impl View

pub fn accessibility_action( self, kind: ActionKind, action: impl Fn() + 'static, ) -> Self

Apply .accessibilityAction(_:_:).

pub fn accessibility_actions( self, category: ActionCategory, content: View, ) -> Self

Apply .accessibilityActions(category:_:).

pub fn accessibility_activation_point(self, x: f64, y: f64) -> Self

Apply .accessibilityActivationPoint(_:).

A UnitPoint is two CGFloats and frozen, so it arrives in d0 and d1 rather than by address.

pub fn accessibility_add_traits(self, traits: &[AccessibilityTrait]) -> Self

Apply .accessibilityAddTraits(_:).

pub fn accessibility_adjustable_action( self, action: impl Fn(i64) + 'static, ) -> Self

Apply .accessibilityAdjustableAction(_:).

The direction reaches the callback as a case number: 0 is .increment, 1 is .decrement.

pub fn accessibility_chart_descriptor(self) -> Self

Apply .accessibilityChartDescriptor(_:) with a synthesized representable.

No public SwiftUI type conforms to AXChartDescriptorRepresentable — the protocol exists for applications to adopt — so the conformance is built at run time and hung on EdgeInsets, which the reference can name too.

pub fn accessibility_children(self, children: View) -> Self

Apply .accessibilityChildren(children:).

pub fn accessibility_custom_content( self, key_label: &str, id: &str, value: &str, importance: CustomContentImportance, ) -> Self

Apply .accessibilityCustomContent(_:_:importance:).

The key is built first, through AccessibilityCustomContentKey.init(_:id:) — four words of LocalizedStringKey and two of String, returning the key through x8 because it is resilient. The modifier then takes that key by address, its own label as another LocalizedStringKey, and the importance in a register.

pub fn accessibility_default_focus(self, value: bool) -> Self

Apply .accessibilityDefaultFocus(_:_:).

The binding’s Value is generic here, which makes FocusState<A>.Binding address-only — unlike the concrete focused(_:), where it travels in three registers.

pub fn accessibility_deprecated_identifier(self, id: &str) -> Self

Apply .accessibility(identifier:), the pre-accessibilityIdentifier name.

pub fn accessibility_direct_touch( self, enabled: bool, options: &[DirectTouchOption], ) -> Self

Apply .accessibilityDirectTouch(_:options:).

pub fn accessibility_drag_point( self, x: f64, y: f64, description: &str, enabled: bool, ) -> Self

Apply .accessibilityDragPoint(_:description:isEnabled:).

pub fn accessibility_drop_point( self, x: f64, y: f64, description: &str, enabled: bool, ) -> Self

Apply .accessibilityDropPoint(_:description:isEnabled:).

pub fn accessibility_element(self, v0: AccessibilityChildBehavior) -> Self

Apply .accessibilityElement(_:).

pub fn accessibility_focused(self) -> Self

Apply .accessibilityFocused(_:).

pub fn accessibility_heading(self, level: HeadingLevel) -> Self

Apply .accessibilityHeading(_:).

pub fn accessibility_hidden(self, hidden: bool) -> Self

Apply .accessibilityHidden(_:).

pub fn accessibility_hint(self, hint: &str) -> Self

Apply .accessibilityHint(_:).

pub fn accessibility_identifier(self, id: &str) -> Self

Apply .accessibilityIdentifier(_:).

pub fn accessibility_ignores_invert_colors(self, value: bool) -> Self

Apply .accessibilityIgnoresInvertColors(_:).

pub fn accessibility_input_labels(self, labels: &[&str], enabled: bool) -> Self

pub fn accessibility_label(self, label: &str) -> Self

Apply .accessibilityLabel(_:).

pub fn accessibility_labeled_pair<'h>( self, role: LabeledPairRole, id: impl IntoHashable<'h>, ) -> Self

Apply .accessibilityLabeledPair(role:id:in:).

pub fn accessibility_linked_group<'h>(self, id: impl IntoHashable<'h>) -> Self

Apply .accessibilityLinkedGroup(id:in:).

pub fn accessibility_remove_traits(self, traits: &[AccessibilityTrait]) -> Self

Apply .accessibilityRemoveTraits(_:).

pub fn accessibility_representation(self, representation: View) -> Self

Apply .accessibilityRepresentation(representation:).

pub fn accessibility_responds_to_user_interaction(self, responds: bool) -> Self

Apply .accessibilityRespondsToUserInteraction(_:).

pub fn accessibility_rotor(self, label: &str, text: &str) -> Self

Apply .accessibilityRotor(_:textRanges:).

The ranges are real Range<String.Index> values taken from text — one spanning the whole string. Range is frozen and its two bounds are stored back to back, so the array elements are built directly rather than through an initialiser.

pub fn accessibility_rotor_entry<'h>(self, id: impl IntoHashable<'h>) -> Self

Apply .accessibilityRotorEntry(id:in:).

pub fn accessibility_scroll_action(self, action: impl Fn(i64) + 'static) -> Self

Apply .accessibilityScrollAction(_:).

The edge reaches the callback as a case number, in Edge’s declared order: top, leading, bottom, trailing.

pub fn accessibility_scroll_status(self, status: &str, enabled: bool) -> Self

Apply .accessibilityScrollStatus(_:isEnabled:).

pub fn accessibility_selection_identifier<'h>( self, id: impl IntoHashable<'h>, ) -> Self

.accessibility(selectionIdentifier:) — which item of a selectable group this is, for assistive technologies.

Deprecated in Swift, with no modern replacement — accessibilityIdentifier is a different thing (a test hook). Bound because it is the one member of that family the crate could not otherwise reach.

The argument is AnyHashable, which is three words: the boxed value, its metadata and its Hashable witness.

pub fn accessibility_shows_large_content_viewer(self) -> Self

Apply .accessibilityShowsLargeContentViewer(_:).

pub fn accessibility_sort_priority(self, priority: f64) -> Self

Apply .accessibilitySortPriority(_:).

pub fn accessibility_text_content_type(self, kind: TextContentType) -> Self

Apply .accessibilityTextContentType(_:).

pub fn accessibility_value(self, value: &str, enabled: bool) -> Self

Apply .accessibilityValue(_:isEnabled:).

pub fn accessibility_zoom_action(self, action: impl Fn() + 'static) -> Self

Apply .accessibilityZoomAction(_:).

pub fn allowed_dynamic_range(self, range: DynamicRange) -> Self

Apply .allowedDynamicRange(_:).

pub fn allows_hit_testing(self, value: bool) -> Self

Apply .allowsHitTesting(_:).

pub fn allows_tightening(self, value: bool) -> Self

Apply .allowsTightening(_:).

pub fn allows_window_activation_events(self, allows: Option<bool>) -> Self

Apply .allowsWindowActivationEvents(_:).

pub fn animation_kind(self, kind: AnimationKind, value: i64) -> Self

.animation(_:value:) with the curve named.

pub fn aspect_ratio_content_mode( self, ratio: Option<f64>, mode: ContentMode, ) -> Self

.aspectRatio(_:contentMode:) with the mode named rather than spelled as a bool.

None for the ratio means “keep whatever the content already has”, which is not the same as Some(1.0).

pub fn background(self, r: f64, g: f64, b: f64, a: f64) -> Self

Apply .background(_:) with a Color.

pub fn background_any_gradient(self, color: u64) -> Self

Apply .background(_:) with an AnyGradient — what .indigo.gradient is.

pub fn background_content(self, content: View, alignment: Alignment) -> Self

Apply .background(alignment:content:).

The same call as .overlay(alignment:content:) with a different symbol: an Alignment in x0/x1, the content closure and its context in x2/x3, four generic words after that. The colour-taking background next door is a different overload entirely — that one is generic over ShapeStyle, this one over View.

pub fn background_extension_effect(self) -> Self

Apply .backgroundExtensionEffect(_:).

pub fn background_in_circle(self) -> Self

Apply .background(in:fillStyle:) — the background style, clipped to a shape.

The shape must be InsettableShape, not merely Shape, so its witness is a different table from the one super::Shape carries.

pub fn background_linear_gradient( self, colors: &[Color], start: (f64, f64), end: (f64, f64), ) -> Self

Apply .background(LinearGradient(colors:startPoint:endPoint:)).

pub fn background_material(self, kind: MaterialKind) -> Self

Apply .background(_: Material) — the blur materials.

pub fn background_radial_gradient( self, colors: &[Color], center: (f64, f64), start_radius: f64, end_radius: f64, ) -> Self

Apply .background(RadialGradient(colors:center:startRadius:endRadius:)).

pub fn background_style_color(self, r: f64, g: f64, b: f64, a: f64) -> Self

.backgroundStyle(_:) with a Color.

background_style_of takes the style as raw bytes and a witness, which is what an arbitrary ShapeStyle needs and what nothing can call without building one first. These three name the styles that have a Rust spelling, so the modifier is reachable the way the documentation writes it.

Not .background(_:): that draws behind this view, while this says what style the views inside should use for their own backgrounds.

pub fn background_style_hierarchical(self, level: Hierarchical) -> Self

.backgroundStyle(_:) with one of the hierarchical levels.

pub fn background_style_value(self, color: u64) -> Self

.backgroundStyle(_:) with an already-resolved Color word.

pub fn badge(self, value: i64) -> Self

Apply .badge(_:).

pub fn border_value(self, color: u64, width: f64) -> Self

Apply .border(_:width:) with a Color that is already built.

For one of SwiftUI’s named colours: Color.gray is semantic and no set of components spells it. See system_color.

pub fn button_style_glass_clear(self) -> Self

Apply .buttonStyle(.glass(.clear)).

.glass(_:) is a static on a PrimitiveButtonStyle extension constrained to GlassButtonStyle — the shape that has been inlinable every other time in this file. This one is exported, which is only knowable by looking.

pub fn clip_rounded_rect(self, radius: f64) -> Self

Apply .clipShape(RoundedRectangle(cornerRadius:)).

pub fn clip_rounded_rect_styled(self, radius: f64, continuous: bool) -> Self

Apply .clipShape(RoundedRectangle(cornerRadius:style:)).

As with super::rounded_rectangle_styled, the style is not optional here even though Swift source can leave it out: leaving it out means .continuous, and writing case 0 builds the other shape.

pub fn color_effect(self, shader: &Shader) -> Self

Apply .colorEffect(_:) — recolours each pixel.

pub fn color_invert(self) -> Self

Apply .colorInvert(_:).

pub fn confirmation_message( self, title: &str, actions: View, message: View, presented: bool, ) -> Self

confirmationDialog(…actions:message:) with a fixed flag, which cannot be dismissed — see confirmation_dialog.

pub fn container_value<T: KeyValue>( self, key: &CustomContainerKey<T>, value: impl IntoKeyValue<T>, ) -> Self

.containerValue(\.key, value) for a key defined here.

What the @_alwaysEmitIntoClient modifier’s body does, since the modifier itself exports no symbol: build a _ContainerValueWritingModifier and apply it with .modifier(_:).

pub fn corner_radius(self, radius: f64) -> Self

Apply .cornerRadius(_:).

Examples found in repository

examples/common/spec.rs (line 648)

fn decorate(mut v: View, node: &Node) -> Result<View, String> {
    if let Some(p) = node.f64_attr("pad") {
        v = v.padding(p);
    }
    if let Some(size) = node.attr("frame") {
        let (w, h) = parse_size(size, node.line)?;
        v = v.frame(w, h);
    }
    if let Some(o) = node.f64_attr("opacity") {
        v = v.opacity(o);
    }
    if let Some(c) = node.attr("bg") {
        let c = parse_color(c, node.line)?;
        v = v.bg(c);
    }
    if let Some(r) = node.f64_attr("corner") {
        v = v.corner_radius(r);
    }
    Ok(v)
}

pub fn custom_animation(self, curve: &CustomAnimationCurve, value: i64) -> Self

.animation(Animation(curve), value:) with a curve written in Rust.

pub fn custom_button_style(self, style: &CustomButtonStyle) -> Self

.buttonStyle(_:) with a style written in Rust.

pub fn custom_label_style(self, style: &CustomLabelStyle) -> Self

.labelStyle(_:) with a style written in Rust.

pub fn custom_modifier(self, modifier: &CustomModifier) -> Self

.modifier(_:) with a modifier written in Rust.

The result is ModifiedContent<Self, RustModifier> — a concrete type, not an opaque one, because modifier<T>(_:) says so. T is unconstrained there, so no witness table is passed at the call: SwiftUI finds the conformance by lookup when it renders, which is exactly why registering it matters.

pub fn custom_transition(self, transition: &CustomTransition) -> Self

.transition(_:) with a transition written in Rust.

Wrapped in an AnyTransition on the way, because that is what transition<T: Transition>(_:) does: it is @_alwaysEmitIntoClient and exports no symbol, so the binding calls what its body calls.

pub fn delete_disabled(self, value: bool) -> Self

Apply .deleteDisabled(_:).

pub fn dialog_icon(self, system_name: Option<&str>) -> Self

Apply .dialogIcon(_:).

pub fn dialog_prevents_app_termination(self, prevents: Option<bool>) -> Self

Apply .dialogPreventsAppTermination(_:).

pub fn dialog_severity(self, value: DialogSeverity) -> Self

pub fn dialog_suppression_toggle(self, state: &BoundState<bool>) -> Self

Apply .dialogSuppressionToggle(isSuppressed:).

pub fn dialog_suppression_toggle_labelled( self, label: &str, state: &BoundState<bool>, ) -> Self

Apply .dialogSuppressionToggle(_:isSuppressed:) with a label.

Seven integer arguments — four for the key, three for the binding — so Self.Type and the witness table travel on the stack rather than in registers.

pub fn disable_autocorrection(self, disable: Option<bool>) -> Self

Apply .disableAutocorrection(_:).

pub fn distortion_effect(self, shader: &Shader, max_w: f64, max_h: f64) -> Self

Apply .distortionEffect(_:maxSampleOffset:) — warps geometry.

pub fn drag_gesture(self, minimum_distance: f64) -> Self

Attach a DragGesture.

pub fn draggable_text(self, text: &str) -> Self

Apply .draggable(_:) with a String payload.

The overload everything else calls draggable: drag this view and a piece of text comes out, droppable anywhere that takes one. The containerItemID: binding next door is a different modifier for a different job — reordering within a container.

String because it is the Transferable conformer that needs no bridging: its witness is exported from CoreTransferable, and its value is two loadable words. A Data or a URL payload would each need their own.

pub fn environment_model(self, model: &Model) -> Self

.environment(model) — put the model where every view below can read it.

The Observable overload. A body that reads a property of the model through Model::get while SwiftUI is tracking it is re-run when that property changes; one that reads a different property is not.

pub fn environment_value<T: KeyValue>( self, key: &CustomEnvKey<T>, value: impl IntoKeyValue<T>, ) -> Self

.environment(\.key, value) for a key defined here.

pub fn equatable(self) -> Self

.equatable() — wrap a view in EquatableView, whatever its type.

equatable_text does this for a Text and nothing else, because the mangled name it resolves names Text. The constraint is Content: Equatable & View, and whether a given type satisfies it is a question the runtime can answer — so this asks, instead of the binding deciding in advance which one type is allowed.

The bound is genuine, not a limitation here: a view erased into AnyView is not Equatable and cannot be made so. That is what the panic says, and it is the same thing Swift’s type checker would say at the call site.

Wrapping is the whole of it — equatable() is @inlinable with the body EquatableView(content: self), and EquatableView stores only its content, so the value is the content’s own bytes copied through its value witness. A raw memcpy would work for a Text and leak a reference for anything holding one.

pub fn file_dialog_browser_options( self, value: FileDialogBrowserOptions, ) -> Self

pub fn file_dialog_confirmation_label(self, value: &str) -> Self

Apply .fileDialogConfirmationLabel(_:).

pub fn file_dialog_customization_id(self, value: &str) -> Self

Apply .fileDialogCustomizationID(_:).

pub fn file_dialog_default_directory(self, path: Option<&str>) -> Self

Apply .fileDialogDefaultDirectory(_:).

pub fn file_dialog_imports_unresolved_aliases(self, value: bool) -> Self

Apply .fileDialogImportsUnresolvedAliases(_:).

pub fn file_dialog_message(self, value: &str) -> Self

Apply .fileDialogMessage(_:).

pub fn file_dialog_url_enabled(self, enabled: bool) -> Self

Apply .fileDialogURLEnabled(_:).

The argument is a Foundation.Predicate<Pack{URL}>, which the #Predicate macro normally builds from an expression tree at compile time. Predicate also exposes .true and .false as statics, and those are values rather than syntax — so they are reachable from here, where an arbitrary predicate is not.

The type is generic over a parameter pack, whose mangling closes with _QP rather than directly; see crate::mangle::pack.

pub fn file_exporter_filename_label(self, value: &str) -> Self

Apply .fileExporterFilenameLabel(_:).

pub fn find_disabled(self, value: bool) -> Self

Apply .findDisabled(_:).

pub fn flips_for_right_to_left_layout_direction(self, value: bool) -> Self

Apply .flipsForRightToLeftLayoutDirection(_:).

pub fn focus_effect_disabled(self, value: bool) -> Self

Apply .focusEffectDisabled(_:).

pub fn focus_section(self) -> Self

Apply .focusSection(_:).

pub fn focused_on(self, projection: [u64; 3]) -> Self

Apply .focused(_:) with a real, installed @FocusState.

focused applies the same modifier with a FocusState built on the spot, which is what SwiftUI stores either way but leaves nothing to read or move. This takes the projection of a property SwiftUI has installed, so crate::state::ComposedView::focus reports whether the field has focus and crate::state::ComposedView::set_focus puts it there.

pub fn focused_scene_object(self) -> Self

Apply .focusedSceneObject(_:).

pub fn focused_scene_value<T: KeyValue>( self, key: &FocusKey<T>, value: impl IntoKeyValue<T>, ) -> Self

.focusedSceneValue(keyPath, value) — publish a value for the whole scene.

What a window tells the menu bar about its selection. The scene form is the one commands read; focused_value_keyed is the same thing scoped to whatever currently has focus.

Examples found in repository

examples/scenes.rs (line 68)

fn main_window() -> ViewHandle {
    vstack(&[
        text("A SwiftUI app, no Swift source")
            .font_size(20.0)
            .padding(8.0),
        divider(),
        text(&format!("count: {}", counter().get()))
            .font_size(34.0)
            .padding(12.0),
        hstack(&[
            button("−", || counter().set(counter().get() - 1)),
            button("+", || counter().set(counter().get() + 1)),
        ]),
        spacer(),
        text("⌘, for Settings · the ★ in the menu bar has a menu")
            .font_size(11.0)
            .opacity(0.6),
    ])
    .padding(24.0)
    .frame(420.0, 300.0)
    .focused_scene_value(counter_focus_key(), counter().get())
    .into_handle()
}

pub fn focused_value_keyed<T: KeyValue>( self, key: &FocusKey<T>, value: impl IntoKeyValue<T>, ) -> Self

.focusedValue(keyPath, value) — publish a value for the focused view.

pub fn focused_value_model(self, model: &Model) -> Self

.focusedValue(model) — publish the model for the commands above it.

The object form of what crate::views::focused_scene_value does with a key path, and the one Apple now recommends: a key is a type, and an @Observable object already is one.

pub fn font_apply(self, font: u64) -> Self

Apply an already-built raw Font value with .font(_:).

pub fn font_custom(self, name: &str, size: f64) -> Self

Apply .font(.custom(_:size:)).

pub fn font_system( self, size: f64, weight: Option<Weight>, design: Option<Design>, ) -> Self

Apply .font(.system(size:weight:design:)).

pub fn font_text_style(self, style: TextStyle) -> Self

Apply .font(_:) with one of the built-in text styles.

pub fn font_weight(self, weight: Weight) -> Self

Apply .fontWeight(_:).

pub fn foreground_color(self, color: Option<Color>) -> Self

Apply .foregroundColor(_:).

pub fn foreground_color_value(self, color: u64) -> Self

Apply .foregroundColor(_:), the deprecated environment-writing one.

Not foreground_style_color: this produces _EnvironmentKeyWritingModifier<Color?> and that produces _ForegroundStyleModifier<Color>. They render the same. Apply .foregroundColor(_:) to a Color that is already built.

For one of SwiftUI’s named colours, which no set of components can spell. See super::system_color.

pub fn foreground_style_color(self, r: f64, g: f64, b: f64, a: f64) -> Self

Apply .foregroundStyle(_:) with a colour.

Named for what it does, not for .foregroundColor(_:) — which is deprecated and a different thing: it writes an environment key, producing _EnvironmentKeyWritingModifier<Color?> where this produces _ForegroundStyleModifier<Color>. The two render alike, so only a type-level comparison tells them apart. See foreground_color for the other one.

pub fn foreground_style_hierarchical(self, level: Hierarchical) -> Self

Apply .foregroundStyle(.linearGradient(colors:startPoint:endPoint:)).

The shorthand in Swift source is a protocol-extension static marked @inlinable, so it has no symbol; the LinearGradient it builds does. Apply .foregroundStyle(_:) with one of the hierarchical levels — .secondary and friends.

pub fn foreground_style_linear_gradient( self, colors: &[u64], start: (f64, f64), end: (f64, f64), ) -> Self

pub fn foreground_style_pair(self, primary: u64, secondary: u64) -> Self

Apply .foregroundStyle(_:_:) — a primary and a secondary style.

What symbolRenderingMode(.palette) needs: a palette symbol takes its layers from successive styles, and with only one it renders as monochrome.

pub fn foreground_style_triple( self, primary: u64, secondary: u64, tertiary: u64, ) -> Self

Apply .foregroundStyle(_:_:_:) — three styles.

A palette symbol takes its layers from successive styles. foreground_style_pair covers the two-layer symbols; the three-layer ones — and there are plenty in SF Symbols — rendered their third layer in the secondary colour, because there was no way to say what it should be.

Eleven words of arguments, so three spill: the three style addresses and Self.Type fill x0–x3, the three style types and the Self: View witness take x4–x7, and all three ShapeStyle witnesses go to the stack.

Spilling only two of them — which is easy to do, since the pair version next door fits in eight words exactly and spills none — left the callee reading a stale word as a witness table. It did not fault there: it faulted much later inside swift::MetadataCacheKey::operator==, recursing on a type built from the garbage, which is what an argument-count mistake looks like from the outside.

pub fn foreground_style_value(self, color: u64) -> Self

Apply .foregroundStyle(_:) to a Color that is already built.

The components overload above cannot express Color.blue: SwiftUI’s named colours are semantic, not literal, and resolve per appearance — the aqua Color.blue is nowhere near (0, 0, 1). This takes the value a static getter handed back instead. See super::system_color.

pub fn frame_max_infinity(self, alignment: Alignment) -> Self

Apply .frame(maxWidth:maxHeight:alignment:) with .infinity for both.

Six Optional<CGFloat>s — min, ideal and max for each axis — then an Alignment, then the two generic words. Each optional is payload and tag, so that is sixteen words in all: x0 through x7 carry the first four optionals and the remaining eight go on the stack. The generic arguments come after every formal parameter, which is what makes them spill; putting them in x6 and x7 builds a frame out of the metadata pointers.

pub fn frame_max_width(self, alignment: Alignment) -> Self

Apply .frame(maxWidth: .infinity) — the width only.

Not frame_max_infinity, which sets both axes. Swift’s .frame(maxWidth: .infinity) leaves maxHeight nil, so the view keeps its content’s height; setting both stretched a card to fill its canvas and moved everything in it.

Six Optional<CGFloat>s — min, ideal and max for each axis — then an Alignment, then the two generic words. Each optional is payload and tag, so that is sixteen words in all: x0 through x7 carry the first four optionals and the remaining eight go on the stack. The generic arguments come after every formal parameter, which is what makes them spill; putting them in x6 and x7 builds a frame out of the metadata pointers.

pub fn gesture<V: GestureData>( self, g: &GestureValue<V>, mask: GestureMask, ) -> Self

.gesture(_:including:).

pub fn glass_effect(self) -> Self

Apply .glassEffect() — Liquid Glass, in its default shape.

The result type is a StaticIf<GlassEnabledPredicate, ...>: SwiftUI picks between the glass-modified view and the original at runtime depending on whether the platform has Liquid Glass enabled.

pub fn glass_effect_id<'h>(self, id: Option<impl IntoHashable<'h>>) -> Self

Apply .glassEffectID(_:in:).

pub fn glass_effect_kind(self, glass: Glass) -> Self

The same, with the variant named.

Identity is the no-op: it still builds the StaticIf, so the view’s type is the one a glass effect gives it, with nothing drawn. That is what makes it usable as the “off” end of a condition without the two branches disagreeing about their type.

pub fn glass_effect_transition(self, value: GlassEffectTransition) -> Self

pub fn glass_effect_union<'h>(self, id: Option<impl IntoHashable<'h>>) -> Self

Apply .glassEffectUnion(id:namespace:).

pub fn grid_cell_columns(self, value: i64) -> Self

Apply .gridCellColumns(_:).

pub fn help(self, value: &str) -> Self

Apply .help(_:).

pub fn help_text(self, value: &str) -> Self

Apply .help(_:).

pub fn high_priority_gesture_of<V: GestureData>( self, g: &GestureValue<V>, mask: GestureMask, ) -> Self

.highPriorityGesture(_:including:) — this gesture wins over the view’s own.

pub fn horizontal_radio_group_layout(self) -> Self

Apply .horizontalRadioGroupLayout(_:).

pub fn interaction_activity_tracking_tag(self, value: &str) -> Self

Apply .interactionActivityTrackingTag(_:).

pub fn interactive_dismiss_disabled(self, value: bool) -> Self

Apply .interactiveDismissDisabled(_:).

pub fn invalidatable_content(self, value: bool) -> Self

Apply .invalidatableContent(_:).

pub fn label_icon_to_title_spacing(self, value: f64) -> Self

Apply .labelIconToTitleSpacing(_:).

pub fn label_reserved_icon_width(self, value: f64) -> Self

Apply .labelReservedIconWidth(_:).

pub fn labels_hidden(self) -> Self

Apply .labelsHidden(_:).

pub fn layer_effect(self, shader: &Shader, max_w: f64, max_h: f64) -> Self

Apply .layerEffect(_:maxSampleOffset:) — can sample neighbouring pixels.

pub fn layout_priority(self, value: f64) -> Self

Apply .layoutPriority(_:).

pub fn layout_value_int(self, value: i64) -> Self

Apply .layoutValue(key:value:) with a runtime-synthesized key.

A second protocol through the same machinery as preference_int, to show nothing about it is specific to PreferenceKey.

pub fn list_item_tint(self, tint: Option<ListItemTint>) -> Self

Apply .listItemTint(_:).

None clears the tint, which is the nil the modifier’s ListItemTint? parameter takes.

pub fn long_press_gesture(self, duration: f64, max_distance: f64) -> Self

Attach a LongPressGesture with .gesture(_:including:).

pub fn luminance_to_alpha(self) -> Self

Apply .luminanceToAlpha(_:).

pub fn magnify_gesture(self, minimum_scale_delta: f64) -> Self

Attach a MagnifyGesture.

pub fn minimum_scale_factor(self, value: f64) -> Self

Apply .minimumScaleFactor(_:).

pub fn monospaced_digit(self) -> Self

Apply .monospacedDigit(_:).

pub fn move_disabled(self, value: bool) -> Self

Apply .moveDisabled(_:).

pub fn multiline_alignment(self, align: TextAlign) -> Self

Apply .multilineTextAlignment(_:).

pub fn navigation_bar_back_button_hidden(self, value: bool) -> Self

Apply .navigationBarBackButtonHidden(_:).

pub fn navigation_split_view_style(self, style: SplitViewStyle) -> Self

Apply .navigationSplitViewStyle(_:).

pub fn navigation_subtitle(self, value: &str) -> Self

Apply .navigationSubtitle(_:).

pub fn navigation_subtitle_text(self, value: &str) -> Self

Apply .navigationSubtitle(_:).

pub fn navigation_view_style_columns(self) -> Self

.navigationViewStyle(.columns) — the two-column split.

The witness is looked up at run time rather than named: a NavigationViewStyle conformance mangles its substitutions against the words in its own type name, so ColumnNavigationViewStyle’s is not DefaultNavigationViewStyle’s with a letter changed. Copying one has produced a witness for the wrong protocol in this crate before.

pub fn navigation_view_style_double_column(self) -> Self

.navigationViewStyle(.doubleColumn) — sidebar plus detail.

pub fn on_continuous_hover( self, space: CoordinateSpace, perform: impl Fn(HoverPhase) + 'static, ) -> Self

Apply .onContinuousHover(coordinateSpace:perform:).

pub fn on_drag_ended_value( self, minimum_distance: f64, action: impl Fn(DragValue) + 'static, ) -> Self

The same, with the value SwiftUI delivered.

on_drag_gesture’s handler is told only that a drag ended. This one is told where it started, where it finished and how fast it was going — see DragValue.

pub fn on_drag_gesture( self, minimum_distance: f64, action: impl Fn() + 'static, ) -> Self

Attach a DragGesture with an onEnded handler.

drag_gesture attaches a bare DragGesture with nothing listening, which builds the same value Swift would but can never be seen to fire. This wires the action SwiftUI calls when the drag ends, so the gesture is observable.

The result type is taken from .gesture’s opaque-result-type descriptor rather than a hand-written mangling: the type is ModifiedContent<AnyView, AddGestureModifier<_EndedGesture<DragGesture>, _>>, and spelling that out by hand is how earlier bindings resolved to null.

pub fn on_long_press_gesture( self, duration: f64, max_distance: f64, action: impl Fn() + 'static, ) -> Self

Apply .onLongPressGesture(minimumDuration:maximumDistance:pressing:perform:).

Unlike long_press_gesture, which attaches a bare LongPressGesture with nothing listening, this takes the action SwiftUI runs when the press completes — so the gesture can be observed rather than only built.

pub fn on_magnify_ended( self, minimum_scale_delta: f64, action: impl Fn(MagnifyValue) + 'static, ) -> Self

Attach a MagnifyGesture with an onEnded handler.

pub fn on_pencil_double_tap(self, action: impl Fn() + 'static) -> Self

Apply .onPencilDoubleTap(perform:).

pub fn on_pencil_squeeze(self, action: impl Fn() + 'static) -> Self

Apply .onPencilSqueeze(perform:).

pub fn on_preference_change_int(self) -> Self

Apply .onPreferenceChange(_:perform:), recording the value.

The value is read back through observed_preference. K.Value must also be Equatable here, so the call carries two witness tables for the one generic parameter.

pub fn on_rotate_ended( self, minimum_degrees: f64, action: impl Fn(RotateValue) + 'static, ) -> Self

Attach a RotateGesture with an onEnded handler.

pub fn on_tap_gesture(self, count: i64, action: impl Fn() + 'static) -> Self

Apply .onTapGesture(count:perform:). The action may capture, as super::button’s may — a tap handler that cannot know which row it is on is one every list has to route around.

pub fn padding_insets(self, insets: EdgeInsets) -> Self

.padding(_: EdgeInsets) — a different inset per edge.

padding_set takes one length for a set of edges; this takes four. The insets go in d0–d3, being a homogeneous float aggregate.

pub fn padding_set(self, edges: EdgeSet, length: Option<f64>) -> Self

Apply .padding(_:_:) — chosen edges, an explicit length.

edges is an Edge.Set bit pattern: 1 top, 2 leading, 4 bottom, 8 trailing, so .vertical is 5 and .all is 15. A None length means the system’s own inset, as in padding_default. .padding(_:_:) with the edges named rather than spelled as a bitmask.

padding_edges takes the raw option-set bits, which a caller has to know; this reads the member out of SwiftUI’s own Edge.Set instead.

pub fn preference_int(self, value: i64) -> Self

Apply .preference(key:value:) with a runtime-synthesized key.

The key type carries a PreferenceKey conformance built by crate::conformance at run time, and its Value is Int. No Swift source declares it, which is the whole point: this is the one family of modifiers that expects the client to supply a conformance.

pub fn preferred_color_scheme(self, scheme: ColorScheme) -> Self

Apply .preferredColorScheme(_:) — light or dark for this subtree.

pub fn presented_window_style(self, style: WindowStyle) -> Self

Apply .presentedWindowStyle(_:).

pub fn presented_window_toolbar_style(self, style: WindowToolbarStyle) -> Self

Apply .presentedWindowToolbarStyle(_:).

pub fn preview_context(self) -> Self

Apply .previewContext(_:).

pub fn preview_device(self, name: Option<&str>) -> Self

Apply .previewDevice(_:).

pub fn preview_display_name(self, name: Option<&str>) -> Self

Apply .previewDisplayName(_:).

pub fn preview_interface_orientation(self, value: InterfaceOrientation) -> Self

pub fn preview_layout(self, layout: PreviewLayout) -> Self

Apply .previewLayout(_:).

pub fn privacy_sensitive(self, value: bool) -> Self

Apply .privacySensitive(_:).

pub fn progress_view_style(self, style: ProgressStyle) -> Self

Apply .progressViewStyle(_:).

Not missing after all. Searching the export table for progressViewStyle finds nothing because the mangling compresses ViewStyle to 08progressC5Style — C substitutes the View of the enclosing SwiftUI.View — so the spelled-out name never appears. The SIL for one line of Swift names it outright.

.linear and .automatic are @_alwaysEmitIntoClient statics with no symbol of their own; the structs they return have plain initialisers, which is what this needs.

pub fn replace_disabled(self, value: bool) -> Self

Apply .replaceDisabled(_:).

pub fn rotate_gesture(self, minimum_degrees: f64) -> Self

Attach a RotateGesture. The minimum delta is an Angle, i.e. radians.

pub fn rotation(self, degrees: f64, anchor_x: f64, anchor_y: f64) -> Self

Apply .rotationEffect(.degrees(_), anchor:).

pub fn rotation_3d(self, degrees: f64, ax: f64, ay: f64, az: f64) -> Self

Apply .rotation3DEffect(_:axis:).

pub fn scaled_to_fill(self) -> Self

Apply .scaledToFill(_:).

pub fn scaled_to_fit(self) -> Self

Apply .scaledToFit(_:).

pub fn scene_padding(self, v0: ScenePadding, v1: EdgeSet) -> Self

Apply .scenePadding(_:).

pub fn scroll_clip_disabled(self, value: bool) -> Self

Apply .scrollClipDisabled(_:).

pub fn scroll_disabled(self, value: bool) -> Self

Apply .scrollDisabled(_:).

pub fn scroll_position_edge(self, edge: Edge) -> Self

.scrollPosition(_:anchor:) — scroll to an edge, and stay bound to it.

scroll_position_id is the other overload, which scrolls to a row by its identity. This one takes a whole ScrollPosition, which is what “scrolled to the top” is: there is no row to name.

The position lives in the binding for the life of the view. SwiftUI writes back as the user scrolls, so it has to be somewhere that outlives the call that made it.

pub fn search_completion(self, value: &str) -> Self

Apply .searchCompletion(_:).

pub fn sign_in_with_apple_button_style(self, style: AppleButtonStyle) -> Self

.signInWithAppleButtonStyle(_:).

Declared on View in the overlay, so its mangled name says SwiftUI.View with the overlay as the extension’s module — which is why it resolves in the overlay’s image and not in SwiftUI’s.

pub fn simultaneous_gesture_of<V: GestureData>( self, g: &GestureValue<V>, mask: GestureMask, ) -> Self

.simultaneousGesture(_:including:) — both this and the view’s own run.

pub fn speech_adjusted_pitch(self, value: f64) -> Self

Apply .speechAdjustedPitch(_:).

pub fn speech_always_includes_punctuation(self, value: bool) -> Self

Apply .speechAlwaysIncludesPunctuation(_:).

pub fn speech_announcements_queued(self, value: bool) -> Self

Apply .speechAnnouncementsQueued(_:).

pub fn speech_spells_out_characters(self, value: bool) -> Self

Apply .speechSpellsOutCharacters(_:).

pub fn submit_scope(self, value: bool) -> Self

Apply .submitScope(_:).

pub fn symbol_color_rendering_mode(self, mode: SymbolColorRendering) -> Self

Apply .symbolColorRenderingMode(_:).

pub fn symbol_effect(self, effect: SymbolEffect) -> Self

.symbolEffect(_:) with any of the indefinite effects.

The case tag is read from the enum’s reflection rather than written down: SymbolEffectConfiguration.Effect numbers its cases in declaration order, which is not the order the documentation lists them — .variableColor is 2 and .scale is 3, where reading down the page would say otherwise. A wrong tag builds a valid value of the wrong case, which renders, and renders wrongly. See abi::enum_case_index.

pub fn symbol_variable_value_mode(self, mode: SymbolVariableValue) -> Self

Apply .symbolVariableValueMode(_:).

pub fn tab_view_customization(self) -> Self

.tabViewCustomization(_:) with a live customization, not nil.

tab_view_customization_none passes nil, which is the “do not persist anything” case and the only one that needed no value. This builds a real TabViewCustomization and hands SwiftUI a binding to it, so the user’s reordering and hiding of tabs is kept — the whole point of the modifier.

The value lives in the binding’s closures for the life of the process: a customization SwiftUI can write back to has to outlive the call that made it, and there is nowhere else to put it.

pub fn tab_view_search_activation(self, activation: TabSearchActivation) -> Self

.tabViewSearchActivation(_:).

pub fn tab_view_style(self, style: TabStyle) -> Self

Apply .tabViewStyle(_:).

pub fn task_once( self, priority: TaskPriority, file: &str, line: i64, action: impl Fn() + Send + Sync + 'static, ) -> Self

Apply .task { … } — the spelling with no id:.

A different modifier from task, not a default-argument version of it: that one builds _TaskValueModifier2<ID> and re-runs when the id changes, this one builds _TaskModifier2 and runs once. _TaskModifier2 is not generic, so there are no generic words to spill.

The name carries the call site — SwiftUI records View.task @ file:line — so a value comparison against a reference only agrees if the caller passes the reference’s own file and line, which is why they are parameters.

pub fn text_baseline_offset(self, amount: f64) -> Self

Text.baselineOffset(_:)

pub fn text_bold(self) -> Self

Text.bold() — the one that returns Text.

Returns the View extension’s result if this is not a Text: that is what a caller wants there, and it is what every one of these used to do.

pub fn text_font(self, font: Option<&Font>) -> Self

Text.font(_:) — the overload that returns Text.

Text("x").font(.body).bold() stays a Text all the way through in Swift precisely because this returns one; going through the View extension for the font is what made the rest of the chain fall back to the environment forms. None clears the font.

pub fn text_font_weight(self, weight: Option<Weight>) -> Self

Text.fontWeight(_:) — the overload that returns Text.

Font.Weight? lowers to two words, a payload and a tag, which land ahead of self — so this is the one shape the single-word helper cannot serve. None clears the weight.

pub fn text_foreground_color(self, color: Color) -> Self

Text.foregroundColor(_:) — the overload that returns Text.

pub fn text_foreground_hierarchical(self, level: Hierarchical) -> Self

Text.foregroundStyle(_:) with one of the hierarchical styles.

pub fn text_foreground_linear_gradient( self, colors: &[u64], start: (f64, f64), end: (f64, f64), ) -> Self

Text.foregroundStyle(LinearGradient(...)).

pub fn text_input_completion(self, value: &str) -> Self

Apply .textInputCompletion(_:).

pub fn text_italic(self) -> Self

Text.italic()

pub fn text_kerning(self, amount: f64) -> Self

Text.kerning(_:) — space added between every pair of characters.

pub fn text_monospaced(self) -> Self

Text.monospaced(_:)

pub fn text_tracking(self, amount: f64) -> Self

Text.tracking(_:) — like kerning, but not suppressed between the pairs the font has a ligature for.

pub fn tint_color(self, color: u64) -> Self

Apply .tint(_:) through the Color? overload.

View.tint has two: one generic over ShapeStyle, which tint calls and which yields _EnvironmentKeyWritingModifier<AnyShapeStyle?>, and one taking a plain Color?, which yields …<Color?>. Swift picks the second for .tint(.white), so a reference written that way disagrees with the first on both type and value.

pub fn toolbar_customizable_placed( self, toolbar_id: &str, item_id: &str, placement: ToolbarItemPlacement, shows_by_default: bool, content: View, ) -> Self

The same, with the item placed somewhere other than .automatic.

pub fn toolbar_item_hidden(self, value: bool) -> Self

Apply .toolbarItemHidden(_:).

pub fn toolbar_placed( self, placement: ToolbarItemPlacement, content: View, ) -> Self

Apply .toolbar { ToolbarItem(placement:) { content } }.

toolbar above is this with .automatic, which is what the placement argument defaults to in Swift.

pub fn touch_bar(self, content: View) -> Self

Apply .touchBar(content:).

pub fn touch_bar_customization_label(self, value: &str) -> Self

Apply .touchBarCustomizationLabel(_:).

pub fn touch_bar_item_presence( self, presence: TouchBarItemPresence, identifier: &str, ) -> Self

Apply .touchBarItemPresence(_:).

The enum holds a String, which makes it larger than four words and so address-only: the argument is a pointer to a buffer this builds, with the string’s two words written first and the tag injected by the enum’s own witness afterwards.

pub fn touch_bar_item_principal(self, value: bool) -> Self

Apply .touchBarItemPrincipal(_:).

pub fn transform_preference_double(self) -> Self

Apply .transformPreference(_:_:), doubling the value in place.

pub fn transition_opacity(self) -> Self

Apply .transition(.opacity).

AnyTransition is eight bytes — a single class reference — so it is loadable: its static getters return it in x0 and it is passed by value. Reading it through an indirect (x8) return, as the larger resilient types like Material and Glass require, yields an uninitialised buffer whose contents are then released as if they were an object.

pub fn transition_slide(self) -> Self

Apply .transition(.slide) — in from the leading edge, out to the trailing.

pub fn typesetting_language(self, v0: TypesettingLanguage, v1: bool) -> Self

Apply .typesettingLanguage(_:).

pub fn unredacted(self) -> Self

Apply .unredacted(_:).

pub fn view_opacity(self, value: f64) -> Self

.opacity(_:), taking Color’s own overload when the receiver is a Color.

Color.opacity(_:) returns Color — the same shape as Text.bold() and Image.resizable(), and the reason Apple’s Color.primary.opacity(0.1) types as a plain Color where the View extension gives ModifiedContent<Color, _OpacityEffect>. Both render identically; only one is the type the listing has.

pub fn window_dismiss_behavior(self, value: WindowInteractionBehavior) -> Self

pub fn window_full_screen_behavior( self, value: WindowInteractionBehavior, ) -> Self

pub fn window_minimize_behavior(self, value: WindowInteractionBehavior) -> Self

pub fn window_resize_behavior(self, value: WindowInteractionBehavior) -> Self

pub fn window_toolbar_full_screen_visibility( self, value: WindowToolbarFullScreenVisibility, ) -> Self

pub fn writing_direction(self, strategy: WritingDirectionStrategy) -> Self

Apply .writingDirection(strategy:).

pub fn writing_tools_affordance_visibility(self, value: Visibility) -> Self

Apply .writingToolsAffordanceVisibility(_:).

pub fn writing_tools_behavior(self, value: WritingToolsBehavior) -> Self

impl View

pub fn foreground_style<S: ShapeStyleArg>(self, style: S) -> Self

.foregroundStyle(_:) — one spelling for every style.

The argument’s type picks the binding, the way its conformance does in Swift. See ShapeStyleArg.

impl View

pub fn background_style<S: BackgroundStyleArg>(self, style: S) -> Self

.backgroundStyle(_:) — one spelling for every style.

The style the views inside this one use for their backgrounds, which is a different question from what View::background draws behind this one. See BackgroundStyleArg.

impl View

pub fn environment<V: EnvironmentArg>(self, value: V) -> Self

.environment(_:_:) — one spelling for every property.

See EnvironmentArg. The leading-dot caveat from ShapeStyleArg applies: name the value’s type rather than writing .environment(.large).

pub fn navigation_view_style(self, style: NavigationViewStyle) -> Self

.navigationViewStyle(_:).

pub unsafe fn modifier(self, modifier_meta: *const c_void, bytes: &[u8]) -> Self

.modifier(_:) — apply a ViewModifier this crate has no name for.

The escape hatch. Every bound modifier goes through this internally; exposing it means a SwiftUI modifier type the crate has never heard of can still be applied, given its metadata and the bytes of a value.

Safety

modifier_meta must be metadata for a type conforming to ViewModifier, and bytes a live value of exactly that type. Neither is checked: a mismatch hands SwiftUI a value of the wrong shape and it writes through it.

pub fn accessibility(self, what: Accessibility<'_>) -> Self

.accessibility(…) — the deprecated family, under its Swift name.

See Accessibility. New code should prefer the modern spellings, which are separate methods here as they are in Swift.

pub fn draggable(self, payload: Draggable<'_>) -> Self

.draggable(_:) — what comes out when this view is dragged.

pub fn scroll_position(self, target: ScrollTarget<'_>) -> Self

.scrollPosition(_:) — where the scroll view should sit.

pub fn transform_environment<K: EnvKey>( self, action: impl Fn(K::Value) -> K::Value + 'static, ) -> Self

.transformEnvironment(_:transform:) — read a property, change it, write it back for everything below.

The key is the type parameter, the way the key path is the argument in Swift:

text("x").transform_environment::<ColorSchemeKey>(|_| ColorScheme::Dark);

pub fn default_app_storage(self, store: AppStorageStore<'_>) -> Self

.defaultAppStorage(_:).

Panics on a suite name UserDefaults refuses — the app’s own bundle identifier, or the global domain. views::default_app_storage_suite returns the None instead, for a caller that wants to handle it.

impl View

pub fn rotation_effect(self, degrees: f64) -> Self

.rotationEffect(_:) — View::rotation about the centre, which is the anchor SwiftUI defaults to.

pub fn rotation_3d_effect(self, degrees: f64, ax: f64, ay: f64, az: f64) -> Self

.rotation3DEffect(_:axis:) — View::rotation_3d under SwiftUI’s name.

pub fn scale_effect(self, sx: f64, sy: f64) -> Self

.scaleEffect(x:y:) — View::scale under SwiftUI’s name.

pub fn multiline_text_alignment(self, align: TextAlign) -> Self

.multilineTextAlignment(_:) — View::multiline_alignment under SwiftUI’s name.

impl View

pub fn clip_shape<S: ClipShapeArg>(self, shape: S) -> Self

.clipShape(_:) — one spelling for every shape.

v.clip_shape(ClipShape::Circle)
    .clip_shape(ClipShape::RoundedRect(8.0));

impl View

pub fn bg(self, c: Color) -> Self

Apply .background(_:) with a color.

Examples found in repository

examples/app.rs (line 14)

fn main() {
    run(|| {
        vstack(&[
            text("Hello from Rust! 🦀")
                .padding(12.0)
                .bg(Color::BLUE)
                .rounded(8.0)
                .opacity(0.95),
            spacer(),
            hstack(&[
                image("star.fill"),
                text("No Swift compiler needed"),
            ]),
            divider(),
            text("Pure dlsym + arm64 asm → SwiftUI")
                .padding(8.0),
        ])
        .padding(40.0)
        .into_handle()
    });
}

examples/common/spec.rs (line 645)

fn decorate(mut v: View, node: &Node) -> Result<View, String> {
    if let Some(p) = node.f64_attr("pad") {
        v = v.padding(p);
    }
    if let Some(size) = node.attr("frame") {
        let (w, h) = parse_size(size, node.line)?;
        v = v.frame(w, h);
    }
    if let Some(o) = node.f64_attr("opacity") {
        v = v.opacity(o);
    }
    if let Some(c) = node.attr("bg") {
        let c = parse_color(c, node.line)?;
        v = v.bg(c);
    }
    if let Some(r) = node.f64_attr("corner") {
        v = v.corner_radius(r);
    }
    Ok(v)
}

pub fn bg_view(self, content: View) -> Self

.background { … } — an arbitrary view behind this one, centred.

SwiftUI has two background overloads and they are different modifiers, not one with a convenience: View::bg reaches the one generic over ShapeStyle, this reaches the one generic over View. So the argument here can be a whole subtree, not only a colour.

pub fn bg_view_aligned(self, content: View, alignment: Alignment) -> Self

.background(alignment:) { … }

pub fn bg_material(self, kind: MaterialKind) -> Self

.background(.regularMaterial) and its neighbours — a blur of whatever is behind the view rather than a colour over it.

pub fn bg_linear_gradient( self, colors: &[Color], start: (f64, f64), end: (f64, f64), ) -> Self

.background(LinearGradient(colors:startPoint:endPoint:))

The points are unit points: (0, 0) is top-leading and (1, 1) bottom-trailing, so a top-to-bottom gradient is (0.5, 0)→(0.5, 1).

pub fn bg_radial_gradient( self, colors: &[Color], center: (f64, f64), start_radius: f64, end_radius: f64, ) -> Self

.background(RadialGradient(colors:center:startRadius:endRadius:))

pub fn opacity(self, value: f64) -> Self

Apply .opacity(_:).

On a Color this is Color.opacity(_:), which returns Color — the same concrete-overload story as Text.bold().

Examples found in repository

examples/app.rs (line 16)

fn main() {
    run(|| {
        vstack(&[
            text("Hello from Rust! 🦀")
                .padding(12.0)
                .bg(Color::BLUE)
                .rounded(8.0)
                .opacity(0.95),
            spacer(),
            hstack(&[
                image("star.fill"),
                text("No Swift compiler needed"),
            ]),
            divider(),
            text("Pure dlsym + arm64 asm → SwiftUI")
                .padding(8.0),
        ])
        .padding(40.0)
        .into_handle()
    });
}

examples/common/spec.rs (line 641)

fn decorate(mut v: View, node: &Node) -> Result<View, String> {
    if let Some(p) = node.f64_attr("pad") {
        v = v.padding(p);
    }
    if let Some(size) = node.attr("frame") {
        let (w, h) = parse_size(size, node.line)?;
        v = v.frame(w, h);
    }
    if let Some(o) = node.f64_attr("opacity") {
        v = v.opacity(o);
    }
    if let Some(c) = node.attr("bg") {
        let c = parse_color(c, node.line)?;
        v = v.bg(c);
    }
    if let Some(r) = node.f64_attr("corner") {
        v = v.corner_radius(r);
    }
    Ok(v)
}

examples/scenes.rs (line 64)

fn main_window() -> ViewHandle {
    vstack(&[
        text("A SwiftUI app, no Swift source")
            .font_size(20.0)
            .padding(8.0),
        divider(),
        text(&format!("count: {}", counter().get()))
            .font_size(34.0)
            .padding(12.0),
        hstack(&[
            button("−", || counter().set(counter().get() - 1)),
            button("+", || counter().set(counter().get() + 1)),
        ]),
        spacer(),
        text("⌘, for Settings · the ★ in the menu bar has a menu")
            .font_size(11.0)
            .opacity(0.6),
    ])
    .padding(24.0)
    .frame(420.0, 300.0)
    .focused_scene_value(counter_focus_key(), counter().get())
    .into_handle()
}

/// The focused-value key the window publishes its count under.
///
/// `.focusedSceneValue(\.key, value)` is how a window tells the commands above
/// it what is selected. Both halves are synthesised at run time: the
/// `FocusedValueKey` conformance *and* the `WritableKeyPath<FocusedValues, Int?>`
/// — `FocusedValues` exports no properties, so unlike `EnvironmentValues` there
/// is no SwiftUI modifier holding a key path to borrow.
///
/// The menu cannot *read* it yet: that needs `@FocusedValue`, a `DynamicProperty`
/// SwiftUI instantiates itself, which is a different mechanism from anything
/// here. What this demonstrates is the publishing half, in a real app.
fn counter_focus_key() -> &'static views::FocusKey {
    static K: std::sync::OnceLock<views::FocusKey> = std::sync::OnceLock::new();
    K.get_or_init(|| views::focus_key("sceneCounter"))
}

fn settings_pane() -> ViewHandle {
    vstack(&[
        text("Preferences").font_size(18.0),
        divider(),
        text("This pane is a `Settings` scene — the one ⌘, opens."),
        text(&format!("It sees the same state: {}", counter().get()))
            .opacity(0.7),
    ])
    .padding(24.0)
    .frame(360.0, 200.0)
    .into_handle()
}

fn utility_window() -> ViewHandle {
    vstack(&[
        text("Utility").font_size(16.0),
        text("A `Window`, not a `WindowGroup`: one of it, addressed by id.")
            .opacity(0.7),
    ])
    .padding(20.0)
    .frame(320.0, 140.0)
    .into_handle()
}

examples/dashboard.rs (line 33)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

pub fn rounded(self, radius: f64) -> Self

Apply .cornerRadius(_:).

Examples found in repository

examples/app.rs (line 15)

fn main() {
    run(|| {
        vstack(&[
            text("Hello from Rust! 🦀")
                .padding(12.0)
                .bg(Color::BLUE)
                .rounded(8.0)
                .opacity(0.95),
            spacer(),
            hstack(&[
                image("star.fill"),
                text("No Swift compiler needed"),
            ]),
            divider(),
            text("Pure dlsym + arm64 asm → SwiftUI")
                .padding(8.0),
        ])
        .padding(40.0)
        .into_handle()
    });
}

pub fn border(self, c: Color, width: f64) -> Self

Apply .border(_:width:).

Through views::border_value rather than views::border, because the latter takes components and pins alpha to 1 — so a translucent border came out opaque and nothing said so.

pub fn border_system(self, c: SystemColor, width: f64) -> Self

.border(_:width:) with one of SwiftUI’s own colours.

pub fn when(self, condition: bool, f: impl FnOnce(Self) -> Self) -> Self

Apply f only when condition holds.

Modifier chains often need a branch, and an if in the middle of a builder chain otherwise forces a temporary binding.

text("hi").when(selected, |v| v.bold().fg(Color::RED))

pub fn when_some<T>( self, value: Option<T>, f: impl FnOnce(Self, T) -> Self, ) -> Self

Apply f with the contained value when value is Some.

pub fn either( self, condition: bool, yes: impl FnOnce(Self) -> Self, no: impl FnOnce(Self) -> Self, ) -> Self

Apply one of two branches.

pub fn card(self, pad: f64, bg: Color, radius: f64) -> Self

Shorthand: padding + background + corner radius.

pub fn shadow(self, c: Color, radius: f64, dx: f64, dy: f64) -> Self

.shadow(color:radius:x:y:)

pub fn blur(self, radius: f64) -> Self

.blur(radius:)

pub fn rotate(self, degrees: f64) -> Self

.rotationEffect(.degrees(_)) about the centre.

Examples found in repository

examples/dashboard.rs (line 40)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

pub fn rotate_anchored(self, degrees: f64, anchor: (f64, f64)) -> Self

.rotationEffect(.degrees(_), anchor:) — the point the view turns about, as a unit point: (0, 0) is top-leading, (0.5, 0.5) the centre.

Not a detail: a dial hand turns about its base and a card flips about an edge, and neither is expressible by rotating about the middle.

pub fn scale(self, sx: f64, sy: f64) -> Self

.scaleEffect(_:) about the centre.

pub fn scale_anchored(self, sx: f64, sy: f64, anchor: (f64, f64)) -> Self

.scaleEffect(_:anchor:) — grow from a unit point rather than the middle.

pub fn offset(self, dx: f64, dy: f64) -> Self

.offset(x:y:)

pub fn brightness(self, amount: f64) -> Self

.brightness(_:)

pub fn saturation(self, amount: f64) -> Self

.saturation(_:)

pub fn contrast(self, amount: f64) -> Self

.contrast(_:)

pub fn grayscale(self, amount: f64) -> Self

.grayscale(_:)

pub fn material(self, kind: MaterialKind) -> Self

.background(_: Material)

pub fn glass(self) -> Self

.glassEffect() — Liquid Glass.

pub fn gradient( self, colors: &[Color], start: (f64, f64), end: (f64, f64), ) -> Self

.background(LinearGradient(…))

pub fn radial_gradient( self, colors: &[Color], center: (f64, f64), start_radius: f64, end_radius: f64, ) -> Self

.background(RadialGradient(…))

pub fn tint(self, c: Color) -> Self

.tint(_:)

pub fn color_scheme(self, scheme: ColorScheme) -> Self

.preferredColorScheme(_:)

pub fn control_size(self, size: ControlSize) -> Self

.controlSize(_:)

pub fn button_style(self, style: ButtonStyle) -> Self

.buttonStyle(_:)

Examples found in repository

examples/settings.rs (line 101)

fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

examples/todo.rs (line 70)

fn row(i: usize, it: &Item) -> View {
    hstack_spacing(
        &[
            // The checkmark is the button, so the whole symbol is the target.
            button_labelled(
                system_image(if it.done { "checkmark.circle.fill" } else { "circle" })
                    .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                    .view()
                    .fg_system(if it.done { SystemColor::Green } else { SystemColor::Gray }),
                move || toggle(i),
            )
            .button_style(views::ButtonStyle::Bordered),
            text(&it.title)
                .strikethrough_styled(it.done, LinePattern::Solid, None)
                .fg_system(if it.done { SystemColor::Gray } else { SystemColor::Primary }),
            spacer(),
        ],
        10.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(6.0))
    .a11y_label(&it.title)
    .a11y_value(if it.done { "Done" } else { "Not done" })
}

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

examples/swift_org_tutorial.rs (line 151)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

examples/dashboard.rs (line 73)

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

pub fn background_shape_style(self, style: ShapeStyle) -> Self

.backgroundStyle(_:) with one of SwiftUI’s semantic styles.

pub fn bg_auto_gradient(self, c: Color) -> Self

.background(_.gradient) — the automatic gradient derived from a colour.

pub fn bg_in_circle(self) -> Self

.background(in: .circle)

pub fn container_background( self, placement: ContainerBackgroundPlacement, alignment: Alignment, content: View, ) -> Self

.containerBackground(for:alignment:content:) — the background a container hands to its whole area, not just this view’s bounds.

See views::ContainerBackgroundPlacement: two of its cases trap on macOS, which is SwiftUI’s own availability rather than anything here.

pub fn fg_value(self, color: u64) -> Self

.foregroundStyle(_:) with an already-built colour, which is how a system colour is passed — see views::system_color_value.

pub fn fg_pair(self, primary: u64, secondary: u64) -> Self

.foregroundStyle(_:_:) — primary and secondary, for a symbol drawn in two tones.

pub fn fg_triple(self, primary: u64, secondary: u64, tertiary: u64) -> Self

.foregroundStyle(_:_:_:) — three tones.

A palette symbol takes its layers from successive styles. fg_pair covers the two-layer symbols; the three-layer ones — and there are plenty in SF Symbols — drew their third layer in the secondary colour, because there was no way to say what it should be.

pub fn tint_value(self, tint: u64) -> Self

.tint(_:) with an already-built colour.

pub fn color_scheme_forced(self, value: ColorScheme) -> Self

.colorScheme(_:) — force light or dark for this subtree, as distinct from View::color_scheme’s preferred scheme, which asks the whole window.

pub fn edges_ignoring_safe_area(self, edges: EdgeSet) -> Self

.edgesIgnoringSafeArea(_:) — the older spelling; see View::ignores_safe_area for the one that takes regions too.

pub fn persistent_system_overlays(self, visibility: Visibility) -> Self

.persistentSystemOverlays(_:) — the home indicator and its neighbours.

pub fn symbol_variant(self, variant: SymbolVariants) -> Self

.symbolVariant(_:) — .fill, .circle and so on, without renaming the symbol.

pub fn symbol_rendering_mode(self, mode: Option<SymbolRenderingMode>) -> Self

.symbolRenderingMode(_:) — None restores the default.

pub fn label_style(self, style: LabelStyle) -> Self

.labelStyle(_:) — icon only, title only, or both.

pub fn menu_style(self, style: MenuStyle) -> Self

.menuStyle(_:)

pub fn button_border_shape(self, shape: ButtonBorderShape) -> Self

.buttonBorderShape(_:)

pub fn scroll_target_behavior(self, behavior: ScrollTargetBehavior) -> Self

.scrollTargetBehavior(_:) — .paging and friends.

pub fn scroll_content_background(self, visibility: Visibility) -> Self

.scrollContentBackground(_:) — hiding it is how a List loses its grouped backdrop.

pub fn symbol_effect_pulse(self) -> Self

.symbolEffect(.pulse)

pub fn symbol_effects_removed(self, removed: bool) -> Self

.symbolEffectsRemoved(_:) — stop inherited effects at this view.

pub fn symbol_color_rendering_mode_flat(self) -> Self

.symbolColorRenderingMode(.flat)

pub fn symbol_variable_value_mode_color(self) -> Self

.symbolVariableValueMode(.color)

pub fn keyframe_animator( self, initial: f64, to: f64, repeating: bool, content: View, ) -> Self

.keyframeAnimator(initialValue:repeating:content:) — drive a value through keyframes and rebuild the content from it.

pub fn phase_animator( self, phases: &[i64], content: View, animated: bool, ) -> Self

.phaseAnimator(_:content:) — step through phases, rebuilding at each.

pub fn transaction(self, action: impl Fn(TransactionRef) + 'static) -> Self

.transaction(_:) — reach the transaction driving the current change, which is how an animation is suppressed for one update.

pub fn geometry_group(self) -> Self

.geometryGroup() — animate this subtree’s geometry as one, rather than letting each child interpolate independently and pull apart.

pub fn transform_effect( self, a: f64, b: f64, c: f64, d: f64, tx: f64, ty: f64, ) -> Self

.transformEffect(_:) — an affine transform, as [a b c d tx ty].

pub fn visual_effect(self) -> Self

.visualEffect(_:)

impl View

pub fn toggle_style(self, style: ToggleStyle) -> Self

.toggleStyle(_:)

pub fn picker_style(self, style: PickerStyle) -> Self

.pickerStyle(_:)

Examples found in repository

examples/settings.rs (line 76)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

pub fn date_picker_style(self, style: DatePickerStyle) -> Self

.datePickerStyle(_:)

pub fn gauge_style(self, style: GaugeStyle) -> Self

.gaugeStyle(_:)

Examples found in repository

examples/dashboard.rs (line 66)

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

pub fn form_style(self, style: FormStyle) -> Self

.formStyle(_:)

Examples found in repository

examples/settings.rs (line 83)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

pub fn group_box_style(self, style: GroupBoxStyle) -> Self

.groupBoxStyle(_:)

pub fn control_group_style(self, style: ControlGroupStyle) -> Self

.controlGroupStyle(_:)

pub fn disclosure_group_style(self, style: DisclosureGroupStyle) -> Self

.disclosureGroupStyle(_:)

pub fn table_style(self, style: TableStyle) -> Self

.tableStyle(_:)

pub fn text_editor_style(self, style: TextEditorStyle) -> Self

.textEditorStyle(_:)

pub fn labeled_content_style(self, style: LabeledContentStyle) -> Self

.labeledContentStyle(_:)

pub fn text_selection(self, style: TextSelectability) -> Self

.textSelection(_:) — whether the user can select and copy the text.

pub fn button_repeat_behavior(self, value: ButtonRepeatBehavior) -> Self

.buttonRepeatBehavior(_:) — whether holding repeats the action.

pub fn button_sizing(self, value: ButtonSizing) -> Self

.buttonSizing(_:)

pub fn menu_button_style(self, style: MenuButtonStyle) -> Self

.menuButtonStyle(_:)

pub fn menu_action_dismiss_behavior( self, value: MenuActionDismissBehavior, ) -> Self

.menuActionDismissBehavior(_:) — whether choosing an item closes the menu.

pub fn slider_thumb_visibility(self, value: Visibility) -> Self

.sliderThumbVisibility(_:)

pub fn spring_loading_behavior(self, value: SpringLoadingBehavior) -> Self

.springLoadingBehavior(_:) — whether hovering a drag over this opens it.

pub fn palette_selection_effect(self, value: PaletteSelectionEffect) -> Self

.paletteSelectionEffect(_:)

pub fn material_active_appearance(self, value: MaterialActiveAppearance) -> Self

.materialActiveAppearance(_:)

pub fn progress_view_style_circular(self) -> Self

.progressViewStyle(.circular)

pub fn menu_indicator(self, visibility: Visibility) -> Self

.menuIndicator(_:) — the chevron that says a control opens a menu.

pub fn menu_order(self, order: MenuOrder) -> Self

.menuOrder(_:)

pub fn labels_visibility(self, visibility: Visibility) -> Self

.labelsVisibility(_:) — hiding a label keeps it for VoiceOver while taking it off the screen, which .hidden() does not.

pub fn header_prominence(self, prominence: Prominence) -> Self

.headerProminence(_:)

pub fn badge_prominence(self, prominence: BadgeProminence) -> Self

.badgeProminence(_:)

pub fn list_style(self, style: ListStyle) -> Self

.listStyle(_:)

Examples found in repository

examples/inbox.rs (line 115)

fn body() -> View {
    let i = inbox();
    let rows = matching();
    navigation_stack(
        list(for_each_items(&rows, |&i| linked_row(i)))
        .list_style(views::ListStyle::InsetListStyle)
        .searchable(&i.query, &i.searching, SearchFieldPlacement::Automatic, "Search"),
    )
    .navigation_title("Inbox")
    .toolbar(button("Compose", || {}).keyboard_shortcut(KeyboardShortcut::DefaultAction))
}

examples/todo.rs (line 122)

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

pub fn list_row_insets(self, insets: Option<[f64; 4]>) -> Self

.listRowInsets(_:) as [top, leading, bottom, trailing]; None restores the default inset.

pub fn list_row_separator( self, visibility: Visibility, edges: VerticalEdgeSet, ) -> Self

.listRowSeparator(_:edges:)

pub fn list_section_separator( self, visibility: Visibility, edges: VerticalEdgeSet, ) -> Self

.listSectionSeparator(_:edges:)

pub fn selection_disabled(self, disabled: bool) -> Self

.selectionDisabled(_:) — a row that shows but cannot be picked.

pub fn swipe_actions( self, edge: HorizontalEdge, allows_full_swipe: bool, content: View, ) -> Self

.swipeActions(edge:allowsFullSwipe:content:)

Examples found in repository

examples/inbox.rs (line 107)

fn linked_row(i: usize) -> View {
    navigation_link_labelled(row(i), detail(i))
        .swipe_actions(HorizontalEdge::Trailing, true, button("Delete", || {}))
}

pub fn refreshable(self, action: impl Fn() + Send + Sync + 'static) -> Self

.refreshable(action:) — pull to refresh.

pub fn scroll_dismisses_keyboard( self, mode: ScrollDismissesKeyboardMode, ) -> Self

.scrollDismissesKeyboard(_:) — what scrolling does to an open keyboard.

pub fn list_row_separator_tint( self, color: Option<Color>, edges: &[VerticalEdgeSet], ) -> Self

.listRowSeparatorTint(_:edges:) — None restores the default.

pub fn list_section_separator_tint( self, color: Option<Color>, edges: &[VerticalEdgeSet], ) -> Self

.listSectionSeparatorTint(_:edges:)

pub fn list_item_tint_monochrome(self, tinted: bool) -> Self

.listItemTint(.monochrome)

pub fn alternating_row_backgrounds( self, value: AlternatingRowBackgroundBehavior, ) -> Self

.alternatingRowBackgrounds(_:)

pub fn section_actions(self, content: View) -> Self

.sectionActions(content:) — controls in a section’s header area.

pub fn section_index_label(self, label: &str) -> Self

.sectionIndexLabel(_:) — the letter this section shows in a scrubber.

pub fn table_column_headers(self, visibility: Visibility) -> Self

.tableColumnHeaders(_:)

pub fn tab_view_style_automatic(self) -> Self

.tabViewStyle(.automatic)

pub fn tab_view_customization_none(self) -> Self

.tabViewCustomization(nil)

pub fn tab_view_search_activation_automatic(self) -> Self

.tabViewSearchActivation(.automatic)

pub fn tab_view_sidebar_header(self, content: View) -> Self

.tabViewSidebarHeader { … }

pub fn tab_view_sidebar_footer(self, content: View) -> Self

.tabViewSidebarFooter { … }

pub fn tab_view_sidebar_bottom_bar(self, content: View) -> Self

.tabViewSidebarBottomBar { … }

pub fn tab_bar_minimize_behavior(self, value: TabBarMinimizeBehavior) -> Self

.tabBarMinimizeBehavior(_:)

impl View

pub fn drag_configuration( self, within_app: DragOperations, outside_app: DragOperations, ) -> Self

.dragConfiguration(within:outside:) — which operations a drag permits inside the app and outside it, which need not be the same.

pub fn drag_container(self, items: &[&str]) -> Self

.dragContainer(for:) — the items a multi-item drag carries.

pub fn drag_container_selection(self, selected: &[&str]) -> Self

.dragContainerSelection(_:) — which of them are selected, so dragging one drags the selection rather than just the item under the finger.

pub fn draggable_container_item(self, id: HashableValue<'_>) -> Self

.draggableContainerItem(id:) — mark this view as one of the container’s items.

pub fn drag_previews_formation(self, value: DragDropPreviewsFormation) -> Self

.dragPreviewsFormation(_:) — how several dragged previews stack up.

pub fn drop_previews_formation(self, value: DragDropPreviewsFormation) -> Self

.dropPreviewsFormation(_:)

pub fn drop_configuration( self, decide: impl Fn() -> DropOperation + 'static, ) -> Self

.dropConfiguration(_:) — decide what a drop over this view would do, which is what sets the cursor before anything is released.

pub fn drop_destination( self, accept: impl Fn(&[String]) -> bool + 'static, targeted: impl Fn(bool) + 'static, ) -> Self

.dropDestination(for:action:isTargeted:) — accept returns whether the drop was taken; targeted fires as the drag enters and leaves.

pub fn on_drag_session_updated(self, action: impl Fn() + 'static) -> Self

.onDragSessionUpdated(_:)

pub fn on_drop_session_updated(self, action: impl Fn() + 'static) -> Self

.onDropSessionUpdated(_:)

pub fn on_copy_command(self, items: &[&str]) -> Self

.onCopyCommand(perform:) — what Copy takes from this view.

pub fn on_cut_command(self, items: &[&str]) -> Self

.onCutCommand(perform:)

pub fn on_paste_command( self, kinds: &[ContentType], paste: impl Fn(&[ItemProvider]) + 'static, ) -> Self

.onPasteCommand(of:perform:)

pub fn on_delete_command(self, action: impl Fn() + 'static) -> Self

.onDeleteCommand(perform:)

pub fn on_move_command(self, action: impl Fn(i64) + 'static) -> Self

.onMoveCommand(perform:) — arrow keys, with the direction as an Int.

pub fn on_exit_command(self, action: impl Fn() + 'static) -> Self

.onExitCommand(perform:) — escape.

pub fn on_command( self, selector: &'static CStr, action: impl Fn() + 'static, ) -> Self

.onCommand(_:perform:) — any other selector by name, which is the way out when a command has no modifier of its own.

pub fn cuttable(self, items: &[&str]) -> Self

.cuttable(for:action:) — what Cut takes, as distinct from View::copyable, which Copy takes.

pub fn paste_destination(self, paste: impl Fn(&[String]) + 'static) -> Self

.pasteDestination(for:action:)

pub fn rename_action(self, action: impl Fn() + 'static) -> Self

.renameAction(_:) — what the Rename command does, which a list row needs for in-place renaming to work at all.

pub fn pointer_style(self, style: Option<PointerStyle>) -> Self

.pointerStyle(_:) — None restores the default cursor.

pub fn pointer_visibility(self, value: Visibility) -> Self

.pointerVisibility(_:)

pub fn on_modifier_keys_changed( self, mask: EventModifier, initial: bool, action: impl Fn(u64, u64) + 'static, ) -> Self

.onModifierKeysChanged(mask:initial:_:)

pub fn modifier_key_alternate( self, modifiers: EventModifier, content: View, ) -> Self

.modifierKeyAlternate(_:_:) — a different view while a key is held.

pub fn on_interactive_resize_change( self, action: impl Fn(bool) + 'static, ) -> Self

.onInteractiveResizeChange(_:)

pub fn user_activity( self, kind: &str, active: bool, action: impl Fn() + 'static, ) -> Self

.userActivity(_:isActive:_:) — advertise what this view is doing, for Handoff and Spotlight.

pub fn on_continue_user_activity( self, kind: &str, action: impl Fn() + 'static, ) -> Self

.onContinueUserActivity(_:perform:) — the other end of Handoff.

pub fn handles_external_events( self, preferring: &[&str], allowing: &[&str], ) -> Self

.handlesExternalEvents(preferring:allowing:)

pub fn allowed_dynamic_range_high(self) -> Self

.allowedDynamicRange(.high)

pub fn tab_item(self, label: View) -> Self

.tabItem { … } — the label a TabView shows for this page.

pub fn high_priority_gesture( self, minimum_distance: f64, action: impl Fn() + 'static, ) -> Self

.highPriorityGesture(_:) — take the gesture ahead of the children, where .gesture would lose to them.

pub fn simultaneous_gesture( self, minimum_distance: f64, action: impl Fn() + 'static, ) -> Self

.simultaneousGesture(_:) — recognise alongside the children rather than instead of them.

pub fn on_open_url(self, action: impl Fn(&str) + 'static) -> Self

.onOpenURL(perform:) — deep links.

pub fn copyable(self, items: &[&str]) -> Self

.copyable(_:) — what a copy command takes from this view.

pub fn scroll_position_id( self, state: &BoundState<String>, anchor: Option<(f64, f64)>, ) -> Self

.scrollPosition(id:anchor:) bound to Rust state — the id of the item at the anchor lands in state, and writing it scrolls there.

pub fn default_scroll_anchor( self, anchor: Option<(f64, f64)>, role: ScrollAnchorRole, ) -> Self

.defaultScrollAnchor(_:for:) — None restores the default.

pub fn scroll_target_layout(self, enabled: bool) -> Self

.scrollTargetLayout() — mark the stack whose children are the targets a paging scroll snaps to.

pub fn scroll_bounce_behavior( self, behavior: ScrollBounceBehavior, axes: AxisSet, ) -> Self

.scrollBounceBehavior(_:axes:)

pub fn scroll_indicators_flash(self, on_appear: bool) -> Self

.scrollIndicatorsFlash(onAppear:)

pub fn scroll_edge_effect_hidden(self, hidden: bool, edges: EdgeSet) -> Self

.scrollEdgeEffectHidden(_:for:)

pub fn scroll_edge_effect_style( self, style: Option<ScrollEdgeEffectStyle>, edges: &[EdgeSetMember], ) -> Self

.scrollEdgeEffectStyle(_:for:) — None restores the default.

pub fn scroll_transition( self, config: ScrollTransitionConfiguration, axis: Option<Axis>, ) -> Self

.scrollTransition(_:axis:) — how a child changes as it crosses the viewport.

pub fn scroll_transition_ends( self, top_leading: ScrollTransitionConfiguration, bottom_trailing: ScrollTransitionConfiguration, axis: Option<Axis>, ) -> Self

.scrollTransition(topLeading:bottomTrailing:axis:) — the two ends of the scroll configured separately.

The single-configuration scroll_transition applies the same one at both ends; this is what lets a view animate on the way in and do nothing on the way out.

pub fn on_scroll_phase_change(self, action: impl Fn(i64, i64) + 'static) -> Self

.onScrollPhaseChange(_:) — the handler sees the old and new phase.

pub fn on_scroll_visibility_change( self, threshold: f64, action: impl Fn(bool) + 'static, ) -> Self

.onScrollVisibilityChange(threshold:_:)

pub fn default_focus(self, value: bool, priority: DefaultFocusPriority) -> Self

.defaultFocus(_:_:) — which control starts focused.

pub fn prefers_default_focus(self, prefers: bool) -> Self

.prefersDefaultFocus(_:in:)

pub fn focus_scope(self) -> Self

.focusScope(_:) — a boundary focus moves within.

pub fn a11y_focused(self) -> Self

.accessibilityFocused(_:)

pub fn a11y_default_focus(self, value: bool) -> Self

.accessibilityDefaultFocus(_:_:)

pub fn focused(self) -> Self

.focused(_:)

pub fn matched_geometry_effect( self, id: HashableValue<'_>, properties: &[GeometryProperties], anchor: (f64, f64), is_source: bool, ) -> Self

.matchedGeometryEffect(id:in:properties:anchor:isSource:) — the pair of views that share an id are interpolated between rather than crossfaded.

pub fn matched_geometry_effect_in( self, id: HashableValue<'_>, namespace: Namespace, properties: &[GeometryProperties], anchor: (f64, f64), is_source: bool, ) -> Self

.matchedGeometryEffect(id:in:properties:anchor:isSource:) in a shared namespace.

The pairing spelling. matched_geometry_effect mints a namespace per call, so the views it makes cannot pair with anything.

pub fn on_drag_item(self, item: &str, preview: View) -> Self

.onDrag { NSItemProvider(object: item) } with a custom preview.

Named apart from View::on_drag, which is the drag gesture — a finger moving on screen — where this is drag and drop, which hands an item to another view or another app.

pub fn on_drop( self, kinds: &[ContentType], accept: impl Fn(&[ItemProvider]) -> bool + 'static, ) -> Self

.onDrop(of:isTargeted:perform:) — the handler returns whether it took the drop.

pub fn on_key_press( self, characters: CharacterSetKind, phases: KeyPressPhases, action: impl Fn(KeyPress) -> KeyPressResult + 'static, ) -> Self

.onKeyPress(_:phases:action:)

The action is handed the views::KeyPress — what was typed, which modifiers were held, and which phase of the press it is — and answers whether it handled it. It used to receive nothing at all, which left a key handler unable to branch on the key.

let v = text("editor").on_key_press(
    CharacterSetKind::Alphanumerics,
    KeyPressPhases::Down,
    |press| {
        if press.characters == "s" && press.holding(EventModifier::Command) {
            KeyPressResult::Handled
        } else {
            KeyPressResult::Ignored
        }
    },
);

pub fn on_key( self, key: Key, action: impl Fn() -> KeyPressResult + 'static, ) -> Self

.onKeyPress(_:action:) — one named key.

on_key_press watches a whole character set and hands the action the press; this watches one key, which is how a shortcut is usually written — “Escape closes this”. Only the character-set form was bound, so a view that cared about Escape had to accept every key and filter.

let sheet = text("editor").on_key(Key::Escape, || KeyPressResult::Handled);

pub fn sensory_feedback( self, feedback: SensoryFeedback, trigger: i64, condition: impl Fn(i64, i64) -> bool + 'static, ) -> Self

.sensoryFeedback(_:trigger:condition:) — haptics, fired when the condition says the trigger’s change deserves one.

pub fn on_hover(self, callback: impl Fn(bool) + 'static) -> Self

Apply .onHover(perform:) — fires callback on gaze enter/exit (visionOS) or mouse enter/exit (macOS).

impl View

pub fn padding(self, amount: f64) -> Self

Apply .padding(_:).

Examples found in repository

examples/inbox.rs (line 73)

fn detail(i: usize) -> View {
    let m = &MESSAGES[i];
    vstack_aligned_spacing(
        &[
            text(m.subject).text_style(TextStyle::Title).bold(),
            text!("From {}", m.from).fg_system(SystemColor::Gray),
            divider(),
            text("Body text would go here.").fg_system(SystemColor::Gray),
            spacer(),
        ],
        HorizontalAlignment::Leading,
        Some(12.0),
    )
    .padding(20.0)
    .navigation_title(m.subject)
}

examples/app.rs (line 13)

fn main() {
    run(|| {
        vstack(&[
            text("Hello from Rust! 🦀")
                .padding(12.0)
                .bg(Color::BLUE)
                .rounded(8.0)
                .opacity(0.95),
            spacer(),
            hstack(&[
                image("star.fill"),
                text("No Swift compiler needed"),
            ]),
            divider(),
            text("Pure dlsym + arm64 asm → SwiftUI")
                .padding(8.0),
        ])
        .padding(40.0)
        .into_handle()
    });
}

examples/common/spec.rs (line 634)

fn decorate(mut v: View, node: &Node) -> Result<View, String> {
    if let Some(p) = node.f64_attr("pad") {
        v = v.padding(p);
    }
    if let Some(size) = node.attr("frame") {
        let (w, h) = parse_size(size, node.line)?;
        v = v.frame(w, h);
    }
    if let Some(o) = node.f64_attr("opacity") {
        v = v.opacity(o);
    }
    if let Some(c) = node.attr("bg") {
        let c = parse_color(c, node.line)?;
        v = v.bg(c);
    }
    if let Some(r) = node.f64_attr("corner") {
        v = v.corner_radius(r);
    }
    Ok(v)
}

examples/dynamic_ui.rs (line 78)

pub fn body() -> View {
    let text_src = current().lock().expect("spec").clone();
    match spec::parse(&text_src).and_then(|nodes| spec::build(&nodes)) {
        Ok(v) => v,
        Err(e) => vstack_aligned_spacing(
            &[
                text("Could not build that screen")
                    .text_style(TextStyle::Headline)
                    .fg_system(SystemColor::Red),
                text(&e).font_size(12.0).fg_system(SystemColor::Secondary),
            ],
            HorizontalAlignment::Leading,
            Some(8.0),
        )
        .padding(20.0),
    }
}

examples/hot_reload.rs (line 107)

fn body() -> View {
    let (src, error, generation, micros) = {
        let g = state_cell().lock().expect("state");
        (g.last_good.clone(), g.error.clone(), g.generation, g.micros)
    };

    // The last version that parsed. It cannot fail — it parsed before — but a
    // spec that builds views from slots could in principle, so the fallback is
    // still handled rather than unwrapped.
    let screen = spec::parse(&src)
        .and_then(|nodes| spec::build(&nodes))
        .unwrap_or_else(|e| text(&e).fg_system(SystemColor::Red).padding(20.0));

    vstack_spacing(&[screen, status(error.as_deref(), generation, micros)], 0.0)
}

/// A strip along the bottom: which generation is on screen, how long the last
/// reload took, what the slots hold, and the error if there is one.
///
/// In the window rather than the terminal because that is where you are
/// looking. Watching a reloader work from a log means watching two things.
fn status(error: Option<&str>, generation: u64, micros: u64) -> View {
    let slots = spec::slot_summary();
    let slot_line = if slots.is_empty() {
        String::new()
    } else {
        slots
            .iter()
            .map(|(k, v)| format!("{k}={v}"))
            .collect::<Vec<_>>()
            .join("  ")
    };

    // The error row is *always* present, empty when there is nothing wrong.
    // An error that appears and disappears would otherwise reflow the screen
    // above it on every save — which looks exactly like the reloader having
    // replaced the view, and makes "did the screen survive this?" impossible
    // to answer by looking.
    let rows = vec![
        divider(),
        hstack_spacing(
            &[
                circle_shape()
                    .fill_system(if error.is_some() {
                        SystemColor::Orange
                    } else {
                        SystemColor::Clear
                    })
                    .frame(8.0, 8.0),
                text(error.unwrap_or(""))
                    .font_size(11.0)
                    .fg_system(SystemColor::Orange),
                spacer(),
            ],
            6.0,
        )
        .padding(6.0)
        .frame(348.0, 24.0),
        hstack_spacing(
            &[
                circle_shape()
                    .fill_system(if error.is_some() {
                        SystemColor::Orange
                    } else {
                        SystemColor::Green
                    })
                    .frame(8.0, 8.0),
                text(&format!("gen {generation}"))
                    .font_size(11.0)
                    .fg_system(SystemColor::Secondary),
                // Microseconds below a millisecond: a reload of a short spec
                // really is that fast, and "0.0 ms" reads as "not measured".
                text(&if micros < 1000 {
                    format!("{micros} \u{b5}s")
                } else {
                    format!("{:.1} ms", micros as f64 / 1000.0)
                })
                .font_size(11.0)
                .fg_system(SystemColor::Secondary),
                spacer(),
                text(&slot_line).font_size(11.0).fg_system(SystemColor::Secondary),
            ],
            8.0,
        )
        .padding(6.0)
        .frame(348.0, 24.0),
    ];
    vstack_spacing(&rows, 0.0)
}

examples/scenes.rs (line 52)

fn main_window() -> ViewHandle {
    vstack(&[
        text("A SwiftUI app, no Swift source")
            .font_size(20.0)
            .padding(8.0),
        divider(),
        text(&format!("count: {}", counter().get()))
            .font_size(34.0)
            .padding(12.0),
        hstack(&[
            button("−", || counter().set(counter().get() - 1)),
            button("+", || counter().set(counter().get() + 1)),
        ]),
        spacer(),
        text("⌘, for Settings · the ★ in the menu bar has a menu")
            .font_size(11.0)
            .opacity(0.6),
    ])
    .padding(24.0)
    .frame(420.0, 300.0)
    .focused_scene_value(counter_focus_key(), counter().get())
    .into_handle()
}

/// The focused-value key the window publishes its count under.
///
/// `.focusedSceneValue(\.key, value)` is how a window tells the commands above
/// it what is selected. Both halves are synthesised at run time: the
/// `FocusedValueKey` conformance *and* the `WritableKeyPath<FocusedValues, Int?>`
/// — `FocusedValues` exports no properties, so unlike `EnvironmentValues` there
/// is no SwiftUI modifier holding a key path to borrow.
///
/// The menu cannot *read* it yet: that needs `@FocusedValue`, a `DynamicProperty`
/// SwiftUI instantiates itself, which is a different mechanism from anything
/// here. What this demonstrates is the publishing half, in a real app.
fn counter_focus_key() -> &'static views::FocusKey {
    static K: std::sync::OnceLock<views::FocusKey> = std::sync::OnceLock::new();
    K.get_or_init(|| views::focus_key("sceneCounter"))
}

fn settings_pane() -> ViewHandle {
    vstack(&[
        text("Preferences").font_size(18.0),
        divider(),
        text("This pane is a `Settings` scene — the one ⌘, opens."),
        text(&format!("It sees the same state: {}", counter().get()))
            .opacity(0.7),
    ])
    .padding(24.0)
    .frame(360.0, 200.0)
    .into_handle()
}

fn utility_window() -> ViewHandle {
    vstack(&[
        text("Utility").font_size(16.0),
        text("A `Window`, not a `WindowGroup`: one of it, addressed by id.")
            .opacity(0.7),
    ])
    .padding(20.0)
    .frame(320.0, 140.0)
    .into_handle()
}

fn menu_bar_item() -> ViewHandle {
    vstack(&[
        text(&format!("count: {}", counter().get())),
        button("Reset", || counter().set(0)),
    ])
    .padding(10.0)
    .into_handle()
}

Additional examples can be found in:

• examples/settings.rs
• examples/dashboard.rs
• examples/swift_org_tutorial.rs
• examples/todo.rs

pub fn padding_edges(self, edges: EdgeSet, length: Option<f64>) -> Self

.padding(_:_:) on chosen edges — .padding(.horizontal, 8).

None asks for SwiftUI’s own default inset rather than a number.

Examples found in repository

examples/inbox.rs (line 98)

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

examples/todo.rs (line 78)

fn row(i: usize, it: &Item) -> View {
    hstack_spacing(
        &[
            // The checkmark is the button, so the whole symbol is the target.
            button_labelled(
                system_image(if it.done { "checkmark.circle.fill" } else { "circle" })
                    .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                    .view()
                    .fg_system(if it.done { SystemColor::Green } else { SystemColor::Gray }),
                move || toggle(i),
            )
            .button_style(views::ButtonStyle::Bordered),
            text(&it.title)
                .strikethrough_styled(it.done, LinePattern::Solid, None)
                .fg_system(if it.done { SystemColor::Gray } else { SystemColor::Primary }),
            spacer(),
        ],
        10.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(6.0))
    .a11y_label(&it.title)
    .a11y_value(if it.done { "Done" } else { "Not done" })
}

pub fn padding_default(self) -> Self

.padding() — the system’s default inset on every edge.

pub fn frame_optional( self, width: Option<f64>, height: Option<f64>, alignment: Alignment, ) -> Self

.frame(width:height:alignment:) with either dimension left out.

An omitted dimension is not zero: it means “take what the parent offers”, which is a different layout from asking for nothing.

Examples found in repository

examples/todo.rs (line 116)

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

pub fn expand(self, alignment: Alignment) -> Self

.frame(maxWidth: .infinity, maxHeight: .infinity) — fill the parent.

pub fn expand_width(self, alignment: Alignment) -> Self

.frame(maxWidth: .infinity) — fill across, keep the natural height.

pub fn frame_aligned(self, w: f64, h: f64, alignment: Alignment) -> Self

.frame(width:height:alignment:).

pub fn frame(self, w: f64, h: f64) -> Self

Apply .frame(width:height:).

Examples found in repository

examples/common/spec.rs (line 638)

fn decorate(mut v: View, node: &Node) -> Result<View, String> {
    if let Some(p) = node.f64_attr("pad") {
        v = v.padding(p);
    }
    if let Some(size) = node.attr("frame") {
        let (w, h) = parse_size(size, node.line)?;
        v = v.frame(w, h);
    }
    if let Some(o) = node.f64_attr("opacity") {
        v = v.opacity(o);
    }
    if let Some(c) = node.attr("bg") {
        let c = parse_color(c, node.line)?;
        v = v.bg(c);
    }
    if let Some(r) = node.f64_attr("corner") {
        v = v.corner_radius(r);
    }
    Ok(v)
}

examples/scenes.rs (line 67)

fn main_window() -> ViewHandle {
    vstack(&[
        text("A SwiftUI app, no Swift source")
            .font_size(20.0)
            .padding(8.0),
        divider(),
        text(&format!("count: {}", counter().get()))
            .font_size(34.0)
            .padding(12.0),
        hstack(&[
            button("−", || counter().set(counter().get() - 1)),
            button("+", || counter().set(counter().get() + 1)),
        ]),
        spacer(),
        text("⌘, for Settings · the ★ in the menu bar has a menu")
            .font_size(11.0)
            .opacity(0.6),
    ])
    .padding(24.0)
    .frame(420.0, 300.0)
    .focused_scene_value(counter_focus_key(), counter().get())
    .into_handle()
}

/// The focused-value key the window publishes its count under.
///
/// `.focusedSceneValue(\.key, value)` is how a window tells the commands above
/// it what is selected. Both halves are synthesised at run time: the
/// `FocusedValueKey` conformance *and* the `WritableKeyPath<FocusedValues, Int?>`
/// — `FocusedValues` exports no properties, so unlike `EnvironmentValues` there
/// is no SwiftUI modifier holding a key path to borrow.
///
/// The menu cannot *read* it yet: that needs `@FocusedValue`, a `DynamicProperty`
/// SwiftUI instantiates itself, which is a different mechanism from anything
/// here. What this demonstrates is the publishing half, in a real app.
fn counter_focus_key() -> &'static views::FocusKey {
    static K: std::sync::OnceLock<views::FocusKey> = std::sync::OnceLock::new();
    K.get_or_init(|| views::focus_key("sceneCounter"))
}

fn settings_pane() -> ViewHandle {
    vstack(&[
        text("Preferences").font_size(18.0),
        divider(),
        text("This pane is a `Settings` scene — the one ⌘, opens."),
        text(&format!("It sees the same state: {}", counter().get()))
            .opacity(0.7),
    ])
    .padding(24.0)
    .frame(360.0, 200.0)
    .into_handle()
}

fn utility_window() -> ViewHandle {
    vstack(&[
        text("Utility").font_size(16.0),
        text("A `Window`, not a `WindowGroup`: one of it, addressed by id.")
            .opacity(0.7),
    ])
    .padding(20.0)
    .frame(320.0, 140.0)
    .into_handle()
}

examples/inbox.rs (line 84)

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

examples/dashboard.rs (line 43)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

examples/hot_reload.rs (line 144)

fn status(error: Option<&str>, generation: u64, micros: u64) -> View {
    let slots = spec::slot_summary();
    let slot_line = if slots.is_empty() {
        String::new()
    } else {
        slots
            .iter()
            .map(|(k, v)| format!("{k}={v}"))
            .collect::<Vec<_>>()
            .join("  ")
    };

    // The error row is *always* present, empty when there is nothing wrong.
    // An error that appears and disappears would otherwise reflow the screen
    // above it on every save — which looks exactly like the reloader having
    // replaced the view, and makes "did the screen survive this?" impossible
    // to answer by looking.
    let rows = vec![
        divider(),
        hstack_spacing(
            &[
                circle_shape()
                    .fill_system(if error.is_some() {
                        SystemColor::Orange
                    } else {
                        SystemColor::Clear
                    })
                    .frame(8.0, 8.0),
                text(error.unwrap_or(""))
                    .font_size(11.0)
                    .fg_system(SystemColor::Orange),
                spacer(),
            ],
            6.0,
        )
        .padding(6.0)
        .frame(348.0, 24.0),
        hstack_spacing(
            &[
                circle_shape()
                    .fill_system(if error.is_some() {
                        SystemColor::Orange
                    } else {
                        SystemColor::Green
                    })
                    .frame(8.0, 8.0),
                text(&format!("gen {generation}"))
                    .font_size(11.0)
                    .fg_system(SystemColor::Secondary),
                // Microseconds below a millisecond: a reload of a short spec
                // really is that fast, and "0.0 ms" reads as "not measured".
                text(&if micros < 1000 {
                    format!("{micros} \u{b5}s")
                } else {
                    format!("{:.1} ms", micros as f64 / 1000.0)
                })
                .font_size(11.0)
                .fg_system(SystemColor::Secondary),
                spacer(),
                text(&slot_line).font_size(11.0).fg_system(SystemColor::Secondary),
            ],
            8.0,
        )
        .padding(6.0)
        .frame(348.0, 24.0),
    ];
    vstack_spacing(&rows, 0.0)
}

pub fn clip_circle(self) -> Self

.clipShape(Circle())

pub fn clip_capsule(self) -> Self

.clipShape(Capsule())

pub fn clip_capsule_styled(self, continuous: bool) -> Self

.clipShape(Capsule(style:)) — false gives the circular arc.

pub fn clip_rounded_styled(self, radius: f64, continuous: bool) -> Self

.clipShape(RoundedRectangle(cornerRadius:style:)) — .continuous is the squircle Apple’s own UI uses, and it is visibly not a circular arc.

pub fn clip_rounded(self, radius: f64) -> Self

.clipShape(RoundedRectangle(cornerRadius:))

pub fn overlay(self, content: View) -> Self

.overlay(alignment: .center) { … }

Examples found in repository

examples/swift_org_tutorial.rs (lines 137-143)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

pub fn overlay_aligned(self, content: View, alignment: Alignment) -> Self

.overlay(alignment:content:) — the same modifier as View::overlay, which pins to the centre.

pub fn mask(self, content: View) -> Self

.mask(alignment: .center) { … } — a _MaskAlignmentEffect.

pub fn mask_aligned(self, content: View, alignment: Alignment) -> Self

.mask(alignment:_:) with an alignment other than the centre.

pub fn mask_plain(self, content: View) -> Self

.mask(_:) — the older, alignment-free overload, which is a _MaskEffect. A different type from View::mask, not a shorthand for it.

pub fn aspect_ratio(self, ratio: f64, fill: bool) -> Self

.aspectRatio(_:contentMode:)

pub fn fixed_size(self, horizontal: bool, vertical: bool) -> Self

.fixedSize(horizontal:vertical:)

pub fn z_index(self, value: f64) -> Self

.zIndex(_:)

pub fn disabled(self, value: bool) -> Self

.disabled(_:)

pub fn hidden(self) -> Self

.hidden()

pub fn blend_mode(self, mode: u8) -> Self

.blendMode(_:)

pub fn navigation_title(self, title: &str) -> Self

.navigationTitle(_:)

Examples found in repository

examples/inbox.rs (line 74)

fn detail(i: usize) -> View {
    let m = &MESSAGES[i];
    vstack_aligned_spacing(
        &[
            text(m.subject).text_style(TextStyle::Title).bold(),
            text!("From {}", m.from).fg_system(SystemColor::Gray),
            divider(),
            text("Body text would go here.").fg_system(SystemColor::Gray),
            spacer(),
        ],
        HorizontalAlignment::Leading,
        Some(12.0),
    )
    .padding(20.0)
    .navigation_title(m.subject)
}

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

/// The row as it appears in the list: a link to the detail, with the swipe
/// action attached to the link rather than to its label.
fn linked_row(i: usize) -> View {
    navigation_link_labelled(row(i), detail(i))
        .swipe_actions(HorizontalEdge::Trailing, true, button("Delete", || {}))
}

fn body() -> View {
    let i = inbox();
    let rows = matching();
    navigation_stack(
        list(for_each_items(&rows, |&i| linked_row(i)))
        .list_style(views::ListStyle::InsetListStyle)
        .searchable(&i.query, &i.searching, SearchFieldPlacement::Automatic, "Search"),
    )
    .navigation_title("Inbox")
    .toolbar(button("Compose", || {}).keyboard_shortcut(KeyboardShortcut::DefaultAction))
}

pub fn navigation_title_bound(self, state: &BoundState<String>) -> Self

.navigationTitle(_:) with a binding — an editable title.

The title bar becomes a rename field: the user edits it in place and the new name is written back into Rust. Only the fixed-string overload was bound, so a document could be shown under a name but never renamed from where the name appears.

let name = BoundState::new(String::from("Untitled"));
let doc = text("body").navigation_title_bound(&name);

pub fn navigation_destination_for<V: IntoView>( self, destination: impl Fn(i64) -> V + 'static, ) -> Self

.navigationDestination(for: Int.self) { value in … } — value-based routing.

This is how a NavigationStack is driven in modern SwiftUI: rows push a value, and the stack asks this modifier what view that value means. Only the isPresented: overload was bound, which is the older one-destination-per-flag shape — fine for a single detail sheet, and no use for a stack that pushes rows.

let stack = navigation_stack(
    list_identified(&[1, 2, 3], |id| text(&format!("row {id}")))
        .navigation_destination_for(|id| text(&format!("detail {id}"))),
);

pub fn alert(self, title: &str, presented: bool, actions: View) -> Self

.alert(_:isPresented:actions:) with a fixed flag.

The flag becomes a Binding.constant, which SwiftUI treats as read-only, so this alert cannot be dismissed — there is nowhere to write false back to. View::alert_bound is the one a user can close.

pub fn alert_bound( self, title: &str, state: &BoundState<bool>, actions: View, ) -> Self

.alert(_:isPresented:actions:) bound to Rust state.

Dismissing writes false into state, so Rust learns the alert closed without being told.

pub fn alert_message_bound( self, title: &str, state: &BoundState<bool>, actions: View, message: View, ) -> Self

.alert(_:isPresented:actions:message:) — an alert that explains itself.

The message is the line under the title: what the buttons are about, and the difference between “Delete” and “Delete — this cannot be undone”. Only the title-and-buttons overload was bound, so an alert could ask but not say why.

let asking = BoundState::new(false);
let page = text("Notes").alert_message_bound(
    "Delete this?",
    &asking,
    button("Delete", || {}),
    text("This cannot be undone."),
);

pub fn alert_message( self, title: &str, presented: bool, actions: View, message: View, ) -> Self

.alert(_:isPresented:actions:message:) with a fixed flag, which cannot be dismissed — see alert.

pub fn confirmation_message_bound( self, title: &str, state: &BoundState<bool>, actions: View, message: View, ) -> Self

.confirmationDialog(_:isPresented:titleVisibility:actions:message:)

The message is the explanatory line under the title, and on a dialog it is often the only place the consequence is stated — “This deletes 12 items” under a bare “Delete”.

pub fn sheet(self, presented: bool, content: View) -> Self

.sheet(isPresented:content:) with a fixed flag — undismissable, as View::alert is. See View::sheet_bound.

pub fn sheet_bound(self, state: &BoundState<bool>, content: View) -> Self

.sheet(isPresented:content:) bound to Rust state, so a swipe down writes false back.

Examples found in repository

examples/settings.rs (line 84)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

pub fn sheet_bound_dismiss( self, state: &BoundState<bool>, content: View, on_dismiss: impl Fn() + 'static, ) -> Self

.sheet(isPresented:onDismiss:content:) — with a callback for the closing.

A sheet that saves what was edited has to know when it was dismissed, and onDismiss was hardwired to nil, so the sheet could be opened and closed and nothing on the Rust side would hear about it.

let editing = BoundState::new(false);
let page = text("Notes").sheet_bound_dismiss(
    &editing,
    text("editor"),
    || println!("saved"),
);

pub fn confirmation_dialog( self, title: &str, presented: bool, actions: View, ) -> Self

.confirmationDialog(_:isPresented:actions:) with a fixed flag — undismissable. See View::confirmation_dialog_bound.

pub fn confirmation_dialog_bound( self, title: &str, state: &BoundState<bool>, actions: View, ) -> Self

.confirmationDialog(_:isPresented:actions:) bound to Rust state.

pub fn a11y_label(self, label: &str) -> Self

.accessibilityLabel(_:)

Examples found in repository

examples/inbox.rs (line 99)

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

examples/dashboard.rs (line 50)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

examples/todo.rs (line 79)

fn row(i: usize, it: &Item) -> View {
    hstack_spacing(
        &[
            // The checkmark is the button, so the whole symbol is the target.
            button_labelled(
                system_image(if it.done { "checkmark.circle.fill" } else { "circle" })
                    .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                    .view()
                    .fg_system(if it.done { SystemColor::Green } else { SystemColor::Gray }),
                move || toggle(i),
            )
            .button_style(views::ButtonStyle::Bordered),
            text(&it.title)
                .strikethrough_styled(it.done, LinePattern::Solid, None)
                .fg_system(if it.done { SystemColor::Gray } else { SystemColor::Primary }),
            spacer(),
        ],
        10.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(6.0))
    .a11y_label(&it.title)
    .a11y_value(if it.done { "Done" } else { "Not done" })
}

pub fn a11y_hidden(self, hidden: bool) -> Self

.accessibilityHidden(_:)

pub fn focusable(self, value: bool) -> Self

.focusable(_:)

pub fn on_disappear(self, action: impl Fn() + 'static) -> Self

.onDisappear(perform:)

pub fn on_long_press(self, duration: f64, max_distance: f64) -> Self

.gesture(LongPressGesture(...))

pub fn on_long_press_perform( self, duration: f64, max_distance: f64, action: impl Fn() + 'static, ) -> Self

.onLongPressGesture(minimumDuration:maximumDistance:pressing:perform:)

Prefer this over on_long_press, which attaches the gesture with nothing listening.

pub fn clipped(self) -> Self

.clipped()

pub fn compositing_group(self) -> Self

.compositingGroup()

pub fn drawing_group(self) -> Self

.drawingGroup() — flatten the subtree through Metal.

pub fn rotate_3d(self, degrees: f64, axis: (f64, f64, f64)) -> Self

.rotation3DEffect(_:axis:)

pub fn on_drag(self, minimum_distance: f64) -> Self

.gesture(DragGesture(...))

pub fn on_drag_ended( self, minimum_distance: f64, action: impl Fn() + 'static, ) -> Self

.gesture(DragGesture(...).onEnded(_:))

Prefer this over on_drag, which attaches the gesture with nothing listening.

pub fn on_drag_value( self, minimum_distance: f64, action: impl Fn(DragValue) + 'static, ) -> Self

.gesture(DragGesture(...).onEnded { value in … }), with the value.

on_drag_ended tells the handler only that a drag ended. This one hands over where it started, where it finished and how fast it was moving — see views::DragValue.

let card = text("drag me").on_drag_value(1.0, |v| {
    let (dx, dy) = v.translation();
    println!("moved {dx} x {dy}");
});

pub fn on_magnify(self, minimum_scale_delta: f64) -> Self

.gesture(MagnifyGesture(...))

pub fn on_magnify_value( self, minimum_scale_delta: f64, action: impl Fn(MagnifyValue) + 'static, ) -> Self

.gesture(MagnifyGesture(...).onEnded { value in … })

on_magnify attaches the gesture with nothing listening — it builds the value Swift would and can never be seen to fire. This one hands over the magnification, the velocity and where the pinch was centred; see views::MagnifyValue.

pub fn on_rotate(self, minimum_degrees: f64) -> Self

.gesture(RotateGesture(...))

pub fn on_rotate_value( self, minimum_degrees: f64, action: impl Fn(RotateValue) + 'static, ) -> Self

.gesture(RotateGesture(...).onEnded { value in … })

As on_rotate, but the handler is told how far. Angle stores radians, so views::RotateValue::degrees converts rather than reading a second field.

pub fn popover(self, presented: bool, content: View) -> Self

.popover(isPresented:content:) with a fixed flag — undismissable. See View::popover_bound.

pub fn popover_bound(self, state: &BoundState<bool>, content: View) -> Self

.popover(isPresented:content:) bound to Rust state, so tapping outside writes false back.

pub fn on_change(self, value: i64, handler: impl Fn(i64, i64) + 'static) -> Self

.onChange(of:_:), watching an Int.

pub fn on_change_str( self, value: &str, handler: impl Fn(String, String) + 'static, ) -> Self

.onChange(of:initial:_:) over a String.

onChange is one of the modifiers an application reaches for most, and it could only watch an Int — a search term, a selected identifier, a mode name all had to be turned into a number first. Swift constrains the watched value to Equatable and nothing else.

let v = text("results").on_change_str("query", |was, now| {
    println!("search went from {was:?} to {now:?}");
});

pub fn on_change_bool( self, value: bool, handler: impl Fn(bool, bool) + 'static, ) -> Self

.onChange(of:initial:_:) over a Bool.

pub fn on_change_f64( self, value: f64, handler: impl Fn(f64, f64) + 'static, ) -> Self

.onChange(of:initial:_:) over a Double.

pub fn toolbar(self, content: View) -> Self

.toolbar { ToolbarItem { content } }

Examples found in repository

examples/inbox.rs (line 119)

fn body() -> View {
    let i = inbox();
    let rows = matching();
    navigation_stack(
        list(for_each_items(&rows, |&i| linked_row(i)))
        .list_style(views::ListStyle::InsetListStyle)
        .searchable(&i.query, &i.searching, SearchFieldPlacement::Automatic, "Search"),
    )
    .navigation_title("Inbox")
    .toolbar(button("Compose", || {}).keyboard_shortcut(KeyboardShortcut::DefaultAction))
}

pub fn toolbar_customizable( self, toolbar_id: &str, item_id: &str, shows_by_default: bool, content: View, ) -> Self

.toolbar(id:) { ToolbarItem(id:showsByDefault:) { content } } — a toolbar the user can rearrange, remembered under toolbar_id.

shows_by_default is whether the item is there before any customization; false leaves it in the palette until it is dragged in.

pub fn transition(self, kind: Transition) -> Self

.transition(.opacity)

Examples found in repository

examples/swift_org_tutorial.rs (line 147)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

examples/todo.rs (line 117)

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

pub fn id(self, value: i64) -> Self

.id(_) — the identity SwiftUI diffs against.

Changing it replaces the view rather than updating it, which is what makes a transition play: the old identity leaves, the new one arrives.

Examples found in repository

examples/swift_org_tutorial.rs (line 148)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

pub fn animation(self, value: i64) -> Self

.animation(.default, value:)

Examples found in repository

examples/dashboard.rs (line 81)

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

pub fn on_appear(self, action: impl Fn() + 'static) -> Self

.onAppear(perform:)

pub fn on_tap(self, action: impl Fn() + 'static) -> Self

.onTapGesture(count:perform:)

pub fn context_menu(self, items: View) -> Self

.contextMenu(menuItems:)

pub fn context_menu_preview(self, items: View, preview: View) -> Self

.contextMenu(menuItems:preview:) — a menu with something to look at.

The preview is what a long press enlarges before the menu appears: the row blown up, a photo, a card. context_menu has no such slot, so the menu came up over the view as it already was.

let row = text("Photo").context_menu_preview(
    button("Delete", || {}),
    image("photo").frame(200.0, 200.0),
);

pub fn scroll(self) -> Self

Wrap in a vertical ScrollView.

Examples found in repository

examples/common/spec.rs (line 570)

fn node_view(node: &Node) -> Result<View, String> {
    let spacing = node.f64_attr("spacing").unwrap_or(8.0);
    let base = match node.name.as_str() {
        "vstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => vstack_aligned_spacing(&kids, h_align(a, node.line)?, Some(spacing)),
                None => vstack_spacing(&kids, spacing),
            }
        }
        "hstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => hstack_aligned_spacing(&kids, v_align(a, node.line)?, Some(spacing)),
                None => hstack_spacing(&kids, spacing),
            }
        }
        "zstack" => zstack_aligned(&children(node)?, align(node.attr("align").unwrap_or("center"), node.line)?),
        "text" => {
            let s = node.value.as_deref().unwrap_or("");
            let mut v = text(s);
            if let Some(style) = node.attr("style") {
                v = v.text_style(text_style(style, node.line)?);
            }
            if let Some(size) = node.f64_attr("size") {
                v = v.font_size(size);
            }
            if node.flag("bold") {
                v = v.bold();
            }
            if node.flag("italic") {
                v = v.italic();
            }
            if let Some(c) = node.attr("color") {
                v = match tint(c, node.line)? {
                    Tint::System(sc) => v.fg_system(sc),
                    Tint::Literal(lc) => v.fg(lc),
                };
            }
            v
        }
        "spacer" => spacer(),
        "divider" => divider(),
        // The action is a no-op on purpose: a spec read from a file has nowhere
        // to put behaviour, and pretending otherwise would be worse than a
        // button that visibly does nothing. `hot_reload.rs` is where a spec
        // gains behaviour, by being reloaded.
        "button" => button(node.value.as_deref().unwrap_or("Button"), || {}),
        "color" => color(parse_color(node.value.as_deref().unwrap_or("#808080"), node.line)?),
        "image" => system_image(node.value.as_deref().unwrap_or("star")).into_view(),
        "rect" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => rectangle_shape().fill_system(sc),
                Tint::Literal(lc) => rectangle_shape().fill(lc),
            },
            None => rectangle_shape().into_view(),
        },
        "circle" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => circle_shape().fill_system(sc),
                Tint::Literal(lc) => circle_shape().fill(lc),
            },
            None => circle_shape().into_view(),
        },
        "capsule" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => capsule_shape().fill_system(sc),
                Tint::Literal(lc) => capsule_shape().fill(lc),
            },
            None => capsule_shape().into_view(),
        },
        "progress" => progress(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("total").unwrap_or(1.0),
        ),
        "gauge" => gauge(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(1.0),
            text(node.attr("label").unwrap_or("")),
        ),
        "group_box" => group_box(stack_children(node)?),
        "list" => list(stack_children(node)?),
        "scroll" => stack_children(node)?.scroll(),
        "form" => form(stack_children(node)?),
        // Every bound control needs an explicit `@name`.
        //
        // Inventing one — from the line, or from position in the tree — looks
        // friendlier and is a trap: adding a line above a `toggle` would
        // change its derived name, and the control would silently reset on the
        // next reload. A name the file states is a name that survives the file
        // being edited, which is the entire point of the slots.
        "toggle" => toggle_bound(
            node.value.as_deref().unwrap_or("Toggle"),
            &flag_slot(&require_slot(node)?, node.flag("on")),
        ),
        "slider" => {
            let lo = node.f64_attr("min").unwrap_or(0.0);
            let hi = node.f64_attr("max").unwrap_or(1.0);
            slider_bound(
                &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(lo)),
                lo,
                hi,
            )
        }
        "stepper" => stepper_bound(
            node.value.as_deref().unwrap_or("Stepper"),
            &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(0.0)),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(100.0),
            node.f64_attr("step").unwrap_or(1.0),
        ),
        "field" => textfield_bound(
            node.value.as_deref().unwrap_or(""),
            &string_slot(&require_slot(node)?, node.attr("text").unwrap_or("")),
        ),
        "label" => label(
            node.value.as_deref().unwrap_or(""),
            node.attr("icon").unwrap_or("star"),
        ),
        other => {
            return Err(format!(
                "line {}: no view called `{other}`; try one of {}",
                node.line,
                NAMES.join(", ")
            ))
        }
    };
    decorate(base, node)
}

pub fn position(self, x: f64, y: f64) -> Self

.position(x:y:) — place the view’s centre at a point in its parent, which is not the same as .offset(x:y:) moving it from where it was.

pub fn hue_rotation(self, radians: f64) -> Self

.hueRotation(.radians(_))

pub fn color_multiply(self, color: Color) -> Self

.colorMultiply(_:) — multiply every pixel by a colour, which tints without covering.

pub fn content_transition(self, transition: ContentTransition) -> Self

.contentTransition(_:) — how a change to the content animates, as distinct from the view arriving or leaving.

pub fn projection_effect(self, m: [f64; 9]) -> Self

.projectionEffect(_:) — a 3x3 projection, row-major.

pub fn aspect_ratio_mode(self, fill: bool) -> Self

.aspectRatio(contentMode:) without pinning a ratio — true fills, false fits.

pub fn safe_area_padding(self, length: f64) -> Self

.safeAreaPadding(_:) — padding measured from the safe area rather than from the view.

pub fn content_margins( self, length: f64, placement: ContentMarginPlacement, ) -> Self

.contentMargins(_:for:)

pub fn container_shape(self, shape: InsettableShape) -> Self

.containerShape(_:) — the shape descendants inherit for clipping.

pub fn coordinate_space(self, name: HashableValue<'_>) -> Self

.coordinateSpace(_:) — name this view’s space so a GeometryProxy can report positions relative to it.

pub fn grid_cell_unsized_axes(self, axes: AxisSet) -> Self

.gridCellUnsizedAxes(_:) — axes this cell should not stretch along.

pub fn grid_column_alignment(self, alignment: HorizontalAlignment) -> Self

.gridColumnAlignment(_:)

pub fn alignment_guide( self, alignment: HorizontalAlignment, compute: impl Fn(ViewDimensions) -> f64 + 'static, ) -> Self

.alignmentGuide(_:computeValue:) — move where this view lines up with its siblings without moving the view.

compute is handed the view’s views::ViewDimensions and answers in terms of them, which is what an alignment guide is for: returning d.width / 2.0 lines the view up by its centre, d.width by its far edge. It used to take no arguments, so the only guide it could express was a constant — the one kind that does not need the modifier.

let v = text("centred").alignment_guide(HorizontalAlignment::Leading, |d| d.width / 2.0);

pub fn container_relative_frame( self, axes: &[AxisSet], alignment: Alignment, ) -> Self

.containerRelativeFrame(_:alignment:) — size against the container rather than the content, which is what makes a carousel page.

pub fn container_relative_frame_thirds( self, axes: &[AxisSet], alignment: Alignment, ) -> Self

.containerRelativeFrame(_:count:span:spacing:alignment:) at thirds.

pub fn on_geometry_change( self, measure: impl Fn(f64, f64) -> i64 + 'static, action: impl Fn(i64, i64) + 'static, ) -> Self

.onGeometryChange(for:of:action:) — observe the measured geometry.

measure is handed the view’s width and height and returns the value to watch; action is called with the old and the new one whenever that value changes. Both used to be blind — measure took no arguments, so it could not read the geometry the modifier exists to report, and action was told only that something had changed.

let v = text("wide?").on_geometry_change(
    |w, _h| (w > 400.0) as i64,
    |was, now| println!("wide: {was} -> {now}"),
);

pub fn on_geometry_change_f64( self, measure: impl Fn(f64, f64) -> f64 + 'static, action: impl Fn(f64, f64) + 'static, ) -> Self

.onGeometryChange(for: Double.self, of:action:) — the same, watching a Double.

Which is usually what is wanted: the value being watched is nearly always a width or a height, and for: Int.self meant rounding it before it could be watched at all.

let v = text("wide?").on_geometry_change_f64(|w, _h| w, |was, now| {
    println!("width {was} -> {now}");
});

pub fn clip_ellipse(self) -> Self

.clipShape(Ellipse())

pub fn layout_direction_behavior(self, value: LayoutDirectionBehavior) -> Self

.layoutDirectionBehavior(_:) — whether this mirrors in a right-to-left language.

pub fn layout_value(self, value: i64) -> Self

.layoutValue(key:value:)

pub fn container_corner_offset(self, edges: EdgeSet, value: bool) -> Self

.containerCornerOffset(_:)

pub fn safe_area_bar( self, edge: VerticalEdge, alignment: HorizontalAlignment, spacing: Option<f64>, content: View, ) -> Self

.safeAreaBar(edge:alignment:spacing:content:) — a bar that shrinks the safe area, as View::safe_area_inset does, but styled as a bar.

pub fn ignores_safe_area(self) -> Self

.ignoresSafeArea() — let the view run under the notch, the home indicator and the keyboard, which is what a full-bleed background wants.

pub fn ignores_safe_area_edges( self, regions: SafeAreaRegions, edges: EdgeSet, ) -> Self

.ignoresSafeArea(_:edges:) — the same, but only the regions and edges named. .ignoresSafeArea(.keyboard) alone is the common case.

pub fn safe_area_inset( self, edge: VerticalEdge, alignment: HorizontalAlignment, spacing: Option<f64>, content: View, ) -> Self

.safeAreaInset(edge:alignment:spacing:) { … } — put a view against one edge and shrink this view’s safe area by however tall it turns out to be. A bottom bar that scrolling content stops above, without measuring.

pub fn scroll_indicators( self, visibility: ScrollIndicatorVisibility, axes: AxisSet, ) -> Self

.scrollIndicators(_:axes:)

The axis is not optional here as it is in Swift: SwiftUI’s default is [.horizontal, .vertical], and Axis.Set has no .all static to name that pair with, so a no-axis convenience would have to quietly pick one.

pub fn content_shape(self, shape: InsettableShape) -> Self

.contentShape(_:) — the region that takes hits, which is otherwise the view’s frame. A circular button in a square frame needs this or its corners stay tappable.

pub fn tag(self, value: HashableValue<'_>) -> Self

.tag(_:) — the value a Picker or TabView selects when this is the chosen row.

pub fn tag_int(self, value: i64) -> Self

.tag(_:) with an Int, which is what a Picker bound to views::BoundState<i64> selects by.

Examples found in repository

examples/settings.rs (line 72)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

pub fn tag_str(self, value: &str) -> Self

.tag(_:) with a String.

pub fn task(self, action: impl Fn() + Send + Sync + 'static) -> Self

.task { … } — run the action once when the view appears, cancelled if it goes away first.

#[track_caller] so the task carries the call site’s file and line, which is what SwiftUI names it by in Instruments — taking file!() here would name every task after this file.

pub fn task_id(self, id: i64, action: impl Fn() + Send + Sync + 'static) -> Self

.task(id:) { … } — as task, but restarted whenever the identity changes.

SwiftUI cancels the running task and starts a new one when id differs from the last body evaluation, which is how a detail view re-fetches when the selection moves. views::task has always built this; it had no chainable method, so the DSL could only ever start a task once.

pub fn image_scale(self, scale: ImageScale) -> Self

.imageScale(_:) — how large an SF Symbol draws relative to its font.

pub fn text_case(self, case: Option<TextCase>) -> Self

.textCase(_:) — None restores the text as written.

impl View

pub fn navigation_destination( self, state: &BoundState<bool>, destination: View, ) -> Self

.navigationDestination(isPresented:destination:) bound to Rust state — pushing sets it, and the back button writes false back.

pub fn inspector(self, state: &BoundState<bool>, content: View) -> Self

.inspector(isPresented:content:) bound to Rust state.

pub fn inspector_column_width(self, width: f64) -> Self

.inspectorColumnWidth(_:) — one fixed width for the inspector column.

pub fn inspector_column_width_range( self, min: Option<f64>, ideal: f64, max: Option<f64>, ) -> Self

.inspectorColumnWidth(min:ideal:max:) — a width the user can drag within.

None for a bound leaves the column unconstrained in that direction, which is not the same as pinning it to zero. .inspector_column_width above is the fixed spelling.

pub fn toolbar_background( self, visibility: Visibility, placements: &[ToolbarPlacement], ) -> Self

.toolbarBackground(_:for:)

pub fn toolbar_visibility( self, visibility: Visibility, placements: &[ToolbarPlacement], ) -> Self

.toolbarVisibility(_:for:) — whether the bar shows at all.

SwiftUI also spells this .toolbar(_:for:); this reaches the named one.

pub fn toolbar_title_display_mode(self, mode: ToolbarTitleDisplayMode) -> Self

.toolbarTitleDisplayMode(_:) — large title or inline.

pub fn toolbar_role(self, role: ToolbarRole) -> Self

.toolbarRole(_:)

pub fn searchable( self, text: &BoundState<String>, presented: &BoundState<bool>, placement: SearchFieldPlacement, prompt: &str, ) -> Self

.searchable(text:isPresented:placement:prompt:), both bindings owned by Rust — the query text lands in text as it is typed.

Examples found in repository

examples/inbox.rs (line 116)

fn body() -> View {
    let i = inbox();
    let rows = matching();
    navigation_stack(
        list(for_each_items(&rows, |&i| linked_row(i)))
        .list_style(views::ListStyle::InsetListStyle)
        .searchable(&i.query, &i.searching, SearchFieldPlacement::Automatic, "Search"),
    )
    .navigation_title("Inbox")
    .toolbar(button("Compose", || {}).keyboard_shortcut(KeyboardShortcut::DefaultAction))
}

pub fn navigation_split_view_style_automatic(self) -> Self

.navigationSplitViewStyle(.automatic)

pub fn navigation_view_style_automatic(self) -> Self

.navigationViewStyle(.automatic)

pub fn navigation_document(self, item: &str) -> Self

.navigationDocument(_:)

pub fn navigation_document_url(self, spec: &str) -> Self

.navigationDocument(_:) with a URL.

pub fn toolbar_background_visibility( self, visibility: Visibility, placements: &[ToolbarPlacement], ) -> Self

.toolbarBackgroundVisibility(_:for:) — distinct from View::toolbar_background, which sets what the background is.

pub fn toolbar_color_scheme( self, scheme: Option<ColorScheme>, placements: &[ToolbarPlacement], ) -> Self

.toolbarColorScheme(_:in:) — None restores the inherited scheme.

pub fn toolbar_title_menu(self, content: View) -> Self

.toolbarTitleMenu(content:) — the menu behind a tappable title.

pub fn presentation_sizing(self) -> Self

.presentationSizing(_:)

pub fn presentation_background_interaction( self, value: PresentationBackgroundInteraction, ) -> Self

.presentationBackgroundInteraction(_:) — whether what is behind a sheet still takes touches, which is what makes a half-sheet usable.

pub fn presentation_compact_adaptation( self, value: PresentationAdaptation, ) -> Self

.presentationCompactAdaptation(_:) — what a popover becomes when the size class is compact, which on a phone is always.

pub fn presentation_content_interaction( self, value: PresentationContentInteraction, ) -> Self

.presentationContentInteraction(_:) — whether a drag resizes the sheet or scrolls its content.

pub fn navigation_transition(self) -> Self

.navigationTransition(_:)

pub fn navigation_split_view_column_width(self, width: f64) -> Self

.navigationSplitViewColumnWidth(_:)

pub fn matched_transition_source(self, id: HashableValue<'_>) -> Self

.matchedTransitionSource(id:in:) — the view a zoom transition grows from, paired with View::matched_geometry_effect’s destination.

pub fn presentation_detents(self, detents: &[PresentationDetent]) -> Self

.presentationDetents(_:) — the heights a sheet can rest at, which is what makes it a half-sheet rather than a full one.

Examples found in repository

examples/settings.rs (line 106)

fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

pub fn presentation_drag_indicator(self, visibility: Visibility) -> Self

.presentationDragIndicator(_:)

Examples found in repository

examples/settings.rs (line 107)

fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

pub fn presentation_corner_radius(self, radius: Option<f64>) -> Self

.presentationCornerRadius(_:) — None restores the system radius.

pub fn presentation_background( self, alignment: Alignment, content: View, ) -> Self

.presentationBackground(alignment:content:)

pub fn tint_system(self, c: SystemColor) -> Self

.tint(_:) with one of SwiftUI’s own colours.

View::tint takes a literal Color; a named colour is not a fixed triple, so for an accent — which is what the system draws controls with — naming it is usually what is meant.

Examples found in repository

examples/dashboard.rs (line 67)

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

pub fn search_toolbar_behavior(self, value: SearchToolbarBehavior) -> Self

.searchToolbarBehavior(_:)

pub fn search_presentation_toolbar_behavior( self, value: SearchPresentationToolbarBehavior, ) -> Self

.searchPresentationToolbarBehavior(_:)

pub fn text_selection_affinity(self, value: TextSelectionAffinity) -> Self

.textSelectionAffinity(_:)

pub fn type_select_equivalent(self, text: Option<&str>) -> Self

.typeSelectEquivalent(_:) — what typing in a list jumps to.

pub fn search_scopes(self, scope: &BoundState<i64>, scopes: View) -> Self

.searchScopes(_:scopes:) bound to Rust state — the chosen scope lands in scope.

pub fn search_suggestions( self, visibility: Visibility, placements: SearchSuggestionsPlacementSet, ) -> Self

.searchSuggestions(_:for:) — where suggestions may appear.

pub fn search_selection(self, changed: impl Fn() + 'static) -> Self

.searchSelection(_:)

pub fn search_focused(self) -> Self

.searchFocused(_:)

pub fn text_input_suggestions(self, count: usize, content: View) -> Self

.textInputSuggestions { … } — completions offered under a field.

pub fn find_navigator(self, state: &BoundState<bool>) -> Self

.findNavigator(isPresented:) bound to Rust state — the find bar.

impl View

pub fn file_exporter( self, state: &BoundState<bool>, item: Option<&str>, kinds: &[ContentType], default_filename: Option<&str>, completion: impl Fn(FileOutcome) + 'static, cancellation: impl Fn() + 'static, ) -> Self

.fileExporter(isPresented:item:contentTypes:defaultFilename:onCompletion:onCancellation:)

pub fn file_importer( self, state: &BoundState<bool>, kinds: &[ContentType], completion: impl Fn(FileOutcome) + 'static, ) -> Self

.fileImporter(isPresented:allowedContentTypes:onCompletion:)

pub fn file_mover( self, state: &BoundState<bool>, file: Option<&str>, completion: impl Fn(FileOutcome) + 'static, ) -> Self

.fileMover(isPresented:file:onCompletion:)

pub fn item_provider(self, item: Option<&str>) -> Self

.itemProvider(_:) — what this view offers to a drag or a service.

pub fn exports_item_providers( self, kinds: &[ContentType], items: &[&str], edit: impl Fn(&[ItemProvider]) -> bool + 'static, ) -> Self

.exportsItemProviders(_:items:onEdit:)

pub fn imports_item_providers( self, kinds: &[ContentType], accept: impl Fn(&[ItemProvider]) -> bool + 'static, ) -> Self

.importsItemProviders(_:onImport:)

pub fn exportable_to_services(self, items: &[&str]) -> Self

.exportableToServices(_:) — what the Services menu may take.

pub fn importable_from_services( self, accept: impl Fn(&[String]) -> bool + 'static, ) -> Self

.importableFromServices(for:action:)

pub fn on_receive( self, complete_immediately: bool, perform: impl Fn(i64) + 'static, ) -> Self

.onReceive(_:perform:) — a publisher’s values, as Ints.

pub fn on_scroll_geometry_change( self, measure: impl Fn(ScrollGeometry) -> i64 + 'static, action: impl Fn(i64, i64) + 'static, ) -> Self

.onScrollGeometryChange(for:of:action:) measure is handed the scroll view’s views::ScrollGeometry and returns the value to watch; action is called with the old and the new one. Both used to be blind, which left the modifier able to notice that something had scrolled and nothing more.

pub fn on_scroll_geometry_change_f64( self, measure: impl Fn(ScrollGeometry) -> f64 + 'static, action: impl Fn(f64, f64) + 'static, ) -> Self

.onScrollGeometryChange(for: Double.self, …) — the same, watching a Double, which a scroll offset is.

pub fn on_scroll_target_visibility_change( self, threshold: f64, visible: impl Fn(&[i64]) + 'static, ) -> Self

.onScrollTargetVisibilityChange(for:threshold:_:) — which targets are on screen, which is how a carousel knows what page it is on.

pub fn dismissal_confirmation_dialog( self, title: &str, should_present: bool, actions: View, message: View, ) -> Self

.dismissalConfirmationDialog(_:shouldPresent:actions:message:) — ask before a sheet closes on unsaved work.

pub fn presentation_prevents_app_termination( self, prevents: Option<bool>, ) -> Self

.presentationPreventsAppTermination(_:) — None restores the default.

pub fn text_input_formatting_control_visibility( self, visibility: Visibility, placements: TextInputFormattingControlPlacementSet, ) -> Self

.textInputFormattingControlVisibility(_:for:)

pub fn hand_gesture_shortcut( self, shortcut: HandGestureShortcut, enabled: bool, ) -> Self

.handGestureShortcut(_:isEnabled:) — the pinch that stands in for a tap on a watch.

pub fn assistive_access_navigation_icon(self, name: &str) -> Self

.assistiveAccessNavigationIcon(_:)

pub fn a11y_rotor(self, label: &str, text: &str) -> Self

.accessibilityRotor(_:textRanges:) — a custom rotor VoiceOver can spin through.

pub fn a11y_rotor_entry(self, id: HashableValue<'_>) -> Self

.accessibilityRotorEntry(id:in:)

pub fn a11y_chart_descriptor(self) -> Self

.accessibilityChartDescriptor(_:)

pub fn environment_object(self) -> Self

.environmentObject(_:)

pub fn focused_object(self) -> Self

.focusedObject(_:)

pub fn default_app_storage_standard(self) -> Self

.defaultAppStorage(_:)

pub fn text_renderer(self) -> Self

.textRenderer(_:)

pub fn attributed_text_formatting_definition(self) -> Self

.attributedTextFormattingDefinition(_:)

pub fn environment_image_scale(self, scale: ImageScale) -> Self

.environment(\.imageScale, _)

pub fn environment_symbol_variants(self, value: SymbolVariants) -> Self

.environment(\.symbolVariants, _)

pub fn transform_environment_image_scale( self, action: impl Fn(ImageScale) -> ImageScale + 'static, ) -> Self

.transformEnvironment(\.imageScale, _)

pub fn focused_value(self, present: bool) -> Self

.focusedValue(_:)

pub fn preference(self, value: i64) -> Self

.preference(key:value:) — write a value for an ancestor to collect.

pub fn on_preference_change(self) -> Self

.onPreferenceChange(_:perform:) — observe what descendants wrote.

The value is read back with views::observed_preference rather than through a closure, because SwiftUI calls the handler on its own schedule and the last value is what a caller wants.

pub fn transform_preference(self) -> Self

.transformPreference(_:_:) — rewrite what passes through.

pub fn anchor_preference(self, transform: impl Fn() -> i64 + 'static) -> Self

.anchorPreference(key:value:transform:) — write a preference derived from this view’s geometry.

pub fn transform_anchor_preference( self, transform: impl Fn(i64) -> i64 + 'static, ) -> Self

.transformAnchorPreference(key:value:transform:)

pub fn overlay_preference_value( self, alignment: Alignment, content: View, ) -> Self

.overlayPreferenceValue(_:alignment:_:) — place content over this view using what a descendant reported, which is how a badge follows the thing it belongs to.

pub fn background_preference_value( self, alignment: Alignment, content: View, ) -> Self

.backgroundPreferenceValue(_:alignment:_:)

pub fn grid_cell_anchor(self, x: f64, y: f64) -> Self

.gridCellAnchor(_:) — where this cell sits in the space the grid gives it, as a unit point.

pub fn popover_anchored( self, state: &BoundState<bool>, anchor: (f64, f64), arrow_edge: Edge, content: View, ) -> Self

.popover(isPresented:attachmentAnchor:arrowEdge:content:) bound to Rust state — the anchored form, where the arrow points at a chosen point rather than the view’s middle.

pub fn window_resize_anchor(self, anchor: Option<(f64, f64)>) -> Self

.windowResizeAnchor(_:) — None restores the default.

impl View

pub fn font_size(self, size: f64) -> Self

.font(.system(size:)) On a Text this is Text.font(_:), which returns Text, so a chain of text modifiers stays one type the way Swift’s does.

Examples found in repository

examples/dynamic_ui.rs (line 73)

pub fn body() -> View {
    let text_src = current().lock().expect("spec").clone();
    match spec::parse(&text_src).and_then(|nodes| spec::build(&nodes)) {
        Ok(v) => v,
        Err(e) => vstack_aligned_spacing(
            &[
                text("Could not build that screen")
                    .text_style(TextStyle::Headline)
                    .fg_system(SystemColor::Red),
                text(&e).font_size(12.0).fg_system(SystemColor::Secondary),
            ],
            HorizontalAlignment::Leading,
            Some(8.0),
        )
        .padding(20.0),
    }
}

examples/scenes.rs (line 51)

fn main_window() -> ViewHandle {
    vstack(&[
        text("A SwiftUI app, no Swift source")
            .font_size(20.0)
            .padding(8.0),
        divider(),
        text(&format!("count: {}", counter().get()))
            .font_size(34.0)
            .padding(12.0),
        hstack(&[
            button("−", || counter().set(counter().get() - 1)),
            button("+", || counter().set(counter().get() + 1)),
        ]),
        spacer(),
        text("⌘, for Settings · the ★ in the menu bar has a menu")
            .font_size(11.0)
            .opacity(0.6),
    ])
    .padding(24.0)
    .frame(420.0, 300.0)
    .focused_scene_value(counter_focus_key(), counter().get())
    .into_handle()
}

/// The focused-value key the window publishes its count under.
///
/// `.focusedSceneValue(\.key, value)` is how a window tells the commands above
/// it what is selected. Both halves are synthesised at run time: the
/// `FocusedValueKey` conformance *and* the `WritableKeyPath<FocusedValues, Int?>`
/// — `FocusedValues` exports no properties, so unlike `EnvironmentValues` there
/// is no SwiftUI modifier holding a key path to borrow.
///
/// The menu cannot *read* it yet: that needs `@FocusedValue`, a `DynamicProperty`
/// SwiftUI instantiates itself, which is a different mechanism from anything
/// here. What this demonstrates is the publishing half, in a real app.
fn counter_focus_key() -> &'static views::FocusKey {
    static K: std::sync::OnceLock<views::FocusKey> = std::sync::OnceLock::new();
    K.get_or_init(|| views::focus_key("sceneCounter"))
}

fn settings_pane() -> ViewHandle {
    vstack(&[
        text("Preferences").font_size(18.0),
        divider(),
        text("This pane is a `Settings` scene — the one ⌘, opens."),
        text(&format!("It sees the same state: {}", counter().get()))
            .opacity(0.7),
    ])
    .padding(24.0)
    .frame(360.0, 200.0)
    .into_handle()
}

fn utility_window() -> ViewHandle {
    vstack(&[
        text("Utility").font_size(16.0),
        text("A `Window`, not a `WindowGroup`: one of it, addressed by id.")
            .opacity(0.7),
    ])
    .padding(20.0)
    .frame(320.0, 140.0)
    .into_handle()
}

examples/settings.rs (line 96)

fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

examples/inbox.rs (line 90)

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

examples/dashboard.rs (line 44)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

examples/swift_org_tutorial.rs (line 141)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

Additional examples can be found in:

• examples/todo.rs
• examples/hot_reload.rs
• examples/common/spec.rs

pub fn font( self, size: f64, weight: Option<Weight>, design: Option<Design>, ) -> Self

.font(.system(size:weight:design:)) — Text.font(_:) on a Text.

pub fn text_style(self, style: TextStyle) -> Self

.font(_:) with a built-in text style. On a Text this is Text.font(_:), which returns Text — so a chain like .text_style(.body).bold() stays a Text the way Swift’s does, instead of each step wrapping the last in an environment modifier.

Examples found in repository

examples/inbox.rs (line 64)

fn detail(i: usize) -> View {
    let m = &MESSAGES[i];
    vstack_aligned_spacing(
        &[
            text(m.subject).text_style(TextStyle::Title).bold(),
            text!("From {}", m.from).fg_system(SystemColor::Gray),
            divider(),
            text("Body text would go here.").fg_system(SystemColor::Gray),
            spacer(),
        ],
        HorizontalAlignment::Leading,
        Some(12.0),
    )
    .padding(20.0)
    .navigation_title(m.subject)
}

examples/dynamic_ui.rs (line 71)

pub fn body() -> View {
    let text_src = current().lock().expect("spec").clone();
    match spec::parse(&text_src).and_then(|nodes| spec::build(&nodes)) {
        Ok(v) => v,
        Err(e) => vstack_aligned_spacing(
            &[
                text("Could not build that screen")
                    .text_style(TextStyle::Headline)
                    .fg_system(SystemColor::Red),
                text(&e).font_size(12.0).fg_system(SystemColor::Secondary),
            ],
            HorizontalAlignment::Leading,
            Some(8.0),
        )
        .padding(20.0),
    }
}

examples/settings.rs (line 98)

fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

examples/dashboard.rs (line 41)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

examples/sugar.rs (line 22)

fn main() {
    let show_detail = true;
    let items = vec![String::from("alpha"), String::from("beta")];

    let sugared = swiftui! {
        VStack(spacing: 8.0) {
            Text("Title").text_style(.large_title)
            if show_detail {
                Text("the details")
            }
            ForEach(items) { item in
                Text(item)
            }
        }
    };

    let by_hand = vstack_spacing(
        &[
            text("Title").text_style(views::TextStyle::LargeTitle),
            conditional(show_detail, text("the details"), empty()),
            for_each_items(&items, |item| text(item)),
        ],
        8.0,
    );

    let a = views::dump_value_to_depth(&sugared.into_handle(), 6);
    let b = views::dump_value_to_depth(&by_hand.into_handle(), 6);
    eprintln!("macro == hand-written? {}", a == b);
    if a != b {
        for (x, y) in a.lines().zip(b.lines()) {
            if x != y {
                eprintln!("  macro: {}\n  hand : {}", x.trim(), y.trim());
                break;
            }
        }
    }
}

examples/swift_org_tutorial.rs (line 134)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

Additional examples can be found in:

• examples/todo.rs
• examples/common/spec.rs

pub fn font_named(self, name: &str, size: f64) -> Self

.font(.custom(_:size:))

pub fn font_ref(self, font: &Font) -> Self

.font(_:) with a prebuilt views::Font, which is far cheaper than rebuilding the font for every view.

pub fn bold(self) -> Self

.bold()

On a Text this is Text.bold(), which returns Text — the same type Swift produces, and the reason the documentation corpus compares equal. On anything else it is the View extension, which writes the environment so the text below inherits it.

Examples found in repository

examples/inbox.rs (line 64)

fn detail(i: usize) -> View {
    let m = &MESSAGES[i];
    vstack_aligned_spacing(
        &[
            text(m.subject).text_style(TextStyle::Title).bold(),
            text!("From {}", m.from).fg_system(SystemColor::Gray),
            divider(),
            text("Body text would go here.").fg_system(SystemColor::Gray),
            spacer(),
        ],
        HorizontalAlignment::Leading,
        Some(12.0),
    )
    .padding(20.0)
    .navigation_title(m.subject)
}

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

examples/settings.rs (line 98)

fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

examples/dashboard.rs (line 41)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

examples/swift_org_tutorial.rs (line 134)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

examples/todo.rs (line 90)

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

examples/common/spec.rs (line 515)

fn node_view(node: &Node) -> Result<View, String> {
    let spacing = node.f64_attr("spacing").unwrap_or(8.0);
    let base = match node.name.as_str() {
        "vstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => vstack_aligned_spacing(&kids, h_align(a, node.line)?, Some(spacing)),
                None => vstack_spacing(&kids, spacing),
            }
        }
        "hstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => hstack_aligned_spacing(&kids, v_align(a, node.line)?, Some(spacing)),
                None => hstack_spacing(&kids, spacing),
            }
        }
        "zstack" => zstack_aligned(&children(node)?, align(node.attr("align").unwrap_or("center"), node.line)?),
        "text" => {
            let s = node.value.as_deref().unwrap_or("");
            let mut v = text(s);
            if let Some(style) = node.attr("style") {
                v = v.text_style(text_style(style, node.line)?);
            }
            if let Some(size) = node.f64_attr("size") {
                v = v.font_size(size);
            }
            if node.flag("bold") {
                v = v.bold();
            }
            if node.flag("italic") {
                v = v.italic();
            }
            if let Some(c) = node.attr("color") {
                v = match tint(c, node.line)? {
                    Tint::System(sc) => v.fg_system(sc),
                    Tint::Literal(lc) => v.fg(lc),
                };
            }
            v
        }
        "spacer" => spacer(),
        "divider" => divider(),
        // The action is a no-op on purpose: a spec read from a file has nowhere
        // to put behaviour, and pretending otherwise would be worse than a
        // button that visibly does nothing. `hot_reload.rs` is where a spec
        // gains behaviour, by being reloaded.
        "button" => button(node.value.as_deref().unwrap_or("Button"), || {}),
        "color" => color(parse_color(node.value.as_deref().unwrap_or("#808080"), node.line)?),
        "image" => system_image(node.value.as_deref().unwrap_or("star")).into_view(),
        "rect" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => rectangle_shape().fill_system(sc),
                Tint::Literal(lc) => rectangle_shape().fill(lc),
            },
            None => rectangle_shape().into_view(),
        },
        "circle" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => circle_shape().fill_system(sc),
                Tint::Literal(lc) => circle_shape().fill(lc),
            },
            None => circle_shape().into_view(),
        },
        "capsule" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => capsule_shape().fill_system(sc),
                Tint::Literal(lc) => capsule_shape().fill(lc),
            },
            None => capsule_shape().into_view(),
        },
        "progress" => progress(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("total").unwrap_or(1.0),
        ),
        "gauge" => gauge(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(1.0),
            text(node.attr("label").unwrap_or("")),
        ),
        "group_box" => group_box(stack_children(node)?),
        "list" => list(stack_children(node)?),
        "scroll" => stack_children(node)?.scroll(),
        "form" => form(stack_children(node)?),
        // Every bound control needs an explicit `@name`.
        //
        // Inventing one — from the line, or from position in the tree — looks
        // friendlier and is a trap: adding a line above a `toggle` would
        // change its derived name, and the control would silently reset on the
        // next reload. A name the file states is a name that survives the file
        // being edited, which is the entire point of the slots.
        "toggle" => toggle_bound(
            node.value.as_deref().unwrap_or("Toggle"),
            &flag_slot(&require_slot(node)?, node.flag("on")),
        ),
        "slider" => {
            let lo = node.f64_attr("min").unwrap_or(0.0);
            let hi = node.f64_attr("max").unwrap_or(1.0);
            slider_bound(
                &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(lo)),
                lo,
                hi,
            )
        }
        "stepper" => stepper_bound(
            node.value.as_deref().unwrap_or("Stepper"),
            &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(0.0)),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(100.0),
            node.f64_attr("step").unwrap_or(1.0),
        ),
        "field" => textfield_bound(
            node.value.as_deref().unwrap_or(""),
            &string_slot(&require_slot(node)?, node.attr("text").unwrap_or("")),
        ),
        "label" => label(
            node.value.as_deref().unwrap_or(""),
            node.attr("icon").unwrap_or("star"),
        ),
        other => {
            return Err(format!(
                "line {}: no view called `{other}`; try one of {}",
                node.line,
                NAMES.join(", ")
            ))
        }
    };
    decorate(base, node)
}

pub fn italic(self) -> Self

.italic() — Text.italic() on a Text, the View extension otherwise.

Examples found in repository

examples/common/spec.rs (line 518)

fn node_view(node: &Node) -> Result<View, String> {
    let spacing = node.f64_attr("spacing").unwrap_or(8.0);
    let base = match node.name.as_str() {
        "vstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => vstack_aligned_spacing(&kids, h_align(a, node.line)?, Some(spacing)),
                None => vstack_spacing(&kids, spacing),
            }
        }
        "hstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => hstack_aligned_spacing(&kids, v_align(a, node.line)?, Some(spacing)),
                None => hstack_spacing(&kids, spacing),
            }
        }
        "zstack" => zstack_aligned(&children(node)?, align(node.attr("align").unwrap_or("center"), node.line)?),
        "text" => {
            let s = node.value.as_deref().unwrap_or("");
            let mut v = text(s);
            if let Some(style) = node.attr("style") {
                v = v.text_style(text_style(style, node.line)?);
            }
            if let Some(size) = node.f64_attr("size") {
                v = v.font_size(size);
            }
            if node.flag("bold") {
                v = v.bold();
            }
            if node.flag("italic") {
                v = v.italic();
            }
            if let Some(c) = node.attr("color") {
                v = match tint(c, node.line)? {
                    Tint::System(sc) => v.fg_system(sc),
                    Tint::Literal(lc) => v.fg(lc),
                };
            }
            v
        }
        "spacer" => spacer(),
        "divider" => divider(),
        // The action is a no-op on purpose: a spec read from a file has nowhere
        // to put behaviour, and pretending otherwise would be worse than a
        // button that visibly does nothing. `hot_reload.rs` is where a spec
        // gains behaviour, by being reloaded.
        "button" => button(node.value.as_deref().unwrap_or("Button"), || {}),
        "color" => color(parse_color(node.value.as_deref().unwrap_or("#808080"), node.line)?),
        "image" => system_image(node.value.as_deref().unwrap_or("star")).into_view(),
        "rect" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => rectangle_shape().fill_system(sc),
                Tint::Literal(lc) => rectangle_shape().fill(lc),
            },
            None => rectangle_shape().into_view(),
        },
        "circle" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => circle_shape().fill_system(sc),
                Tint::Literal(lc) => circle_shape().fill(lc),
            },
            None => circle_shape().into_view(),
        },
        "capsule" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => capsule_shape().fill_system(sc),
                Tint::Literal(lc) => capsule_shape().fill(lc),
            },
            None => capsule_shape().into_view(),
        },
        "progress" => progress(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("total").unwrap_or(1.0),
        ),
        "gauge" => gauge(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(1.0),
            text(node.attr("label").unwrap_or("")),
        ),
        "group_box" => group_box(stack_children(node)?),
        "list" => list(stack_children(node)?),
        "scroll" => stack_children(node)?.scroll(),
        "form" => form(stack_children(node)?),
        // Every bound control needs an explicit `@name`.
        //
        // Inventing one — from the line, or from position in the tree — looks
        // friendlier and is a trap: adding a line above a `toggle` would
        // change its derived name, and the control would silently reset on the
        // next reload. A name the file states is a name that survives the file
        // being edited, which is the entire point of the slots.
        "toggle" => toggle_bound(
            node.value.as_deref().unwrap_or("Toggle"),
            &flag_slot(&require_slot(node)?, node.flag("on")),
        ),
        "slider" => {
            let lo = node.f64_attr("min").unwrap_or(0.0);
            let hi = node.f64_attr("max").unwrap_or(1.0);
            slider_bound(
                &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(lo)),
                lo,
                hi,
            )
        }
        "stepper" => stepper_bound(
            node.value.as_deref().unwrap_or("Stepper"),
            &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(0.0)),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(100.0),
            node.f64_attr("step").unwrap_or(1.0),
        ),
        "field" => textfield_bound(
            node.value.as_deref().unwrap_or(""),
            &string_slot(&require_slot(node)?, node.attr("text").unwrap_or("")),
        ),
        "label" => label(
            node.value.as_deref().unwrap_or(""),
            node.attr("icon").unwrap_or("star"),
        ),
        other => {
            return Err(format!(
                "line {}: no view called `{other}`; try one of {}",
                node.line,
                NAMES.join(", ")
            ))
        }
    };
    decorate(base, node)
}

pub fn monospaced(self) -> Self

.monospaced() — Text.monospaced() on a Text.

pub fn weight(self, weight: Weight) -> Self

.fontWeight(_:) — Text.fontWeight(_:) on a Text, which returns Text, and the View extension otherwise.

pub fn fg(self, c: Color) -> Self

.foregroundStyle(_:) On a Text this is Text.foregroundColor(_:), which returns Text.

Examples found in repository

examples/swift_org_tutorial.rs (line 142)

fn body() -> View {
    let colour = COLORS[COLOR.load(Ordering::Relaxed) % COLORS.len()];

    vstack![
        // Text("Why not try…").font(.largeTitle.bold())
        text("Why not try…").text_style(TextStyle::LargeTitle).bold(),
        vstack![
            // Circle().fill(colors.randomElement() ?? .blue).padding().overlay(…)
            circle_shape().fill_system(colour).padding(16.0).overlay(
                // Image(systemName: "figure.\(selected.lowercased())")
                //     .font(.system(size: 144)).foregroundColor(.white)
                image!("figure.{}", selected().to_lowercase())
                    .font_size(144.0)
                    .fg(Color::WHITE),
            ),
            // Text("\(selected)!").font(.title)
            text!("{}!", selected()).text_style(TextStyle::Title),
        ]
        .transition(Transition::Slide)
        .id(ID.load(Ordering::Relaxed)),
        spacer(),
        // Button("Try again") { … }.buttonStyle(.borderedProminent)
        button("Try again", try_again).button_style(ButtonStyle::BorderedProminent),
    ]
}

examples/common/spec.rs (line 523)

fn node_view(node: &Node) -> Result<View, String> {
    let spacing = node.f64_attr("spacing").unwrap_or(8.0);
    let base = match node.name.as_str() {
        "vstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => vstack_aligned_spacing(&kids, h_align(a, node.line)?, Some(spacing)),
                None => vstack_spacing(&kids, spacing),
            }
        }
        "hstack" => {
            let kids = children(node)?;
            match node.attr("align") {
                Some(a) => hstack_aligned_spacing(&kids, v_align(a, node.line)?, Some(spacing)),
                None => hstack_spacing(&kids, spacing),
            }
        }
        "zstack" => zstack_aligned(&children(node)?, align(node.attr("align").unwrap_or("center"), node.line)?),
        "text" => {
            let s = node.value.as_deref().unwrap_or("");
            let mut v = text(s);
            if let Some(style) = node.attr("style") {
                v = v.text_style(text_style(style, node.line)?);
            }
            if let Some(size) = node.f64_attr("size") {
                v = v.font_size(size);
            }
            if node.flag("bold") {
                v = v.bold();
            }
            if node.flag("italic") {
                v = v.italic();
            }
            if let Some(c) = node.attr("color") {
                v = match tint(c, node.line)? {
                    Tint::System(sc) => v.fg_system(sc),
                    Tint::Literal(lc) => v.fg(lc),
                };
            }
            v
        }
        "spacer" => spacer(),
        "divider" => divider(),
        // The action is a no-op on purpose: a spec read from a file has nowhere
        // to put behaviour, and pretending otherwise would be worse than a
        // button that visibly does nothing. `hot_reload.rs` is where a spec
        // gains behaviour, by being reloaded.
        "button" => button(node.value.as_deref().unwrap_or("Button"), || {}),
        "color" => color(parse_color(node.value.as_deref().unwrap_or("#808080"), node.line)?),
        "image" => system_image(node.value.as_deref().unwrap_or("star")).into_view(),
        "rect" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => rectangle_shape().fill_system(sc),
                Tint::Literal(lc) => rectangle_shape().fill(lc),
            },
            None => rectangle_shape().into_view(),
        },
        "circle" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => circle_shape().fill_system(sc),
                Tint::Literal(lc) => circle_shape().fill(lc),
            },
            None => circle_shape().into_view(),
        },
        "capsule" => match node.attr("color") {
            Some(c) => match tint(c, node.line)? {
                Tint::System(sc) => capsule_shape().fill_system(sc),
                Tint::Literal(lc) => capsule_shape().fill(lc),
            },
            None => capsule_shape().into_view(),
        },
        "progress" => progress(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("total").unwrap_or(1.0),
        ),
        "gauge" => gauge(
            node.value.as_deref().and_then(|v| v.parse().ok()).unwrap_or(0.5),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(1.0),
            text(node.attr("label").unwrap_or("")),
        ),
        "group_box" => group_box(stack_children(node)?),
        "list" => list(stack_children(node)?),
        "scroll" => stack_children(node)?.scroll(),
        "form" => form(stack_children(node)?),
        // Every bound control needs an explicit `@name`.
        //
        // Inventing one — from the line, or from position in the tree — looks
        // friendlier and is a trap: adding a line above a `toggle` would
        // change its derived name, and the control would silently reset on the
        // next reload. A name the file states is a name that survives the file
        // being edited, which is the entire point of the slots.
        "toggle" => toggle_bound(
            node.value.as_deref().unwrap_or("Toggle"),
            &flag_slot(&require_slot(node)?, node.flag("on")),
        ),
        "slider" => {
            let lo = node.f64_attr("min").unwrap_or(0.0);
            let hi = node.f64_attr("max").unwrap_or(1.0);
            slider_bound(
                &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(lo)),
                lo,
                hi,
            )
        }
        "stepper" => stepper_bound(
            node.value.as_deref().unwrap_or("Stepper"),
            &number_slot(&require_slot(node)?, node.f64_attr("value").unwrap_or(0.0)),
            node.f64_attr("min").unwrap_or(0.0),
            node.f64_attr("max").unwrap_or(100.0),
            node.f64_attr("step").unwrap_or(1.0),
        ),
        "field" => textfield_bound(
            node.value.as_deref().unwrap_or(""),
            &string_slot(&require_slot(node)?, node.attr("text").unwrap_or("")),
        ),
        "label" => label(
            node.value.as_deref().unwrap_or(""),
            node.attr("icon").unwrap_or("star"),
        ),
        other => {
            return Err(format!(
                "line {}: no view called `{other}`; try one of {}",
                node.line,
                NAMES.join(", ")
            ))
        }
    };
    decorate(base, node)
}

pub fn baseline_offset(self, amount: f64) -> Self

Text.baselineOffset(_:)

pub fn fg_system(self, c: SystemColor) -> Self

.foregroundColor(_:) with one of SwiftUI’s named colours.

Not the same modifier as View::fg, and not a colour that components can spell: see views::system_color.

Examples found in repository

examples/inbox.rs (line 65)

fn detail(i: usize) -> View {
    let m = &MESSAGES[i];
    vstack_aligned_spacing(
        &[
            text(m.subject).text_style(TextStyle::Title).bold(),
            text!("From {}", m.from).fg_system(SystemColor::Gray),
            divider(),
            text("Body text would go here.").fg_system(SystemColor::Gray),
            spacer(),
        ],
        HorizontalAlignment::Leading,
        Some(12.0),
    )
    .padding(20.0)
    .navigation_title(m.subject)
}

fn row(i: usize) -> View {
    let m = &MESSAGES[i];
    hstack_spacing(
        &[
            // An unread dot, or the space where one would be.
            view_if!(
                m.unread,
                circle_shape().fill_system(SystemColor::Blue).frame(8.0, 8.0),
                empty().frame(8.0, 8.0)
            ),
            vstack_aligned(
                &[
                    text(m.from).bold(),
                    text(m.subject).font_size(12.0).fg_system(SystemColor::Gray),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
        ],
        8.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(4.0))
    .a11y_label(&format!("{}, {}", m.from, m.subject))
    .a11y_hint(if m.unread { "Unread" } else { "Read" })
}

examples/dynamic_ui.rs (line 72)

pub fn body() -> View {
    let text_src = current().lock().expect("spec").clone();
    match spec::parse(&text_src).and_then(|nodes| spec::build(&nodes)) {
        Ok(v) => v,
        Err(e) => vstack_aligned_spacing(
            &[
                text("Could not build that screen")
                    .text_style(TextStyle::Headline)
                    .fg_system(SystemColor::Red),
                text(&e).font_size(12.0).fg_system(SystemColor::Secondary),
            ],
            HorizontalAlignment::Leading,
            Some(8.0),
        )
        .padding(20.0),
    }
}

examples/hot_reload.rs (line 107)

fn body() -> View {
    let (src, error, generation, micros) = {
        let g = state_cell().lock().expect("state");
        (g.last_good.clone(), g.error.clone(), g.generation, g.micros)
    };

    // The last version that parsed. It cannot fail — it parsed before — but a
    // spec that builds views from slots could in principle, so the fallback is
    // still handled rather than unwrapped.
    let screen = spec::parse(&src)
        .and_then(|nodes| spec::build(&nodes))
        .unwrap_or_else(|e| text(&e).fg_system(SystemColor::Red).padding(20.0));

    vstack_spacing(&[screen, status(error.as_deref(), generation, micros)], 0.0)
}

/// A strip along the bottom: which generation is on screen, how long the last
/// reload took, what the slots hold, and the error if there is one.
///
/// In the window rather than the terminal because that is where you are
/// looking. Watching a reloader work from a log means watching two things.
fn status(error: Option<&str>, generation: u64, micros: u64) -> View {
    let slots = spec::slot_summary();
    let slot_line = if slots.is_empty() {
        String::new()
    } else {
        slots
            .iter()
            .map(|(k, v)| format!("{k}={v}"))
            .collect::<Vec<_>>()
            .join("  ")
    };

    // The error row is *always* present, empty when there is nothing wrong.
    // An error that appears and disappears would otherwise reflow the screen
    // above it on every save — which looks exactly like the reloader having
    // replaced the view, and makes "did the screen survive this?" impossible
    // to answer by looking.
    let rows = vec![
        divider(),
        hstack_spacing(
            &[
                circle_shape()
                    .fill_system(if error.is_some() {
                        SystemColor::Orange
                    } else {
                        SystemColor::Clear
                    })
                    .frame(8.0, 8.0),
                text(error.unwrap_or(""))
                    .font_size(11.0)
                    .fg_system(SystemColor::Orange),
                spacer(),
            ],
            6.0,
        )
        .padding(6.0)
        .frame(348.0, 24.0),
        hstack_spacing(
            &[
                circle_shape()
                    .fill_system(if error.is_some() {
                        SystemColor::Orange
                    } else {
                        SystemColor::Green
                    })
                    .frame(8.0, 8.0),
                text(&format!("gen {generation}"))
                    .font_size(11.0)
                    .fg_system(SystemColor::Secondary),
                // Microseconds below a millisecond: a reload of a short spec
                // really is that fast, and "0.0 ms" reads as "not measured".
                text(&if micros < 1000 {
                    format!("{micros} \u{b5}s")
                } else {
                    format!("{:.1} ms", micros as f64 / 1000.0)
                })
                .font_size(11.0)
                .fg_system(SystemColor::Secondary),
                spacer(),
                text(&slot_line).font_size(11.0).fg_system(SystemColor::Secondary),
            ],
            8.0,
        )
        .padding(6.0)
        .frame(348.0, 24.0),
    ];
    vstack_spacing(&rows, 0.0)
}

examples/dashboard.rs (line 44)

fn tile(i: usize) -> View {
    let value = reading(i);
    vstack_spacing(
        &[
            zstack![
                circle_shape().stroke_system(SystemColor::Gray, 6.0).opacity(0.25),
                // The filled part: the same circle trimmed to the fraction, and
                // turned so the arc starts at the top rather than at three
                // o'clock.
                circle_shape()
                    .trim(0.0, value)
                    .stroke_system(TINTS[i], 6.0)
                    .rotate(-90.0),
                text!("{:.0}", value * 100.0).text_style(TextStyle::Title2).bold(),
            ]
            .frame(72.0, 72.0),
            text(LABELS[i]).font_size(12.0).fg_system(SystemColor::Gray),
        ],
        8.0,
    )
    .padding(12.0)
    .a11y_element(AccessibilityChildBehavior::Combine)
    .a11y_label(LABELS[i])
    .a11y_value(&format!("{:.0} percent", value * 100.0))
}

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

examples/todo.rs (line 67)

fn row(i: usize, it: &Item) -> View {
    hstack_spacing(
        &[
            // The checkmark is the button, so the whole symbol is the target.
            button_labelled(
                system_image(if it.done { "checkmark.circle.fill" } else { "circle" })
                    .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                    .view()
                    .fg_system(if it.done { SystemColor::Green } else { SystemColor::Gray }),
                move || toggle(i),
            )
            .button_style(views::ButtonStyle::Bordered),
            text(&it.title)
                .strikethrough_styled(it.done, LinePattern::Solid, None)
                .fg_system(if it.done { SystemColor::Gray } else { SystemColor::Primary }),
            spacer(),
        ],
        10.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(6.0))
    .a11y_label(&it.title)
    .a11y_value(if it.done { "Done" } else { "Not done" })
}

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

examples/settings.rs (line 62)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

/// The sheet, which the user can dismiss — the flag is Rust's, so closing it
/// writes `false` back rather than leaving the two sides disagreeing.
fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

Additional examples can be found in:

• examples/common/spec.rs

pub fn fg_linear_gradient( self, colors: &[Color], start: (f64, f64), end: (f64, f64), ) -> Self

.foregroundStyle(LinearGradient(colors:startPoint:endPoint:)) — text and symbols painted with a gradient instead of a flat colour.

Unit points, as in View::bg_linear_gradient. On a Text this is Text.foregroundStyle(_:), which returns Text.

pub fn kerning(self, amount: f64) -> Self

.kerning(_:) — Text.kerning(_:) on a Text, which returns Text.

pub fn tracking(self, amount: f64) -> Self

.tracking(_:) — like kerning, but not suppressed between the pairs the font has a ligature for.

pub fn line_spacing(self, amount: f64) -> Self

.lineSpacing(_:)

pub fn line_limit(self, limit: i64) -> Self

.lineLimit(_:)

pub fn text_align(self, align: TextAlign) -> Self

.multilineTextAlignment(_:)

pub fn autocorrection_disabled(self, disable: Option<bool>) -> Self

.disableAutocorrection(_:) — None restores the system default.

Named for the modern spelling because that is what a caller looks for, but autocorrectionDisabled(_:) is inlined and exports no symbol — this reaches disableAutocorrection(_:), which is the same modifier and the one SwiftUI still exports.

pub fn text_scale(self, scale: TextScale, enabled: bool) -> Self

.textScale(_:isEnabled:)

pub fn dynamic_type_size(self, size: DynamicTypeSize) -> Self

.dynamicTypeSize(_:) — pin the size class rather than following the system setting.

pub fn accent_color(self, color: Option<Color>) -> Self

.accentColor(_:) — None restores the inherited accent.

Deprecated in SwiftUI in favour of View::tint, and kept because the documentation still shows it.

pub fn underline(self) -> Self

.underline()

pub fn underline_styled( self, active: bool, pattern: LinePattern, color: Option<Color>, ) -> Self

.underline(_:pattern:color:) — None keeps the text’s own colour.

active is not decoration: this writes the environment, so passing false is how a subtree turns off an underline it would otherwise inherit. There is no other way to say that.

pub fn strikethrough(self) -> Self

.strikethrough()

pub fn strikethrough_styled( self, active: bool, pattern: LinePattern, color: Option<Color>, ) -> Self

.strikethrough(_:pattern:color:) — active: false turns off an inherited strikethrough, as with View::underline_styled.

Examples found in repository

examples/todo.rs (line 72)

fn row(i: usize, it: &Item) -> View {
    hstack_spacing(
        &[
            // The checkmark is the button, so the whole symbol is the target.
            button_labelled(
                system_image(if it.done { "checkmark.circle.fill" } else { "circle" })
                    .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                    .view()
                    .fg_system(if it.done { SystemColor::Green } else { SystemColor::Gray }),
                move || toggle(i),
            )
            .button_style(views::ButtonStyle::Bordered),
            text(&it.title)
                .strikethrough_styled(it.done, LinePattern::Solid, None)
                .fg_system(if it.done { SystemColor::Gray } else { SystemColor::Primary }),
            spacer(),
        ],
        10.0,
    )
    .padding_edges(EdgeSet::Vertical, Some(6.0))
    .a11y_label(&it.title)
    .a11y_value(if it.done { "Done" } else { "Not done" })
}

pub fn truncation_mode(self, mode: TruncationMode) -> Self

.truncationMode(_:) — which end of over-long text gets the ellipsis.

pub fn line_height(self, height: Option<LineHeightKind>) -> Self

.lineHeight(_:) — None restores the font’s own leading.

pub fn font_design(self, design: Design) -> Self

.fontDesign(_:) — .monospaced and friends, without restating the size.

pub fn font_width(self, width: Option<FontWidth>) -> Self

.fontWidth(_:) — None restores the default width.

pub fn redacted(self, reasons: RedactionReasons) -> Self

.redacted(reason:) — the placeholder treatment, for loading states.

pub fn text_field_style(self, style: TextFieldStyle) -> Self

.textFieldStyle(_:) — .roundedBorder is the one that looks like a field rather than a line of text.

Examples found in repository

examples/settings.rs (lines 51-53)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

examples/todo.rs (line 97)

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

pub fn submit_label(self, label: SubmitLabel) -> Self

.submitLabel(_:) — what the return key says.

Examples found in repository

examples/todo.rs (line 99)

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

pub fn on_submit( self, trigger: SubmitTrigger, action: impl Fn() + 'static, ) -> Self

.onSubmit(of:_:) — the return key, or a search field’s, or a collection’s, depending on the trigger.

Examples found in repository

examples/todo.rs (line 98)

fn body() -> View {
    let todos = items().lock().unwrap().clone();
    let remaining = todos.iter().filter(|i| !i.done).count();

    vstack_aligned_spacing(
        &[
            hstack![
                text("Todo").text_style(TextStyle::LargeTitle).bold(),
                spacer(),
                text!("{remaining} left").fg_system(SystemColor::Gray),
            ],
            hstack_spacing(
                &[
                    textfield_bound("What needs doing?", draft())
                        .text_field_style(views::TextFieldStyle::RoundedBorderTextFieldStyle)
                        .on_submit(SubmitTrigger::Text, add)
                        .submit_label(SubmitLabel::Done),
                    button("Add", add).button_style(views::ButtonStyle::BorderedProminent),
                ],
                8.0,
            ),
            // The empty state is a branch, so it arrives and leaves rather than
            // appearing from nothing.
            view_if!(
                todos.is_empty(),
                vstack_spacing(
                    &[
                        system_image("checkmark.seal").view().font_size(40.0)
                            .fg_system(SystemColor::Green),
                        text("Nothing left to do").fg_system(SystemColor::Gray),
                    ],
                    8.0,
                )
                .frame_optional(None, Some(160.0), Alignment::Center)
                .transition(Transition::ScaleWithOpacity { scale: 0.8, anchor: (0.5, 0.5) }),
                list(for_each_items(
                    &todos.iter().cloned().enumerate().collect::<Vec<_>>(),
                    |(i, it)| row(*i, it),
                ))
                .list_style(views::ListStyle::PlainListStyle)
            ),
        ],
        HorizontalAlignment::Leading,
        Some(14.0),
    )
    .padding(20.0)
}

pub fn text_content_type(self, kind: Option<TextContentKind>) -> Self

.textContentType(_:) — what the field holds, which is what lets the system offer a saved password or a one-time code. None clears it.

pub fn keyboard_shortcut(self, shortcut: KeyboardShortcut) -> Self

.keyboardShortcut(_:) — .defaultAction is return, .cancelAction is escape, which is what makes a button the one a sheet’s return key hits.

Examples found in repository

examples/inbox.rs (line 119)

fn body() -> View {
    let i = inbox();
    let rows = matching();
    navigation_stack(
        list(for_each_items(&rows, |&i| linked_row(i)))
        .list_style(views::ListStyle::InsetListStyle)
        .searchable(&i.query, &i.searching, SearchFieldPlacement::Automatic, "Search"),
    )
    .navigation_title("Inbox")
    .toolbar(button("Compose", || {}).keyboard_shortcut(KeyboardShortcut::DefaultAction))
}

examples/dashboard.rs (line 74)

fn body() -> View {
    vstack_aligned_spacing(
        &[
            text("System").text_style(TextStyle::LargeTitle).bold(),
            grid(&[grid_row(&[tile(0), tile(1), tile(2)])]),
            divider(),
            // A gauge over the busiest reading, which is a different control
            // from the rings and reads the same state.
            vstack_aligned(
                &[
                    text("Busiest").font_size(12.0).fg_system(SystemColor::Gray),
                    gauge(reading(1), 0.0, 1.0, text("Memory"))
                        .gauge_style(views::GaugeStyle::AccessoryLinearCapacityGaugeStyle)
                        .tint_system(SystemColor::Orange),
                ],
                HorizontalAlignment::Leading,
            ),
            spacer(),
            button("Refresh", refresh)
                .button_style(views::ButtonStyle::BorderedProminent)
                .keyboard_shortcut(KeyboardShortcut::DefaultAction),
        ],
        HorizontalAlignment::Leading,
        Some(16.0),
    )
    .padding(20.0)
    // Animate whatever changed, rather than snapping to the new reading.
    .animation(LOAD[0].load(Ordering::Relaxed) as i64)
}

pub fn list_row_background(self, background: Option<View>) -> Self

.listRowBackground(_:) — None restores the default.

impl View

pub fn new(handle: ViewHandle) -> Self

Wrap a handle so the chainable modifiers can be used on it.

pub fn handle(&self) -> &ViewHandle

Get the underlying handle.

pub fn into_handle(self) -> ViewHandle

Consume and return the handle.

Examples found in repository

examples/dashboard.rs (line 99)

fn content_view() -> swiftui_native::ViewHandle {
    state::root_view(|_| body().into_handle())
}

examples/inbox.rs (line 123)

fn content_view() -> swiftui_native::ViewHandle {
    state::root_view(|_| body().into_handle())
}

examples/settings.rs (line 121)

fn content_view() -> swiftui_native::ViewHandle {
    state::root_view(|_| body().into_handle())
}

examples/todo.rs (line 132)

fn content_view() -> swiftui_native::ViewHandle {
    state::root_view(|_| body().into_handle())
}

examples/swift_org_tutorial.rs (line 176)

fn content_view() -> swiftui_native::ViewHandle {
    state::root_view(|_generation| body().into_handle())
}

examples/dynamic_ui.rs (line 83)

fn content_view() -> swiftui_native::ViewHandle {
    swiftui_native::state::root_view(|_| body().into_handle())
}

/// Screens written here as *data*, not as Rust.
///
/// Each is a string this file could have read from disk instead; they are
/// inline so the example runs with no arguments and so the renders are
/// reproducible. Between them they reach stacks, shapes, controls, text
/// styling and nesting — the same span the hand-written examples cover, with
/// nothing about them in the compiled code.
const DEMOS: &[(&str, &str)] = &[
    (
        "readout",
        r#"
// A status readout. Nothing here is a Rust type.
vstack spacing=14 pad=20 align=leading {
  text "Deployment" style=large_title bold
  text "3 of 4 regions healthy" color=secondary size=13

  divider

  hstack spacing=12 {
    circle color=green frame=14x14
    text "us-east" size=14
    spacer
    text "ok" color=green size=13
  }
  hstack spacing=12 {
    circle color=green frame=14x14
    text "us-west" size=14
    spacer
    text "ok" color=green size=13
  }
  hstack spacing=12 {
    circle color=orange frame=14x14
    text "eu-central" size=14
    spacer
    text "degraded" color=orange size=13
  }
  hstack spacing=12 {
    circle color=gray frame=14x14
    text "ap-south" size=14
    spacer
    text "draining" color=gray size=13
  }

  divider
  text "Rollout" size=12 color=secondary
  progress 0.62
  spacer
  button "Promote"
}
"#,
    ),
    (
        "card",
        r#"
// A card, to show layering and a hex colour.
zstack align=center frame=320x200 {
  color #1d2b53 frame=300x180 corner=16
  vstack spacing=10 pad=24 align=leading {
    text "Boarding pass" style=title2 bold color=white
    text "LHR to SFO" color=white size=14 opacity=0.8
    spacer
    hstack spacing=16 {
      vstack spacing=2 align=leading {
        text "GATE" size=10 color=white opacity=0.6
        text "B14" style=title3 bold color=white
      }
      vstack spacing=2 align=leading {
        text "SEAT" size=10 color=white opacity=0.6
        text "22A" style=title3 bold color=white
      }
      spacer
      image "airplane"
    }
  }
}
"#,
    ),
    (
        "gauges",
        r#"
// Three gauges and a grouped block, from data alone.
vstack spacing=16 pad=20 align=leading {
  text "Capacity" style=title bold
  gauge 0.34 label="CPU"
  gauge 0.71 label="Memory"
  gauge 0.12 label="Disk"
  divider
  group_box {
    vstack spacing=6 align=leading {
      text "Notes" style=headline
      text "Every view on this screen was named by a string." size=12 color=secondary
      text "The binary has no VStack<...> type baked in for it." size=12 color=secondary
    }
  }
  spacer
}
"#,
    ),
];

fn demo(name: &str) -> Option<&'static str> {
    DEMOS.iter().find(|(n, _)| *n == name).map(|(_, s)| *s)
}

/// Read a spec from a path, a demo name, or stdin for `-`.
fn load(arg: &str) -> Result<String, String> {
    if arg == "-" {
        use std::io::Read;
        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).map_err(|e| e.to_string())?;
        return Ok(s);
    }
    if let Some(d) = demo(arg) {
        return Ok(d.to_string());
    }
    std::fs::read_to_string(arg).map_err(|e| format!("{arg}: {e}"))
}

/// Read specs from stdin and render each as it arrives.
///
/// A blank line submits. This is the shortest demonstration there is: the same
/// process, still running, drawing a screen typed a moment ago.
fn repl() {
    use std::io::{BufRead, Write};
    eprintln!("Type a screen. Blank line renders it; Ctrl-D quits.");
    eprintln!("Names: {}", spec::NAMES.join(" "));
    let stdin = std::io::stdin();
    let mut buf = String::new();
    let mut n = 0usize;
    loop {
        eprint!("> ");
        let _ = std::io::stderr().flush();
        let mut line = String::new();
        match stdin.lock().read_line(&mut line) {
            Ok(0) => break,
            Ok(_) => {}
            Err(e) => {
                eprintln!("{e}");
                break;
            }
        }
        if line.trim().is_empty() {
            if buf.trim().is_empty() {
                continue;
            }
            match spec::parse(&buf).and_then(|nodes| spec::build(&nodes)) {
                Ok(v) => {
                    n += 1;
                    let out = format!(
                        "{}/../../target/dynamic_ui_repl_{n}.png",
                        env!("CARGO_MANIFEST_DIR")
                    );
                    let handle = v.into_handle();
                    eprintln!("  {}", swiftui_native::diag::type_name(
                        swiftui_native::views::meta_of(&handle)
                    ));
                    if swiftui_native::render::render(&handle, 420, 420).write_png(&out) {
                        eprintln!("  wrote {out}");
                    }
                }
                Err(e) => eprintln!("  {e}"),
            }
            buf.clear();
        } else {
            buf.push_str(&line);
        }
    }
}

/// Print the Swift type a spec builds.
///
/// The strongest short proof that this is real SwiftUI and not a lookalike: the
/// name comes from the Swift runtime's own metadata, and it is a different name
/// for every different spec.
fn print_type(arg: &str) -> i32 {
    match load(arg).and_then(|s| {
        spec::parse(&s).and_then(|nodes| spec::build(&nodes)).map(|v| v.into_handle())
    }) {
        Ok(h) => {
            println!(
                "{}",
                swiftui_native::diag::type_name(swiftui_native::views::meta_of(&h))
            );
            0
        }
        Err(e) => {
            eprintln!("{e}");
            1
        }
    }
}

#[cfg(target_os = "macos")]
fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let flag = |f: &str| args.iter().any(|a| a == f);

    if flag("--names") {
        println!("{}", spec::NAMES.join("\n"));
        return;
    }
    if flag("--repl") {
        return repl();
    }
    if let Some(i) = args.iter().position(|a| a == "--type") {
        let Some(arg) = args.get(i + 1) else {
            eprintln!("--type wants a spec: a path, `-`, or a demo name");
            std::process::exit(2);
        };
        std::process::exit(print_type(arg));
    }
    if flag("--render") {
        // One PNG per built-in spec. Different text, different Swift type,
        // different picture — from one binary, in one process.
        for (name, src) in DEMOS {
            set_spec(src);
            // The spec's own view, for the type name: `content_view` wraps it
            // in the runtime-synthesised `RustView` that carries `@State`, and
            // that wrapper is the same whatever the spec says. What differs —
            // and what makes the point — is the type underneath it.
            let built = body().into_handle();
            let out = format!("{}/../../target/dynamic_ui_{name}.png", env!("CARGO_MANIFEST_DIR"));
            let ok = swiftui_native::render::render(&content_view(), 380, 420).write_png(&out);
            println!(
                "{name:10} {}\n           {}",
                swiftui_native::diag::type_name(swiftui_native::views::meta_of(&built)),
                if ok { out } else { "render failed".to_string() }
            );
        }
        return;
    }
    if flag("--sim") {
        return simulator::main(&simulator::Bundle {
            example: "dynamic_ui",
            bundle_id: "dev.rswift.DynamicUI",
            executable: "DynamicUI",
            display_name: "Dynamic UI",
            launch_args: &[],
        });
    }

    // A path or a demo name, else the first demo.
    if let Some(arg) = args.iter().find(|a| !a.starts_with("--")) {
        match load(arg) {
            Ok(s) => set_spec(&s),
            Err(e) => {
                eprintln!("{e}");
                std::process::exit(1);
            }
        }
    }
    show_window(&content_view(), "Dynamic UI", 380.0, 460.0);
}

Additional examples can be found in:

• examples/hot_reload.rs
• examples/app.rs
• examples/scenes.rs
• examples/sugar.rs

Trait Implementations

impl Debug for View

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

Formats the value using the given formatter.

impl IntoView for View

fn into_view(self) -> View