cella_gui 1.0.0

A GUI for the Cella cellular automata library
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

//! The rule editor's working copy of a rule.
//!
//! The editor cannot edit a `Rule1D`/`Rule2D` in place: the user types partial
//! values (an empty Wolfram code, a half-typed number) that would not validate.
//! So the editor keeps everything as `String`s here, and only converts to a real
//! rule when "Apply to grid" is pressed — which is what `to_rule` does, and why
//! it returns a `Result`.

use cella_lib::*;

#[derive(Clone, Debug)]
pub(in crate::gui) struct Rule1DSubruleEdit {
    pub(in crate::gui) current: String,
    pub(in crate::gui) criteria: String,
    pub(in crate::gui) wolfram_code: String,
    pub(in crate::gui) n: u8,
    pub(in crate::gui) randomness_enabled: bool,
    pub(in crate::gui) randomness_value: f64,
    pub(in crate::gui) output: String,
}

#[derive(Clone, Debug)]
pub(in crate::gui) struct Rule1DEdit {
    pub(in crate::gui) subrules: Vec<Rule1DSubruleEdit>,
}

impl Rule1DEdit {
    pub(in crate::gui) fn from_rule(rule: &Rule1D) -> Self {
        let subs = rule
            .subrules
            .iter()
            .map(|s| Rule1DSubruleEdit {
                current: s.current_type.as_str().to_string(),
                criteria: s.criteria_type.as_str().to_string(),
                wolfram_code: s.wolfram_code.to_string(),
                n: s.n,
                randomness_enabled: s.randomness.is_some(),
                randomness_value: s.randomness.unwrap_or(0.0),
                output: s.output_type.as_str().to_string(),
            })
            .collect();
        Self { subrules: subs }
    }
    pub(in crate::gui) fn to_rule(&self) -> Result<Rule1D, String> {
        let mut subs: Vec<Rule1DSubrule> = Vec::new();
        for s in &self.subrules {
            let code = s
                .wolfram_code
                .trim()
                .parse::<u128>()
                .map_err(|e| format!("wolfram_code parse error: {}", e))?;
            let randomness = if s.randomness_enabled {
                Some(s.randomness_value)
            } else {
                None
            };
            let sub = Rule1DSubrule {
                current_type: CellType::from(s.current.clone()),
                criteria_type: CellType::from(s.criteria.clone()),
                wolfram_code: code,
                n: s.n,
                randomness,
                output_type: CellType::from(s.output.clone()),
            };
            if let Err(e) = sub.validate() {
                return Err(format!("validation error: {}", e));
            }
            subs.push(sub);
        }
        Ok(Rule1D { subrules: subs })
    }
}

#[derive(Clone, Debug)]
pub(in crate::gui) struct Rule2DSubruleEdit {
    pub(in crate::gui) current: String,
    pub(in crate::gui) criteria: String,
    pub(in crate::gui) count: u32,
    pub(in crate::gui) op: CountOp,
    pub(in crate::gui) limit_enabled: bool,
    pub(in crate::gui) limit_value: u32,
    pub(in crate::gui) range: u8,
    pub(in crate::gui) neighborhood: Neighborhood2D,
    pub(in crate::gui) randomness_enabled: bool,
    pub(in crate::gui) randomness_value: f64,
    pub(in crate::gui) output: String,
}

#[derive(Clone, Debug)]
pub(in crate::gui) struct Rule2DEdit {
    pub(in crate::gui) subrules: Vec<Rule2DSubruleEdit>,
}

impl Rule2DEdit {
    pub(in crate::gui) fn from_rule(rule: &Rule2D) -> Self {
        let subs = rule
            .subrules
            .iter()
            .map(|s| Rule2DSubruleEdit {
                current: s.current_type.as_str().to_string(),
                criteria: s.criteria_type.as_str().to_string(),
                count: s.count,
                op: s.op,
                limit_enabled: s.limit.is_some(),
                limit_value: s.limit.unwrap_or(0),
                range: s.range,
                neighborhood: s.neighborhood,
                randomness_enabled: s.randomness.is_some(),
                randomness_value: s.randomness.unwrap_or(0.0),
                output: s.output_type.as_str().to_string(),
            })
            .collect();
        Self { subrules: subs }
    }
    pub(in crate::gui) fn to_rule(&self) -> Result<Rule2D, String> {
        let mut subs: Vec<Rule2DSubrule> = Vec::new();
        for s in &self.subrules {
            let randomness = if s.randomness_enabled {
                Some(s.randomness_value)
            } else {
                None
            };
            let limit = if s.limit_enabled {
                Some(s.limit_value)
            } else {
                None
            };
            let sub = Rule2DSubrule::new(
                CellType::from(s.current.clone()),
                CellType::from(s.criteria.clone()),
                s.count,
                s.op,
                s.range,
                s.neighborhood,
                CellType::from(s.output.clone()),
                randomness,
                limit,
            );
            if let Err(e) = sub.validate() {
                return Err(format!("validation error: {}", e));
            }
            subs.push(sub);
        }
        Ok(Rule2D { subrules: subs })
    }
}