Skip to main content

orbital_scheduler/timeline/engine/
event_layout.rs

1//! Horizontal event positioning math for timeline lanes.
2
3use orbital_base_components::{DatetimeTimezone, OrbitalDateTime, ToUnixSeconds};
4
5use crate::timeline::engine::TimelineVisibleRange;
6use crate::PlannedEvent;
7
8/// Minimum visible block width as a percentage of the visible range.
9pub const MIN_EVENT_WIDTH_PCT: f64 = 0.5;
10
11/// Percentage-based layout rect within a timeline lane.
12#[derive(Clone, Copy, Debug, PartialEq)]
13pub struct TimelineEventLayoutRect {
14    pub left_pct: f64,
15    pub width_pct: f64,
16}
17
18fn rezone(dt: OrbitalDateTime, display_tz: DatetimeTimezone) -> OrbitalDateTime {
19    OrbitalDateTime::from_instant(dt.instant(), display_tz)
20}
21
22fn span_seconds(range: &TimelineVisibleRange) -> f64 {
23    let start = range.range_start.to_unix_seconds();
24    let end = range.range_end.to_unix_seconds();
25    (end - start).max(1) as f64
26}
27
28/// Whether the event intersects the visible timeline range in `display_tz`.
29pub fn event_overlaps_range(
30    event: &PlannedEvent,
31    range: &TimelineVisibleRange,
32    display_tz: DatetimeTimezone,
33) -> bool {
34    event_layout_in_range(event, range, display_tz).is_some()
35}
36
37/// Wall-clock start/end in `display_tz`, clipped to the visible range, as percentage rect.
38pub fn event_layout_in_range(
39    event: &PlannedEvent,
40    range: &TimelineVisibleRange,
41    display_tz: DatetimeTimezone,
42) -> Option<TimelineEventLayoutRect> {
43    let start = rezone(event.start, display_tz);
44    let end = rezone(event.end, display_tz);
45
46    if end <= range.range_start || start > range.range_end {
47        return None;
48    }
49
50    let clip_start = if start < range.range_start {
51        range.range_start
52    } else {
53        start
54    };
55    let clip_end = if end > range.range_end {
56        range.range_end
57    } else {
58        end
59    };
60
61    let span = span_seconds(range);
62    let offset = (clip_start.to_unix_seconds() - range.range_start.to_unix_seconds()) as f64;
63    let duration = (clip_end.to_unix_seconds() - clip_start.to_unix_seconds()).max(0) as f64;
64
65    let mut left_pct = (offset / span) * 100.0;
66    let mut width_pct = (duration / span * 100.0).max(MIN_EVENT_WIDTH_PCT);
67
68    if left_pct + width_pct > 100.0 {
69        width_pct = (100.0 - left_pct).max(MIN_EVENT_WIDTH_PCT);
70    }
71    if left_pct + width_pct > 100.0 {
72        left_pct = (100.0 - width_pct).max(0.0);
73    }
74
75    Some(TimelineEventLayoutRect {
76        left_pct,
77        width_pct,
78    })
79}
80
81/// Events assigned to a resource lane within the visible range.
82pub fn events_for_lane<'a>(
83    events: &'a [PlannedEvent],
84    resource_id: &str,
85    range: &TimelineVisibleRange,
86    display_tz: DatetimeTimezone,
87) -> Vec<&'a PlannedEvent> {
88    events
89        .iter()
90        .filter(|event| {
91            event.resource_id.as_deref() == Some(resource_id)
92                && event_overlaps_range(event, range, display_tz)
93        })
94        .collect()
95}
96
97#[cfg(test)]
98mod tests {
99    use super::*;
100    use orbital_base_components::TryFromUnixSeconds;
101
102    fn anchor() -> OrbitalDateTime {
103        OrbitalDateTime::try_from_unix_seconds(1_735_689_600_i64, DatetimeTimezone::Utc)
104            .expect("valid")
105            .start_of_day()
106    }
107
108    fn event_at(start_hms: (u32, u32, u32), end_hms: (u32, u32, u32)) -> PlannedEvent {
109        let base = anchor();
110        let start = base
111            .apply_hms(start_hms.0, start_hms.1, start_hms.2)
112            .expect("start");
113        let end = base
114            .apply_hms(end_hms.0, end_hms.1, end_hms.2)
115            .expect("end");
116        let mut event = PlannedEvent::new("evt", "Test", start, end);
117        event.resource_id = Some("room-a".into());
118        event
119    }
120
121    #[test]
122    fn nine_to_ten_am_layout_on_day_preset() {
123        let range = super::super::visible_range::timeline_visible_range(
124            anchor(),
125            crate::TimelinePreset::Day,
126            DatetimeTimezone::Utc,
127            true,
128        )
129        .expect("range");
130        let event = event_at((9, 0, 0), (10, 0, 0));
131        let rect = event_layout_in_range(&event, &range, DatetimeTimezone::Utc).expect("layout");
132        assert!(rect.left_pct > 0.0);
133        assert!(rect.width_pct > 0.0);
134    }
135
136    #[test]
137    fn zero_duration_uses_min_width() {
138        let range = super::super::visible_range::timeline_visible_range(
139            anchor(),
140            crate::TimelinePreset::Day,
141            DatetimeTimezone::Utc,
142            true,
143        )
144        .expect("range");
145        let event = event_at((9, 0, 0), (9, 0, 0));
146        let rect = event_layout_in_range(&event, &range, DatetimeTimezone::Utc).expect("layout");
147        assert!((rect.width_pct - MIN_EVENT_WIDTH_PCT).abs() < 0.01);
148    }
149}