From 2218f7ff901528536f2d6064d347dd8df6113221 Mon Sep 17 00:00:00 2001 From: isark Date: Tue, 18 Jul 2023 20:59:59 +0200 Subject: [PATCH] Some tweaks to reduce some issues --- src-tauri/src/main.rs | 8 ++--- src-tauri/src/overlay.rs | 64 +++++++++++++++++++++++++------------- src/app/app.component.html | 2 ++ src/app/app.component.ts | 30 +++++++++++++----- 4 files changed, 71 insertions(+), 33 deletions(-) diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs index 7dad4fb..d529ef2 100644 --- a/src-tauri/src/main.rs +++ b/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>) { 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) { +fn set_auto_hide(auto_hide: bool, state: tauri::State) { log::info!("set_auto_hide: {auto_hide:?}"); if let Ok(mut settings) = state.lock() { settings.auto_hide = auto_hide; diff --git a/src-tauri/src/overlay.rs b/src-tauri/src/overlay.rs index 07a83d9..27546b2 100644 --- a/src-tauri/src/overlay.rs +++ b/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 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; +pub type LockedOverlayData = Mutex; fn wrap_underlay_rx(rx: MpscReceiver) -> Receiver { 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,11 +108,14 @@ impl Overlay { } fn handle_overlay_focused(fsm: &mut InitializedStateMachine, focus: bool) { - if let State::Visible {} = fsm.state() { - if focus { - fsm.window.set_ignore_cursor_events(true).ok(); - underlayer::focus_target(); + match fsm.state() { + State::Visible {} => { + if focus { + fsm.window.set_ignore_cursor_events(true).ok(); + underlayer::focus_target(); + } } + _ => (), } } @@ -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::() + .state::() .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 { 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 { - log::trace!("in super_visible"); Super } #[superstate] fn common(&mut self, event: &Event) -> Response { - 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(); } diff --git a/src/app/app.component.html b/src/app/app.component.html index 884f049..04a77c3 100644 --- a/src/app/app.component.html +++ b/src/app/app.component.html @@ -13,4 +13,6 @@ + + diff --git a/src/app/app.component.ts b/src/app/app.component.ts index ef649cb..cd04464 100644 --- a/src/app/app.component.ts +++ b/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", @@ -12,23 +18,31 @@ import { listen } from '@tauri-apps/api/event'; export class AppComponent implements OnInit { auto_hide: boolean = true; interactable: boolean = false; - + ngOnInit(): void { register('F6', () => { this.interactable = !this.interactable; - invoke("set_interactable", {interactable: this.interactable}).then(); - }).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: Event) => { + if (event.payload.Interactable) { + this.interactable = true; + console.log("interactable", this.interactable); - listen('OverlayStateChange', (event) => { - console.log(event, 'OverlayStateChange'); + } 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(); } }