Function vstack_spacing 

pub fn vstack_spacing(children: &[View], spacing: f64) -> View

VStack(spacing:) { … }.

Examples found in repository

examples/common/spec.rs (line 478)

pub fn build(nodes: &[Node]) -> Result<View, String> {
    match nodes {
        [] => Err("the spec is empty".to_string()),
        [one] => node_view(one),
        many => {
            let kids: Result<Vec<View>, String> = many.iter().map(node_view).collect();
            Ok(vstack_spacing(&kids?, 8.0))
        }
    }
}

fn children(node: &Node) -> Result<Vec<View>, String> {
    node.children.iter().map(node_view).collect()
}

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)
}

/// A container that takes a single child gets its children stacked.
fn stack_children(node: &Node) -> Result<View, String> {
    let kids = children(node)?;
    Ok(match kids.len() {
        1 => kids.into_iter().next().expect("one"),
        _ => vstack_spacing(&kids, node.f64_attr("spacing").unwrap_or(8.0)),
    })
}

examples/hot_reload.rs (line 109)

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/settings.rs (lines 91-104)

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 (lines 30-47)

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/sugar.rs (lines 20-27)

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/todo.rs (lines 108-115)

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)
}