Simplify Subsplit Editor State

This exposes segment group state separately from flat segment rows in the run editor and removes the extra per-row group metadata that the frontend does not need for rendering or editing.

This also updates the C API and TypeScript binding generation for the restructured editor state and covers the group selection behavior in editor tests.

Author: CryZe

capi/bind_gen/src/typescript.ts

@@ -895,6 +895,8 @@ export interface RunEditorStateJson {
     timing_method: TimingMethodJson,
     /** The state of all the segments. */
     segments: RunEditorRowJson[],
+    /** The segment groups of the run. */
+    segment_groups: RunEditorSegmentGroupJson[],
     /** The names of all the custom comparisons that exist for this Run. */
     comparison_names: string[],
     /** Describes which actions are currently available. */
@@ -999,8 +1001,8 @@ export interface RunEditorButtonsJson {
      */
     can_create_segment_group: boolean,
     /**
-     * Describes whether the currently selected segments are exactly one
-     * segment group that can be removed.
+     * Describes whether the currently selected segments are exactly one or more
+     * segment groups that can be removed.
      */
     can_remove_segment_group: boolean,
 }
@@ -1029,18 +1031,16 @@ export interface RunEditorRowJson {
     comparison_times: string[],
     /** Describes the segment's selection state. */
     selected: "NotSelected" | "Selected" | "Active",
-    /** Describes how this segment participates in a segment group. */
-    segment_group: RunEditorSegmentGroupStateJson,
+    /** The index of the group this segment belongs to, if any. */
+    segment_group_index: number | null,
 }
 
-/** Describes a segment's role in a segment group. */
-export interface RunEditorSegmentGroupStateJson {
-    /** The index of the group this segment belongs to, if any. */
-    group_index: number | null,
-    /** Whether this segment is a subsplit inside the group. */
-    is_subsplit: boolean,
-    /** Whether this segment is the major split ending the group. */
-    is_major_split: boolean,
+/** Describes a segment group. */
+export interface RunEditorSegmentGroupJson {
+    /** The first segment in the group. */
+    start: number,
+    /** The segment after the last segment in the group. */
+    end: number,
     /**
      * The explicit group name. If this is `null`, the major split name is the
      * display name of the group.

capi/src/run_editor.rs

@@ -328,8 +328,7 @@ pub unsafe extern "C" fn RunEditor_create_segment_group_from_selection(
     }
 }
 
-/// Removes the native segment group containing the active segment, while
-/// keeping all segments.
+/// Removes the selected native segment groups, while keeping all segments.
 #[unsafe(no_mangle)]
 pub extern "C" fn RunEditor_remove_active_segment_group(this: &mut RunEditor) -> bool {
     this.remove_active_segment_group()

crates/livesplit-hotkey/src/macos/mod.rs

@@ -456,25 +456,29 @@ unsafe extern "C" fn callback(
     let modifier_flags = unsafe { CGEventGetFlags(event) };
     let mut modifiers = Modifiers::empty();
 
-    if modifier_flags.intersects(EventFlags::SHIFT | EventFlags::LEFT_SHIFT | EventFlags::RIGHT_SHIFT)
+    if modifier_flags
+        .intersects(EventFlags::SHIFT | EventFlags::LEFT_SHIFT | EventFlags::RIGHT_SHIFT)
         && !matches!(key_code, KeyCode::ShiftLeft | KeyCode::ShiftRight)
     {
         modifiers.insert(Modifiers::SHIFT);
     }
 
-    if modifier_flags.intersects(EventFlags::CONTROL | EventFlags::LEFT_CONTROL | EventFlags::RIGHT_CONTROL)
+    if modifier_flags
+        .intersects(EventFlags::CONTROL | EventFlags::LEFT_CONTROL | EventFlags::RIGHT_CONTROL)
         && !matches!(key_code, KeyCode::ControlLeft | KeyCode::ControlRight)
     {
         modifiers.insert(Modifiers::CONTROL);
     }
 
-    if modifier_flags.intersects(EventFlags::OPTION | EventFlags::LEFT_OPTION | EventFlags::RIGHT_OPTION)
+    if modifier_flags
+        .intersects(EventFlags::OPTION | EventFlags::LEFT_OPTION | EventFlags::RIGHT_OPTION)
         && !matches!(key_code, KeyCode::AltLeft | KeyCode::AltRight)
     {
         modifiers.insert(Modifiers::ALT);
     }
 
-    if modifier_flags.intersects(EventFlags::COMMAND | EventFlags::LEFT_COMMAND | EventFlags::RIGHT_COMMAND)
+    if modifier_flags
+        .intersects(EventFlags::COMMAND | EventFlags::LEFT_COMMAND | EventFlags::RIGHT_COMMAND)
         && !matches!(key_code, KeyCode::MetaLeft | KeyCode::MetaRight)
     {
         modifiers.insert(Modifiers::META);

src/run/editor/mod.rs

@@ -1119,12 +1119,30 @@ impl Editor {
     }
 
     fn selected_segment_group_index(&self) -> Option<usize> {
-        let (start, end) = self.selected_segment_range()?;
-        self.run
-            .segment_groups()
-            .groups()
-            .iter()
-            .position(|group| group.start() == start && group.end() == end)
+        let indices = self.selected_segment_group_indices()?;
+        (indices.len() == 1).then_some(indices[0])
+    }
+
+    fn selected_segment_group_indices(&self) -> Option<Vec<usize>> {
+        let mut group_indices = Vec::new();
+        let mut grouped_segment_count = 0;
+
+        for (group_index, group) in self.run.segment_groups().groups().iter().enumerate() {
+            let selected_in_group = (group.start()..group.end())
+                .filter(|index| self.selected_segments.contains(index))
+                .count();
+            if selected_in_group == 0 {
+                continue;
+            }
+            if selected_in_group != group.end() - group.start() {
+                return None;
+            }
+            group_indices.push(group_index);
+            grouped_segment_count += selected_in_group;
+        }
+
+        (!group_indices.is_empty() && grouped_segment_count == self.selected_segments.len())
+            .then_some(group_indices)
     }
 
     /// Checks if the currently selected segments can be turned into a group.
@@ -1144,9 +1162,10 @@ impl Editor {
             .any(|group| start < group.end() && end > group.start())
     }
 
-    /// Checks if the currently selected segments are exactly one whole group.
+    /// Checks if the currently selected segments are exactly one or more whole
+    /// groups.
     pub fn can_remove_active_segment_group(&self) -> bool {
-        self.selected_segment_group_index().is_some()
+        self.selected_segment_group_indices().is_some()
     }
 
     /// Creates a segment group from the currently selected contiguous segment
@@ -1170,16 +1189,18 @@ impl Editor {
         true
     }
 
-    /// Removes the group containing the active segment, while keeping all
-    /// segments.
+    /// Removes the selected segment groups, while keeping all segments.
     pub fn remove_active_segment_group(&mut self) -> bool {
-        let Some(group_index) = self.selected_segment_group_index() else {
+        let Some(mut group_indices) = self.selected_segment_group_indices() else {
             return false;
         };
-        self.run
-            .segment_groups_mut()
-            .groups_mut()
-            .remove(group_index);
+        group_indices.sort_unstable();
+        for group_index in group_indices.into_iter().rev() {
+            self.run
+                .segment_groups_mut()
+                .groups_mut()
+                .remove(group_index);
+        }
         self.raise_run_edited();
         true
     }

src/run/editor/state.rs

@@ -32,6 +32,8 @@ pub struct State {
     pub timing_method: TimingMethod,
     /// The state of all the segments.
     pub segments: Vec<Segment>,
+    /// The native segment groups of the run.
+    pub segment_groups: Vec<SegmentGroup>,
     /// The names of all the custom comparisons that exist for this Run.
     pub comparison_names: Vec<String>,
     /// Describes which actions are currently available.
@@ -86,19 +88,17 @@ pub struct Segment {
     pub comparison_times: Vec<String>,
     /// Describes the segment's selection state.
     pub selected: SelectionState,
-    /// Describes how this segment participates in a native segment group.
-    pub segment_group: SegmentGroupState,
+    /// The index of the group this segment belongs to, if any.
+    pub segment_group_index: Option<usize>,
 }
 
-/// Describes a segment's role in a native segment group.
+/// Describes a native segment group.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct SegmentGroupState {
-    /// The index of the group this segment belongs to, if any.
-    pub group_index: Option<usize>,
-    /// Whether this segment is a subsplit inside the group.
-    pub is_subsplit: bool,
-    /// Whether this segment is the major split ending the group.
-    pub is_major_split: bool,
+pub struct SegmentGroup {
+    /// The first segment in the group.
+    pub start: usize,
+    /// The segment after the last segment in the group.
+    pub end: usize,
     /// The explicit group name. If this is `None`, the major split name is the
     /// display name of the group.
     pub name: Option<String>,
@@ -171,6 +171,24 @@ impl Editor {
             can_create_segment_group: self.can_create_segment_group_from_selection(),
             can_remove_segment_group: self.can_remove_active_segment_group(),
         };
+        let mut segment_groups = Vec::with_capacity(self.run.segment_groups().groups().len());
+        for group in self.run.segment_groups().groups() {
+            let (group_icon, has_explicit_icon) = group.icon().map_or(
+                (self.run.segment(group.major_index()).icon(), false),
+                |icon| (icon, true),
+            );
+            let icon = *image_cache
+                .cache(group_icon.id(), || group_icon.clone())
+                .id();
+            segment_groups.push(SegmentGroup {
+                start: group.start(),
+                end: group.end(),
+                name: group.name().map(str::to_owned),
+                icon,
+                has_explicit_icon,
+            });
+        }
+
         let mut segments = Vec::with_capacity(self.run.len());
 
         for segment_index in 0..self.run.len() {
@@ -198,36 +216,10 @@ impl Editor {
                 SelectionState::NotSelected
             };
 
-            let segment_group = self
+            let segment_group_index = self
                 .run
                 .segment_groups()
-                .group_index_for_segment(segment_index)
-                .map(|group_index| {
-                    let group = &self.run.segment_groups().groups()[group_index];
-                    let (group_icon, has_explicit_icon) = group.icon().map_or(
-                        (self.run.segment(group.major_index()).icon(), false),
-                        |icon| (icon, true),
-                    );
-                    let icon = *image_cache
-                        .cache(group_icon.id(), || group_icon.clone())
-                        .id();
-                    SegmentGroupState {
-                        group_index: Some(group_index),
-                        is_subsplit: segment_index < group.major_index(),
-                        is_major_split: segment_index == group.major_index(),
-                        name: group.name().map(str::to_owned),
-                        icon,
-                        has_explicit_icon,
-                    }
-                })
-                .unwrap_or(SegmentGroupState {
-                    group_index: None,
-                    is_subsplit: false,
-                    is_major_split: false,
-                    name: None,
-                    icon: *ImageId::EMPTY,
-                    has_explicit_icon: false,
-                });
+                .group_index_for_segment(segment_index);
 
             segments.push(Segment {
                 icon,
@@ -237,7 +229,7 @@ impl Editor {
                 best_segment_time,
                 comparison_times,
                 selected,
-                segment_group,
+                segment_group_index,
             });
         }
 
@@ -249,6 +241,7 @@ impl Editor {
             attempts,
             timing_method,
             segments,
+            segment_groups,
             comparison_names,
             buttons,
             metadata: self.run.metadata().clone(),

src/run/editor/tests/mod.rs

@@ -183,13 +183,11 @@ fn creates_renames_and_removes_segment_groups() {
 
     let mut image_cache = ImageCache::new();
     let state = editor.state(&mut image_cache, Lang::English);
-    assert_eq!(state.segments[0].segment_group.group_index, Some(0));
-    assert!(state.segments[0].segment_group.is_subsplit);
-    assert!(state.segments[2].segment_group.is_major_split);
-    assert_eq!(
-        state.segments[2].segment_group.name.as_deref(),
-        Some("Renamed")
-    );
+    assert_eq!(state.segments[0].segment_group_index, Some(0));
+    assert_eq!(state.segments[2].segment_group_index, Some(0));
+    assert_eq!(state.segment_groups[0].start, 0);
+    assert_eq!(state.segment_groups[0].end, 3);
+    assert_eq!(state.segment_groups[0].name.as_deref(), Some("Renamed"));
 
     assert!(editor.remove_active_segment_group());
     assert!(editor.close().segment_groups().groups().is_empty());
@@ -230,21 +228,21 @@ fn segment_group_icons_can_be_explicit_or_inherited() {
 
     let mut image_cache = ImageCache::new();
     let state = editor.state(&mut image_cache, Lang::English);
-    assert_eq!(state.segments[0].segment_group.icon, *major_icon.id());
-    assert!(!state.segments[0].segment_group.has_explicit_icon);
+    assert_eq!(state.segment_groups[0].icon, *major_icon.id());
+    assert!(!state.segment_groups[0].has_explicit_icon);
 
     let group_icon = Image::new([4, 5, 6].as_slice().into(), Image::ICON);
     assert!(editor.set_active_segment_group_icon(group_icon.clone()));
 
     let state = editor.state(&mut image_cache, Lang::English);
-    assert_eq!(state.segments[0].segment_group.icon, *group_icon.id());
-    assert!(state.segments[0].segment_group.has_explicit_icon);
+    assert_eq!(state.segment_groups[0].icon, *group_icon.id());
+    assert!(state.segment_groups[0].has_explicit_icon);
 
     assert!(editor.remove_active_segment_group_icon());
 
     let state = editor.state(&mut image_cache, Lang::English);
-    assert_eq!(state.segments[0].segment_group.icon, *major_icon.id());
-    assert!(!state.segments[0].segment_group.has_explicit_icon);
+    assert_eq!(state.segment_groups[0].icon, *major_icon.id());
+    assert!(!state.segment_groups[0].has_explicit_icon);
 }
 
 #[test]
@@ -300,6 +298,30 @@ fn mixed_selection_cannot_create_or_remove_segment_group() {
     assert!(editor.remove_active_segment_group());
 }
 
+#[test]
+fn removes_multiple_selected_segment_groups() {
+    let mut run = Run::new();
+    for name in ["A", "B", "C", "D", "E", "F"] {
+        run.push_segment(Segment::new(name));
+    }
+
+    let mut editor = Editor::new(run).unwrap();
+    editor.select_range(1);
+    assert!(editor.create_segment_group_from_selection(Some("Group A")));
+    editor.select_only(2);
+    editor.select_range(4);
+    assert!(editor.create_segment_group_from_selection(Some("Group B")));
+
+    editor.select_only(0);
+    editor.select_additionally(1);
+    editor.select_additionally(2);
+    editor.select_additionally(3);
+    editor.select_additionally(4);
+    assert!(editor.can_remove_active_segment_group());
+    assert!(editor.remove_active_segment_group());
+    assert!(editor.run().segment_groups().groups().is_empty());
+}
+
 #[test]
 fn ungrouped_selection_before_group_can_create_segment_group() {
     let mut run = Run::new();