Some tweaks to reduce some issues

src-tauri/src/main.rs

@@ -2,7 +2,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 use crossbeam::channel::Sender;
-use overlay::{Event, LockedOverlaySettings, Overlay};
+use overlay::{Event, LockedOverlayData, Overlay};
 
 use simple_logger::SimpleLogger;
 // use overlay::{Overlay, Manager};
@@ -15,15 +15,15 @@ fn set_interactable(interactable: bool, state: tauri::State<Sender<Event>>) {
     log::info!("set_interactable: {interactable:?}");
     if interactable {
         state
-            .send(Event::State(overlay::State::Interactable{}))
+            .send(overlay::State::Interactable{}.into())
             .ok();
     } else {
-        state.send(Event::Return).ok();
+        state.send(overlay::Event::Return).ok();
     }
 }
 
 #[tauri::command]
-fn set_auto_hide(auto_hide: bool, state: tauri::State<LockedOverlaySettings>) {
+fn set_auto_hide(auto_hide: bool, state: tauri::State<LockedOverlayData>) {
     log::info!("set_auto_hide: {auto_hide:?}");
     if let Ok(mut settings) = state.lock() {
         settings.auto_hide = auto_hide;

src-tauri/src/overlay.rs

@@ -4,10 +4,26 @@ use crossbeam::{
 };
 use serde::Serialize;
 use statig::prelude::*;
-use std::sync::{mpsc::Receiver as MpscReceiver, Mutex};
+use std::{
+    sync::{mpsc::Receiver as MpscReceiver, Mutex},
+    time::Duration,
+};
 use tauri::{Manager, PhysicalPosition, PhysicalSize, Window};
 use underlayer::{Bounds, UnderlayEvent};
 
+
+impl From<State> for Event {
+    fn from(value: State) -> Self {
+        Self::State(value)
+    }
+}
+
+impl From<&State> for Event {
+    fn from(value: &State) -> Self {
+        Self::State(value.clone())
+    }
+}
+
 #[derive(Debug)]
 pub enum Event {
     State(State),
@@ -22,10 +38,10 @@ pub struct Overlay {
     previous: State,
 }
 
-pub struct OverlaySettings {
+pub struct OverlayData {
     pub auto_hide: bool,
 }
-pub type LockedOverlaySettings = Mutex<OverlaySettings>;
+pub type LockedOverlayData = Mutex<OverlayData>;
 
 fn wrap_underlay_rx(rx: MpscReceiver<UnderlayEvent>) -> Receiver<UnderlayEvent> {
     let (cb_underlay_tx, cb_underlay_rx) = crossbeam::channel::unbounded();
@@ -45,7 +61,9 @@ impl Overlay {
             previous: State::hidden(),
         };
 
-        window.manage(Mutex::new(OverlaySettings { auto_hide: true }));
+        window.manage(Mutex::new(OverlayData {
+            auto_hide: true
+        }));
 
         let mut fsm = Overlay::uninitialized_state_machine(overlay).init();
 
@@ -90,12 +108,15 @@ impl Overlay {
     }
 
     fn handle_overlay_focused(fsm: &mut InitializedStateMachine<Overlay>, focus: bool) {
-        if let State::Visible {} = fsm.state() {
+        match fsm.state() {
+            State::Visible {} => {
                 if focus {
                     fsm.window.set_ignore_cursor_events(true).ok();
                     underlayer::focus_target();
                 }
             }
+            _ => (),
+        }
     }
 
     fn handle_underlay_event(fsm: &mut InitializedStateMachine<Overlay>, event: UnderlayEvent) {
@@ -108,17 +129,21 @@ impl Overlay {
                 fsm.handle(&Event::Bounds(bounds));
             }
             UnderlayEvent::MoveResize(bounds) => fsm.handle(&Event::Bounds(bounds)),
-            UnderlayEvent::Detach => fsm.handle(&Event::State(State::hidden())),
-            UnderlayEvent::Focus => fsm.handle(&Event::State(State::Visible {})),
+            UnderlayEvent::Detach => fsm.handle(&State::hidden().into()),
+            UnderlayEvent::Focus => {
+                if let State::Hidden {} = fsm.state() {
+                    fsm.handle(&State::Visible {  }.into());
+                }
+            }
             UnderlayEvent::Blur => {
                 if !fsm.window.is_focused().unwrap()
                     && fsm
                         .window
-                        .state::<LockedOverlaySettings>()
+                        .state::<LockedOverlayData>()
                         .lock()
                         .is_ok_and(|s| s.auto_hide)
                 {
-                    fsm.handle(&Event::State(State::Hidden {}))
+                    fsm.handle(&State::Hidden {}.into())
                 }
             }
             UnderlayEvent::X11FullscreenEvent { is_fullscreen: _ } => {}
@@ -150,31 +175,31 @@ impl Overlay {
                 .set_size(PhysicalSize::new(self.bounds.width, self.bounds.height))
                 .ok();
         }
-
-        log::trace!("on_enter_visible");
     }
 
     #[action]
     fn on_enter_interactable(&mut self) {
-        log::trace!("on_enter_interactable");
         self.window.set_ignore_cursor_events(false).ok();
         self.window.set_focus().ok();
     }
 
     #[action]
     fn on_enter_hidden(&mut self) {
-        log::trace!("on_enter_hidden");
         self.window.hide().ok();
         self.window.set_resizable(false).ok();
     }
 
     #[action]
     fn on_exit_interactable(&mut self) {
-        log::trace!("on_exit_interactable");
         self.window.set_ignore_cursor_events(true).ok();
     }
 
-    #[state(superstate = "super_visible")]
+    #[action]
+    fn on_explicitly_visible(&mut self) {
+        underlayer::focus_target();
+    }
+
+    #[state(superstate = "super_visible", entry_action = "on_explicitly_visible")]
     fn visible(&mut self, event: &Event) -> Response<State> {
         match event {
             Event::State(underlying) => match underlying {
@@ -217,13 +242,11 @@ impl Overlay {
     #[superstate(superstate = "common", entry_action = "on_enter_visible")]
     #[allow(unused_variables)]
     fn super_visible(&mut self, event: &Event) -> Response<State> {
-        log::trace!("in super_visible");
         Super
     }
 
     #[superstate]
     fn common(&mut self, event: &Event) -> Response<State> {
-        log::trace!("in common");
         match event {
             Event::Bounds(bounds) => {
                 self.bounds = *bounds;
@@ -246,7 +269,6 @@ impl Overlay {
     }
 
     fn on_transition(&mut self, src: &State, dest: &State) {
-        log::trace!("from {src:?} to {dest:?}");
         if src != dest {
             self.previous = src.clone();
         }

src/app/app.component.html

@@ -13,4 +13,6 @@
   </div>
 
   <input type="checkbox" [(ngModel)]="auto_hide" (change)="toggleAutoHide()">
+  <input type="checkbox" [(ngModel)]="interactable">
+
 </div>

src/app/app.component.ts

@@ -2,7 +2,13 @@ import { AfterViewInit, Component, OnInit } from "@angular/core";
 import { app } from "@tauri-apps/api";
 import { invoke } from "@tauri-apps/api/tauri";
 import { register } from "@tauri-apps/api/globalShortcut";
-import { listen } from '@tauri-apps/api/event';
+import { Event, listen } from '@tauri-apps/api/event';
+
+class StateEvent {
+  Visible?: any;
+  Interactable?: any;
+  Hidden?: any;
+}
 
 @Component({
   selector: "app-root",
@@ -16,19 +22,27 @@ export class AppComponent implements OnInit {
   ngOnInit(): void {
     register('F6', () => {
       this.interactable = !this.interactable;
-			invoke("set_interactable", {interactable: this.interactable}).then();
+      console.log("interactable", this.interactable);
+      invoke("set_interactable", { interactable: this.interactable }).then();
     }).then();
 
-    invoke("set_auto_hide", {auto_hide: this.auto_hide}).then();
+    invoke("set_auto_hide", { auto_hide: this.auto_hide }).then();
 
-    listen('OverlayStateChange', (event) => {
-      console.log(event, 'OverlayStateChange');
+    listen('OverlayStateChange', (event: Event<StateEvent>) => {
+      if (event.payload.Interactable) {
+        this.interactable = true;
+        console.log("interactable", this.interactable);
+
+      } else {
+        this.interactable = false;
+        console.log("interactable", this.interactable);
+      }
     }).then();
   }
 
   toggleAutoHide() {
     console.log("toggle auto hide!!");
-    invoke("set_auto_hide", {autoHide: this.auto_hide}).then();
+    invoke("set_auto_hide", { autoHide: this.auto_hide }).then();
   }
 
 }