slate-framework 1.0.1

GPU-accelerated Rust UI framework — umbrella crate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! Div visual + layout-style builders.

use taffy::prelude::*;

use crate::color::Color;
use crate::reactive_value::Reactive;
use crate::style::Style;

use super::Div;

impl Div {
    /// Configure layout style via closure.
    ///
    /// # Example
    /// ```ignore
    /// Div::new().style(|s| s.padding_all(16.0).gap(8.0).column())
    /// ```
    pub fn style(mut self, f: impl FnOnce(Style) -> Style) -> Self {
        self.layout_style = f(self.layout_style);
        self
    }

    /// Set background color (linear, premultiplied RGBA).
    ///
    /// Accepts a plain color or a signal-backed [`Reactive`]: a signal value
    /// is read here (under the render observer), so the view re-renders and the
    /// background re-resolves when that signal changes.
    pub fn background(mut self, color: impl Into<Reactive<Color>>) -> Self {
        let value: Reactive<Color> = color.into();
        self.visual.background = Some(value.resolve().0);
        self
    }

    /// Set corner radius in logical pixels.
    ///
    /// Accepts a plain `f32` or a signal-backed [`Reactive`]; see [`Self::background`].
    pub fn corner_radius(mut self, radius: impl Into<Reactive<f32>>) -> Self {
        let value: Reactive<f32> = radius.into();
        self.visual.corner_radius = value.resolve();
        self
    }

    /// Set flex direction (convenience method).
    pub fn direction(mut self, direction: FlexDirection) -> Self {
        self.layout_style.flex_direction = direction;
        self
    }

    /// Set flex direction to column (convenience method).
    pub fn column(mut self) -> Self {
        self.layout_style.flex_direction = FlexDirection::Column;
        self
    }

    /// Set flex direction to row (convenience method).
    pub fn row(mut self) -> Self {
        self.layout_style.flex_direction = FlexDirection::Row;
        self
    }

    /// Set flex grow (convenience method).
    pub fn flex_grow(mut self, grow: f32) -> Self {
        self.layout_style.flex_grow = grow;
        self
    }

    /// Set gap between children (convenience method).
    pub fn gap(mut self, gap: f32) -> Self {
        self.layout_style.gap = gap;
        self
    }
}