anathema-widgets 0.2.11

Anathema widget base
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

use anathema_templates::blueprints::Blueprint;
use anathema_value_resolver::Scope;
use eval::SlotEval;

pub use self::element::Element;
use self::eval::{ComponentEval, ControlFlowEval, Evaluator, ForLoopEval, SingleEval};
pub use self::update::update_widget;
use crate::error::Result;
use crate::layout::EvalCtx;
use crate::nodes::eval::WithEval;
use crate::widget::WidgetTreeView;

pub(crate) mod component;
pub(crate) mod controlflow;
pub(crate) mod element;
pub(crate) mod eval;
pub(crate) mod loops;
mod update;
pub(crate) mod with;

// -----------------------------------------------------------------------------
//   - Generators -
// -----------------------------------------------------------------------------
pub enum WidgetGenerator<'bp> {
    Children(&'bp [Blueprint]),
    Single,
    Slot(&'bp [Blueprint]),
    Loop(&'bp [Blueprint]),
    ControlFlow,
    Noop,
}

#[derive(Debug)]
pub enum WidgetKind<'bp> {
    Element(Element<'bp>),
    For(loops::For<'bp>),
    With(with::With<'bp>),
    Iteration(loops::Iteration<'bp>),
    ControlFlow(controlflow::ControlFlow<'bp>),
    ControlFlowContainer(u16),
    Component(component::Component<'bp>),
    Slot,
}

#[derive(Debug)]
pub struct WidgetContainer<'bp> {
    pub kind: WidgetKind<'bp>,
    pub(crate) children: &'bp [Blueprint],
}

impl<'bp> WidgetContainer<'bp> {
    pub fn new(kind: WidgetKind<'bp>, blueprints: &'bp [Blueprint]) -> Self {
        Self {
            kind,
            children: blueprints,
        }
    }
}

pub fn eval_blueprint<'bp>(
    blueprint: &'bp Blueprint,
    ctx: &mut EvalCtx<'_, 'bp>,
    scope: &Scope<'_, 'bp>,
    parent: &[u16],
    tree: &mut WidgetTreeView<'_, 'bp>,
) -> Result<()> {
    match blueprint {
        Blueprint::Single(single) => SingleEval.eval(single, ctx, scope, parent, tree),
        Blueprint::For(for_loop) => ForLoopEval.eval(for_loop, ctx, scope, parent, tree),
        Blueprint::With(with) => WithEval.eval(with, ctx, scope, parent, tree),
        Blueprint::ControlFlow(flow) => ControlFlowEval.eval(flow, ctx, scope, parent, tree),
        Blueprint::Component(component) => ComponentEval.eval(component, ctx, scope, parent, tree),
        Blueprint::Slot(blueprints) => SlotEval.eval(blueprints, ctx, scope, parent, tree),
    }
}