ribir_core 0.2.0-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

//! Data widget help attach data to a widget and get a new widget which behavior
//! is same as origin widget.

use crate::{
  prelude::*,
  render_helper::{RenderProxy, RenderTarget},
};

pub struct DataWidget<D> {
  render: Box<dyn Render>,
  data: D,
}

/// A wrapper widget which can attach any data to a widget and not care about
/// what the data is.
pub struct AnonymousWrapper {
  render: Box<dyn Render>,
  _data: Box<dyn Any>,
}

impl<D: Query> DataWidget<D> {
  pub(crate) fn attach(render: Box<dyn Render>, data: D) -> Box<dyn Render> {
    Box::new(RenderProxy::new(DataWidget { render, data }))
  }
}

impl AnonymousWrapper {
  #[inline]
  pub fn new(render: Box<dyn Render>, data: Box<dyn Any>) -> Self {
    AnonymousWrapper { render, _data: data }
  }
}

impl Widget {
  pub fn attach_data<D: Query>(self, data: D, ctx: &BuildCtx) -> Widget {
    let arena = &mut ctx.tree.borrow_mut().arena;
    self.id().attach_data(data, arena);

    self
  }

  pub fn attach_state_data<D: Query>(
    self,
    data: impl StateReader<Value = D>,
    ctx: &BuildCtx,
  ) -> Widget {
    match data.try_into_value() {
      Ok(data) => self.attach_data(data, ctx),
      Err(data) => self.attach_data(data, ctx),
    }
  }

  pub fn attach_anonymous_data(self, data: impl Any, ctx: &BuildCtx) -> Widget {
    let arena = &mut ctx.tree.borrow_mut().arena;
    self.id().attach_anonymous_data(data, arena);
    self
  }
}

impl<D> RenderTarget for DataWidget<D> {
  type Target = dyn Render;

  #[inline]
  fn proxy<V>(&self, f: impl FnOnce(&Self::Target) -> V) -> V { f(&*self.render) }
}

impl<D: Query> Query for DataWidget<D> {
  fn query_inside_first(
    &self,
    type_id: TypeId,
    callback: &mut dyn FnMut(&dyn Any) -> bool,
  ) -> bool {
    self.render.query_inside_first(type_id, callback)
      && self.data.query_inside_first(type_id, callback)
  }

  fn query_outside_first(
    &self,
    type_id: TypeId,
    callback: &mut dyn FnMut(&dyn Any) -> bool,
  ) -> bool {
    self.data.query_outside_first(type_id, callback)
      && self.render.query_outside_first(type_id, callback)
  }
}

impl Query for AnonymousWrapper {
  crate::widget::impl_proxy_query!(render);
}

impl RenderTarget for AnonymousWrapper {
  type Target = dyn Render;
  #[inline]
  fn proxy<V>(&self, f: impl FnOnce(&Self::Target) -> V) -> V { f(&*self.render) }
}