Add Basic Subsplits Support in Splits Component

All the splits without any segment groups behave like they did before
and the segment groups now properly open up and close as they are being
entered. This is done by transforming the segment groups iterator and
implementing an iterator on top that flattens it with a specific segment
in focus that determines the group that is supposed to be open. After
this flattening almost all the original logic remains, but now with the
current segment index and the run's length instead being based on this
flattened segment group representation.

Author: CryZe

capi/bind_gen/src/typescript.ts

@@ -244,11 +244,20 @@ export interface SplitStateJson {
      * on.
      */
     is_current_split: boolean,
+    /** Describes whether the segment is part of a segment group. */
+    is_subsplit: boolean,
+    /**
+     * Describes whether the row should be considered an even or an odd row.
+     * This is useful for visualizing the rows with alternating colors.
+     */
+    is_even: boolean,
     /**
      * The index of the segment based on all the segments of the run. This may
      * differ from the index of this `SplitStateJson` in the
      * `SplitsComponentStateJson` object, as there can be a scrolling window,
-     * showing only a subset of segments. Each index is guaranteed to be unique.
+     * showing only a subset of segments. Indices are not guaranteed to be
+     * unique, as they may appear in both group headers and in segments within
+     * the groups. Only the pair of index and `is_subsplit` is unique.
      */
     index: number,
 }

src/component/splits/mod.rs

@@ -11,13 +11,16 @@ use crate::settings::{
 };
 use crate::timing::formatter::{Delta, Regular, TimeFormatter};
 use crate::{
-    analysis, comparison, CachedImageId, GeneralLayoutSettings, Segment, TimeSpan, Timer,
-    TimingMethod,
+    analysis, comparison, run::SegmentGroupsIter, CachedImageId, GeneralLayoutSettings, Segment,
+    TimeSpan, Timer, TimingMethod,
 };
 use serde_json::{to_writer, Result};
-use std::borrow::Cow;
-use std::cmp::{max, min};
-use std::io::Write;
+use std::{
+    borrow::Cow,
+    cmp::{max, min},
+    io::Write,
+    iter,
+};
 
 #[cfg(test)]
 mod tests;
@@ -197,10 +200,17 @@ pub struct SplitState {
     /// Describes if this segment is the segment the active attempt is currently
     /// on.
     pub is_current_split: bool,
+    /// Describes whether the segment is part of a segment group.
+    pub is_subsplit: bool,
+    /// Describes whether the row should be considered an even or an odd row.
+    /// This is useful for visualizing the rows with alternating colors.
+    pub is_even: bool,
     /// The index of the segment based on all the segments of the run. This may
     /// differ from the index of this `SplitState` in the `State` object, as
-    /// there can be a scrolling window, showing only a subset of segments. Each
-    /// index is guaranteed to be unique.
+    /// there can be a scrolling window, showing only a subset of segments.
+    /// Indices are not guaranteed to be unique, as they may appear in both
+    /// group headers and in segments within the groups. Only the pair of index
+    /// and `is_subsplit` is unique.
     pub index: usize,
 }
 
@@ -379,12 +389,27 @@ impl Component {
         let run = timer.run();
         self.icon_ids.resize(run.len(), CachedImageId::default());
 
+        let current_split = timer.current_split_index();
+
+        let mut index_of_segment_in_focus = None;
+        let mut flattened_count = 0;
+        for (flattened_index, segment) in flatten(
+            run.segment_groups_iter(),
+            current_split.unwrap_or_else(|| run.len()),
+        )
+        .enumerate()
+        {
+            if segment.in_focus {
+                index_of_segment_in_focus = Some(flattened_index);
+            }
+            flattened_count += 1;
+        }
+
         let mut visual_split_count = self.settings.visual_split_count;
         if visual_split_count == 0 {
-            visual_split_count = run.len();
+            visual_split_count = flattened_count;
         }
 
-        let current_split = timer.current_split_index();
         let method = timer.current_timing_method();
 
         let always_show_last_split = if self.settings.always_show_last_split {
@@ -393,27 +418,27 @@ impl Component {
             1
         };
         let skip_count = min(
-            current_split.map_or(0, |c_s| {
+            index_of_segment_in_focus.map_or(0, |c_s| {
                 c_s.saturating_sub(
                     visual_split_count
                         .saturating_sub(2)
                         .saturating_sub(self.settings.split_preview_count)
                         .saturating_add(always_show_last_split),
                 ) as isize
             }),
-            run.len() as isize - visual_split_count as isize,
+            flattened_count as isize - visual_split_count as isize,
         );
         self.scroll_offset = min(
             max(self.scroll_offset, -skip_count),
-            run.len() as isize - skip_count - visual_split_count as isize,
+            flattened_count as isize - skip_count - visual_split_count as isize,
         );
         let skip_count = max(0, skip_count + self.scroll_offset) as usize;
         let take_count = visual_split_count + always_show_last_split as usize - 1;
         let always_show_last_split = self.settings.always_show_last_split;
 
         let show_final_separator = self.settings.separator_last_split
             && always_show_last_split
-            && skip_count + take_count + 1 < run.len();
+            && skip_count + take_count + 1 < flattened_count;
 
         let Settings {
             show_thin_separators,
@@ -425,46 +450,56 @@ impl Component {
 
         let mut icon_changes = Vec::new();
 
-        let mut splits: Vec<_> = run
-            .segments()
-            .iter()
-            .enumerate()
-            .zip(self.icon_ids.iter_mut())
-            .skip(skip_count)
-            .filter(|&((i, _), _)| {
-                i - skip_count < take_count || (always_show_last_split && i + 1 == run.len())
-            })
-            .map(|((i, segment), icon_id)| {
-                let columns = columns
+        let mut splits = Vec::with_capacity(visual_split_count);
+
+        for (flattened_index, segment) in flatten(
+            run.segment_groups_iter(),
+            current_split.unwrap_or_else(|| run.len()),
+        )
+        .enumerate()
+        .skip(skip_count)
+        .filter(|&(i, _)| {
+            i - skip_count < take_count || (always_show_last_split && i + 1 == flattened_count)
+        }) {
+            let columns = if segment.kind
+                != FlattenedSegmentGroupItemKind::GroupHeader(SegmentGroupVisibility::Shown)
+            {
+                columns
                     .iter()
                     .map(|column| {
                         column_state(
                             column,
                             timer,
                             layout_settings,
-                            segment,
-                            i,
+                            segment.segment,
+                            segment.index,
                             current_split,
                             method,
                         )
                     })
-                    .collect();
+                    .collect()
+            } else {
+                Vec::new()
+            };
 
-                if let Some(icon_change) = icon_id.update_with(Some(segment.icon())) {
-                    icon_changes.push(IconChange {
-                        segment_index: i,
-                        icon: icon_change.to_owned(),
-                    });
-                }
+            if let Some(icon_change) =
+                self.icon_ids[segment.index].update_with(Some(segment.segment.icon()))
+            {
+                icon_changes.push(IconChange {
+                    segment_index: segment.index,
+                    icon: icon_change.to_owned(),
+                });
+            }
 
-                SplitState {
-                    name: segment.name().to_string(),
-                    columns,
-                    is_current_split: Some(i) == current_split,
-                    index: i,
-                }
-            })
-            .collect();
+            splits.push(SplitState {
+                name: segment.name.to_string(),
+                columns,
+                is_current_split: segment.in_focus,
+                is_subsplit: segment.kind == FlattenedSegmentGroupItemKind::Subsplit,
+                is_even: flattened_index % 2 == 0,
+                index: segment.index,
+            });
+        }
 
         if fill_with_blank_space && splits.len() < visual_split_count {
             let blank_split_count = visual_split_count - splits.len();
@@ -473,6 +508,8 @@ impl Component {
                     name: String::new(),
                     columns: Vec::new(),
                     is_current_split: false,
+                    is_subsplit: false,
+                    is_even: true,
                     index: (usize::max_value() ^ 1) - 2 * i,
                 });
             }
@@ -808,3 +845,63 @@ impl ColumnUpdateWith {
         }
     }
 }
+
+#[derive(Copy, Clone, PartialEq)]
+enum SegmentGroupVisibility {
+    Collapsed,
+    Shown,
+}
+
+#[derive(Copy, Clone, PartialEq)]
+enum FlattenedSegmentGroupItemKind {
+    GroupHeader(SegmentGroupVisibility),
+    Subsplit,
+}
+
+struct FlattenedSegmentGroupItem<'groups_or_segments, 'segments> {
+    segment: &'segments Segment,
+    name: &'groups_or_segments str,
+    index: usize,
+    kind: FlattenedSegmentGroupItemKind,
+    in_focus: bool,
+}
+
+fn flatten<'groups_or_segments, 'segments: 'groups_or_segments>(
+    iter: SegmentGroupsIter<'groups_or_segments, 'segments>,
+    focus_segment_index: usize,
+) -> impl Iterator<Item = FlattenedSegmentGroupItem<'groups_or_segments, 'segments>> {
+    iter.flat_map(move |group| {
+        let start_index = group.start_index();
+        let (children, visibility) =
+            if group.contains(focus_segment_index) && group.len() > 1 {
+                (
+                    Some(group.segments().iter().enumerate().map(
+                        move |(local_index, subsplit)| {
+                            let index = start_index + local_index;
+                            FlattenedSegmentGroupItem {
+                                segment: subsplit,
+                                name: subsplit.name(),
+                                index,
+                                kind: FlattenedSegmentGroupItemKind::Subsplit,
+                                in_focus: index == focus_segment_index,
+                            }
+                        },
+                    )),
+                    SegmentGroupVisibility::Shown,
+                )
+            } else {
+                (None, SegmentGroupVisibility::Collapsed)
+            };
+
+        let header_index = start_index + group.len() - 1;
+        iter::once(FlattenedSegmentGroupItem {
+            segment: group.ending_segment(),
+            name: group.name_or_default(),
+            index: header_index,
+            kind: FlattenedSegmentGroupItemKind::GroupHeader(visibility),
+            in_focus: visibility == SegmentGroupVisibility::Collapsed
+                && header_index == focus_segment_index,
+        })
+        .chain(children.into_iter().flatten())
+    })
+}

src/rendering/component/splits.rs

@@ -64,9 +64,11 @@ pub(in crate::rendering) fn render<B: Backend>(
     }
 
     let icon_size = split_height - 0.2;
-    let icon_right = if component.has_icons { 2.0 * MARGIN + icon_size } else { MARGIN };
 
     for (i, split) in component.splits.iter().enumerate() {
+        let icon_left = if split.is_subsplit { 2.5 * MARGIN } else { MARGIN };
+        let icon_right = if component.has_icons { icon_left + MARGIN + icon_size } else { icon_left };
+
         if component.show_thin_separators && i + 1 != component.splits.len() {
             context.render_rectangle(
                 [0.0, split_height - 0.05],
@@ -82,13 +84,13 @@ pub(in crate::rendering) fn render<B: Backend>(
                 &component.current_split_gradient,
             );
         } else if let Some((even, odd)) = &split_background {
-            let color = if split.index % 2 == 0 { even } else { odd };
+            let color = if split.is_even { even } else { odd };
             context.render_rectangle([0.0, 0.0], [width, split_height - 0.05], color);
         }
 
         {
             if let Some(Some(icon)) = split_icons.get(split.index) {
-                context.render_icon([MARGIN, 0.1 - 0.5 * 0.05], [icon_size, icon_size], icon);
+                context.render_icon([icon_left, 0.1 - 0.5 * 0.05], [icon_size, icon_size], icon);
             }
 
             let mut left_x = width - MARGIN;

src/rendering/software/tests.rs

@@ -123,7 +123,7 @@ fn subsplits_layout() {
     check_dims(
         &layout.state(&timer),
         [300, 800],
-        0xe94bafac,
+        0x8eaaddc,
         "subsplits_layout",
     );
 }

src/run/segment_groups.rs

@@ -57,18 +57,21 @@ impl SegmentGroups {
     }
 }
 
+#[derive(Debug)]
 pub struct SegmentGroupView<'group, 'segments> {
     name: Option<&'group str>,
     segments: &'segments [Segment],
     ending_segment: &'segments Segment,
+    start_index: usize,
+    end_index: usize,
 }
 
 impl<'group, 'segments> SegmentGroupView<'group, 'segments> {
-    pub fn group_name(&self) -> Option<&'group str> {
+    pub fn name(&self) -> Option<&'group str> {
         self.name
     }
 
-    pub fn group_name_or_default<'a>(&self) -> &'a str
+    pub fn name_or_default<'a>(&self) -> &'a str
     where
         'group: 'a,
         'segments: 'a,
@@ -84,6 +87,14 @@ impl<'group, 'segments> SegmentGroupView<'group, 'segments> {
         self.ending_segment
     }
 
+    pub fn start_index(&self) -> usize {
+        self.start_index
+    }
+
+    pub fn contains(&self, index: usize) -> bool {
+        index >= self.start_index && index < self.end_index
+    }
+
     pub fn len(&self) -> usize {
         self.segments.len()
     }
@@ -99,14 +110,20 @@ impl<'groups, 'segments> Iterator for SegmentGroupsIter<'groups, 'segments> {
     type Item = SegmentGroupView<'groups, 'segments>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let index = self.index;
-        if self.iter.peek().map_or(true, |group| group.start > index) {
+        let start_index = self.index;
+        if self
+            .iter
+            .peek()
+            .map_or(true, |group| group.start > start_index)
+        {
             self.index += 1;
-            let ending_segment = self.segments.get(index)?;
+            let ending_segment = self.segments.get(start_index)?;
             Some(SegmentGroupView {
                 name: None,
                 segments: slice::from_ref(ending_segment),
                 ending_segment,
+                start_index,
+                end_index: self.index,
             })
         } else {
             let group = self.iter.next()?;
@@ -116,6 +133,8 @@ impl<'groups, 'segments> Iterator for SegmentGroupsIter<'groups, 'segments> {
                 name: group.name.as_ref().map(String::as_str),
                 segments,
                 ending_segment: segments.last().unwrap(),
+                start_index,
+                end_index: self.index,
             })
         }
     }