Struct Shape 

pub struct Shape { /* private fields */ }

A shape value, not yet erased to a view.

circle and its neighbours hand back a ViewHandle, because a shape conforms to View and that is all most callers want. Shape.fill(_:style:) and .stroke(_:lineWidth:) are not view modifiers, though — they are extension methods on Shape whose receiver is @in_guaranteed Self with Self: Shape, and an AnyView satisfies neither. So reaching them needs the value, its metadata and its Shape witness table kept together, which is what this is.

The bytes are the shape’s own storage: empty for Circle, Rectangle and Ellipse, which have no stored properties at all.

Implementations

impl Shape

pub fn circle() -> Self

Circle()

Examples found in repository

examples/ios_app.rs (line 202)

fn shapes() -> views::ViewHandle {
    let swatch = |shape: views::Shape, c: Color| {
        views::frame(&shape.fill(views::color_value_of(c)), 58.0, 44.0)
    };
    views::hstack_spacing(
        &[
            swatch(views::Shape::circle(), Color::new(0.95, 0.35, 0.30, 1.0)),
            swatch(views::Shape::capsule(), Color::new(0.98, 0.70, 0.20, 1.0)),
            swatch(views::Shape::rounded_rectangle(10.0, true), Color::new(0.30, 0.65, 1.0, 1.0)),
            swatch(views::Shape::ellipse(), Color::new(0.35, 0.85, 0.55, 1.0)),
        ],
        10.0,
    )
}

pub fn rectangle() -> Self

Rectangle()

pub fn ellipse() -> Self

Ellipse()

Examples found in repository

examples/ios_app.rs (line 205)

fn shapes() -> views::ViewHandle {
    let swatch = |shape: views::Shape, c: Color| {
        views::frame(&shape.fill(views::color_value_of(c)), 58.0, 44.0)
    };
    views::hstack_spacing(
        &[
            swatch(views::Shape::circle(), Color::new(0.95, 0.35, 0.30, 1.0)),
            swatch(views::Shape::capsule(), Color::new(0.98, 0.70, 0.20, 1.0)),
            swatch(views::Shape::rounded_rectangle(10.0, true), Color::new(0.30, 0.65, 1.0, 1.0)),
            swatch(views::Shape::ellipse(), Color::new(0.35, 0.85, 0.55, 1.0)),
        ],
        10.0,
    )
}

pub fn capsule() -> Self

Capsule() — one byte of RoundedCornerStyle.

Case 1, .continuous, which is what Capsule() with no argument means. This said case 0 and called it .circular until a listing needed a capsule’s corner style to match; nothing had compared one before, and Self::rounded_rectangle next door had the numbering right all along.

Examples found in repository

examples/ios_app.rs (line 203)

fn shapes() -> views::ViewHandle {
    let swatch = |shape: views::Shape, c: Color| {
        views::frame(&shape.fill(views::color_value_of(c)), 58.0, 44.0)
    };
    views::hstack_spacing(
        &[
            swatch(views::Shape::circle(), Color::new(0.95, 0.35, 0.30, 1.0)),
            swatch(views::Shape::capsule(), Color::new(0.98, 0.70, 0.20, 1.0)),
            swatch(views::Shape::rounded_rectangle(10.0, true), Color::new(0.30, 0.65, 1.0, 1.0)),
            swatch(views::Shape::ellipse(), Color::new(0.35, 0.85, 0.55, 1.0)),
        ],
        10.0,
    )
}

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

RoundedRectangle(cornerRadius:style:) — a CGSize then the style.

style is RoundedCornerStyle: .circular is case 0 and .continuous is case 1. The one-argument spelling in Swift source does not mean circular — the declared default is .continuous, and the two differ by about two hundred pixels around the corners of a 200x50 box.

Examples found in repository

examples/ios_app.rs (line 204)

fn shapes() -> views::ViewHandle {
    let swatch = |shape: views::Shape, c: Color| {
        views::frame(&shape.fill(views::color_value_of(c)), 58.0, 44.0)
    };
    views::hstack_spacing(
        &[
            swatch(views::Shape::circle(), Color::new(0.95, 0.35, 0.30, 1.0)),
            swatch(views::Shape::capsule(), Color::new(0.98, 0.70, 0.20, 1.0)),
            swatch(views::Shape::rounded_rectangle(10.0, true), Color::new(0.30, 0.65, 1.0, 1.0)),
            swatch(views::Shape::ellipse(), Color::new(0.35, 0.85, 0.55, 1.0)),
        ],
        10.0,
    )
}

fn controls() -> views::ViewHandle {
    views::vstack_spacing(
        &[
            // Two toggles, both starting `false`: one bound to Rust-owned
            // state, one a constant. If they ever disagree on screen, the
            // binding's getter is at fault rather than the control.
            views::toggle_bound("Bound to Rust state", switch_state()),
            views::toggle("Constant false", false),
            views::hstack_spacing(
                &[
                    label_text(&format!("{:.2}", slider_state().get()), 14.0, None, 0.9),
                    views::slider_bound(slider_state(), 0.0, 1.0),
                ],
                10.0,
            ),
            views::stepper_bound(
                &format!("Stepper: {:.0}", stepper_state().get()),
                stepper_state(),
                0.0,
                10.0,
                1.0,
            ),
            // Reads the stepper's Rust value. A `ProgressView` takes a plain
            // number rather than a binding, so it can only ever show what it
            // was built with — which is fine now that every write rebuilds the
            // body from current state.
            views::progress(stepper_state().get(), 10.0),
            views::hstack_spacing(
                &[
                    views::button_style(
                        &views::button("Bordered", on_tap),
                        views::ButtonStyle::Bordered,
                    ),
                    views::button_style(
                        &views::button("Glass", on_tap),
                        views::ButtonStyle::Glass,
                    ),
                ],
                12.0,
            ),
            views::textfield("A text field", ""),
        ],
        12.0,
    )
}

fn symbols() -> views::ViewHandle {
    let icon = |name: &str, c: Color| {
        views::foreground_style_color(
            &views::font_system(&views::system_image(name), 24.0, None, None),
            c.r, c.g, c.b, c.a,
        )
    };
    views::hstack_spacing(
        &[
            icon("star.fill", Color::new(1.0, 0.8, 0.2, 1.0)),
            icon("heart.fill", Color::new(1.0, 0.35, 0.45, 1.0)),
            icon("bolt.fill", Color::new(0.55, 0.8, 1.0, 1.0)),
            icon("cloud.sun.fill", Color::new(0.8, 0.85, 1.0, 1.0)),
            icon("checkmark.seal.fill", Color::new(0.4, 0.9, 0.6, 1.0)),
        ],
        16.0,
    )
}

fn effects() -> views::ViewHandle {
    let tile = |c: Color| views::frame(&views::color(c.r, c.g, c.b, c.a), 48.0, 40.0);
    views::hstack_spacing(
        &[
            views::blur(&tile(Color::new(0.95, 0.4, 0.3, 1.0)), 4.0),
            views::shadow(
                &tile(Color::new(0.3, 0.7, 1.0, 1.0)),
                Color::new(0.0, 0.0, 0.0, 0.8),
                8.0,
                0.0,
                4.0,
            ),
            views::opacity(&tile(Color::new(0.5, 0.9, 0.5, 1.0)), 0.35),
            views::corner_radius(&tile(Color::new(0.9, 0.7, 0.2, 1.0)), 12.0),
            views::border(&tile(Color::new(0.0, 0.0, 0.0, 0.0)), 1.0, 1.0, 1.0, 2.0),
        ],
        10.0,
    )
}

fn layout() -> views::ViewHandle {
    let chip = |s: &str, c: Color| {
        views::corner_radius(
            &views::background(&views::padding(&label_text(s, 13.0, None, 1.0), 8.0), c.r, c.g, c.b, c.a),
            8.0,
        )
    };
    views::vstack_spacing(
        &[
            views::hstack_spacing(
                &[
                    chip("HStack", Color::new(0.35, 0.35, 0.8, 0.8)),
                    views::spacer(),
                    chip("Spacer", Color::new(0.8, 0.35, 0.5, 0.8)),
                ],
                8.0,
            ),
            views::divider(),
            views::zstack(&[
                views::frame(
                    &views::Shape::rounded_rectangle(8.0, true)
                        .fill(views::color_value_of(Color::new(0.2, 0.5, 0.9, 0.55))),
                    120.0,
                    34.0,
                ),
                label_text("ZStack", 13.0, Some(views::Weight::Semibold), 1.0),
            ]),
        ],
        10.0,
    )
}

pub fn view(&self) -> ViewHandle

pub fn path() -> PathBuilder

A Path, built by the four mutating methods below.

Path is 33 bytes — a reference plus a discriminator — so it is neither one word nor a neat multiple of one, and every method takes it as inout through x20 while the points travel in d0 onwards.

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

.inset(by:) — the shape drawn inside its own bounds.

inset(by:) is an InsettableShape requirement, so it is exported once per conforming type rather than once on the protocol: there is a Circle.inset, a Rectangle.inset and so on, and no InsettableShape.inset at all. The result is some InsettableShape, whose first conformance is InsettableShape — so the Shape witness comes from the concrete metadata, as with stroke(lineWidth:).

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

.offset(x:y:) — an OffsetShape around this one.

A concrete wrapper, not an opaque return, so there is no substitution list to build: the result’s size comes from its own metadata and the call writes it through x8.

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

.rotation(_:anchor:) — a RotatedShape around this one.

Angle stores radians, and .center is UnitPoint(0.5, 0.5).

pub unsafe fn fill_style( &self, style: &[u8], meta: *const c_void, wt: *const c_void, ) -> ViewHandle

.fill(_:style:) with any ShapeStyle — its value, metadata and witness table.

Safety

style must hold an initialised value of the type meta describes, and wt must be that type’s ShapeStyle conformance.

pub unsafe fn stroke_style( &self, style: &[u8], meta: *const c_void, wt: *const c_void, line_width: f64, ) -> ViewHandle

.stroke(_:lineWidth:) with any ShapeStyle.

Safety

style must hold an initialised value of the type meta describes, and wt must be that type’s ShapeStyle conformance.

pub fn fill(&self, color: u64) -> ViewHandle

.fill(_:style:) with a Color.

Examples found in repository

examples/ios_app.rs (line 198)

fn shapes() -> views::ViewHandle {
    let swatch = |shape: views::Shape, c: Color| {
        views::frame(&shape.fill(views::color_value_of(c)), 58.0, 44.0)
    };
    views::hstack_spacing(
        &[
            swatch(views::Shape::circle(), Color::new(0.95, 0.35, 0.30, 1.0)),
            swatch(views::Shape::capsule(), Color::new(0.98, 0.70, 0.20, 1.0)),
            swatch(views::Shape::rounded_rectangle(10.0, true), Color::new(0.30, 0.65, 1.0, 1.0)),
            swatch(views::Shape::ellipse(), Color::new(0.35, 0.85, 0.55, 1.0)),
        ],
        10.0,
    )
}

fn controls() -> views::ViewHandle {
    views::vstack_spacing(
        &[
            // Two toggles, both starting `false`: one bound to Rust-owned
            // state, one a constant. If they ever disagree on screen, the
            // binding's getter is at fault rather than the control.
            views::toggle_bound("Bound to Rust state", switch_state()),
            views::toggle("Constant false", false),
            views::hstack_spacing(
                &[
                    label_text(&format!("{:.2}", slider_state().get()), 14.0, None, 0.9),
                    views::slider_bound(slider_state(), 0.0, 1.0),
                ],
                10.0,
            ),
            views::stepper_bound(
                &format!("Stepper: {:.0}", stepper_state().get()),
                stepper_state(),
                0.0,
                10.0,
                1.0,
            ),
            // Reads the stepper's Rust value. A `ProgressView` takes a plain
            // number rather than a binding, so it can only ever show what it
            // was built with — which is fine now that every write rebuilds the
            // body from current state.
            views::progress(stepper_state().get(), 10.0),
            views::hstack_spacing(
                &[
                    views::button_style(
                        &views::button("Bordered", on_tap),
                        views::ButtonStyle::Bordered,
                    ),
                    views::button_style(
                        &views::button("Glass", on_tap),
                        views::ButtonStyle::Glass,
                    ),
                ],
                12.0,
            ),
            views::textfield("A text field", ""),
        ],
        12.0,
    )
}

fn symbols() -> views::ViewHandle {
    let icon = |name: &str, c: Color| {
        views::foreground_style_color(
            &views::font_system(&views::system_image(name), 24.0, None, None),
            c.r, c.g, c.b, c.a,
        )
    };
    views::hstack_spacing(
        &[
            icon("star.fill", Color::new(1.0, 0.8, 0.2, 1.0)),
            icon("heart.fill", Color::new(1.0, 0.35, 0.45, 1.0)),
            icon("bolt.fill", Color::new(0.55, 0.8, 1.0, 1.0)),
            icon("cloud.sun.fill", Color::new(0.8, 0.85, 1.0, 1.0)),
            icon("checkmark.seal.fill", Color::new(0.4, 0.9, 0.6, 1.0)),
        ],
        16.0,
    )
}

fn effects() -> views::ViewHandle {
    let tile = |c: Color| views::frame(&views::color(c.r, c.g, c.b, c.a), 48.0, 40.0);
    views::hstack_spacing(
        &[
            views::blur(&tile(Color::new(0.95, 0.4, 0.3, 1.0)), 4.0),
            views::shadow(
                &tile(Color::new(0.3, 0.7, 1.0, 1.0)),
                Color::new(0.0, 0.0, 0.0, 0.8),
                8.0,
                0.0,
                4.0,
            ),
            views::opacity(&tile(Color::new(0.5, 0.9, 0.5, 1.0)), 0.35),
            views::corner_radius(&tile(Color::new(0.9, 0.7, 0.2, 1.0)), 12.0),
            views::border(&tile(Color::new(0.0, 0.0, 0.0, 0.0)), 1.0, 1.0, 1.0, 2.0),
        ],
        10.0,
    )
}

fn layout() -> views::ViewHandle {
    let chip = |s: &str, c: Color| {
        views::corner_radius(
            &views::background(&views::padding(&label_text(s, 13.0, None, 1.0), 8.0), c.r, c.g, c.b, c.a),
            8.0,
        )
    };
    views::vstack_spacing(
        &[
            views::hstack_spacing(
                &[
                    chip("HStack", Color::new(0.35, 0.35, 0.8, 0.8)),
                    views::spacer(),
                    chip("Spacer", Color::new(0.8, 0.35, 0.5, 0.8)),
                ],
                8.0,
            ),
            views::divider(),
            views::zstack(&[
                views::frame(
                    &views::Shape::rounded_rectangle(8.0, true)
                        .fill(views::color_value_of(Color::new(0.2, 0.5, 0.9, 0.55))),
                    120.0,
                    34.0,
                ),
                label_text("ZStack", 13.0, Some(views::Weight::Semibold), 1.0),
            ]),
        ],
        10.0,
    )
}

pub fn stroked(&self, line_width: f64) -> Self

.stroke(lineWidth:), kept as a Shape rather than erased to a view.

What overlay(_:in:) wants: its in: argument is a Shape, and a stroked shape still is one.

pub fn parts(&self) -> (Vec<u8>, *const c_void, *const c_void)

The value, metadata and Shape witness, for a call that takes a shape.

pub fn stroke_default(&self, line_width: f64) -> ViewHandle

.stroke(lineWidth:) — no style, so it strokes with the foreground.

One generic parameter rather than two, so the substitution list is just Self and its Shape witness, and the line width is the only formal argument.

pub fn stroke(&self, color: u64, line_width: f64) -> ViewHandle

.stroke(_:lineWidth:) with a Color.

impl Shape

pub fn trim(&self, from: f64, to: f64) -> Self

.trim(from:to:) — keep a fraction of the shape’s path.

How a progress ring is drawn: a stroked circle trimmed to the fraction complete. Without it a “ring showing 70%” is a full circle.

.trim is @inlinable, so SwiftUI exports no function for it — but _TrimmedShape<S> is just the shape and two CGFloats, its descriptor is exported, and the field offsets come from the metadata rather than being assumed.