gled-ui 2.30.1

gled's egui interface, shared by the desktop app and the browser
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

//! Everything an interface knows of the engine, rebuilt from the messages it
//! receives. The desktop app and the browser fill it the same way; only the
//! transport differs.

use std::sync::Arc;

use gled_model::input::event::InputEvent;
use gled_protocol::{
    message::ServerMessage,
    midi::MidiMonitorEvent,
    replica::StateReplica,
    state::{EngineEvent, SoundSnapshot},
};

use crate::layout::ClientLayout;

#[derive(Debug, Default)]
pub(crate) struct ClientModel {
    /// The engine's state and assets.
    pub(crate) replica: StateReplica,
    pub(crate) layout: ClientLayout,
    pub(crate) sound: Arc<SoundSnapshot>,
    /// The newest preview frame not yet shown.
    pub(crate) preview: Option<Arc<Vec<u8>>>,
    /// Engine events not yet handled.
    pub(crate) events: Vec<EngineEvent>,
    /// Input events that arrived since they were last taken, for assigning
    /// inputs.
    pub(crate) input_events: Vec<InputEvent>,
    /// MIDI traffic not yet shown in the monitor.
    pub(crate) midi_monitor: Vec<MidiMonitorEvent>,
    /// Messages captured for MIDI learn, not yet looked at.
    pub(crate) midi_learn: Vec<[u8; 3]>,
    /// The server's version, once it welcomed this interface.
    pub(crate) server_version: Option<String>,
    /// Set when the state changed since the flag was last cleared.
    pub(crate) state_changed: bool,
    /// Set when the server welcomed this interface, which starts a new
    /// session: action numbers start over.
    pub(crate) welcomed: bool,
}

impl ClientModel {
    pub(crate) fn apply(&mut self, message: ServerMessage) {
        match message {
            ServerMessage::Welcome { app_version, .. } => {
                self.server_version = Some(app_version);
                self.welcomed = true;
            }
            ServerMessage::Preview(output) => self.preview = Some(output.0),
            ServerMessage::Sound(sound) => self.sound = sound,
            ServerMessage::Event(event) => self.events.push(event),
            ServerMessage::InputEvents(events) => self.input_events.extend(events),
            ServerMessage::MidiMonitor(events) => self.midi_monitor.extend(events),
            ServerMessage::MidiLearn(messages) => self.midi_learn.extend(messages),
            message => {
                if self.replica.apply(&message) {
                    self.state_changed = true;
                    let svg = self
                        .replica
                        .state
                        .project
                        .as_ref()
                        .and_then(|project| project.svg.as_ref());
                    self.layout.update(svg);
                }
            }
        }
    }
}