yororen_ui 0.2.0

Reusable UI components and widgets built on top of gpui.
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::{path::PathBuf, sync::Arc};

use gpui::InteractiveElement;
use gpui::{
    AnyElement, Div, ElementId, Image, ImageFormat, IntoElement, ObjectFit, ParentElement,
    RenderOnce, Styled, StyledImage, div, img,
};

use crate::theme::ActiveTheme;

pub fn image(source: impl Into<ImageSource>) -> ImageView {
    ImageView::new(source)
}

pub enum ImageSource {
    Embedded(Arc<Image>),
    Path(PathBuf),
}

impl From<Arc<Image>> for ImageSource {
    fn from(value: Arc<Image>) -> Self {
        Self::Embedded(value)
    }
}

impl From<PathBuf> for ImageSource {
    fn from(value: PathBuf) -> Self {
        Self::Path(value)
    }
}

#[derive(Clone, Copy)]
pub enum ImageFit {
    Contain,
    Cover,
}

impl From<ImageFit> for ObjectFit {
    fn from(value: ImageFit) -> Self {
        match value {
            ImageFit::Contain => ObjectFit::Contain,
            ImageFit::Cover => ObjectFit::Cover,
        }
    }
}

#[derive(IntoElement)]
pub struct ImageView {
    element_id: ElementId,
    base: Div,
    source: ImageSource,
    fit: ImageFit,
}

impl ImageView {
    pub fn new(source: impl Into<ImageSource>) -> Self {
        Self {
            element_id: "ui:image".into(),
            base: div(),
            source: source.into(),
            fit: ImageFit::Contain,
        }
    }

    pub fn id(mut self, id: impl Into<ElementId>) -> Self {
        self.element_id = id.into();
        self
    }

    /// Alias for `id(...)`. Use `key(...)` when you want to emphasize state identity.
    pub fn key(self, key: impl Into<ElementId>) -> Self {
        self.id(key)
    }

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

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

impl Styled for ImageView {
    fn style(&mut self) -> &mut gpui::StyleRefinement {
        self.base.style()
    }
}

impl RenderOnce for ImageView {
    fn render(self, _window: &mut gpui::Window, cx: &mut gpui::App) -> impl IntoElement {
        let bg = cx.theme().surface.sunken;
        let fg = cx.theme().content.tertiary;
        let placeholder = move || -> AnyElement {
            div()
                .size_full()
                .rounded_md()
                .bg(bg)
                .flex()
                .items_center()
                .justify_center()
                .text_color(fg)
                .child("Image")
                .into_any_element()
        };

        let fallback = move || -> AnyElement {
            div()
                .size_full()
                .rounded_md()
                .bg(bg)
                .flex()
                .items_center()
                .justify_center()
                .text_color(fg)
                .child("Failed")
                .into_any_element()
        };

        let image = match self.source {
            ImageSource::Embedded(image) => img(image),
            ImageSource::Path(path) => img(path),
        }
        .object_fit(self.fit.into())
        .with_loading(placeholder)
        .with_fallback(fallback)
        .size_full();

        self.base.id(self.element_id).child(image)
    }
}

pub fn image_from_bytes(bytes: Vec<u8>) -> Arc<Image> {
    Arc::new(Image::from_bytes(ImageFormat::Png, bytes))
}