sim-lib-view-daw 0.1.2

DAW timeline, mixer, plugin rack, and synth lenses for SIM Web.
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
139
140
141
142
143
144
145
146

//! Shared builders for instrument-specific editor scenes.

use sim_kernel::Expr;
use sim_lib_music_synth::InstrumentEditorDescriptor;
use sim_lib_scene::{data_map, node, sym};

pub(crate) fn editor_root(
    descriptor: &InstrumentEditorDescriptor,
    role: &str,
    fixture_name: &str,
    children: Vec<Expr>,
) -> Expr {
    node(
        "stack",
        vec![
            ("lens", sym(descriptor.view_id)),
            ("role", sym(role)),
            ("route", sym(descriptor.route_name)),
            ("fixture", Expr::String(fixture_name.to_owned())),
            ("fixture-names", string_list(descriptor.fixture_names)),
            ("dir", sym("column")),
            ("children", Expr::List(children)),
        ],
    )
}

pub(crate) fn action(role: &str, action: &str, label: &str) -> Expr {
    node(
        "button",
        vec![
            ("role", sym(role)),
            ("action", sym(action)),
            ("label", Expr::String(label.to_owned())),
        ],
    )
}

pub(crate) fn slider(role: &str, param: &str, min: f64, max: f64, value: f64) -> Expr {
    node(
        "slider",
        vec![
            ("role", sym(role)),
            ("param", sym(param)),
            ("min", number(min)),
            ("max", number(max)),
            ("value", number(value)),
        ],
    )
}

pub(crate) fn table(role: &str, rows: Vec<Expr>) -> Expr {
    node(
        "table",
        vec![("role", sym(role)), ("rows", Expr::List(rows))],
    )
}

pub(crate) fn grid(
    role: &str,
    rows: &[Vec<f64>],
    row_labels: &[&str],
    col_labels: &[&str],
) -> Expr {
    node(
        "grid",
        vec![
            ("role", sym(role)),
            ("rows", numeric_rows(rows)),
            ("row-labels", string_list(row_labels)),
            ("col-labels", string_list(col_labels)),
        ],
    )
}

pub(crate) fn graph(role: &str, nodes: &[&str], edges: &[(&str, &str)]) -> Expr {
    node(
        "graph",
        vec![
            ("role", sym(role)),
            (
                "nodes",
                Expr::List(nodes.iter().map(|name| graph_node(name)).collect()),
            ),
            (
                "edges",
                Expr::List(
                    edges
                        .iter()
                        .map(|(from, to)| graph_edge(from, to))
                        .collect(),
                ),
            ),
        ],
    )
}

pub(crate) fn row(fields: Vec<(&str, Expr)>) -> Expr {
    data_map(fields)
}

pub(crate) fn validation_panel(code: &str, target: &str) -> Expr {
    node(
        "badge",
        vec![
            ("role", sym("instrument-editor-validation")),
            ("status", sym("error")),
            ("validation", sym(code)),
            ("target", sym(target)),
            ("label", Expr::String(format!("{target}: {code}"))),
        ],
    )
}

pub(crate) fn number_list(values: &[f64]) -> Expr {
    Expr::List(values.iter().map(|value| number(*value)).collect())
}

pub(crate) fn string_list(values: &[&str]) -> Expr {
    Expr::List(
        values
            .iter()
            .map(|value| Expr::String((*value).to_owned()))
            .collect(),
    )
}

pub(crate) fn numeric_rows(rows: &[Vec<f64>]) -> Expr {
    Expr::List(
        rows.iter()
            .map(|row| Expr::List(row.iter().map(|value| number(*value)).collect()))
            .collect(),
    )
}

pub(crate) use sim_value::build::float as number;

fn graph_node(name: &str) -> Expr {
    node(
        "node",
        vec![("id", sym(name)), ("label", Expr::String(name.to_owned()))],
    )
}

fn graph_edge(from: &str, to: &str) -> Expr {
    node("edge", vec![("from", sym(from)), ("to", sym(to))])
}