Introduce an extensible widget system

rmf_site_editor/Cargo.toml

@@ -45,7 +45,7 @@ rfd = "0.12"
 urdf-rs = "0.7"
 utm = "0.1.6"
 sdformat_rs = { git = "https://github.com/open-rmf/sdf_rust_experimental", rev = "a5daef0"}
-gz-fuel = { git = "https://github.com/open-rmf/gz-fuel-rs", branch = "luca/ehttp" }
+gz-fuel = { git = "https://github.com/open-rmf/gz-fuel-rs", branch = "main" }
 pathdiff = "*"
 tera = "1.19.1"
 ehttp = { version = "0.4", features = ["native-async"] }

rmf_site_editor/src/issue.rs

@@ -16,15 +16,11 @@
 */
 
 use crate::site::ChangePlugin;
-use crate::widgets::{
-    diagnostic_window::DiagnosticWindowState,
-    menu_bar::{MenuEvent, MenuItem, MenuVisualizationStates, ToolMenu},
+use bevy::{
+    prelude::*,
+    utils::{HashMap, Uuid},
 };
-use crate::AppState;
-use bevy::prelude::*;
-use bevy::utils::{HashMap, Uuid};
 use rmf_site_format::{FilteredIssueKinds, FilteredIssues, IssueKey};
-use std::collections::HashSet;
 
 #[derive(Component, Debug, Clone)]
 pub struct Issue {
@@ -60,55 +56,14 @@ pub struct IssueDictionary(HashMap<Uuid, String>);
 #[derive(Default)]
 pub struct IssuePlugin;
 
-#[derive(Resource)]
-pub struct IssueMenu {
-    diagnostic_tool: Entity,
-}
-
-impl FromWorld for IssueMenu {
-    fn from_world(world: &mut World) -> Self {
-        let target_states = HashSet::from([
-            AppState::SiteEditor,
-            AppState::SiteDrawingEditor,
-            AppState::SiteVisualizer,
-        ]);
-        // Tools menu
-        let diagnostic_tool = world
-            .spawn(MenuItem::Text("Diagnostic Tool".to_string()))
-            .insert(MenuVisualizationStates(target_states))
-            .id();
-
-        let tool_header = world.resource::<ToolMenu>().get();
-        world
-            .entity_mut(tool_header)
-            .push_children(&[diagnostic_tool]);
-
-        IssueMenu { diagnostic_tool }
-    }
-}
-
-fn handle_diagnostic_window_visibility(
-    mut menu_events: EventReader<MenuEvent>,
-    issue_menu: Res<IssueMenu>,
-    mut diagnostic_window: ResMut<DiagnosticWindowState>,
-) {
-    for event in menu_events.read() {
-        if event.clicked() && event.source() == issue_menu.diagnostic_tool {
-            diagnostic_window.show = true;
-        }
-    }
-}
-
 impl Plugin for IssuePlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<ValidateWorkspace>()
             .add_plugins((
                 ChangePlugin::<FilteredIssues<Entity>>::default(),
                 ChangePlugin::<FilteredIssueKinds>::default(),
             ))
-            .init_resource::<IssueDictionary>()
-            .init_resource::<IssueMenu>()
-            .add_systems(Update, handle_diagnostic_window_visibility);
+            .init_resource::<IssueDictionary>();
     }
 }
 

rmf_site_editor/src/site/fuel_cache.rs

@@ -40,12 +40,26 @@ pub struct SetFuelApiKey(pub String);
 /// Using channels instead of events to allow usage in wasm since, unlike event writers, they can
 /// be cloned and moved into async functions therefore don't have lifetime issues
 #[derive(Debug, Resource)]
-pub struct UpdateFuelCacheChannels {
+pub struct FuelCacheUpdateChannel {
     pub sender: Sender<FuelCacheUpdated>,
     pub receiver: Receiver<FuelCacheUpdated>,
 }
 
-impl Default for UpdateFuelCacheChannels {
+impl Default for FuelCacheUpdateChannel {
+    fn default() -> Self {
+        let (sender, receiver) = crossbeam_channel::unbounded();
+        Self { sender, receiver }
+    }
+}
+
+/// Channels that give incremental updates about what models have been fetched.
+#[derive(Debug, Resource)]
+pub struct FuelCacheProgressChannel {
+    pub sender: Sender<FuelModel>,
+    pub receiver: Receiver<FuelModel>,
+}
+
+impl Default for FuelCacheProgressChannel {
     fn default() -> Self {
         let (sender, receiver) = crossbeam_channel::unbounded();
         Self { sender, receiver }
@@ -56,13 +70,15 @@ pub fn handle_update_fuel_cache_requests(
     mut events: EventReader<UpdateFuelCache>,
     mut gallery_status: ResMut<AssetGalleryStatus>,
     fuel_client: Res<FuelClient>,
-    channels: Res<UpdateFuelCacheChannels>,
+    update_channel: Res<FuelCacheUpdateChannel>,
+    progress_channel: Res<FuelCacheProgressChannel>,
 ) {
     if events.read().last().is_some() {
         info!("Updating fuel cache, this might take a few minutes");
         gallery_status.fetching_cache = true;
         let mut fuel_client = fuel_client.clone();
-        let sender = channels.sender.clone();
+        let sender = update_channel.sender.clone();
+        let progress = progress_channel.sender.clone();
         IoTaskPool::get()
             .spawn(async move {
                 // Only write to cache in non wasm, no file system in web
@@ -71,17 +87,27 @@ pub fn handle_update_fuel_cache_requests(
                 #[cfg(not(target_arch = "wasm32"))]
                 let write_to_disk = true;
                 // Send client if update was successful
-                let res = fuel_client.update_cache(write_to_disk).await;
+
+                let res = fuel_client
+                    .update_cache_with_progress(write_to_disk, Some(progress))
+                    .await;
                 sender
                     .send(FuelCacheUpdated(res))
                     .expect("Failed sending fuel cache update event");
             })
             .detach();
     }
+
+    while let Ok(next_model) = progress_channel.receiver.try_recv() {
+        info!(
+            "Received model {} owned by {}",
+            next_model.name, next_model.owner,
+        );
+    }
 }
 
 pub fn read_update_fuel_cache_results(
-    channels: Res<UpdateFuelCacheChannels>,
+    channels: Res<FuelCacheUpdateChannel>,
     mut fuel_client: ResMut<FuelClient>,
     mut gallery_status: ResMut<AssetGalleryStatus>,
 ) {

rmf_site_editor/src/site/mod.rs

@@ -186,7 +186,8 @@ impl Plugin for SitePlugin {
         .init_resource::<SiteAssets>()
         .init_resource::<CurrentLevel>()
         .init_resource::<PhysicalLightToggle>()
-        .init_resource::<UpdateFuelCacheChannels>()
+        .init_resource::<FuelCacheUpdateChannel>()
+        .init_resource::<FuelCacheProgressChannel>()
         .init_resource::<ModelTrashcan>()
         .register_type::<NameInSite>()
         .register_type::<AssetSource>()

rmf_site_editor/src/site/util.rs

@@ -72,6 +72,13 @@ impl EdgeLabels {
             Self::LeftRight => "right",
         }
     }
+
+    pub fn side(&self, side: Side) -> &'static str {
+        match side {
+            Side::Left => self.start(),
+            Side::Right => self.end(),
+        }
+    }
 }
 
 #[derive(Component, Debug, Default, Clone, Deref, DerefMut)]

rmf_site_editor/src/widgets/building_preview.rs

@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2024 Open Source Robotics Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+use crate::{
+    site::{AlignSiteDrawings, FinishEditDrawing},
+    widgets::prelude::*,
+    AppState, CurrentWorkspace, Icons,
+};
+use bevy::prelude::*;
+use bevy_egui::egui::{Button, Ui};
+
+#[derive(Default)]
+pub struct BuildingPreviewPlugin {}
+
+impl Plugin for BuildingPreviewPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(PropertiesTilePlugin::<BuildingPreview>::new());
+    }
+}
+
+#[derive(SystemParam)]
+pub struct BuildingPreview<'w> {
+    app_state: Res<'w, State<AppState>>,
+    next_app_state: ResMut<'w, NextState<AppState>>,
+    icons: Res<'w, Icons>,
+    current_workspace: Res<'w, CurrentWorkspace>,
+    align_site: EventWriter<'w, AlignSiteDrawings>,
+    finish_edit_drawing: EventWriter<'w, FinishEditDrawing>,
+}
+
+impl<'w> WidgetSystem<Tile> for BuildingPreview<'w> {
+    fn show(_: Tile, ui: &mut Ui, state: &mut SystemState<Self>, world: &mut World) {
+        let mut params = state.get_mut(world);
+        if *params.app_state == AppState::SiteEditor {
+            if ui.add(Button::new("Building preview")).clicked() {
+                params.next_app_state.set(AppState::SiteVisualizer);
+            }
+        }
+
+        if *params.app_state == AppState::SiteVisualizer {
+            if ui
+                .add(Button::image_and_text(
+                    params.icons.alignment.egui(),
+                    "Align Drawings",
+                ))
+                .on_hover_text(
+                    "Align all drawings in the site based on their fiducials and measurements",
+                )
+                .clicked()
+            {
+                if let Some(site) = params.current_workspace.root {
+                    params.align_site.send(AlignSiteDrawings(site));
+                }
+            }
+
+            if ui
+                .add(Button::image_and_text(
+                    params.icons.exit.egui(),
+                    "Return to site editor",
+                ))
+                .clicked()
+            {
+                params.next_app_state.set(AppState::SiteEditor);
+            }
+        }
+
+        if *params.app_state == AppState::SiteDrawingEditor {
+            if ui
+                .add(Button::image_and_text(
+                    params.icons.exit.egui(),
+                    "Return to site editor",
+                ))
+                .clicked()
+            {
+                params.finish_edit_drawing.send(FinishEditDrawing(None));
+            }
+        }
+    }
+}