Add basic functionality to operation state timeline

Author: hansruebb

gui/src/backend.rs

@@ -166,36 +166,7 @@ pub trait ReplayableBackendVariant: BackendVariant {
     }
 
     fn skip_to_next_flightmode(&mut self, _reverse: bool) {
-        //let fm: Option<FlightMode> = self.data_store().current_enum_value(Metric::FlightMode, self.end());
-
-        //let Some(end) = self.end() else {
-        //    return;
-        //};
-
-        //let i = self.all_vehicle_states().partition_point(|(t, _)| *t <= end);
-
-        //let next_flightmode = if reverse {
-        //    self.all_vehicle_states()[..i]
-        //        .iter()
-        //        .rev()
-        //        .filter(|(_t, vs)| vs.mode.is_some() && vs.mode != fm)
-        //        .map(|(t, _)| t)
-        //        .next()
-        //} else {
-        //    self.all_vehicle_states()[i..]
-        //        .iter()
-        //        .filter(|(_t, vs)| vs.mode.is_some() && vs.mode != fm)
-        //        .map(|(t, _)| t)
-        //        .next()
-        //};
-
-        //if let Some(inst) = next_flightmode {
-        //    let playing = self.playing();
-        //    *self.playback_state_mut() = Some(PlaybackState::Paused(*inst));
-        //    if playing {
-        //        self.playpause();
-        //    }
-        //}
+        println!("Skipping FlightMode currently not supported!");
     }
 
     fn playback_ui(&mut self, ui: &mut egui::Ui) {

gui/src/frontend.rs

@@ -1,19 +1,38 @@
 use crate::{
     frontend::{metric_monitor::MetricMonitor, popup_manager::PopupManager},
     settings::AppSettings,
-    widgets::{map::MapState, plot::SharedPlotState},
+    widgets::{
+        map::MapState,
+        plot::SharedPlotState,
+        time_line::{HyacinthAnomalousState, HyacinthNominalState},
+    },
 };
 
 pub mod metric_monitor;
 pub mod popup_manager;
 //TODO Hans: Probably should not be here
 pub mod constraints;
 
+struct HyacinthState {
+    nominal: HyacinthNominalState,
+    anomalous: Option<HyacinthAnomalousState>,
+}
+
+impl Default for HyacinthState {
+    fn default() -> Self {
+        Self {
+            nominal: HyacinthNominalState::IdleActive,
+            anomalous: None,
+        }
+    }
+}
+
 pub struct Frontend {
     popup_manager: PopupManager,
     metric_monitor: MetricMonitor,
     map: MapState,
     shared_plot: SharedPlotState,
+    hyacinth_state: HyacinthState,
 }
 
 impl Frontend {
@@ -24,6 +43,7 @@ impl Frontend {
             metric_monitor: Default::default(),
             map: MapState::new(ctx, mapbox_token),
             shared_plot: SharedPlotState::new(),
+            hyacinth_state: Default::default(),
         };
     }
 
@@ -58,4 +78,20 @@ impl Frontend {
     pub fn shared_plot_mut(&mut self) -> &mut SharedPlotState {
         return &mut self.shared_plot;
     }
+
+    pub fn hyacinth_nominal_state(&self) -> HyacinthNominalState {
+        return self.hyacinth_state.nominal;
+    }
+
+    pub fn hyacinth_anomolous_state(&self) -> Option<HyacinthAnomalousState> {
+        return self.hyacinth_state.anomalous;
+    }
+
+    pub fn set_hyacinth_nominal_state(&mut self, state: HyacinthNominalState) {
+        return self.hyacinth_state.nominal = state;
+    }
+
+    pub fn set_hyacinth_anomalous_state(&mut self, state: Option<HyacinthAnomalousState>) {
+        return self.hyacinth_state.anomalous = state;
+    }
 }

gui/src/frontend/popup_manager.rs

@@ -169,18 +169,31 @@ impl TriggerBuilder<()> {
             popups: Default::default(),
         };
     }
+
+    pub fn add_all<Contents: PopupContentList>(
+        self,
+        popups: Contents,
+        position: Pos2,
+    ) -> TriggerBuilder<Contents::AsPopupList> {
+        return TriggerBuilder {
+            id: self.id,
+            bounding_box: self.bounding_box,
+            popups: popups.position(position),
+        };
+    }
 }
 
 impl<L: PopupList> TriggerBuilder<L> {
-    pub fn add<K, F>(self, position: Pos2, add_contents: F) -> TriggerBuilder<(PrimedPopup<K, F>, L)>
+    pub fn add<C /*, K, F*/>(self, position: Pos2, contents: C) -> TriggerBuilder<(PositionedPopup<C>, L)>
     where
-        K: PopupKind + NotInPopupList<L>,
-        F: FnOnce(&mut egui::Ui, &mut Frontend, &mut Backend) -> <K as PopupKind>::Response,
+        //K: PopupKind + NotInPopupList<L>,
+        //F: FnOnce(&mut egui::Ui, &mut Frontend, &mut Backend) -> <K as PopupKind>::Response,
+        C: PopupContents, //<Kind = K, Contents = F>,
     {
         return TriggerBuilder {
             id: self.id,
             bounding_box: self.bounding_box,
-            popups: self.popups.add(PrimedPopup::new(position, add_contents)),
+            popups: self.popups.add(PositionedPopup::new(position, contents)),
         };
     }
 
@@ -200,29 +213,81 @@ impl<L: PopupList> TriggerBuilder<L> {
     }
 }
 
-pub struct PrimedPopup<K, F>
+pub trait PopupContentList: Sized + Clone {
+    type AsPopupList: PopupList;
+    fn add<C: PopupContents>(self, contents: C) -> (Self, C) {
+        return (self, contents);
+    }
+
+    fn position(self, position: Pos2) -> Self::AsPopupList;
+}
+impl PopupContentList for () {
+    type AsPopupList = ();
+    fn position(self, _position: Pos2) -> Self::AsPopupList {}
+}
+impl<H, T> PopupContentList for (H, T)
+where
+    H: PopupContents,
+    T: PopupContentList,
+{
+    type AsPopupList = (PositionedPopup<H>, T::AsPopupList);
+    fn position(self, position: Pos2) -> Self::AsPopupList {
+        return (PositionedPopup::new(position, self.0), self.1.position(position));
+    }
+}
+
+pub trait PopupContents: Clone {
+    type Kind: PopupKind;
+    type Contents: FnOnce(&mut egui::Ui, &mut Frontend, &mut Backend) -> <Self::Kind as PopupKind>::Response;
+    fn contents(self) -> Self::Contents;
+}
+
+impl<K, F> PopupContents for PopupContentData<K, F>
+where
+    K: PopupKind,
+    F: FnOnce(&mut egui::Ui, &mut Frontend, &mut Backend) -> <K as PopupKind>::Response + Clone,
+{
+    type Kind = K;
+    type Contents = F;
+
+    fn contents(self) -> Self::Contents {
+        return self.add_contents;
+    }
+}
+
+#[derive(Clone)]
+pub struct PopupContentData<K, F>
 where
     K: PopupKind,
     F: FnOnce(&mut egui::Ui, &mut Frontend, &mut Backend) -> <K as PopupKind>::Response,
 {
     popup_kind: PhantomData<K>,
-    position: Pos2,
     add_contents: F,
 }
-impl<K, F> PrimedPopup<K, F>
+
+impl<K, F> PopupContentData<K, F>
 where
     K: PopupKind,
     F: FnOnce(&mut egui::Ui, &mut Frontend, &mut Backend) -> <K as PopupKind>::Response,
 {
-    pub fn new(position: Pos2, add_contents: F) -> Self {
+    pub fn new(add_contents: F) -> Self {
         Self {
-            position,
             add_contents,
             popup_kind: PhantomData,
         }
     }
 }
 
+pub struct PositionedPopup<Contents: PopupContents> {
+    position: Pos2,
+    contents: Contents,
+}
+impl<Contents: PopupContents> PositionedPopup<Contents> {
+    pub fn new(position: Pos2, contents: Contents) -> Self {
+        Self { position, contents }
+    }
+}
+
 pub trait PopupResponse: Sized {
     fn union(self, other: egui::Response) -> Self;
 }
@@ -252,23 +317,19 @@ pub trait DisplayablePopup {
     fn position(&self) -> &Pos2;
     fn show(self, ui: &mut Ui, frontend: &mut Frontend, backend: &mut Backend) -> <Self::Kind as PopupKind>::Response;
 }
-impl<K, F> DisplayablePopup for PrimedPopup<K, F>
-where
-    K: PopupKind,
-    F: FnOnce(&mut egui::Ui, &mut Frontend, &mut Backend) -> <K as PopupKind>::Response,
-{
-    type Kind = K;
+impl<Contents: PopupContents> DisplayablePopup for PositionedPopup<Contents> {
+    type Kind = Contents::Kind;
 
     fn position(&self) -> &Pos2 {
         return &self.position;
     }
 
-    fn show(self, ui: &mut Ui, frontend: &mut Frontend, backend: &mut Backend) -> <K as PopupKind>::Response {
-        return (self.add_contents)(ui, frontend, backend);
+    fn show(self, ui: &mut Ui, frontend: &mut Frontend, backend: &mut Backend) -> <Self::Kind as PopupKind>::Response {
+        return (self.contents.contents())(ui, frontend, backend);
     }
 }
 
-pub trait PopupKind: Sized {
+pub trait PopupKind: Sized + Clone {
     type Response: PopupResponse;
     fn id(trigger_id: &egui::Id) -> egui::Id;
     fn close_condition() -> PopupCloseCondition;
@@ -281,7 +342,7 @@ pub trait PopupKind: Sized {
         P: DisplayablePopup<Kind = Self>;
 }
 
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct Tooltip {}
 impl PopupKind for Tooltip {
     type Response = egui::Response;
@@ -306,6 +367,7 @@ impl PopupKind for Tooltip {
     }
 }
 
+#[derive(Clone)]
 pub struct ContextMenu {}
 impl PopupKind for ContextMenu {
     type Response = egui::Response;
@@ -329,6 +391,8 @@ impl PopupKind for ContextMenu {
         PopupManager::add_context_menu(trigger, ui, frontend, backend);
     }
 }
+
+#[derive(Clone)]
 pub struct DropdownMenu {}
 impl PopupKind for DropdownMenu {
     type Response = egui::Response;
@@ -353,6 +417,7 @@ impl PopupKind for DropdownMenu {
     }
 }
 
+#[derive(Clone)]
 pub struct ModalDialog {}
 impl PopupKind for ModalDialog {
     type Response = egui::InnerResponse<bool>;

gui/src/lib.rs

@@ -27,10 +27,7 @@ use crate::panels::metric_status_bar::MetricStatusBar;
 use crate::panels::*;
 use crate::settings::AppSettings;
 use crate::tabs::*;
-use crate::widgets::time_line::{
-    COLOR_ABORT, COLOR_HOLD, COLOR_NOMINAL_IGNITION, COLOR_NOMINAL_IN_FLIGHT, COLOR_NOMINAL_ON_GROUND, Timeline,
-    TimelineState,
-};
+use crate::widgets::time_line::{HyacinthAnomalousState, HyacinthNominalState, Timeline};
 use crate::windows::*;
 
 /// Main state object of our GUI application
@@ -200,34 +197,14 @@ impl Sam {
 
         // Header containing text indicators and flight mode buttons
         HeaderPanel::show(ctx, self.backend_mut(), enabled);
+
         egui::TopBottomPanel::top("my_panel").show(ctx, |ui| {
             ui.add(Timeline::new(
-                vec![
-                    TimelineState::new("Verification", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("IdlePassivated", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("N₂ Filling", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("IdleActive", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("HarwareArmed", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("N₂O Filling", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("SoftwareArmed", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("Ignition", COLOR_NOMINAL_IGNITION),
-                    TimelineState::new("BurnPhase", COLOR_NOMINAL_IN_FLIGHT),
-                    TimelineState::new("CoastPhase", COLOR_NOMINAL_IN_FLIGHT),
-                    TimelineState::new("DroguePhase", COLOR_NOMINAL_IN_FLIGHT),
-                    TimelineState::new("MainPhase", COLOR_NOMINAL_IN_FLIGHT),
-                    TimelineState::new("LandedActive", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("Passivation", COLOR_NOMINAL_ON_GROUND),
-                    TimelineState::new("LandedPassivated", COLOR_NOMINAL_ON_GROUND),
-                ],
-                vec![
-                    TimelineState::new("Hold", COLOR_HOLD),
-                    TimelineState::new("Abort", COLOR_ABORT),
-                ],
-                0,
+                HyacinthNominalState::as_timeline(&self.frontend),
+                HyacinthAnomalousState::as_timeline(&self.frontend),
                 Rotation2::new(0f32), //f32::consts::PI / 2f32),
                 &mut self.frontend,
                 self.backends.last_mut().unwrap(),
-                //self.backend_mut(),
             ));
         });