ribir_core 0.0.1-alpha.4

Ribir is a framework for building modern native/wasm cross-platform user interface applications.
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

use super::{child_convert::IntoChild, *};
use crate::widget::ImplMarker;

/// Trait specify what child a widget can have, and the target type is the
/// result of widget compose its child.
pub trait SingleWithChild<M, C> {
  type Target;
  fn with_child(self, child: C) -> Self::Target;
}

/// A node of widget with not compose its child.
pub struct WidgetPair<W, C> {
  pub widget: W,
  pub child: C,
}

impl<W: SingleChild> SingleChild for Option<W> {}

impl<W: SingleChild, C> SingleWithChild<W, C> for W {
  type Target = WidgetPair<W, C>;

  #[inline]
  fn with_child(self, child: C) -> Self::Target { WidgetPair { widget: self, child } }
}

impl<W, C1: SingleChild, C2> SingleWithChild<W, C2> for WidgetPair<W, C1> {
  type Target = WidgetPair<W, WidgetPair<C1, C2>>;

  fn with_child(self, c: C2) -> Self::Target {
    let WidgetPair { widget, child } = self;
    WidgetPair { widget, child: child.with_child(c) }
  }
}

impl<W, C, M> IntoWidget<NotSelf<M>> for WidgetPair<W, C>
where
  W: IntoSingleParent,
  C: IntoChild<M, Option<Widget>>,
  M: ImplMarker,
{
  fn into_widget(self) -> Widget {
    let Self { widget, child } = self;
    Widget::Render {
      render: widget.into_single_parent(),
      children: Some(child.into_child().map_or_else(Vec::default, |w| vec![w])),
    }
  }
}

impl<W, C, M1, M2> IntoWidget<NotSelf<[(M1, M2); 1]>> for WidgetPair<Option<W>, C>
where
  WidgetPair<W, C>: IntoWidget<M1>,
  C: IntoWidget<M2>,
  M1: ImplMarker,
  M2: ImplMarker,
{
  fn into_widget(self) -> Widget {
    let Self { widget, child } = self;
    if let Some(widget) = widget {
      WidgetPair { widget, child }.into_widget()
    } else {
      child.into_widget()
    }
  }
}

impl<W, D, M1, M2> IntoWidget<NotSelf<[(M1, M2); 2]>>
  for WidgetPair<W, Stateful<DynWidget<Option<D>>>>
where
  WidgetPair<W, Widget>: IntoWidget<M1>,
  D: IntoChild<M2, Widget> + 'static,
  M1: ImplMarker,
  M2: ImplMarker,
{
  fn into_widget(self) -> Widget {
    let Self { widget, child } = self;
    WidgetPair { widget, child: child.into_widget() }.into_widget()
  }
}

trait IntoSingleParent {
  fn into_single_parent(self) -> Box<dyn Render>;
}

impl<W: SingleChild + Render + 'static> IntoSingleParent for W {
  fn into_single_parent(self) -> Box<dyn Render> { Box::new(self) }
}

impl<D> IntoSingleParent for Stateful<DynWidget<D>>
where
  D: SingleChild + Render + 'static,
{
  fn into_single_parent(self) -> Box<dyn Render> { Box::new(DynRender::new(self)) }
}

impl<D> IntoSingleParent for Stateful<DynWidget<Option<D>>>
where
  D: SingleChild + Render + 'static,
{
  fn into_single_parent(self) -> Box<dyn Render> { Box::new(DynRender::new(self)) }
}

#[cfg(test)]
mod tests {
  use crate::test_helper::MockBox;

  use super::*;

  #[test]
  fn pair_with_child() {
    let mock_box = MockBox { size: ZERO_SIZE };
    let _ = mock_box
      .clone()
      .with_child(mock_box.clone())
      .with_child(mock_box)
      .into_widget();
  }
}