1use crate::capabilities::foundation::theme::use_theme;
2use crate::capabilities::primitives::icon::Icon;
3use crate::capabilities::primitives::icon_source::IconSource;
4use gpui::{prelude::FluentBuilder as _, *};
5
6#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
7pub enum TimelineItemVariant {
8 #[default]
9 Default,
10 Success,
11 Warning,
12 Error,
13 Info,
14}
15
16impl TimelineItemVariant {
17 fn default_icon(&self) -> &'static str {
18 match self {
19 TimelineItemVariant::Default => "circle",
20 TimelineItemVariant::Success => "circle-check",
21 TimelineItemVariant::Warning => "triangle-alert",
22 TimelineItemVariant::Error => "circle-alert",
23 TimelineItemVariant::Info => "info",
24 }
25 }
26}
27
28#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
29pub enum TimelineOrientation {
30 #[default]
31 Vertical,
32 Horizontal,
33}
34
35#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
36pub enum TimelineSize {
37 Sm,
38 #[default]
39 Md,
40 Lg,
41}
42
43#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
44pub enum TimelineLayout {
45 #[default]
46 Left,
47 Right,
48 Center,
49}
50
51#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
52pub enum TimelineConnectorStyle {
53 #[default]
54 Solid,
55 Dashed,
56 None,
57}
58
59#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
60pub enum TimelineIndicatorStyle {
61 #[default]
62 Dot,
63 Icon,
64 Number,
65}
66
67#[derive(Copy, Clone, Debug, PartialEq, Eq)]
68pub enum TimelineItemPosition {
69 Left,
70 Right,
71}
72
73impl TimelineSize {
74 fn icon_size(&self) -> Pixels {
75 match self {
76 TimelineSize::Sm => px(14.0),
77 TimelineSize::Md => px(18.0),
78 TimelineSize::Lg => px(22.0),
79 }
80 }
81
82 fn dot_size(&self) -> Pixels {
83 match self {
84 TimelineSize::Sm => px(10.0),
85 TimelineSize::Md => px(14.0),
86 TimelineSize::Lg => px(18.0),
87 }
88 }
89
90 fn number_size(&self) -> Pixels {
91 match self {
92 TimelineSize::Sm => px(20.0),
93 TimelineSize::Md => px(26.0),
94 TimelineSize::Lg => px(32.0),
95 }
96 }
97
98 fn connector_width(&self) -> Pixels {
99 match self {
100 TimelineSize::Sm => px(2.0),
101 TimelineSize::Md => px(2.0),
102 TimelineSize::Lg => px(3.0),
103 }
104 }
105
106 fn title_size(&self) -> f32 {
107 match self {
108 TimelineSize::Sm => 13.0,
109 TimelineSize::Md => 14.0,
110 TimelineSize::Lg => 16.0,
111 }
112 }
113
114 fn description_size(&self) -> f32 {
115 match self {
116 TimelineSize::Sm => 12.0,
117 TimelineSize::Md => 13.0,
118 TimelineSize::Lg => 14.0,
119 }
120 }
121
122 fn spacing(&self) -> Pixels {
123 match self {
124 TimelineSize::Sm => px(12.0),
125 TimelineSize::Md => px(16.0),
126 TimelineSize::Lg => px(20.0),
127 }
128 }
129
130 fn item_gap(&self) -> Pixels {
131 match self {
132 TimelineSize::Sm => px(20.0),
133 TimelineSize::Md => px(28.0),
134 TimelineSize::Lg => px(36.0),
135 }
136 }
137}
138
139#[derive(Clone)]
140pub struct TimelineItem {
141 pub title: SharedString,
142 pub description: Option<SharedString>,
143 pub timestamp: Option<SharedString>,
144 pub icon: Option<IconSource>,
145 pub variant: TimelineItemVariant,
146 pub position: Option<TimelineItemPosition>,
147}
148
149impl TimelineItem {
150 pub fn new(title: impl Into<SharedString>) -> Self {
151 Self {
152 title: title.into(),
153 description: None,
154 timestamp: None,
155 icon: None,
156 variant: TimelineItemVariant::default(),
157 position: None,
158 }
159 }
160
161 pub fn description(mut self, desc: impl Into<SharedString>) -> Self {
162 self.description = Some(desc.into());
163 self
164 }
165
166 pub fn timestamp(mut self, ts: impl Into<SharedString>) -> Self {
167 self.timestamp = Some(ts.into());
168 self
169 }
170
171 pub fn icon(mut self, icon: impl Into<IconSource>) -> Self {
172 self.icon = Some(icon.into());
173 self
174 }
175
176 pub fn variant(mut self, variant: TimelineItemVariant) -> Self {
177 self.variant = variant;
178 self
179 }
180
181 pub fn success(mut self) -> Self {
182 self.variant = TimelineItemVariant::Success;
183 self
184 }
185
186 pub fn warning(mut self) -> Self {
187 self.variant = TimelineItemVariant::Warning;
188 self
189 }
190
191 pub fn error(mut self) -> Self {
192 self.variant = TimelineItemVariant::Error;
193 self
194 }
195
196 pub fn info(mut self) -> Self {
197 self.variant = TimelineItemVariant::Info;
198 self
199 }
200
201 pub fn position(mut self, position: TimelineItemPosition) -> Self {
202 self.position = Some(position);
203 self
204 }
205
206 pub fn left(mut self) -> Self {
207 self.position = Some(TimelineItemPosition::Left);
208 self
209 }
210
211 pub fn right(mut self) -> Self {
212 self.position = Some(TimelineItemPosition::Right);
213 self
214 }
215
216 fn get_color(&self, theme: &crate::capabilities::foundation::theme::Theme) -> Hsla {
217 match self.variant {
218 TimelineItemVariant::Default => theme.tokens.muted_foreground,
219 TimelineItemVariant::Success => rgb(0x22c55e).into(),
220 TimelineItemVariant::Warning => rgb(0xf59e0b).into(),
221 TimelineItemVariant::Error => theme.tokens.destructive,
222 TimelineItemVariant::Info => theme.tokens.primary,
223 }
224 }
225}
226
227#[derive(IntoElement)]
228pub struct Timeline {
229 items: Vec<TimelineItem>,
230 orientation: TimelineOrientation,
231 size: TimelineSize,
232 layout: TimelineLayout,
233 alternating: bool,
234 indicator_style: TimelineIndicatorStyle,
235 connector_style: TimelineConnectorStyle,
236 connector_color: Option<Hsla>,
237 content_width: Option<Pixels>,
238 style: StyleRefinement,
239}
240
241impl Timeline {
242 pub fn new(items: Vec<TimelineItem>) -> Self {
243 Self {
244 items,
245 orientation: TimelineOrientation::default(),
246 size: TimelineSize::default(),
247 layout: TimelineLayout::default(),
248 alternating: false,
249 indicator_style: TimelineIndicatorStyle::default(),
250 connector_style: TimelineConnectorStyle::default(),
251 connector_color: None,
252 content_width: None,
253 style: StyleRefinement::default(),
254 }
255 }
256
257 pub fn vertical(items: Vec<TimelineItem>) -> Self {
258 Self::new(items).orientation(TimelineOrientation::Vertical)
259 }
260
261 pub fn horizontal(items: Vec<TimelineItem>) -> Self {
262 Self::new(items).orientation(TimelineOrientation::Horizontal)
263 }
264
265 pub fn orientation(mut self, orientation: TimelineOrientation) -> Self {
266 self.orientation = orientation;
267 self
268 }
269
270 pub fn size(mut self, size: TimelineSize) -> Self {
271 self.size = size;
272 self
273 }
274
275 pub fn sm(mut self) -> Self {
276 self.size = TimelineSize::Sm;
277 self
278 }
279
280 pub fn md(mut self) -> Self {
281 self.size = TimelineSize::Md;
282 self
283 }
284
285 pub fn lg(mut self) -> Self {
286 self.size = TimelineSize::Lg;
287 self
288 }
289
290 pub fn layout(mut self, layout: TimelineLayout) -> Self {
291 self.layout = layout;
292 self
293 }
294
295 pub fn left_layout(mut self) -> Self {
296 self.layout = TimelineLayout::Left;
297 self
298 }
299
300 pub fn right_layout(mut self) -> Self {
301 self.layout = TimelineLayout::Right;
302 self
303 }
304
305 pub fn center_layout(mut self) -> Self {
306 self.layout = TimelineLayout::Center;
307 self
308 }
309
310 pub fn alternating(mut self, alternating: bool) -> Self {
311 self.alternating = alternating;
312 if alternating {
313 self.layout = TimelineLayout::Center;
314 }
315 self
316 }
317
318 pub fn indicator_style(mut self, style: TimelineIndicatorStyle) -> Self {
319 self.indicator_style = style;
320 self
321 }
322
323 pub fn dot_indicators(mut self) -> Self {
324 self.indicator_style = TimelineIndicatorStyle::Dot;
325 self
326 }
327
328 pub fn icon_indicators(mut self) -> Self {
329 self.indicator_style = TimelineIndicatorStyle::Icon;
330 self
331 }
332
333 pub fn number_indicators(mut self) -> Self {
334 self.indicator_style = TimelineIndicatorStyle::Number;
335 self
336 }
337
338 pub fn connector_style(mut self, style: TimelineConnectorStyle) -> Self {
339 self.connector_style = style;
340 self
341 }
342
343 pub fn solid_connector(mut self) -> Self {
344 self.connector_style = TimelineConnectorStyle::Solid;
345 self
346 }
347
348 pub fn dashed_connector(mut self) -> Self {
349 self.connector_style = TimelineConnectorStyle::Dashed;
350 self
351 }
352
353 pub fn no_connector(mut self) -> Self {
354 self.connector_style = TimelineConnectorStyle::None;
355 self
356 }
357
358 pub fn connector_color(mut self, color: Hsla) -> Self {
359 self.connector_color = Some(color);
360 self
361 }
362
363 pub fn content_width(mut self, width: Pixels) -> Self {
364 self.content_width = Some(width);
365 self
366 }
367
368 #[deprecated(note = "Use indicator_style(TimelineIndicatorStyle::Icon) instead")]
369 pub fn show_icons(mut self, show: bool) -> Self {
370 if show {
371 self.indicator_style = TimelineIndicatorStyle::Icon;
372 }
373 self
374 }
375}
376
377impl Timeline {
378 fn render_indicator(
379 &self,
380 item: &TimelineItem,
381 index: usize,
382 theme: &crate::capabilities::foundation::theme::Theme,
383 ) -> AnyElement {
384 let item_color = item.get_color(theme);
385 let size = self.size;
386
387 match self.indicator_style {
388 TimelineIndicatorStyle::Dot => div()
389 .size(size.dot_size())
390 .rounded_full()
391 .bg(item_color)
392 .flex_shrink_0()
393 .into_any_element(),
394
395 TimelineIndicatorStyle::Icon => {
396 let icon_source = item
397 .icon
398 .clone()
399 .unwrap_or_else(|| IconSource::Named(item.variant.default_icon().into()));
400 div()
401 .flex()
402 .items_center()
403 .justify_center()
404 .size(size.icon_size() + px(10.0))
405 .rounded_full()
406 .bg(item_color.opacity(0.15))
407 .border_2()
408 .border_color(item_color)
409 .flex_shrink_0()
410 .child(
411 Icon::new(icon_source)
412 .size(size.icon_size())
413 .color(item_color),
414 )
415 .into_any_element()
416 }
417
418 TimelineIndicatorStyle::Number => div()
419 .flex()
420 .items_center()
421 .justify_center()
422 .size(size.number_size())
423 .rounded_full()
424 .bg(item_color)
425 .flex_shrink_0()
426 .text_size(px(size.title_size() - 2.0))
427 .font_weight(FontWeight::SEMIBOLD)
428 .text_color(theme.tokens.background)
429 .child(format!("{}", index + 1))
430 .into_any_element(),
431 }
432 }
433
434 fn render_connector(
435 &self,
436 theme: &crate::capabilities::foundation::theme::Theme,
437 length: Pixels,
438 ) -> Option<AnyElement> {
439 if self.connector_style == TimelineConnectorStyle::None {
440 return None;
441 }
442
443 let color = self.connector_color.unwrap_or(theme.tokens.border);
444 let width = self.size.connector_width();
445
446 let connector = match self.connector_style {
447 TimelineConnectorStyle::Solid => div().w(width).h(length).bg(color).into_any_element(),
448 TimelineConnectorStyle::Dashed => {
449 let num_dashes = ((length / px(8.0)) as usize).max(1);
450 div()
451 .w(width)
452 .h(length)
453 .flex()
454 .flex_col()
455 .gap(px(4.0))
456 .overflow_hidden()
457 .children(
458 (0..num_dashes)
459 .map(|_| div().w(width).h(px(4.0)).bg(color).into_any_element()),
460 )
461 .into_any_element()
462 }
463 TimelineConnectorStyle::None => return None,
464 };
465
466 Some(connector)
467 }
468
469 fn render_content(
470 &self,
471 item: &TimelineItem,
472 theme: &crate::capabilities::foundation::theme::Theme,
473 align_right: bool,
474 ) -> AnyElement {
475 let size = self.size;
476
477 div()
478 .flex()
479 .flex_col()
480 .gap(px(4.0))
481 .when(align_right, |d| d.items_end())
482 .when_some(self.content_width, |d, w| d.w(w))
483 .child(
484 div()
485 .flex()
486 .flex_col()
487 .gap(px(2.0))
488 .when(align_right, |d| d.items_end())
489 .child(
490 div()
491 .text_size(px(size.title_size()))
492 .font_weight(FontWeight::MEDIUM)
493 .text_color(theme.tokens.foreground)
494 .when(align_right, |d| d.text_align(TextAlign::Right))
495 .child(item.title.clone()),
496 )
497 .when_some(item.timestamp.clone(), |d, ts| {
498 d.child(
499 div()
500 .text_size(px(size.description_size() - 1.0))
501 .text_color(theme.tokens.muted_foreground)
502 .when(align_right, |d| d.text_align(TextAlign::Right))
503 .child(ts),
504 )
505 }),
506 )
507 .when_some(item.description.clone(), |d, desc| {
508 d.child(
509 div()
510 .text_size(px(size.description_size()))
511 .text_color(theme.tokens.muted_foreground)
512 .when(align_right, |d| d.text_align(TextAlign::Right))
513 .child(desc),
514 )
515 })
516 .into_any_element()
517 }
518
519 fn render_vertical_left_item(
520 &self,
521 item: &TimelineItem,
522 index: usize,
523 is_last: bool,
524 theme: &crate::capabilities::foundation::theme::Theme,
525 ) -> AnyElement {
526 let indicator = self.render_indicator(item, index, theme);
527 let connector = if !is_last {
528 self.render_connector(theme, self.size.item_gap())
529 } else {
530 None
531 };
532 let content = self.render_content(item, theme, false);
533
534 div()
535 .flex()
536 .gap(self.size.spacing())
537 .child(
538 div()
539 .flex()
540 .flex_col()
541 .items_center()
542 .child(indicator)
543 .when_some(connector, |d, c| d.child(c)),
544 )
545 .child(
546 div()
547 .flex_1()
548 .pb(if is_last {
549 px(0.0)
550 } else {
551 self.size.item_gap()
552 })
553 .child(content),
554 )
555 .into_any_element()
556 }
557
558 fn render_vertical_right_item(
559 &self,
560 item: &TimelineItem,
561 index: usize,
562 is_last: bool,
563 theme: &crate::capabilities::foundation::theme::Theme,
564 ) -> AnyElement {
565 let indicator = self.render_indicator(item, index, theme);
566 let connector = if !is_last {
567 self.render_connector(theme, self.size.item_gap())
568 } else {
569 None
570 };
571 let content = self.render_content(item, theme, true);
572
573 div()
574 .flex()
575 .flex_row_reverse()
576 .gap(self.size.spacing())
577 .child(
578 div()
579 .flex()
580 .flex_col()
581 .items_center()
582 .child(indicator)
583 .when_some(connector, |d, c| d.child(c)),
584 )
585 .child(
586 div()
587 .flex_1()
588 .pb(if is_last {
589 px(0.0)
590 } else {
591 self.size.item_gap()
592 })
593 .child(content),
594 )
595 .into_any_element()
596 }
597
598 fn render_vertical_center_item(
599 &self,
600 item: &TimelineItem,
601 index: usize,
602 is_last: bool,
603 theme: &crate::capabilities::foundation::theme::Theme,
604 on_left: bool,
605 ) -> AnyElement {
606 let indicator = self.render_indicator(item, index, theme);
607 let connector = if !is_last {
608 self.render_connector(theme, self.size.item_gap())
609 } else {
610 None
611 };
612 let left_content = if on_left {
613 Some(self.render_content(item, theme, true))
614 } else {
615 None
616 };
617
618 let right_content = if on_left {
619 None
620 } else {
621 Some(self.render_content(item, theme, false))
622 };
623
624 div()
625 .flex()
626 .w_full()
627 .child(
628 div()
629 .flex_1()
630 .flex()
631 .justify_end()
632 .pr(self.size.spacing())
633 .when_some(left_content, |d, c| d.child(c)),
634 )
635 .child(
636 div()
637 .flex()
638 .flex_col()
639 .items_center()
640 .child(indicator)
641 .when_some(connector, |d, c| d.child(c)),
642 )
643 .child(
644 div()
645 .flex_1()
646 .pl(self.size.spacing())
647 .pb(if is_last {
648 px(0.0)
649 } else {
650 self.size.item_gap()
651 })
652 .when_some(right_content, |d, c| d.child(c)),
653 )
654 .into_any_element()
655 }
656
657 fn render_horizontal_item(
658 &self,
659 item: &TimelineItem,
660 index: usize,
661 is_last: bool,
662 theme: &crate::capabilities::foundation::theme::Theme,
663 ) -> AnyElement {
664 let indicator = self.render_indicator(item, index, theme);
665 let content = div()
666 .flex()
667 .flex_col()
668 .items_center()
669 .gap(px(4.0))
670 .max_w(px(120.0))
671 .child(
672 div()
673 .text_size(px(self.size.title_size()))
674 .font_weight(FontWeight::MEDIUM)
675 .text_color(theme.tokens.foreground)
676 .text_center()
677 .child(item.title.clone()),
678 )
679 .when_some(item.timestamp.clone(), |d, ts| {
680 d.child(
681 div()
682 .text_size(px(self.size.description_size() - 1.0))
683 .text_color(theme.tokens.muted_foreground)
684 .text_center()
685 .child(ts),
686 )
687 })
688 .when_some(item.description.clone(), |d, desc| {
689 d.child(
690 div()
691 .text_size(px(self.size.description_size()))
692 .text_color(theme.tokens.muted_foreground)
693 .text_center()
694 .child(desc),
695 )
696 });
697
698 let connector = if !is_last {
699 self.render_connector(theme, self.size.item_gap()).map(|_| {
700 div()
701 .h(self.size.connector_width())
702 .w(self.size.item_gap())
703 .bg(self.connector_color.unwrap_or(theme.tokens.border))
704 .into_any_element()
705 })
706 } else {
707 None
708 };
709
710 div()
711 .flex()
712 .flex_col()
713 .items_center()
714 .gap(self.size.spacing())
715 .child(content)
716 .child(
717 div()
718 .flex()
719 .items_center()
720 .child(indicator)
721 .when_some(connector, |d, c| d.child(c)),
722 )
723 .into_any_element()
724 }
725}
726
727impl Styled for Timeline {
728 fn style(&mut self) -> &mut StyleRefinement {
729 &mut self.style
730 }
731}
732
733impl RenderOnce for Timeline {
734 fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
735 let theme = use_theme(cx);
736 let items = self.items.clone();
737 let items_len = items.len();
738 let user_style = self.style.clone();
739
740 let container = match self.orientation {
741 TimelineOrientation::Vertical => div().flex().flex_col().w_full(),
742 TimelineOrientation::Horizontal => div().flex().flex_row().items_start(),
743 };
744
745 container
746 .children(items.iter().enumerate().map(|(i, item)| {
747 let is_last = i == items_len - 1;
748
749 match self.orientation {
750 TimelineOrientation::Vertical => {
751 let item_position = item.position.unwrap_or({
752 if self.alternating {
753 if i % 2 == 0 {
754 TimelineItemPosition::Left
755 } else {
756 TimelineItemPosition::Right
757 }
758 } else {
759 TimelineItemPosition::Left
760 }
761 });
762
763 match self.layout {
764 TimelineLayout::Left => {
765 self.render_vertical_left_item(item, i, is_last, &theme)
766 }
767 TimelineLayout::Right => {
768 self.render_vertical_right_item(item, i, is_last, &theme)
769 }
770 TimelineLayout::Center => {
771 let on_left = item_position == TimelineItemPosition::Left;
772 self.render_vertical_center_item(item, i, is_last, &theme, on_left)
773 }
774 }
775 }
776 TimelineOrientation::Horizontal => {
777 self.render_horizontal_item(item, i, is_last, &theme)
778 }
779 }
780 }))
781 .map(|this| {
782 let mut div = this;
783 div.style().refine(&user_style);
784 div
785 })
786 }
787}
788
789pub fn timeline(items: Vec<TimelineItem>) -> Timeline {
790 Timeline::new(items)
791}