Handle no model argument being passed

crates/fj-app/src/main.rs

@@ -70,7 +70,7 @@ fn main() -> anyhow::Result<()> {
 
 fn no_model_error() -> anyhow::Error {
     anyhow!(
-        "You must specify a model to start Fornjot.\n\
+        "You must specify a model to start Fornjot in export only mode.\n\
         - Pass a model as a command-line argument. See `fj-app --help`.\n\
         - Specify a default model in the configuration file."
     )

crates/fj-host/src/host.rs

@@ -13,21 +13,18 @@ impl Host {
     ///
     /// This is only useful, if you want to continuously watch the model for
     /// changes. If you don't just keep using `Model`.
-    pub fn from_model(model: Option<Model>) -> Option<Result<Self, Error>> {
-        if let Some(model) = model {
-            let watch_path = model.watch_path();
-            let evaluator = Evaluator::from_model(model);
-            let _watcher = match Watcher::watch_model(&watch_path, &evaluator) {
-                Ok(_watcher) => _watcher,
-                Err(e) => return Some(Err(e)),
-            };
+    pub fn from_model(model: Model) -> Result<Self, Error> {
+        let watch_path = model.watch_path();
+        let evaluator = Evaluator::from_model(model);
+        let _watcher = match Watcher::watch_model(&watch_path, &evaluator) {
+            Ok(_watcher) => _watcher,
+            Err(e) => return Err(e),
+        };
 
-            return Some(Ok(Self {
-                evaluator,
-                _watcher,
-            }));
-        }
-        None
+        return Ok(Self {
+            evaluator,
+            _watcher,
+        });
     }
 
     /// Access a channel with evaluation events

crates/fj-viewer/Cargo.toml

@@ -18,11 +18,15 @@ egui-wgpu = "0.19.0"
 fj-interop.workspace = true
 fj-math.workspace = true
 raw-window-handle = "0.4.3"
-rfd = "0.10.0"
 thiserror = "1.0.35"
 tracing = "0.1.37"
 wgpu_glyph = "0.17.0"
 
+[dependencies.rfd]
+version = "0.10.0"
+default_features = false
+features = ["xdg-portal"]
+
 [dependencies.wgpu]
 version = "0.13.1"
 features = ["webgl"]

crates/fj-viewer/src/graphics/renderer.rs

@@ -1,4 +1,4 @@
-use std::{io, mem::size_of};
+use std::{io, mem::size_of, path::PathBuf};
 
 use crossbeam_channel::{Receiver, Sender};
 use thiserror::Error;
@@ -8,7 +8,7 @@ use wgpu_glyph::ab_glyph::InvalidFont;
 
 use crate::{
     camera::Camera,
-    gui::{Gui, GuiEvent},
+    gui::Gui,
     screen::{Screen, ScreenSize},
 };
 
@@ -159,8 +159,8 @@ impl Renderer {
 
     pub(crate) fn init_gui(
         &self,
-        event_rx: Receiver<GuiEvent>,
-        event_tx: Sender<GuiEvent>,
+        event_rx: Receiver<()>,
+        event_tx: Sender<PathBuf>,
     ) -> Gui {
         Gui::new(&self.device, self.surface_config.format, event_rx, event_tx)
     }

crates/fj-viewer/src/gui.rs

@@ -24,12 +24,6 @@ use fj_math::{Aabb, Scalar};
 
 use crate::graphics::DrawConfig;
 
-/// Event that are passed between the event_loop and gui
-pub enum GuiEvent {
-    AskModel,
-    LoadModel(PathBuf),
-}
-
 struct GuiState {
     has_model: bool,
 }
@@ -45,17 +39,17 @@ pub struct Gui {
     context: egui::Context,
     render_pass: egui_wgpu::renderer::RenderPass,
     options: Options,
-    event_rx: Receiver<GuiEvent>,
-    event_tx: Sender<GuiEvent>,
+    event_rx: Receiver<()>,
+    event_tx: Sender<PathBuf>,
     state: GuiState,
 }
 
 impl Gui {
     pub(crate) fn new(
         device: &wgpu::Device,
         texture_format: wgpu::TextureFormat,
-        event_rx: Receiver<GuiEvent>,
-        event_tx: Sender<GuiEvent>,
+        event_rx: Receiver<()>,
+        event_tx: Sender<PathBuf>,
     ) -> Self {
         // The implementation of the integration with `egui` is likely to need
         // to change "significantly" depending on what architecture approach is
@@ -126,15 +120,10 @@ impl Gui {
                 })
                 .ok();
 
-            let gui_event = match gui_event {
-                Some(gui_event) => gui_event,
+            match gui_event {
+                Some(_) => self.state.has_model = false,
                 None => break,
             };
-
-            match gui_event {
-                GuiEvent::AskModel => self.state.has_model = false,
-                _ => {}
-            }
         }
 
         self.context.set_pixels_per_point(pixels_per_point);
@@ -298,17 +287,18 @@ impl Gui {
                 .anchor(egui::Align2::CENTER_CENTER, [0_f32, -5_f32])
                 .show(&self.context, |ui| {
                     ui.vertical_centered(|ui| {
-                        ui.label(
+                        ui.label(egui::RichText::new(
                             "No model selected please choose a model to view.",
-                        );
+                        ).color(egui::Color32::BLACK)
+                        .background_color(egui::Color32::WHITE));
                         if ui
                             .button(egui::RichText::new("Pick a model"))
                             .clicked()
                         {
                             let model_dir = show_file_dialog();
                             if let Some(model_dir) = model_dir {
                                 self.event_tx
-                                    .send(GuiEvent::LoadModel(model_dir))
+                                    .send(model_dir)
                                     .expect("Channel is disconnected");
 
                                 self.state.has_model = true;

crates/fj-viewer/src/lib.rs

@@ -24,7 +24,7 @@ mod viewer;
 pub use self::{
     camera::Camera,
     graphics::{DrawConfig, Renderer, RendererInitError},
-    gui::{Gui, GuiEvent},
+    gui::Gui,
     input::{InputEvent, InputHandler},
     screen::{NormalizedScreenPosition, Screen, ScreenSize},
     viewer::Viewer,

crates/fj-viewer/src/viewer.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use fj_interop::{
     processed_shape::ProcessedShape, status_report::StatusReport,
 };
@@ -7,10 +9,8 @@ use tracing::warn;
 use crossbeam_channel::{Receiver, Sender};
 
 use crate::{
-    camera::FocusPoint,
-    gui::{Gui, GuiEvent},
-    Camera, DrawConfig, InputEvent, InputHandler, NormalizedScreenPosition,
-    Renderer, RendererInitError, Screen, ScreenSize,
+    camera::FocusPoint, gui::Gui, Camera, DrawConfig, InputEvent, InputHandler,
+    NormalizedScreenPosition, Renderer, RendererInitError, Screen, ScreenSize,
 };
 
 /// The Fornjot model viewer
@@ -44,8 +44,8 @@ impl Viewer {
     /// Construct a new instance of `Viewer`
     pub async fn new(
         screen: &impl Screen,
-        event_rx: Receiver<GuiEvent>,
-        event_tx: Sender<GuiEvent>,
+        event_rx: Receiver<()>,
+        event_tx: Sender<PathBuf>,
     ) -> Result<Self, RendererInitError> {
         let renderer = Renderer::new(screen).await?;
         let gui = renderer.init_gui(event_rx, event_tx);