graphix-package-gui 0.9.0

A dataflow language for UIs and network programming, GUI package
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

use super::{GuiW, IcedElement};
use crate::types::{ColorV, FontV, HAlignV, LengthV, VAlignV};
use anyhow::{Context, Result};
use arcstr::ArcStr;
use graphix_compiler::expr::ExprId;
use graphix_rt::{GXExt, GXHandle, TRef};
use iced_widget as widget;
use netidx::publisher::Value;
use tokio::try_join;

pub(crate) struct TextW<X: GXExt> {
    content: TRef<X, String>,
    size: TRef<X, Option<f64>>,
    color: TRef<X, Option<ColorV>>,
    font: TRef<X, Option<FontV>>,
    width: TRef<X, LengthV>,
    height: TRef<X, LengthV>,
    halign: TRef<X, HAlignV>,
    valign: TRef<X, VAlignV>,
}

impl<X: GXExt> TextW<X> {
    pub(crate) async fn compile(gx: GXHandle<X>, source: Value) -> Result<GuiW<X>> {
        let [(_, color), (_, content), (_, font), (_, halign), (_, height), (_, size), (_, valign), (_, width)] =
            source.cast_to::<[(ArcStr, u64); 8]>().context("text flds")?;
        let (color, content, font, halign, height, size, valign, width) = try_join! {
            gx.compile_ref(color),
            gx.compile_ref(content),
            gx.compile_ref(font),
            gx.compile_ref(halign),
            gx.compile_ref(height),
            gx.compile_ref(size),
            gx.compile_ref(valign),
            gx.compile_ref(width),
        }?;
        Ok(Box::new(Self {
            content: TRef::new(content).context("text tref content")?,
            size: TRef::new(size).context("text tref size")?,
            color: TRef::new(color).context("text tref color")?,
            font: TRef::new(font).context("text tref font")?,
            width: TRef::new(width).context("text tref width")?,
            height: TRef::new(height).context("text tref height")?,
            halign: TRef::new(halign).context("text tref halign")?,
            valign: TRef::new(valign).context("text tref valign")?,
        }))
    }
}

impl<X: GXExt> super::GuiWidget<X> for TextW<X> {
    fn handle_update(
        &mut self,
        _rt: &tokio::runtime::Handle,
        id: ExprId,
        v: &Value,
    ) -> Result<bool> {
        let mut changed = false;
        changed |= self.content.update(id, v).context("text update content")?.is_some();
        changed |= self.size.update(id, v).context("text update size")?.is_some();
        changed |= self.color.update(id, v).context("text update color")?.is_some();
        changed |= self.font.update(id, v).context("text update font")?.is_some();
        changed |= self.width.update(id, v).context("text update width")?.is_some();
        changed |= self.height.update(id, v).context("text update height")?.is_some();
        changed |= self.halign.update(id, v).context("text update halign")?.is_some();
        changed |= self.valign.update(id, v).context("text update valign")?.is_some();
        Ok(changed)
    }

    fn view(&self) -> IcedElement<'_> {
        let content = self.content.t.as_deref().unwrap_or("");
        let mut t = widget::Text::new(content);
        if let Some(Some(sz)) = self.size.t {
            t = t.size(sz as f32);
        }
        if let Some(Some(c)) = self.color.t.as_ref() {
            t = t.color(c.0);
        }
        if let Some(Some(f)) = self.font.t.as_ref() {
            t = t.font(f.0);
        }
        if let Some(w) = self.width.t.as_ref() {
            t = t.width(w.0);
        }
        if let Some(h) = self.height.t.as_ref() {
            t = t.height(h.0);
        }
        if let Some(a) = self.halign.t.as_ref() {
            t = t.align_x(a.0);
        }
        if let Some(a) = self.valign.t.as_ref() {
            t = t.align_y(a.0);
        }
        t.into()
    }
}