update packages to latest versionsHEADmain

1 files changed, 136 insertions, 54 deletions

diff --git a/src/ui/fleet_window.rs b/src/ui/fleet_window.rs
index eb8ccde..55e3d59 100644
--- a/src/ui/fleet_window.rs
+++ b/src/ui/fleet_window.rs
@@ -1,17 +1,22 @@
-use std::cell::RefCell;
-
 use crate::GameState;
-use crate::eguictx::EguiCtx;
-use crate::fleet::{Fleet, FleetsManager};
+use crate::fleet::{Fleet, FleetId, FleetsManager};
+use crate::solar_system::orbit::StaticOrbiter;
 use crate::solar_system::{Kilometers, SolarSystem, SystemId};
 use crate::solar_system::body::BodyId;
 
+#[derive(Default, Clone, PartialEq)]
+enum FleetMenuPanelSel {
+    #[default]
+    Info,
+    Schedule
+}
 
 #[derive(Default, Clone)]
 pub struct FleetWindowState
 {
     pub open: bool,
-    pub selected_system: Option<SystemId>,
+    pub selected_fleet: Option<FleetId>,
+    pub menu_panel: FleetMenuPanelSel,
 
     pub new_fleet_window: Option<NewFleetWindowState>
 }
@@ -33,7 +38,7 @@ pub struct NewFleetWindowState
     pub fleet_sma: Kilometers
 }
 
-#[derive(Default, Clone)]
+#[derive(Clone)]
 pub struct NewFleet
 {
     pub system: SystemId,
@@ -46,8 +51,9 @@ impl FleetWindowState
 {
     pub fn paint(
         &mut self,
+        ui: &mut egui::Ui,
         game_state: &GameState,
-        eguictx: &EguiCtx,
+        focused_system: &Option<SystemId>,
         focused_body: &Option<BodyId>)
     -> FleetWindowAction
     {
@@ -59,22 +65,30 @@ impl FleetWindowState
         let mut mgr_open = self.open;
         egui::Window::new("Fleet Manager")
             .open(&mut mgr_open)
-            .show(eguictx.context(), |ui| {
+            .show(ui.ctx(), |ui| {
             
-            ui.horizontal(|ui| {
-                self.paint_systems_list(
-                    &mut action, 
-                    ui, 
-                    fleets_manager, 
-                    star_systems, 
-                    focused_body
-                );
+            ui.vertical(|ui| {
+                ui.horizontal(|ui| {
+                    self.paint_fleet_list(fleets_manager, ui);
+                    self.paint_fleet_menu(star_systems, fleets_manager, ui);
+                });
+
+                if focused_system.is_some() {
+                    if ui.button("New Fleet").clicked() {
+                        if self.new_fleet_window.is_none() {
+                            self.new_fleet_window = Some(NewFleetWindowState::new(
+                                focused_system.unwrap(),
+                                focused_body.unwrap_or(0)
+                            ));
+                        }
+                    }
+                }
             });
         });
 
         match &mut self.new_fleet_window {
             Some(new_fleet_window) => {
-                action.new_fleet = new_fleet_window.paint(game_state, eguictx);
+                action.new_fleet = new_fleet_window.paint(ui, game_state);
                 if action.new_fleet.is_some() || !new_fleet_window.open {
                     self.new_fleet_window = None;
                 }
@@ -86,53 +100,106 @@ impl FleetWindowState
         action
     }
 
-    fn paint_systems_list(
+    fn paint_fleet_menu(
         &mut self,
-        action: &mut FleetWindowAction,
-        ui: &mut egui::Ui,
-        fleets_manager: &FleetsManager,
         star_systems: &[SolarSystem],
-        focused_body: &Option<BodyId>)
-    -> egui::InnerResponse<()>
+        fleets_man: &FleetsManager,
+        ui: &mut egui::Ui)
     {
-        ui.vertical(|ui| {
-            for system in star_systems {
-                self.paint_fleet_list(fleets_manager, &system, ui);
+        let fleet = match self.selected_fleet {
+            Some(id) => { fleets_man.entry(id) },
+            None => { return; }
+        };
+        let fleet = match fleet {
+            Some(entry) => entry,
+            None => {
+                self.selected_fleet = None;
+                return;
             }
+        };
 
-            if self.selected_system.is_none() { return; }
-            if ui.button("New Fleet").clicked() {
-                if self.new_fleet_window.is_none() {
-                    self.new_fleet_window = Some(NewFleetWindowState::new(
-                            self.selected_system.unwrap(),
-                            focused_body.unwrap_or(0)
-                            ));
+        ui.separator();
+        ui.vertical(|ui| {
+            ui.horizontal(|ui| {
+                if ui.button("Info").clicked() {
+                    self.menu_panel = FleetMenuPanelSel::Info;
                 }
+                if ui.button("Schedule").clicked() {
+                    self.menu_panel = FleetMenuPanelSel::Schedule;
+                }
+            });
+            self.paint_fleet_menu_info(star_systems, fleets_man, fleet, ui);
+        });
+    }
+
+    fn paint_fleet_menu_info(
+        &mut self,
+        star_systems: &[SolarSystem],
+        fleets_man: &FleetsManager,
+        fleet: &Fleet,
+        ui: &mut egui::Ui)
+    {
+        if self.menu_panel != FleetMenuPanelSel::Info {
+            return;
+        }
+        egui::Frame::canvas(ui.style()).show(ui, |ui| {
+            ui.set_min_width(200.0);
+            ui.style_mut().interaction.selectable_labels = false;
+
+            if let Some(orbit) = fleet.orbit() {
+                let star_system = &star_systems[orbit.system()];
+                let parent = star_system.body(orbit.parent());
+
+                ui.push_id("orbital_info_table", |ui| {
+                    egui_extras::TableBuilder::new(ui)
+                    .column(egui_extras::Column::auto())
+                    .column(egui_extras::Column::remainder())
+                    .body(|mut body| {
+                        body.row(16.0, |mut row| {
+                            row.col(|col| { col.label("System"); });
+                            row.col(|col| { col.label(star_system.name()); });
+                        });
+                        body.row(16.0, |mut row| {
+                            row.col(|col| { col.label("Orbiting"); });
+                            row.col(|col| { col.label(parent.name()); });
+                        });
+                        body.row(16.0, |mut row| {
+                            row.col(|col| { col.label("Radius"); });
+                            row.col(|col| { col.label(format!("{:.1}", orbit.sma())); });
+                        });
+                    });
+                });
+
+                ui.separator();
             }
-        })
+
+            let heading = fleet.heading();
+            egui_extras::TableBuilder::new(ui)
+            .column(egui_extras::Column::auto())
+            .column(egui_extras::Column::remainder())
+            .body(|mut body| {
+                body.row(16.0, |mut row| {
+                    row.col(|col| { col.label("Heading"); });
+                    row.col(|col| { 
+                        col.label(format!("{:?} by {:?}", 
+                            cgmath::Deg::<f32>::from(heading.x),
+                            cgmath::Deg::<f32>::from(heading.y)
+                        )); 
+                    });
+                });
+            });
+        });
     }
 
     fn paint_fleet_list(
         &mut self,
-        fleets_manager: &FleetsManager,
-        star_system: &SolarSystem,
+        fleets_man: &FleetsManager,
         ui: &mut egui::Ui)
     {
-        let fleet_ids = star_system.fleets(fleets_manager);
-        egui::collapsing_header::CollapsingState::load_with_default_open(
-            ui.ctx(),
-            ui.make_persistent_id(format!("fleet_window_star_{}", star_system.id())),
-            true
-            )
-        .show_header(ui, |ui| {
-            let selected = self.selected_system.is_some_and(|id| { id == star_system.id() });
-            if ui.selectable_label(selected, star_system.name()).clicked() {
-                self.selected_system = if !selected { Some(star_system.id()) } else { None };
-            }
-        })
-        .body(|ui| {
+        let fleet_ids = fleets_man.all();
+        ui.vertical(|ui| {
             for id in fleet_ids {
-                if let Some(fleet) = fleets_manager.entry(id) {
+                if let Some(fleet) = fleets_man.entry(id) {
                     self.paint_fleet_entry(fleet, ui);
                 }
             }
@@ -144,7 +211,10 @@ impl FleetWindowState
         fleet: &Fleet,
         ui: &mut egui::Ui)
     {
-        ui.label(fleet.name());
+        let selected = self.selected_fleet.is_some_and(|id| { id == fleet.id() });
+        if ui.selectable_label(selected, fleet.name()).clicked() {
+            self.selected_fleet = if selected { None } else { Some(fleet.id()) };
+        }
     }
 } // FleetWindowAction
 
@@ -164,8 +234,8 @@ impl NewFleetWindowState
 
     pub fn paint(
         &mut self,
-        game_state: &GameState,
-        eguictx: &EguiCtx)
+        ui: &mut egui::Ui,
+        game_state: &GameState,)
     -> Option<NewFleet>
     {
         let solar_system = &game_state.solar_systems()[self.parent_system];
@@ -174,7 +244,7 @@ impl NewFleetWindowState
         match egui::Window::new("New Fleet")
         .collapsible(false)
         .open(&mut self.open)
-        .show(eguictx.context(), |ui| {
+        .show(ui.ctx(), |ui| {
             ui.vertical(|ui| {
                 ui.horizontal(|ui| {
                     ui.label("Name: ");
@@ -205,4 +275,16 @@ impl NewFleetWindowState
             None => None
         }
     }
+} // impl FleetWindowState
+
+impl Default for NewFleet
+{
+    fn default() -> Self {
+        Self { 
+            system: Default::default(), 
+            orbiting: Default::default(), 
+            name: "New Fleet".to_string(),
+            sma: Default::default()
+        }
+    }
 }