Merge pull request #406 from dwall-rs/main

0.1.22

Author: thep0y

Cargo.lock

@@ -4,7 +4,7 @@ members = ["daemon", "src-tauri"]
 
 [workspace.package]
 authors = ["thep0y"]
-version = "0.1.21"
+version = "0.1.22"
 # homepage = ""
 repository = "https://github.com/dwall-rs/dwall"
 license = "AGPL-3.0"

Cargo.toml

@@ -1,35 +1,13 @@
 use std::fmt;
 
 use serde::Deserialize;
-use windows::{
-    core::PCWSTR,
-    Win32::{
-        Foundation::{ERROR_SUCCESS, LPARAM, WPARAM},
-        System::Registry::{
-            RegCloseKey, RegOpenKeyExW, RegQueryValueExW, RegSetValueExW, HKEY, HKEY_CURRENT_USER,
-            KEY_QUERY_VALUE, KEY_SET_VALUE, REG_DWORD, REG_SAM_FLAGS,
-        },
-        UI::WindowsAndMessaging::{SendNotifyMessageW, HWND_BROADCAST, WM_SETTINGCHANGE},
-    },
+use windows::Win32::{
+    Foundation::{LPARAM, WPARAM},
+    System::Registry::{KEY_QUERY_VALUE, KEY_SET_VALUE, REG_DWORD},
+    UI::WindowsAndMessaging::{SendNotifyMessageW, HWND_BROADCAST, WM_SETTINGCHANGE},
 };
 
-use crate::{error::DwallResult, utils::string::WideStringExt};
-
-/// Custom error types for registry operations
-#[derive(thiserror::Error, Debug)]
-pub enum ColorModeRegistryError {
-    #[error("Registry operation failed: Open key {0}")]
-    Open(u32),
-
-    #[error("Registry operation failed: Query value {0}")]
-    Query(u32),
-
-    #[error("Registry operation failed: Set value {0}")]
-    Set(u32),
-
-    #[error("Registry operation failed: Close key {0}")]
-    Close(u32),
-}
+use crate::{error::DwallResult, registry::RegistryKey, utils::string::WideStringExt};
 
 #[derive(Debug, PartialEq, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
@@ -38,78 +16,23 @@ pub enum ColorMode {
     Dark,
 }
 
-impl fmt::Display for ColorMode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ColorMode {
+    fn as_u32(&self) -> u32 {
         match self {
-            ColorMode::Light => write!(f, "Light"),
-            ColorMode::Dark => write!(f, "Dark"),
-        }
-    }
-}
-
-/// RAII wrapper for Windows registry key handles
-/// Automatically closes the key handle when dropped
-struct RegistryKey {
-    hkey: HKEY,
-    path: String,
-}
-
-impl RegistryKey {
-    /// Open a registry key with specified access rights
-    fn open(path: &str, access: REG_SAM_FLAGS) -> DwallResult<Self> {
-        debug!(path = path, "Attempting to open registry key");
-        let wide_path = Vec::from_str(path);
-        let mut hkey = HKEY::default();
-
-        unsafe {
-            let result = RegOpenKeyExW(
-                HKEY_CURRENT_USER,
-                PCWSTR(wide_path.as_ptr()),
-                None,
-                access,
-                &mut hkey,
-            );
-
-            match result {
-                ERROR_SUCCESS => {
-                    info!(path = path, "Successfully opened registry key");
-                    Ok(Self {
-                        hkey,
-                        path: path.to_string(),
-                    })
-                }
-                err => {
-                    error!(
-                        path = path,
-                        error_code = err.0,
-                        "Failed to open registry key"
-                    );
-                    Err(ColorModeRegistryError::Open(err.0).into())
-                }
-            }
+            ColorMode::Light => 1,
+            ColorMode::Dark => 0,
         }
     }
-
-    /// Get the raw HKEY handle
-    fn as_raw(&self) -> HKEY {
-        self.hkey
+    fn to_le_bytes(&self) -> [u8; 4] {
+        self.as_u32().to_le_bytes()
     }
 }
 
-impl Drop for RegistryKey {
-    fn drop(&mut self) {
-        trace!(path = self.path, "Automatically closing registry key");
-        unsafe {
-            let err = RegCloseKey(self.hkey);
-            if err != ERROR_SUCCESS {
-                warn!(
-                    path = self.path,
-                    error_code = err.0,
-                    "Failed to close registry key on drop"
-                );
-            } else {
-                debug!(path = self.path, "Successfully closed registry key");
-            }
+impl fmt::Display for ColorMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ColorMode::Light => write!(f, "Light"),
+            ColorMode::Dark => write!(f, "Dark"),
         }
     }
 }
@@ -132,41 +55,26 @@ impl ColorModeManager {
         info!("Retrieving current system color mode");
         let registry_key = RegistryKey::open(Self::PERSONALIZE_KEY_PATH, KEY_QUERY_VALUE)?;
 
-        let value_name = Vec::from_str(Self::APPS_THEME_VALUE);
-        let mut value: u32 = 0;
-        let mut size = std::mem::size_of::<u32>() as u32;
-
-        unsafe {
-            let result = RegQueryValueExW(
-                registry_key.as_raw(),
-                PCWSTR(value_name.as_ptr()),
-                None,
-                None,
-                Some(&mut value as *mut u32 as *mut u8),
-                Some(&mut size),
-            );
-
-            match result {
-                ERROR_SUCCESS => {
-                    let mode = if value == 1 {
-                        debug!("Current color mode is Light");
-                        ColorMode::Light
-                    } else {
-                        debug!("Current color mode is Dark");
-                        ColorMode::Dark
-                    };
-                    Ok(mode)
-                }
-                err => {
-                    error!(
-                        value_name = Self::APPS_THEME_VALUE,
-                        error_code = err.0,
-                        "Failed to query color mode value"
-                    );
-                    Err(ColorModeRegistryError::Query(err.0).into())
-                }
-            }
-        }
+        let mut data: u32 = 0;
+        let mut data_size = std::mem::size_of_val(&data) as u32;
+        let mut data_type = REG_DWORD;
+
+        registry_key.query(
+            Self::APPS_THEME_VALUE,
+            Some(std::ptr::addr_of_mut!(data_type)),
+            Some(std::ptr::addr_of_mut!(data) as *mut u8),
+            Some(&mut data_size),
+        )?;
+        debug!(value = data, "Retrieved app theme value from registry");
+
+        let mode = if data == 1 {
+            debug!("Current color mode is Light");
+            ColorMode::Light
+        } else {
+            debug!("Current color mode is Dark");
+            ColorMode::Dark
+        };
+        Ok(mode)
     }
 
     /// Set the system color mode in the registry
@@ -181,51 +89,25 @@ impl ColorModeManager {
         info!(mode = %mode, "Setting system color mode");
         let registry_key = RegistryKey::open(Self::PERSONALIZE_KEY_PATH, KEY_SET_VALUE)?;
 
-        let value = match mode {
-            ColorMode::Light => [1u8, 0, 0, 0],
-            ColorMode::Dark => [0u8, 0, 0, 0],
-        };
-
-        let apps_value = Vec::from_str(Self::APPS_THEME_VALUE);
-        let system_value = Vec::from_str(Self::SYSTEM_THEME_VALUE);
-
-        unsafe {
-            let set_apps_result = RegSetValueExW(
-                registry_key.as_raw(),
-                PCWSTR(apps_value.as_ptr()),
-                None,
-                REG_DWORD,
-                Some(&value),
-            );
-
-            let set_system_result = RegSetValueExW(
-                registry_key.as_raw(),
-                PCWSTR(system_value.as_ptr()),
-                None,
-                REG_DWORD,
-                Some(&value),
-            );
-
-            match (set_apps_result, set_system_result) {
-                (ERROR_SUCCESS, ERROR_SUCCESS) => {
-                    info!(mode = %mode, "Successfully set color mode");
-                }
-                _ => {
-                    error!(
-                        mode = %mode,
-                        apps_result = set_apps_result.0,
-                        system_result = set_system_result.0,
-                        "Failed to set color mode"
-                    );
-                    return Err(ColorModeRegistryError::Set(
-                        set_apps_result.0 | set_system_result.0,
-                    )
-                    .into());
-                }
-            };
-
-            notify_theme_change()?;
-        }
+        let value = mode.to_le_bytes();
+
+        registry_key
+            .set(Self::APPS_THEME_VALUE, REG_DWORD, &value)
+            .map_err(|e| {
+                error!(error =?e, "Failed to set apps theme value");
+                e
+            })?;
+        info!(mode = %mode, "Successfully set apps theme value");
+
+        registry_key
+            .set(Self::SYSTEM_THEME_VALUE, REG_DWORD, &value)
+            .map_err(|e| {
+                error!(error =?e, "Failed to set system theme value");
+                e
+            })?;
+        info!(mode = %mode, "Successfully set system theme value");
+
+        notify_theme_change()?;
 
         Ok(())
     }

bun.lockb

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use serde_valid::Validate;
 use thiserror::Error;
 
-use crate::{error::DwallResult, lazy::DWALL_CONFIG_DIR, theme::ThemeError};
+use crate::{error::DwallResult, lazy::DWALL_CONFIG_DIR};
 
 #[derive(Error, Debug)]
 pub enum ConfigError {
@@ -77,16 +77,38 @@ impl CoordinateSource {
     }
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[serde(untagged)]
+pub enum MonitorSpecificWallpapers {
+    All(String),
+    Specific(HashMap<String, String>),
+}
+
+impl MonitorSpecificWallpapers {
+    pub fn is_all(&self) -> bool {
+        matches!(self, MonitorSpecificWallpapers::All(_))
+    }
+
+    pub fn is_empty(&self) -> bool {
+        match self {
+            MonitorSpecificWallpapers::All(_) => false,
+            MonitorSpecificWallpapers::Specific(wallpapers) => wallpapers.is_empty(),
+        }
+    }
+
+    pub fn get(&self, monitor_id: &str) -> Option<&String> {
+        match self {
+            MonitorSpecificWallpapers::All(theme_id) => Some(theme_id),
+            MonitorSpecificWallpapers::Specific(wallpapers) => wallpapers.get(monitor_id),
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Validate, Clone, PartialEq)]
 pub struct Config {
     #[serde(skip_serializing_if = "Option::is_none")]
     github_mirror_template: Option<String>,
 
-    /// When `monitor_specific_wallpapers` is not set, `selected_theme_id` will be applied to all monitors.
-    /// Otherwise, `selected_theme_id` will not take effect, and wallpapers will be set according to `monitor_specific_wallpapers`.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    selected_theme_id: Option<String>,
-
     #[serde(default = "default_image_format")]
     image_format: ImageFormat,
 
@@ -104,7 +126,7 @@ pub struct Config {
 
     /// Wallpapers specific to each monitor, using monitor ID as key
     #[serde(default = "default_monitor_specific_wallpapers")]
-    monitor_specific_wallpapers: HashMap<String, String>,
+    monitor_specific_wallpapers: MonitorSpecificWallpapers,
 
     /// Time interval for detecting solar altitude angle and azimuth angle
     /// Measured in seconds, range: [1, 600]
@@ -138,8 +160,8 @@ fn default_themes_directory() -> PathBuf {
     DWALL_CONFIG_DIR.join("themes")
 }
 
-fn default_monitor_specific_wallpapers() -> HashMap<String, String> {
-    HashMap::new()
+fn default_monitor_specific_wallpapers() -> MonitorSpecificWallpapers {
+    MonitorSpecificWallpapers::Specific(HashMap::new())
 }
 
 impl Config {
@@ -160,13 +182,6 @@ impl Config {
         Ok(())
     }
 
-    /// Returns the default theme ID or an error if not set
-    pub fn default_theme_id(&self) -> DwallResult<&str> {
-        self.selected_theme_id
-            .as_deref()
-            .ok_or(ThemeError::MissingDefaultTheme.into())
-    }
-
     /// Returns the themes directory path
     pub fn themes_directory(&self) -> &Path {
         &self.themes_directory
@@ -205,7 +220,7 @@ impl Config {
     }
 
     /// Returns the monitor-specific wallpapers map
-    pub fn monitor_specific_wallpapers(&self) -> &HashMap<String, String> {
+    pub fn monitor_specific_wallpapers(&self) -> &MonitorSpecificWallpapers {
         &self.monitor_specific_wallpapers
     }
 
@@ -239,11 +254,10 @@ impl Default for Config {
             image_format: Default::default(),
             coordinate_source: Default::default(),
             github_mirror_template: Default::default(),
-            selected_theme_id: Default::default(),
             auto_detect_color_mode: default_auto_detect_color_mode(),
             themes_directory: default_themes_directory(),
             lock_screen_wallpaper_enabled: default_lock_screen_wallpaper_enabled(),
-            monitor_specific_wallpapers: Default::default(),
+            monitor_specific_wallpapers: default_monitor_specific_wallpapers(),
             // On the equator, an azimuth change of 0.1 degrees takes
             // approximately 12 seconds, and an altitude change of 0.1
             // degrees takes about 24 seconds.