guise-ui 0.4.1

A Mantine-inspired component library for gpui, Zed's GPU-accelerated UI framework.
Documentation 
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! `Group` — children laid out in a row with consistent spacing.

use gpui::prelude::*;
use gpui::{div, px, AnyElement, App, IntoElement, Window};

use super::{apply_align, apply_justify, Align, Justify};
use crate::theme::{theme, Size};

/// A horizontal flex container. The Mantine `Group`.
#[derive(IntoElement)]
pub struct Group {
    children: Vec<AnyElement>,
    gap: Size,
    align: Align,
    justify: Justify,
    wrap: bool,
    grow: bool,
}

impl Group {
    pub fn new() -> Self {
        Group {
            children: Vec::new(),
            gap: Size::Md,
            align: Align::Center,
            justify: Justify::Start,
            wrap: true,
            grow: false,
        }
    }

    pub fn gap(mut self, gap: Size) -> Self {
        self.gap = gap;
        self
    }

    pub fn align(mut self, align: Align) -> Self {
        self.align = align;
        self
    }

    pub fn justify(mut self, justify: Justify) -> Self {
        self.justify = justify;
        self
    }

    /// Allow children to wrap onto multiple lines (default true).
    pub fn wrap(mut self, wrap: bool) -> Self {
        self.wrap = wrap;
        self
    }

    /// Stretch children to share the available width equally.
    pub fn grow(mut self, grow: bool) -> Self {
        self.grow = grow;
        self
    }
}

impl Default for Group {
    fn default() -> Self {
        Group::new()
    }
}

impl ParentElement for Group {
    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
        self.children.extend(elements);
    }
}

impl RenderOnce for Group {
    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
        let gap = theme(cx).spacing(self.gap);
        let mut base = div().flex().flex_row().gap(px(gap));
        if self.wrap {
            base = base.flex_wrap();
        }
        let grow = self.grow;
        apply_justify(apply_align(base, self.align), self.justify).children(
            self.children.into_iter().map(move |c| {
                if grow {
                    div().flex_1().child(c).into_any_element()
                } else {
                    c
                }
            }),
        )
    }
}