Expand items to approximately one pixel, without overlapping neighboring items.

Author: elliottslaughter

src/app.rs

@@ -677,6 +677,9 @@ impl Slot {
             return hover_pos;
         }
 
+        // Figure out roughly how large a pixel is on the screen.
+        let pixel_ns = (cx.view_interval.duration_ns() as f32 / rect.width()) as i64;
+
         // Track which item, if any, we're interacting with
         let mut interact_item = None;
 
@@ -709,11 +712,27 @@ impl Slot {
                     continue;
                 }
 
+                // Expand interval to use at least one pixel, but do NOT
+                // overlap neighboring items.
+                let mut interval = item.interval;
+                if interval.duration_ns() < pixel_ns {
+                    let expand_ns = (pixel_ns - interval.duration_ns()) / 2;
+                    interval = interval.grow(expand_ns);
+                    if item_idx > 0 {
+                        let last_item = &row_items[item_idx - 1];
+                        interval = interval.subtract_before(last_item.interval.stop);
+                    }
+                    if item_idx < row_items.len() - 1 {
+                        let next_item = &row_items[item_idx + 1];
+                        interval = interval.subtract_after(next_item.interval.start);
+                    }
+                }
+
                 // Note: the interval is EXCLUSIVE. This turns out to be what
                 // we want here, because in screen coordinates interval.stop
                 // is the BEGINNING of the interval.stop nanosecond.
-                let start = cx.view_interval.unlerp(item.interval.start).at_least(0.0);
-                let stop = cx.view_interval.unlerp(item.interval.stop).at_most(1.0);
+                let start = cx.view_interval.unlerp(interval.start).at_least(0.0);
+                let stop = cx.view_interval.unlerp(interval.stop).at_most(1.0);
                 let min = rect.lerp_inside(Vec2::new(start, (irow as f32 + 0.05) / rows as f32));
                 let max = rect.lerp_inside(Vec2::new(stop, (irow as f32 + 0.95) / rows as f32));
 

src/timestamp.rs

@@ -103,14 +103,26 @@ impl Interval {
     }
     pub fn intersection(self, other: Interval) -> Self {
         Self {
-            start: Timestamp(self.start.0.max(other.start.0)),
-            stop: Timestamp(self.stop.0.min(other.stop.0)),
+            start: self.start.max(other.start),
+            stop: self.stop.min(other.stop),
         }
     }
     pub fn union(self, other: Interval) -> Self {
         Self {
-            start: Timestamp(self.start.0.min(other.start.0)),
-            stop: Timestamp(self.stop.0.max(other.stop.0)),
+            start: self.start.min(other.start),
+            stop: self.stop.max(other.stop),
+        }
+    }
+    pub fn subtract_before(self, point: Timestamp) -> Self {
+        Self {
+            start: self.start.max(point),
+            stop: self.stop.max(point),
+        }
+    }
+    pub fn subtract_after(self, point: Timestamp) -> Self {
+        Self {
+            start: self.start.min(point),
+            stop: self.stop.min(point),
         }
     }
     // Convert a timestamp into [0,1] relative space
@@ -488,6 +500,46 @@ mod tests {
             assert_eq!(i1.union(i0), Interval::new(Timestamp(0), Timestamp(15)));
         }
 
+        #[test]
+        fn test_subtract_before() {
+            let p0 = Timestamp(0);
+            let p1 = Timestamp(10);
+            let p2 = Timestamp(20);
+            let i0 = Interval::new(Timestamp(5), Timestamp(15));
+            assert_eq!(
+                i0.subtract_before(p0),
+                Interval::new(Timestamp(5), Timestamp(15))
+            );
+            assert_eq!(
+                i0.subtract_before(p1),
+                Interval::new(Timestamp(10), Timestamp(15))
+            );
+            assert_eq!(
+                i0.subtract_before(p2),
+                Interval::new(Timestamp(20), Timestamp(20))
+            );
+        }
+
+        #[test]
+        fn test_subtract_after() {
+            let p0 = Timestamp(0);
+            let p1 = Timestamp(10);
+            let p2 = Timestamp(20);
+            let i0 = Interval::new(Timestamp(5), Timestamp(15));
+            assert_eq!(
+                i0.subtract_after(p0),
+                Interval::new(Timestamp(0), Timestamp(0))
+            );
+            assert_eq!(
+                i0.subtract_after(p1),
+                Interval::new(Timestamp(5), Timestamp(10))
+            );
+            assert_eq!(
+                i0.subtract_after(p2),
+                Interval::new(Timestamp(5), Timestamp(15))
+            );
+        }
+
         #[test]
         fn test_grow() {
             let i0 = Interval::new(Timestamp(5), Timestamp(10));