fix: settings reopen, hotkey debounce, reregister, startup task, updater UI, version 1.0.10

Londopy · Londopy · commit 68dfa086acc8 · 2026-05-27T20:26:54.000-07:00
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -39,6 +39,20 @@ jobs:
           rustup default stable
           rustup target add ${{ matrix.target }}
 
+      - name: Set version from tag
+        shell: pwsh
+        run: |
+          $ver = "${{ github.ref_name }}".TrimStart("v")
+          $lines = Get-Content Cargo.toml
+          $done = $false
+          $lines = $lines | ForEach-Object {
+            if (!$done -and $_ -match '^version\s*=\s*"') {
+              $done = $true
+              "version = `"$ver`""
+            } else { $_ }
+          }
+          $lines | Set-Content Cargo.toml
+
       - name: Cache cargo registry
         uses: actions/cache@v4
         with:
@@ -93,6 +107,20 @@ jobs:
           rustup update stable
           rustup default stable
 
+      - name: Set version from tag
+        shell: pwsh
+        run: |
+          $ver = "${{ github.ref_name }}".TrimStart("v")
+          $lines = Get-Content Cargo.toml
+          $done = $false
+          $lines = $lines | ForEach-Object {
+            if (!$done -and $_ -match '^version\s*=\s*"') {
+              $done = $true
+              "version = `"$ver`""
+            } else { $_ }
+          }
+          $lines | Set-Content Cargo.toml
+
       - name: Cache cargo registry
         uses: actions/cache@v4
         with:
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "HideDesktopApps"
-version = "1.0.7"
+version = "1.0.10"
 edition = "2021"
 description = "System tray app to hide/show desktop icons, taskbar, and windows via hotkeys"
 repository = "https://github.com/Londopy/HideDesktopApps"
diff --git a/src/hotkeys.rs b/src/hotkeys.rs
@@ -87,47 +87,43 @@ fn parse_key_code(key: &str) -> Result<Code> {
     Ok(code)
 }
 
-/// Registered hotkeys with their associated IDs.
+/// Registered hotkeys with their IDs and the original HotKey objects (needed for unregister).
 pub struct RegisteredHotkeys {
-    #[allow(dead_code)]
     pub manager: GlobalHotKeyManager,
     pub icons_id: u32,
     pub taskbar_id: u32,
     pub windows_id: u32,
+    icons_hk: HotKey,
+    taskbar_hk: HotKey,
+    windows_hk: HotKey,
 }
 
-/// Register all three hotkeys from config. Returns errors per-hotkey so partial
-/// registration is possible (we still function with 2/3 hotkeys working).
+/// Parse a hotkey string, falling back to a default and notifying on failure.
+fn parse_or_default(
+    s: &str,
+    fallback: &str,
+    cmd_tx: &std::sync::mpsc::Sender<crate::Cmd>,
+) -> HotKey {
+    match parse_hotkey(s) {
+        Ok(hk) => hk,
+        Err(e) => {
+            eprintln!("Failed to parse hotkey '{}': {e}", s);
+            let _ = cmd_tx.send(crate::Cmd::HotkeyFailed(s.to_string()));
+            parse_hotkey(fallback).unwrap()
+        }
+    }
+}
+
+/// Register all three hotkeys from config.
 pub fn register_hotkeys(
     hotkeys_config: &crate::config::HotkeysConfig,
     cmd_tx: &std::sync::mpsc::Sender<crate::Cmd>,
-) -> Result<RegisteredHotkeys> {
+) -> anyhow::Result<RegisteredHotkeys> {
     let manager = GlobalHotKeyManager::new()?;
 
-    let icons_hk = match parse_hotkey(&hotkeys_config.icons) {
-        Ok(hk) => hk,
-        Err(e) => {
-            eprintln!("Failed to parse icons hotkey: {e}");
-            let _ = cmd_tx.send(crate::Cmd::HotkeyFailed(hotkeys_config.icons.clone()));
-            parse_hotkey("ctrl+alt+h").unwrap()
-        }
-    };
-    let taskbar_hk = match parse_hotkey(&hotkeys_config.taskbar) {
-        Ok(hk) => hk,
-        Err(e) => {
-            eprintln!("Failed to parse taskbar hotkey: {e}");
-            let _ = cmd_tx.send(crate::Cmd::HotkeyFailed(hotkeys_config.taskbar.clone()));
-            parse_hotkey("ctrl+alt+t").unwrap()
-        }
-    };
-    let windows_hk = match parse_hotkey(&hotkeys_config.windows) {
-        Ok(hk) => hk,
-        Err(e) => {
-            eprintln!("Failed to parse windows hotkey: {e}");
-            let _ = cmd_tx.send(crate::Cmd::HotkeyFailed(hotkeys_config.windows.clone()));
-            parse_hotkey("ctrl+alt+w").unwrap()
-        }
-    };
+    let icons_hk = parse_or_default(&hotkeys_config.icons, "ctrl+alt+h", cmd_tx);
+    let taskbar_hk = parse_or_default(&hotkeys_config.taskbar, "ctrl+alt+t", cmd_tx);
+    let windows_hk = parse_or_default(&hotkeys_config.windows, "ctrl+alt+w", cmd_tx);
 
     let icons_id = icons_hk.id();
     let taskbar_id = taskbar_hk.id();
@@ -151,16 +147,48 @@ pub fn register_hotkeys(
         icons_id,
         taskbar_id,
         windows_id,
+        icons_hk,
+        taskbar_hk,
+        windows_hk,
     })
 }
 
-/// Re-register hotkeys after a config change (unregister old ones first).
+/// Unregister old hotkeys and register new ones after a config change.
 pub fn reregister_hotkeys(
-    _registered: &mut RegisteredHotkeys,
-    _hotkeys_config: &crate::config::HotkeysConfig,
-    _cmd_tx: &std::sync::mpsc::Sender<crate::Cmd>,
+    registered: &mut RegisteredHotkeys,
+    hotkeys_config: &crate::config::HotkeysConfig,
+    cmd_tx: &std::sync::mpsc::Sender<crate::Cmd>,
 ) {
-    // Unregister all current hotkeys
+    // Unregister existing hotkeys (ignore errors — they may already be gone).
+    let _ = registered.manager.unregister(registered.icons_hk);
+    let _ = registered.manager.unregister(registered.taskbar_hk);
+    let _ = registered.manager.unregister(registered.windows_hk);
+
+    // Parse new hotkeys.
+    let icons_hk = parse_or_default(&hotkeys_config.icons, "ctrl+alt+h", cmd_tx);
+    let taskbar_hk = parse_or_default(&hotkeys_config.taskbar, "ctrl+alt+t", cmd_tx);
+    let windows_hk = parse_or_default(&hotkeys_config.windows, "ctrl+alt+w", cmd_tx);
+
+    registered.icons_id = icons_hk.id();
+    registered.taskbar_id = taskbar_hk.id();
+    registered.windows_id = windows_hk.id();
+
+    if let Err(e) = registered.manager.register(icons_hk) {
+        eprintln!("Re-register icons hotkey failed: {e}");
+        let _ = cmd_tx.send(crate::Cmd::HotkeyFailed(hotkeys_config.icons.clone()));
+    }
+    if let Err(e) = registered.manager.register(taskbar_hk) {
+        eprintln!("Re-register taskbar hotkey failed: {e}");
+        let _ = cmd_tx.send(crate::Cmd::HotkeyFailed(hotkeys_config.taskbar.clone()));
+    }
+    if let Err(e) = registered.manager.register(windows_hk) {
+        eprintln!("Re-register windows hotkey failed: {e}");
+        let _ = cmd_tx.send(crate::Cmd::HotkeyFailed(hotkeys_config.windows.clone()));
+    }
+
+    registered.icons_hk = icons_hk;
+    registered.taskbar_hk = taskbar_hk;
+    registered.windows_hk = windows_hk;
 }
 
 /// Poll for a pending hotkey event without blocking.
diff --git a/src/main.rs b/src/main.rs
@@ -131,6 +131,16 @@ fn main_loop(
     // Owned so we can swap it out when the profile list changes.
     let mut tray_handle = tray_handle;
 
+    // Debounce: Windows fires WM_HOTKEY repeatedly while a key is held, which
+    // would cause rapid toggling. Ignore events within 400 ms of the last fire.
+    let debounce = Duration::from_millis(400);
+    let epoch = Instant::now()
+        .checked_sub(debounce)
+        .unwrap_or_else(Instant::now);
+    let mut last_icons_fire = epoch;
+    let mut last_taskbar_fire = epoch;
+    let mut last_windows_fire = epoch;
+
     loop {
         // Pump Win32 messages — tray_icon and global_hotkey both rely on a
         // message loop on Windows.
@@ -152,11 +162,20 @@ fn main_loop(
         while let Some(event) = hotkeys::poll_hotkey_event() {
             let id = event.id();
             if id == hotkey_reg.icons_id {
-                let _ = cmd_tx.send(Cmd::ToggleIcons);
+                if last_icons_fire.elapsed() >= debounce {
+                    last_icons_fire = Instant::now();
+                    let _ = cmd_tx.send(Cmd::ToggleIcons);
+                }
             } else if id == hotkey_reg.taskbar_id {
-                let _ = cmd_tx.send(Cmd::ToggleTaskbar);
+                if last_taskbar_fire.elapsed() >= debounce {
+                    last_taskbar_fire = Instant::now();
+                    let _ = cmd_tx.send(Cmd::ToggleTaskbar);
+                }
             } else if id == hotkey_reg.windows_id {
-                let _ = cmd_tx.send(Cmd::ToggleWindows);
+                if last_windows_fire.elapsed() >= debounce {
+                    last_windows_fire = Instant::now();
+                    let _ = cmd_tx.send(Cmd::ToggleWindows);
+                }
             } else {
                 // Check profile hotkeys
                 let cfg = config_shared.lock().unwrap().clone();
diff --git a/src/startup.rs b/src/startup.rs
@@ -1,12 +1,33 @@
-use anyhow::Result;
+use anyhow::{bail, Result};
+use std::os::windows::process::CommandExt;
 use std::path::PathBuf;
 use winreg::enums::*;
 use winreg::RegKey;
 
+const TASK_NAME: &str = "HideDesktopApps";
 const APP_NAME: &str = "HideDesktopApps";
-const RUN_KEY: &str = r"Software\Microsoft\Windows\CurrentVersion\Run";
+// Suppress the console window that PowerShell/schtasks would otherwise flash.
+const CREATE_NO_WINDOW: u32 = 0x0800_0000;
 
-/// Old VBS launcher path — used only to clean up on migration.
+/// Run a hidden PowerShell command and return an error if it fails.
+fn powershell(script: &str) -> Result<()> {
+    let status = std::process::Command::new("powershell.exe")
+        .args([
+            "-WindowStyle",
+            "Hidden",
+            "-NonInteractive",
+            "-Command",
+            script,
+        ])
+        .creation_flags(CREATE_NO_WINDOW)
+        .status()?;
+    if !status.success() {
+        bail!("PowerShell exited with code {:?}", status.code());
+    }
+    Ok(())
+}
+
+/// Path of the old VBS launcher — cleaned up on migration.
 fn legacy_vbs_path() -> PathBuf {
     let appdata = std::env::var("APPDATA").unwrap_or_default();
     PathBuf::from(appdata)
@@ -18,69 +39,83 @@ fn legacy_vbs_path() -> PathBuf {
         .join("HideDesktopApps.vbs")
 }
 
-/// Remove the old VBS launcher if it exists (left over from a previous install).
-fn remove_legacy_vbs() {
-    let path = legacy_vbs_path();
-    if path.exists() {
-        let _ = std::fs::remove_file(&path);
+/// Remove any leftover startup entries from older installs.
+fn cleanup_legacy() {
+    // Old VBS launcher
+    let vbs = legacy_vbs_path();
+    if vbs.exists() {
+        let _ = std::fs::remove_file(&vbs);
+    }
+    // Old registry Run entry
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    if let Ok(key) = hkcu.open_subkey_with_flags(
+        r"Software\Microsoft\Windows\CurrentVersion\Run",
+        KEY_SET_VALUE,
+    ) {
+        let _ = key.delete_value(APP_NAME);
     }
 }
 
-/// Write a registry Run entry so the app launches at login.
-/// The exe path is quoted to handle spaces in the path.
-pub fn register(exe_path: &str, _delay_s: u32) -> Result<()> {
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-    let key = hkcu.open_subkey_with_flags(RUN_KEY, KEY_SET_VALUE)?;
-    // Quote the path so spaces are handled correctly.
-    let value = format!("\"{}\"", exe_path);
-    key.set_value(APP_NAME, &value)?;
-    // Clean up the old VBS launcher if it's still around.
-    remove_legacy_vbs();
+/// Register a scheduled task that runs the app at logon with an optional delay.
+/// Uses the same PowerShell approach as the installer so both agree on the task name.
+pub fn register(exe_path: &str, delay_s: u32) -> Result<()> {
+    // ISO 8601 duration, e.g. PT30S for 30 seconds.
+    let delay = format!("PT{}S", delay_s);
+    // Escape single quotes inside the exe path for use in a PowerShell string.
+    let escaped = exe_path.replace('\'', "''");
+    let script = format!(
+        "$t = New-ScheduledTaskTrigger -AtLogOn; \
+         $t.Delay = '{delay}'; \
+         $a = New-ScheduledTaskAction -Execute '\"{escaped}\"'; \
+         $s = New-ScheduledTaskSettingsSet -ExecutionTimeLimit 0 -AllowStartIfOnBatteries $true; \
+         Register-ScheduledTask -TaskName '{TASK_NAME}' -Trigger $t -Action $a -Settings $s -Force | Out-Null"
+    );
+    powershell(&script)?;
+    cleanup_legacy();
     Ok(())
 }
 
-/// Remove the registry Run entry.
+/// Remove the scheduled task (and any legacy startup entries).
 pub fn unregister() -> Result<()> {
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-    let key = hkcu.open_subkey_with_flags(RUN_KEY, KEY_SET_VALUE)?;
-    // delete_value returns an error if the value doesn't exist; that's fine.
-    let _ = key.delete_value(APP_NAME);
-    remove_legacy_vbs();
+    let script = format!(
+        "Unregister-ScheduledTask -TaskName '{TASK_NAME}' -Confirm:$false -ErrorAction SilentlyContinue"
+    );
+    powershell(&script)?;
+    cleanup_legacy();
     Ok(())
 }
 
-/// Returns true if the registry Run entry exists.
+/// Returns true if the scheduled task exists.
 pub fn is_registered() -> bool {
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-    if let Ok(key) = hkcu.open_subkey(RUN_KEY) {
-        let val: Result<String, _> = key.get_value(APP_NAME);
-        val.is_ok()
-    } else {
-        false
-    }
+    std::process::Command::new("schtasks.exe")
+        .args(["/query", "/tn", TASK_NAME])
+        .creation_flags(CREATE_NO_WINDOW)
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
 }
 
-/// Sync the startup entry to match the config.
+/// Sync the startup task to match config — called on every app startup.
 pub fn sync_startup(config: &crate::config::StartupConfig, exe_path: &str) {
     crate::dlog!("sync_startup: enabled={}, exe={}", config.enabled, exe_path);
     if config.enabled {
         match register(exe_path, config.delay_s) {
-            Ok(()) => crate::dlog!("startup: registered OK"),
+            Ok(()) => crate::dlog!("startup: task registered OK"),
             Err(e) => {
                 crate::dlog!("startup: register failed: {}", e);
-                eprintln!("Failed to register startup: {e}");
+                eprintln!("Failed to register startup task: {e}");
             }
         }
     } else if is_registered() {
         match unregister() {
-            Ok(()) => crate::dlog!("startup: unregistered OK"),
+            Ok(()) => crate::dlog!("startup: task unregistered OK"),
             Err(e) => {
                 crate::dlog!("startup: unregister failed: {}", e);
-                eprintln!("Failed to unregister startup: {e}");
+                eprintln!("Failed to unregister startup task: {e}");
             }
         }
     } else {
-        crate::dlog!("startup: disabled and not registered, nothing to do");
+        crate::dlog!("startup: disabled and task not present, nothing to do");
     }
 }
 
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
diff --git a/src/ui/updater_tab.rs b/src/ui/updater_tab.rs
