Add a checkbox to quit on disconnect

Cargo.lock

@@ -1757,7 +1757,7 @@ checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 
 [[package]]
 name = "lemur"
-version = "0.2.5"
+version = "0.2.7"
 dependencies = [
  "anyhow",
  "atoi",

Cargo.toml

@@ -4,7 +4,7 @@ description = "An emulator for the Virtual Boy."
 repository = "https://git.virtual-boy.com/PVB/lemur"
 publish = false
 license = "MIT"
-version = "0.2.5"
+version = "0.2.7"
 edition = "2021"
 
 [dependencies]

shrooms-vb-core

@@ -1 +1 @@
-Subproject commit 06849b54ba7f7fd8bba09e1cf8a8cc9107ec269b
+Subproject commit 57dcd8370a885541ae6a1de0f35b25675728b226

src/app.rs

@@ -211,11 +211,15 @@ impl ApplicationHandler<UserEvent> for Application {
                 );
                 self.open(event_loop, Box::new(p2));
             }
-            UserEvent::Quit => {
+            UserEvent::Quit(sim_id) => {
+                self.viewports
+                    .retain(|_, viewport| viewport.app.sim_id() != sim_id);
+                if !self.viewports.contains_key(&ViewportId::ROOT) {
                     event_loop.exit();
                 }
             }
         }
+    }
 
     fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
         if let Some(viewport) = self.viewports.get(&ViewportId::ROOT) {
@@ -269,17 +273,23 @@ impl Viewport {
         });
         egui_extras::install_image_loaders(&ctx);
 
-        let mut painter = egui_wgpu::winit::Painter::new(
+        #[allow(unused_mut)]
-            ctx.clone(),
+        let mut wgpu_config = egui_wgpu::WgpuConfiguration {
-            egui_wgpu::WgpuConfiguration {
             present_mode: wgpu::PresentMode::AutoNoVsync,
             ..egui_wgpu::WgpuConfiguration::default()
-            },
+        };
-            1,
+        #[cfg(windows)]
-            None,
+        {
-            false,
+            if let egui_wgpu::WgpuSetup::CreateNew {
-            true,
+                supported_backends, ..
-        );
+            } = &mut wgpu_config.wgpu_setup
+            {
+                *supported_backends -= wgpu::Backends::VULKAN;
+            }
+        }
+
+        let mut painter =
+            egui_wgpu::winit::Painter::new(ctx.clone(), wgpu_config, 1, None, false, true);
 
         let mut info = ViewportInfo::default();
         let mut builder = app.initial_viewport();
@@ -395,7 +405,7 @@ pub enum UserEvent {
     OpenDebugger(SimId),
     OpenInput,
     OpenPlayer2,
-    Quit,
+    Quit(SimId),
 }
 
 pub enum Action {

src/emulator/shrooms_vb_core.rs

@@ -190,7 +190,8 @@ impl Sim {
         let memory = vec![0u64; size.div_ceil(4)];
         let sim: *mut VB = Box::into_raw(memory.into_boxed_slice()).cast();
         unsafe { vb_init(sim) };
-        unsafe { vb_set_option(sim, VBOption::PseudoHalt, 1) };
+        // pseudohalt is disabled due to breaking red alarm
+        unsafe { vb_set_option(sim, VBOption::PseudoHalt, 0) };
         unsafe { vb_set_keys(sim, VBKey::SGN.bits()) };
         unsafe { vb_reset(sim) };
 

src/window.rs

@@ -5,6 +5,8 @@ pub use gdb::GdbServerWindow;
 pub use input::InputWindow;
 use winit::event::KeyEvent;
 
+use crate::emulator::SimId;
+
 mod about;
 mod game;
 mod game_screen;
@@ -13,6 +15,9 @@ mod input;
 
 pub trait AppWindow {
     fn viewport_id(&self) -> ViewportId;
+    fn sim_id(&self) -> SimId {
+        SimId::Player1
+    }
     fn initial_viewport(&self) -> ViewportBuilder;
     fn show(&mut self, ctx: &Context);
     fn on_init(&mut self, render_state: &egui_wgpu::RenderState) {

src/window/game.rs

@@ -78,19 +78,20 @@ impl GameWindow {
                 ui.close_menu();
             }
             if ui.button("Quit").clicked() {
-                ctx.send_viewport_cmd(ViewportCommand::Close);
+                let _ = self.proxy.send_event(UserEvent::Quit(self.sim_id));
             }
         });
         ui.menu_button("Emulation", |ui| {
             let state = self.client.emulator_state();
             let is_ready = self.client.sim_state(self.sim_id) == SimState::Ready;
             let can_pause = is_ready && state == EmulatorState::Running;
+            let can_resume = is_ready && state == EmulatorState::Paused;
             if state == EmulatorState::Running {
-                if ui.add_enabled(is_ready, Button::new("Pause")).clicked() {
+                if ui.add_enabled(can_pause, Button::new("Pause")).clicked() {
                     self.client.send_command(EmulatorCommand::Pause);
                     ui.close_menu();
                 }
-            } else if ui.add_enabled(can_pause, Button::new("Resume")).clicked() {
+            } else if ui.add_enabled(can_resume, Button::new("Resume")).clicked() {
                 self.client.send_command(EmulatorCommand::Resume);
                 ui.close_menu();
             }
@@ -317,6 +318,10 @@ impl AppWindow for GameWindow {
         }
     }
 
+    fn sim_id(&self) -> SimId {
+        self.sim_id
+    }
+
     fn initial_viewport(&self) -> ViewportBuilder {
         ViewportBuilder::default()
             .with_title("Lemur")
@@ -380,6 +385,7 @@ impl AppWindow for GameWindow {
         if self.sim_id == SimId::Player2 {
             self.client.send_command(EmulatorCommand::StopSecondSim);
         }
+        let _ = self.proxy.send_event(UserEvent::Quit(self.sim_id));
     }
 }
 

src/window/gdb.rs

@@ -12,7 +12,8 @@ use super::AppWindow;
 pub struct GdbServerWindow {
     sim_id: SimId,
     port_str: String,
-    launched: bool,
+    connected: bool,
+    quit_on_disconnect: bool,
     server: GdbServer,
     proxy: EventLoopProxy<UserEvent>,
 }
@@ -22,7 +23,8 @@ impl GdbServerWindow {
         Self {
             sim_id,
             port_str: (8080 + sim_id.to_index()).to_string(),
-            launched: false,
+            connected: false,
+            quit_on_disconnect: false,
             server: GdbServer::new(sim_id, client),
             proxy,
         }
@@ -31,8 +33,9 @@ impl GdbServerWindow {
     pub fn launch(&mut self, port: u16) {
         self.server.stop();
         self.port_str = port.to_string();
-        self.launched = true;
+        self.quit_on_disconnect = true;
         self.server.start(port);
+        self.connected = true;
     }
 }
 
@@ -41,6 +44,10 @@ impl AppWindow for GdbServerWindow {
         ViewportId::from_hash_of(format!("Debugger-{}", self.sim_id))
     }
 
+    fn sim_id(&self) -> SimId {
+        self.sim_id
+    }
+
     fn initial_viewport(&self) -> ViewportBuilder {
         ViewportBuilder::default()
             .with_title(format!("GDB Server ({})", self.sim_id))
@@ -61,16 +68,20 @@ impl AppWindow for GdbServerWindow {
                 ui.label("Port");
                 let port_editor = TextEdit::singleline(&mut self.port_str).desired_width(100.0);
                 ui.add_enabled(!status.running(), port_editor);
+                ui.checkbox(&mut self.quit_on_disconnect, "Quit on disconnect");
             });
 
             if !status.running() {
-                if self.launched {
+                if self.connected && self.quit_on_disconnect {
-                    self.proxy.send_event(UserEvent::Quit).unwrap();
+                    self.proxy.send_event(UserEvent::Quit(self.sim_id)).unwrap();
+                } else {
+                    self.connected = false;
                 }
                 let start_button = Button::new("Start");
                 if ui.add_enabled(port_num.is_some(), start_button).clicked() {
                     let port = port_num.unwrap();
                     self.server.start(port);
+                    self.connected = true;
                 }
             } else {
                 let stop_button = Button::new("Stop");