orbital_scheduler/timeline/engine/
event_layout.rs1use orbital_base_components::{DatetimeTimezone, OrbitalDateTime, ToUnixSeconds};
4
5use crate::timeline::engine::TimelineVisibleRange;
6use crate::PlannedEvent;
7
8pub const MIN_EVENT_WIDTH_PCT: f64 = 0.5;
10
11#[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
28pub 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
37pub 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
81pub 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}