Implement an Event System

This adds an event system. The events usually come from the hotkey
system, an auto splitter, the UI, or through a network connection. The
UI usually provides the implementation for the so called event sink,
forwarding all the events to the actual timer. It is able to intercept
the events and for example ask the user for confirmation before applying
them. Other handling is possible such as automatically saving the splits
or notifying a server about changes happening in the run.

Cargo.toml

@@ -41,7 +41,7 @@ bytemuck = { version = "1.9.1", default-features = false }
 bytemuck_derive = { version = "1.4.1", default_features = false }
 cfg-if = "1.0.0"
 itoa = { version = "1.0.3", default-features = false }
-time = { version = "0.3.3", default-features = false }
+time = { version = "0.3.36", default-features = false }
 hashbrown = "0.14.0"
 libm = "0.2.1"
 livesplit-hotkey = { path = "crates/livesplit-hotkey", version = "0.7.0", default-features = false }

capi/Cargo.toml

@@ -21,7 +21,7 @@ web-sys = { version = "0.3.28", optional = true }
 default = ["image-shrinking"]
 image-shrinking = ["livesplit-core/image-shrinking"]
 software-rendering = ["livesplit-core/software-rendering"]
-wasm-web = ["livesplit-core/wasm-web"]
+wasm-web = ["livesplit-core/wasm-web", "wasm-bindgen", "web-sys"]
 auto-splitting = ["livesplit-core/auto-splitting"]
 assume-str-parameters-are-utf8 = []
-web-rendering = ["wasm-web", "livesplit-core/web-rendering", "wasm-bindgen", "web-sys"]
+web-rendering = ["wasm-web", "livesplit-core/web-rendering"]

capi/src/auto_splitting_runtime.rs

@@ -6,7 +6,7 @@ use crate::shared_timer::OwnedSharedTimer;
 use std::{os::raw::c_char, path::PathBuf};
 
 #[cfg(feature = "auto-splitting")]
-use livesplit_core::auto_splitting::Runtime as AutoSplittingRuntime;
+type AutoSplittingRuntime = livesplit_core::auto_splitting::Runtime<livesplit_core::SharedTimer>;
 
 #[cfg(not(feature = "auto-splitting"))]
 use livesplit_core::SharedTimer;

capi/src/delta_component.rs

@@ -1,11 +1,9 @@
-//! The Delta Component is a component that shows the how far ahead or behind
-//! the current attempt is compared to the chosen comparison.
+//! The Delta Component is a component that shows how far ahead or behind the
+//! current attempt is compared to the chosen comparison.
 
 use super::{output_vec, Json};
-use crate::component::OwnedComponent;
-use crate::key_value_component_state::OwnedKeyValueComponentState;
-use livesplit_core::component::delta::Component as DeltaComponent;
-use livesplit_core::{GeneralLayoutSettings, Timer};
+use crate::{component::OwnedComponent, key_value_component_state::OwnedKeyValueComponentState};
+use livesplit_core::{component::delta::Component as DeltaComponent, GeneralLayoutSettings, Timer};
 
 /// type
 pub type OwnedDeltaComponent = Box<DeltaComponent>;

capi/src/event_sink.rs

@@ -0,0 +1,110 @@
+//! An event sink accepts events that are meant to be passed to the timer. The
+//! events usually come from the hotkey system, an auto splitter, the UI, or
+//! through a network connection. The UI usually provides the implementation for
+//! this, forwarding all the events to the actual timer. It is able to intercept
+//! the events and for example ask the user for confirmation before applying
+//! them. Other handling is possible such as automatically saving the splits or
+//! notifying a server about changes happening in the run.
+
+use std::sync::Arc;
+
+use crate::shared_timer::OwnedSharedTimer;
+
+/// type
+#[derive(Clone)]
+pub struct EventSink(pub(crate) Arc<dyn EventSinkAndQuery>);
+
+/// type
+pub type OwnedEventSink = Box<EventSink>;
+
+/// Creates a new Event Sink.
+#[no_mangle]
+pub extern "C" fn EventSink_from_timer(timer: OwnedSharedTimer) -> OwnedEventSink {
+    Box::new(EventSink(Arc::new(*timer)))
+}
+
+/// drop
+#[no_mangle]
+pub extern "C" fn EventSink_drop(this: OwnedEventSink) {
+    drop(this);
+}
+
+pub(crate) trait EventSinkAndQuery:
+    livesplit_core::event::Sink + livesplit_core::event::TimerQuery + Send + Sync + 'static
+{
+}
+
+impl<T> EventSinkAndQuery for T where
+    T: livesplit_core::event::Sink + livesplit_core::event::TimerQuery + Send + Sync + 'static
+{
+}
+
+impl livesplit_core::event::Sink for EventSink {
+    fn start(&self) {
+        self.0.start()
+    }
+
+    fn split(&self) {
+        self.0.split()
+    }
+
+    fn split_or_start(&self) {
+        self.0.split_or_start()
+    }
+
+    fn reset(&self, save_attempt: Option<bool>) {
+        self.0.reset(save_attempt)
+    }
+
+    fn undo_split(&self) {
+        self.0.undo_split()
+    }
+
+    fn skip_split(&self) {
+        self.0.skip_split()
+    }
+
+    fn toggle_pause_or_start(&self) {
+        self.0.toggle_pause_or_start()
+    }
+
+    fn pause(&self) {
+        self.0.pause()
+    }
+
+    fn resume(&self) {
+        self.0.resume()
+    }
+
+    fn undo_all_pauses(&self) {
+        self.0.undo_all_pauses()
+    }
+
+    fn switch_to_previous_comparison(&self) {
+        self.0.switch_to_previous_comparison()
+    }
+
+    fn switch_to_next_comparison(&self) {
+        self.0.switch_to_next_comparison()
+    }
+
+    fn toggle_timing_method(&self) {
+        self.0.toggle_timing_method()
+    }
+
+    fn set_game_time(&self, time: livesplit_core::TimeSpan) {
+        self.0.set_game_time(time)
+    }
+
+    fn pause_game_time(&self) {
+        self.0.pause_game_time()
+    }
+
+    fn resume_game_time(&self) {
+        self.0.resume_game_time()
+    }
+
+    fn set_custom_variable(&self, name: &str, value: &str) {
+        self.0.set_custom_variable(name, value)
+    }
+}

capi/src/hotkey_system.rs

@@ -6,8 +6,10 @@
 
 use std::{os::raw::c_char, str::FromStr};
 
-use crate::{hotkey_config::OwnedHotkeyConfig, output_str, shared_timer::OwnedSharedTimer, str};
-use livesplit_core::{hotkey::KeyCode, HotkeySystem};
+use crate::{event_sink::EventSink, hotkey_config::OwnedHotkeyConfig, output_str, str};
+use livesplit_core::hotkey::KeyCode;
+
+type HotkeySystem = livesplit_core::HotkeySystem<EventSink>;
 
 /// type
 pub type OwnedHotkeySystem = Box<HotkeySystem>;
@@ -16,18 +18,18 @@ pub type NullableOwnedHotkeySystem = Option<OwnedHotkeySystem>;
 
 /// Creates a new Hotkey System for a Timer with the default hotkeys.
 #[no_mangle]
-pub extern "C" fn HotkeySystem_new(shared_timer: OwnedSharedTimer) -> NullableOwnedHotkeySystem {
-    HotkeySystem::new(*shared_timer).ok().map(Box::new)
+pub extern "C" fn HotkeySystem_new(event_sink: &EventSink) -> NullableOwnedHotkeySystem {
+    HotkeySystem::new(event_sink.clone()).ok().map(Box::new)
 }
 
 /// Creates a new Hotkey System for a Timer with a custom configuration for the
 /// hotkeys.
 #[no_mangle]
 pub extern "C" fn HotkeySystem_with_config(
-    shared_timer: OwnedSharedTimer,
+    event_sink: &EventSink,
     config: OwnedHotkeyConfig,
 ) -> NullableOwnedHotkeySystem {
-    HotkeySystem::with_config(*shared_timer, *config)
+    HotkeySystem::with_config(event_sink.clone(), *config)
         .ok()
         .map(Box::new)
 }

capi/src/lib.rs

@@ -32,6 +32,7 @@ pub mod current_pace_component;
 pub mod delta_component;
 pub mod detailed_timer_component;
 pub mod detailed_timer_component_state;
+pub mod event_sink;
 pub mod fuzzy_list;
 pub mod general_layout_settings;
 pub mod graph_component;
@@ -83,6 +84,8 @@ pub mod timer_write_lock;
 pub mod title_component;
 pub mod title_component_state;
 pub mod total_playtime_component;
+#[cfg(all(target_family = "wasm", feature = "wasm-web"))]
+pub mod web_event_sink;
 #[cfg(all(target_family = "wasm", feature = "web-rendering"))]
 pub mod web_rendering;
 

capi/src/run.rs

@@ -234,6 +234,12 @@ pub extern "C" fn Run_segment(this: &Run, index: usize) -> &Segment {
     this.segment(index)
 }
 
+/// Returns the amount of segments in this Run.
+#[no_mangle]
+pub extern "C" fn Run_segments_len(this: &Run) -> usize {
+    this.segments().len()
+}
+
 /// Returns the amount attempt history elements are stored in this Run.
 #[no_mangle]
 pub extern "C" fn Run_attempt_history_len(this: &Run) -> usize {

capi/src/segment.rs

@@ -11,7 +11,7 @@ pub type OwnedSegment = Box<Segment>;
 
 /// Creates a new Segment with the name given.
 #[no_mangle]
-pub unsafe extern "C" fn Segment_new(name: &c_char) -> OwnedSegment {
+pub unsafe extern "C" fn Segment_new(name: *const c_char) -> OwnedSegment {
     Box::new(Segment::new(str(name)))
 }
 

capi/src/timer.rs

@@ -1,6 +1,6 @@
 //! A Timer provides all the capabilities necessary for doing speedrun attempts.
 
-use super::{output_str, output_time, output_time_span, output_vec};
+use super::{output_str, output_time, output_time_span, output_vec, str};
 use crate::{
     run::{NullableOwnedRun, OwnedRun},
     shared_timer::OwnedSharedTimer,
@@ -204,6 +204,12 @@ pub extern "C" fn Timer_set_current_timing_method(this: &mut Timer, method: Timi
     this.set_current_timing_method(method);
 }
 
+/// Toggles between the Real Time and Game Time timing methods.
+#[no_mangle]
+pub extern "C" fn Timer_toggle_timing_method(this: &mut Timer) {
+    this.toggle_timing_method();
+}
+
 /// Returns the current comparison that is being compared against. This may
 /// be a custom comparison or one of the Comparison Generators.
 #[no_mangle]
@@ -287,6 +293,18 @@ pub extern "C" fn Timer_set_loading_times(this: &mut Timer, time: &TimeSpan) {
     this.set_loading_times(*time);
 }
 
+/// Sets the value of a custom variable with the name specified. If the variable
+/// does not exist, a temporary variable gets created that will not be stored in
+/// the splits file.
+#[no_mangle]
+pub unsafe extern "C" fn Timer_set_custom_variable(
+    this: &mut Timer,
+    name: *const c_char,
+    value: *const c_char,
+) {
+    this.set_custom_variable(str(name), str(value));
+}
+
 /// Returns the current Timer Phase.
 #[no_mangle]
 pub extern "C" fn Timer_current_phase(this: &Timer) -> TimerPhase {