Gros ménage

Author: tand00

core/src/error.rs

@@ -1,4 +1,4 @@
-use std::collections::VecDeque;
+use std::{cell::RefCell, collections::VecDeque};
 
 use serde::{Deserialize, Serialize};
 
@@ -12,12 +12,23 @@ pub struct SovaError {
     pub text: String
 }
 
+#[derive(Debug, Default)]
 pub struct ErrorQueue {
-    pub buffer: VecDeque<SovaError>
+    buffer: RefCell<VecDeque<SovaError>>
 }
 
 impl ErrorQueue {
+    pub fn throw(&self, err: SovaError) {
+        self.buffer.borrow_mut().push_back(err);
+    }
+
+    pub fn poll(&self) -> Option<SovaError> {
+        self.buffer.borrow_mut().pop_front()
+    }
 
+    pub fn clear(&self) {
+        self.buffer.borrow_mut().clear();
+    }
 }
 
 impl SovaError {

core/src/protocol/audio_engine_proxy.rs

@@ -27,8 +27,8 @@ impl AudioEnginePayload {
                 let addr = addr.parse::<i64>();
                 match args {
                     VariableValue::Map(mut map) => {
-                        if !map.contains_key("dur") {
-                            map.insert("dur".to_owned(), dur_s.into());
+                        if !map.contains_key("duration") {
+                            map.insert("duration".to_owned(), dur_s.into());
                         }
                         if let Ok(a) = addr {
                             map.insert("voice".to_owned(), a.into());
@@ -41,8 +41,8 @@ impl AudioEnginePayload {
                     }
                     VariableValue::Str(s) => {
                         let mut map = HashMap::new();
-                        map.insert("s".to_owned(), s.into());
-                        map.insert("dur".to_owned(), dur_s.into());
+                        map.insert("sound".to_owned(), s.into());
+                        map.insert("duration".to_owned(), dur_s.into());
                         if let Ok(a) = addr {
                             map.insert("voice".to_owned(), a.into());
                         }

core/src/protocol/osc.rs

@@ -5,7 +5,6 @@ use std::net::{SocketAddr, UdpSocket};
 use crate::clock::TimeSpan;
 use crate::vm::variable::VariableValue;
 use crate::protocol::error::ProtocolError;
-use crate::util::decimal_operations::float64_from_decimal;
 
 mod message;
 pub use message::*;
@@ -64,8 +63,8 @@ impl OSCOut {
                     match arg {
                         VariableValue::Integer(i) => Ok(OscType::Int(i as i32)),
                         VariableValue::Float(f) => Ok(OscType::Float(f as f32)),
-                        VariableValue::Decimal(sign, num, den) => {
-                            let f = float64_from_decimal(sign, num, den);
+                        VariableValue::Decimal(d) => {
+                            let f = f64::from(d);
                             Ok(OscType::Float(f as f32))
                         }
                         VariableValue::Str(s) => Ok(OscType::String(s)),

core/src/protocol/osc/message.rs

@@ -159,11 +159,11 @@ impl OSCMessage {
                     VariableValue::Map(map) => map,
                     value => {
                         let mut map = HashMap::new();
-                        map.insert("s".to_owned(), value);
+                        map.insert("sound".to_owned(), value);
                         map
                     }
                 };
-                if args.contains_key("s") && !args.contains_key("sustain") {
+                if (args.contains_key("s") || args.contains_key("sound")) && !args.contains_key("sustain") {
                     let dur_s = (duration as f64) / 1_000_000.0;
                     args.insert("sustain".to_owned(), dur_s.into());
                 }

core/src/schedule.rs

@@ -1,12 +1,5 @@
 use crate::{
-    clock::{Clock, ClockServer, NEVER, SyncTime},
-    device_map::DeviceMap,
-    log_println,
-    protocol::TimedMessage,
-    scene::Scene,
-    schedule::{playback::PlaybackManager, scheduler_actions::ActionProcessor},
-    vm::{LanguageCenter, PartialContext, variable::VariableStore},
-    world::ACTIVE_WAITING_SWITCH_MICROS,
+    clock::{Clock, ClockServer, NEVER, SyncTime}, device_map::DeviceMap, error::ErrorQueue, log_println, protocol::TimedMessage, scene::Scene, schedule::{playback::PlaybackManager, scheduler_actions::ActionProcessor}, vm::{LanguageCenter, PartialContext, variable::VariableStore}, world::ACTIVE_WAITING_SWITCH_MICROS
 };
 
 use crossbeam_channel::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
@@ -43,6 +36,8 @@ pub struct Scheduler {
     playback_manager: PlaybackManager,
     shutdown_requested: bool,
 
+    error_queue: ErrorQueue,
+
     scene_structure: Vec<Vec<f64>>,
 }
 
@@ -102,6 +97,7 @@ impl Scheduler {
             playback_manager: PlaybackManager::default(),
             shutdown_requested: false,
             scene_structure: Vec::new(),
+            error_queue: Default::default()
         }
     }
 
@@ -232,6 +228,7 @@ impl Scheduler {
         partial.clock = Some(&self.clock);
         partial.device_map = Some(&self.devices);
         partial.structure = Some(&self.scene_structure);
+        partial.errors = Some(&self.error_queue);
         let (events, wait) = self.scene.update_executions(partial);
         for event in events {
             for msg in self.devices.map_event(event, date, &self.clock) {
@@ -306,6 +303,10 @@ impl Scheduler {
 
             let next_exec_delay = self.process_executions(date);
 
+            while let Some(error) = self.error_queue.poll() {
+                let _ = self.update_notifier.send(SovaNotification::Error(error));
+            }
+
             // Check if global variables changed and send notification
             let one_letter_vars: VariableStore = self.scene.vars.one_letter_vars().collect();
             if one_letter_vars != one_letters_before {

core/src/util/decimal_operations/decimal.rs

@@ -1,8 +1,10 @@
 use std::{cmp::Ordering, fmt::Display, ops::{Add, Div, Mul, Neg, Rem, Sub}};
 
+use serde::{Deserialize, Serialize};
+
 use crate::util::decimal_operations::{add_decimal, decimal_from_float64, div_decimal, eq_decimal, float64_from_decimal, lt_decimal, mul_decimal, rem_decimal, simplify_decimal, string_from_decimal, sub_decimal};
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
 pub struct Decimal {
     pub sign: i8,
     pub num: u64,
@@ -19,6 +21,9 @@ impl Decimal {
     pub fn zero() -> Self {
         Self { sign: 1, num: 0, den: 1 }
     }
+    pub fn is_zero(&self) -> bool {
+        self.num == 0
+    }
 }
 
 impl Default for Decimal {
@@ -146,6 +151,12 @@ impl From<Decimal> for f64 {
     }
 }
 
+impl From<Decimal> for i64 {
+    fn from(value: Decimal) -> Self {
+        (value.sign as i64) * (value.den / value.num) as i64
+    }
+}
+
 impl From<(i8, u64, u64)> for Decimal {
     fn from(value: (i8, u64, u64)) -> Self {
         Decimal { 

core/src/util/music/scale.rs

@@ -83,6 +83,6 @@ impl Scale {
 
 impl Default for Scale {
     fn default() -> Self {
-        Self::chromatic(NOTE_C, 4)
+        Self::major(NOTE_C, 4)
     }
 }