1 files changed, 29 insertions, 22 deletions

diff --git a/src/emulators/graphical_emulator.rs b/src/emulators/graphical_emulator.rs
index 2680d3f..503a8f4 100644
--- a/src/emulators/graphical_emulator.rs
+++ b/src/emulators/graphical_emulator.rs
@@ -1,14 +1,13 @@
 use crate::*;
 
-use gilrs::Gilrs;
-
-
 pub struct GraphicalEmulator {
     pub br: BedrockEmulator<GraphicalDeviceBus>,
     pub debug: DebugState,
+    #[cfg(feature = "gamepad")]
     pub gilrs: Option<Gilrs>,
 
     pub fullscreen: bool,
+    pub visible: bool,
     pub scale: u32,
     pub render_mark: Instant,  // last time screen was rendered
     pub frame_mark: Instant,   // refreshes when clean
@@ -18,18 +17,18 @@ pub struct GraphicalEmulator {
 
 impl GraphicalEmulator {
     pub fn new(config: EmulatorConfig, debug: bool) -> Self {
-        let gilrs = match Gilrs::new() {
-            Ok(gilrs) => Some(gilrs),
-            Err(err) => {
-                info!("Could not start gamepad listener: {}", err);
-                None
-            }
-        };
-
         Self {
             br: BedrockEmulator::new(GraphicalDeviceBus::new(&config)),
             debug: DebugState::new(debug, config.symbols_path.as_ref()),
-            gilrs,
+
+            #[cfg(feature = "gamepad")]
+            gilrs: match Gilrs::new() {
+                Ok(gilrs) => Some(gilrs),
+                Err(err) => {
+                    info!("Could not start gamepad listener: {}", err);
+                    None
+                }
+            },
 
             fullscreen: config.fullscreen,
             scale: config.zoom.into(),
@@ -37,6 +36,7 @@ impl GraphicalEmulator {
             render_mark: Instant::now(),
             frame_mark: Instant::now(),
             config,
+            visible: false,
         }
     }
 
@@ -44,7 +44,8 @@ impl GraphicalEmulator {
         self.br.core.mem.load_program(bytecode);
     }
 
-    pub fn run(self, mut phosphor: Phosphor, visible: bool) {
+    pub fn run(mut self, mut phosphor: Phosphor, visible: bool) {
+        self.visible = visible;
         let window = WindowBuilder {
             dimensions: Some(self.dimensions()),
             size_bounds: Some(self.size_bounds()),
@@ -59,7 +60,6 @@ impl GraphicalEmulator {
             program: Box::new(self),
             visible,
         };
-
         phosphor.add_window(window);
         phosphor.run().unwrap();
     }
@@ -112,7 +112,7 @@ impl GraphicalDeviceBus {
             input:  InputDevice::new(),
             screen: ScreenDevice::new(&config),
             stream: StreamDevice::new(&config),
-            file:   FileDevice::new(),
+            file:   FileDevice::new(&config),
             wake_queue: WakeQueue::new(),
         }
     }
@@ -164,13 +164,13 @@ impl WindowProgram for GraphicalEmulator {
             Event::FocusChange(_) => (),
             Event::Initialise => (),
             Event::ScrollLines { axis, distance } => match axis {
-                Axis::Horizontal => self.br.dev.input.on_horizontal_scroll(distance * 20.0),
-                Axis::Vertical   => self.br.dev.input.on_vertical_scroll(distance * 20.0),
-            }
-            Event::ScrollPixels { axis, distance } => match axis {
                 Axis::Horizontal => self.br.dev.input.on_horizontal_scroll(distance),
                 Axis::Vertical   => self.br.dev.input.on_vertical_scroll(distance),
             }
+            Event::ScrollPixels { axis, distance } => match axis {
+                Axis::Horizontal => self.br.dev.input.on_horizontal_scroll(distance / 20.0),
+                Axis::Vertical   => self.br.dev.input.on_vertical_scroll(distance / 20.0),
+            }
 
             Event::Close => (),
             Event::KeyboardInput { key, action } => {
@@ -203,6 +203,8 @@ impl WindowProgram for GraphicalEmulator {
 
     fn process(&mut self, requests: &mut EventWriter<Request>) {
         self.br.dev.stream.flush();
+
+        #[cfg(feature = "gamepad")]
         if let Some(gilrs) = &mut self.gilrs {
             while let Some(event) = gilrs.next_event() {
                 self.br.dev.input.on_gamepad_event(event);
@@ -233,9 +235,6 @@ impl WindowProgram for GraphicalEmulator {
             if let Some(signal) = self.br.evaluate(BATCH_SIZE, self.debug.enabled) {
                 match signal {
                     Signal::Break => {
-                        if self.br.dev.input.accessed || self.br.dev.screen.accessed {
-                            requests.write(Request::SetVisible(true));
-                        }
                     }
                     Signal::Fork | Signal::Reset => {
                         self.br.reset();
@@ -260,6 +259,14 @@ impl WindowProgram for GraphicalEmulator {
             }
         }
 
+        if !self.visible {
+            if self.br.dev.input.accessed || self.br.dev.screen.accessed {
+                info!("Making window visible");
+                requests.write(Request::SetVisible(true));
+                self.visible = true;
+            }
+        }
+
         if std::mem::take(&mut self.br.dev.screen.dirty_dimensions) {
             requests.write(Request::SetSizeBounds(self.size_bounds()));
         }