fix: runtime issues — left-click, startup task, toggle buttons

- tray: left-click now toggles icons (right-click shows menu)
  via .with_menu_on_left_click(false)
- startup: add -ExecutionPolicy Bypass to all PowerShell calls
  so the scheduled task registers reliably regardless of policy
- installer: desktop shortcut is checked by default and writes
  to userdesktop instead of commondesktop (fixes silent failure
  when installing without elevation)
- icons: send WM_COMMAND(0x7402) to SHELLDLL_DefView instead of
  Progman — more reliable on Windows 10/11
- logging: add debug.log written to %APPDATA%\HideDesktopApps\
  so errors from Win32 calls are visible (eprintln goes nowhere
  in a windows_subsystem=windows app)

Author: Londopy

assets/installer.iss

@@ -1,47 +1,43 @@
 use anyhow::Result;
 use windows::core::w;
 use windows::Win32::Foundation::HWND;
-use windows::Win32::UI::WindowsAndMessaging::{FindWindowW, SendMessageTimeoutW, SMTO_ABORTIFHUNG};
+use windows::Win32::UI::WindowsAndMessaging::{
+    FindWindowW, SendMessageTimeoutW, SMTO_ABORTIFHUNG,
+};
 
 const WM_COMMAND: u32 = 0x0111;
-// Shell command to toggle desktop icon visibility
 const SHCMD_TOGGLE_DESKTOP_ICONS: u32 = 0x7402;
 
 fn get_progman() -> HWND {
-    // SAFETY: FFI call to find the Progman window which hosts desktop icons
     unsafe {
         FindWindowW(w!("Progman"), windows::core::PCWSTR::null())
             .unwrap_or(HWND(std::ptr::null_mut()))
     }
 }
 
 fn get_shell_defview() -> Option<HWND> {
-    // SAFETY: FFI calls to traverse the window hierarchy to find ShellDefView
     unsafe {
         let progman = get_progman();
-        if progman.0.is_null() {
-            return None;
-        }
-
-        let defview = windows::Win32::UI::WindowsAndMessaging::FindWindowExW(
-            progman,
-            HWND(std::ptr::null_mut()),
-            w!("SHELLDLL_DefView"),
-            windows::core::PCWSTR::null(),
-        )
-        .unwrap_or(HWND(std::ptr::null_mut()));
-
-        if !defview.0.is_null() {
-            return Some(defview);
+        if !progman.0.is_null() {
+            let dv = windows::Win32::UI::WindowsAndMessaging::FindWindowExW(
+                progman,
+                HWND(std::ptr::null_mut()),
+                w!("SHELLDLL_DefView"),
+                windows::core::PCWSTR::null(),
+            )
+            .unwrap_or(HWND(std::ptr::null_mut()));
+            if !dv.0.is_null() {
+                return Some(dv);
+            }
         }
 
-        // Desktop icons may be hosted inside a WorkerW instead of Progman
+        // On Windows 11 DefView may be hosted inside a WorkerW, not Progman.
         let mut found = HWND(std::ptr::null_mut());
+
         unsafe extern "system" fn find_defview_cb(
             hwnd: HWND,
             lparam: windows::Win32::Foundation::LPARAM,
         ) -> windows::Win32::Foundation::BOOL {
-            // SAFETY: lparam is a valid pointer to HWND that we passed in
             let target = &mut *(lparam.0 as *mut HWND);
             let dv = windows::Win32::UI::WindowsAndMessaging::FindWindowExW(
                 hwnd,
@@ -72,11 +68,13 @@ fn get_shell_defview() -> Option<HWND> {
 
 /// Returns true if desktop icons are currently visible.
 pub fn are_icons_visible() -> bool {
-    // SAFETY: FFI call to find the SysListView32 which is the icon container
     unsafe {
         let defview = match get_shell_defview() {
             Some(dv) => dv,
-            None => return true,
+            None => {
+                crate::dlog!("are_icons_visible: SHELLDLL_DefView not found, assuming visible");
+                return true;
+            }
         };
 
         let listview = windows::Win32::UI::WindowsAndMessaging::FindWindowExW(
@@ -88,46 +86,67 @@ pub fn are_icons_visible() -> bool {
         .unwrap_or(HWND(std::ptr::null_mut()));
 
         if listview.0.is_null() {
+            crate::dlog!("are_icons_visible: SysListView32 not found, assuming visible");
             return true;
         }
 
-        windows::Win32::UI::WindowsAndMessaging::IsWindowVisible(listview).as_bool()
+        let visible =
+            windows::Win32::UI::WindowsAndMessaging::IsWindowVisible(listview).as_bool();
+        crate::dlog!("are_icons_visible: SysListView32 visible = {visible}");
+        visible
     }
 }
 
-/// Toggle desktop icon visibility by sending a WM_COMMAND to the ShellDefView.
+/// Toggle desktop icon visibility by sending WM_COMMAND(0x7402) to
+/// SHELLDLL_DefView. Falls back to Progman if DefView is not found.
 pub fn toggle_icons() -> Result<()> {
-    // SAFETY: FFI calls to send a shell command that toggles icon visibility
     unsafe {
-        let progman = get_progman();
-        anyhow::ensure!(!progman.0.is_null(), "Could not find Progman window");
+        let target = match get_shell_defview() {
+            Some(dv) => {
+                crate::dlog!("toggle_icons: target = SHELLDLL_DefView");
+                dv
+            }
+            None => {
+                let progman = get_progman();
+                anyhow::ensure!(!progman.0.is_null(), "Could not find Progman window");
+                crate::dlog!("toggle_icons: target = Progman (fallback)");
+                progman
+            }
+        };
 
         let mut result = 0usize;
         SendMessageTimeoutW(
-            progman,
+            target,
             WM_COMMAND,
             windows::Win32::Foundation::WPARAM(SHCMD_TOGGLE_DESKTOP_ICONS as usize),
             windows::Win32::Foundation::LPARAM(0),
             SMTO_ABORTIFHUNG,
             1000,
             Some(&mut result),
         );
+        crate::dlog!("toggle_icons: WM_COMMAND sent, result = {result}");
     }
     Ok(())
 }
 
-/// Hide desktop icons. If already hidden, does nothing.
+/// Hide desktop icons. Does nothing if already hidden.
 pub fn hide_icons() -> Result<()> {
+    crate::dlog!("hide_icons called");
     if are_icons_visible() {
         toggle_icons()?;
+    } else {
+        crate::dlog!("hide_icons: already hidden, skipping");
     }
     Ok(())
 }
 
-/// Show desktop icons. If already visible, does nothing.
+/// Show desktop icons. Does nothing if already visible.
 pub fn show_icons() -> Result<()> {
+    crate::dlog!("show_icons called");
     if !are_icons_visible() {
         toggle_icons()?;
+    } else {
+        crate::dlog!("show_icons: already visible, skipping");
     }
     Ok(())
 }

src/icons.rs

@@ -0,0 +1,31 @@
+use std::fs::OpenOptions;
+use std::io::Write;
+
+/// Write a line to %APPDATA%\HideDesktopApps\debug.log.
+/// Does nothing if the path can't be opened — never panics.
+pub fn write(msg: &str) {
+    let log_path = match std::env::var("APPDATA") {
+        Ok(appdata) => std::path::PathBuf::from(appdata)
+            .join("HideDesktopApps")
+            .join("debug.log"),
+        Err(_) => return,
+    };
+
+    // Make sure the directory exists before trying to open the file.
+    if let Some(parent) = log_path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+
+    if let Ok(mut file) = OpenOptions::new().create(true).append(true).open(&log_path) {
+        let now = chrono::Local::now();
+        let _ = writeln!(file, "[{}] {}", now.format("%H:%M:%S%.3f"), msg);
+    }
+}
+
+/// Convenience macro so call sites look like eprintln!.
+#[macro_export]
+macro_rules! dlog {
+    ($($arg:tt)*) => {
+        $crate::log_util::write(&format!($($arg)*))
+    };
+}

src/log_util.rs

@@ -4,6 +4,8 @@ mod config;
 mod discord;
 mod hotkeys;
 mod icons;
+#[macro_use]
+mod log_util;
 mod notifications;
 mod profiles;
 mod startup;
@@ -58,6 +60,7 @@ fn main() {
 }
 
 fn run() -> Result<()> {
+    dlog!("--- HideDesktopApps starting ---");
     let config = config::load_config()?;
     let config_shared = Arc::new(Mutex::new(config.clone()));
     let state_shared = Arc::new(Mutex::new(AppState::default()));
@@ -236,15 +239,18 @@ fn main_loop(
         while let Ok(cmd) = cmd_rx.try_recv() {
             match cmd {
                 Cmd::ToggleIcons => {
+                    dlog!("Cmd::ToggleIcons received");
                     let mut state = state_shared.lock().unwrap();
                     if state.icons_hidden {
                         if let Err(e) = icons::show_icons() {
+                            dlog!("show_icons error: {e}");
                             eprintln!("show_icons error: {e}");
                         } else {
                             state.icons_hidden = false;
                         }
                     } else {
                         if let Err(e) = icons::hide_icons() {
+                            dlog!("hide_icons error: {e}");
                             eprintln!("hide_icons error: {e}");
                         } else {
                             state.icons_hidden = true;
@@ -255,15 +261,18 @@ fn main_loop(
                 }
 
                 Cmd::ToggleTaskbar => {
+                    dlog!("Cmd::ToggleTaskbar received");
                     let mut state = state_shared.lock().unwrap();
                     if state.taskbar_hidden {
                         if let Err(e) = taskbar::show_taskbar() {
+                            dlog!("show_taskbar error: {e}");
                             eprintln!("show_taskbar error: {e}");
                         } else {
                             state.taskbar_hidden = false;
                         }
                     } else {
                         if let Err(e) = taskbar::hide_taskbar() {
+                            dlog!("hide_taskbar error: {e}");
                             eprintln!("hide_taskbar error: {e}");
                         } else {
                             state.taskbar_hidden = true;
@@ -274,10 +283,12 @@ fn main_loop(
                 }
 
                 Cmd::ToggleWindows => {
+                    dlog!("Cmd::ToggleWindows received");
                     let mut state = state_shared.lock().unwrap();
                     let cfg = config_shared.lock().unwrap().clone();
                     if state.windows_hidden {
                         if let Err(e) = win_ops::restore_windows(&state.hidden_windows) {
+                            dlog!("restore_windows error: {e}");
                             eprintln!("restore_windows error: {e}");
                         } else {
                             state.hidden_windows.clear();
@@ -289,7 +300,10 @@ fn main_loop(
                                 state.hidden_windows = hidden;
                                 state.windows_hidden = true;
                             }
-                            Err(e) => eprintln!("hide_windows error: {e}"),
+                            Err(e) => {
+                                dlog!("hide_windows error: {e}");
+                                eprintln!("hide_windows error: {e}");
+                            }
                         }
                     }
                     tray::update_tray(&tray_handle, &state);
@@ -329,56 +343,10 @@ fn main_loop(
                 }
 
                 Cmd::OpenSettings => {
+                    dlog!("Cmd::OpenSettings received");
                     ui::open_settings(Arc::clone(&config_shared), cmd_tx.clone());
                 }
 
                 Cmd::CheckForUpdates => {
                     let cfg = config_shared.lock().unwrap().clone();
-                    updater::background_check(cfg.updater, cmd_tx.clone());
-                }
-
-                Cmd::Restart => {
-                    // Restore all before restarting
-                    {
-                        let mut state = state_shared.lock().unwrap();
-                        profiles::restore_all(&mut state);
-                    }
-                    let exe = std::env::current_exe()
-                        .unwrap_or_else(|_| std::path::PathBuf::from("HideDesktopApps.exe"));
-                    let _ = std::process::Command::new(exe).spawn();
-                    return Ok(());
-                }
-
-                Cmd::Exit => {
-                    // Restore everything cleanly before exiting
-                    let mut state = state_shared.lock().unwrap();
-                    profiles::restore_all(&mut state);
-                    return Ok(());
-                }
-
-                Cmd::UpdateAvailable(version) => {
-                    let cfg = config_shared.lock().unwrap().clone();
-                    notifications::notify_update_available(&version, &cfg.notifications);
-                    eprintln!("Update available: {version}");
-                }
-
-                Cmd::HotkeyFailed(hotkey) => {
-                    let cfg = config_shared.lock().unwrap().clone();
-                    notifications::notify_hotkey_failed(&hotkey, &cfg.notifications);
-                }
-            }
-        }
-    }
-}
-
-/// Update Discord Rich Presence if enabled.
-fn update_discord(state: &AppState, config: &AppConfig) {
-    if config.discord.enabled {
-        discord::set_rich_presence(
-            state.icons_hidden,
-            state.taskbar_hidden,
-            state.windows_hidden,
-            state.active_profile.clone(),
-        );
-    }
-}
+                    updater::background_check(cfg.updater, cmd_t

src/main.rs

@@ -18,6 +18,8 @@ Register-ScheduledTask -TaskName 'HideDesktopApps' -Action $action -Trigger $tri
 
     let output = std::process::Command::new("powershell")
         .args([
+            "-ExecutionPolicy",
+            "Bypass",
             "-WindowStyle",
             "Hidden",
             "-NonInteractive",
@@ -38,6 +40,8 @@ Register-ScheduledTask -TaskName 'HideDesktopApps' -Action $action -Trigger $tri
 pub fn unregister() -> Result<()> {
     let output = std::process::Command::new("powershell")
         .args([
+            "-ExecutionPolicy",
+            "Bypass",
             "-WindowStyle",
             "Hidden",
             "-NonInteractive",
@@ -58,6 +62,8 @@ pub fn unregister() -> Result<()> {
 pub fn is_registered() -> bool {
     let out = std::process::Command::new("powershell")
         .args([
+            "-ExecutionPolicy",
+            "Bypass",
             "-WindowStyle",
             "Hidden",
             "-NonInteractive",
@@ -74,10 +80,4 @@ pub fn sync_startup(config: &crate::config::StartupConfig, exe_path: &str) {
     if config.enabled {
         if let Err(e) = register(exe_path, config.delay_s) {
             eprintln!("Failed to register startup task: {e}");
-        }
-    } else if is_registered() {
-        if let Err(e) = unregister() {
-            eprintln!("Failed to unregister startup task: {e}");
-        }
-    }
-}
+