ag

Author: dsh0416

crates/gdcef/src/utils.rs

@@ -57,52 +57,137 @@ pub fn get_display_scale_factor() -> f32 {
 #[cfg(target_os = "linux")]
 fn linux_desktop_scale_candidate() -> Option<f32> {
     *LINUX_DESKTOP_SCALE_CANDIDATE.get_or_init(|| {
-        let scales = gnome_monitors_xml_scales();
-        scales
-            .into_iter()
-            .filter(|scale| scale.is_finite() && *scale > 1.0)
-            .max_by(|a, b| a.total_cmp(b))
+        let scales = gnome_monitor_scales();
+        match scales.primary_scale {
+            Some(scale) if scale.is_finite() && scale > 1.0 => Some(scale),
+            Some(_) => None,
+            None => scales
+                .all_scales
+                .into_iter()
+                .filter(|scale| scale.is_finite() && *scale > 1.0)
+                .max_by(|a, b| a.total_cmp(b)),
+        }
     })
 }
 
 #[cfg(target_os = "linux")]
-fn gnome_monitors_xml_scales() -> Vec<f32> {
+#[derive(Default)]
+struct GnomeMonitorScales {
+    primary_scale: Option<f32>,
+    all_scales: Vec<f32>,
+}
+
+#[cfg(target_os = "linux")]
+fn gnome_monitor_scales() -> GnomeMonitorScales {
+    let scales = gnome_monitors_xml_scales();
+    let primary_scale = scales
+        .logical_monitors
+        .iter()
+        .find(|monitor| monitor.primary)
+        .and_then(|monitor| monitor.scale);
+    let all_scales = scales
+        .logical_monitors
+        .into_iter()
+        .filter_map(|monitor| monitor.scale)
+        .collect::<Vec<_>>();
+    GnomeMonitorScales {
+        primary_scale,
+        all_scales,
+    }
+}
+
+#[cfg(target_os = "linux")]
+#[derive(Default)]
+struct GnomeMonitorsXml {
+    logical_monitors: Vec<GnomeLogicalMonitor>,
+}
+
+#[cfg(target_os = "linux")]
+#[derive(Default)]
+struct GnomeLogicalMonitor {
+    primary: bool,
+    scale: Option<f32>,
+}
+
+#[cfg(target_os = "linux")]
+enum MonitorXmlText {
+    Primary,
+    Scale,
+}
+
+#[cfg(target_os = "linux")]
+fn gnome_monitors_xml_scales() -> GnomeMonitorsXml {
     use quick_xml::Reader;
     use quick_xml::events::Event;
 
-    let Some(home) = std::env::var_os("HOME") else {
-        return Vec::new();
+    let Some(config_home) = linux_config_home() else {
+        return GnomeMonitorsXml::default();
     };
-    let path = PathBuf::from(home).join(".config/monitors.xml");
+    let path = config_home.join("monitors.xml");
     let Ok(contents) = std::fs::read_to_string(path) else {
-        return Vec::new();
+        return GnomeMonitorsXml::default();
     };
     let mut reader = Reader::from_str(&contents);
     reader.config_mut().trim_text(true);
 
-    let mut scales = Vec::new();
-    let mut in_scale = false;
+    let mut logical_monitors = Vec::new();
+    let mut current_monitor: Option<GnomeLogicalMonitor> = None;
+    let mut text_target: Option<MonitorXmlText> = None;
     loop {
         match reader.read_event() {
-            Ok(Event::Start(element)) if element.name().as_ref() == b"scale" => {
-                in_scale = true;
+            Ok(Event::Start(element)) if element.name().as_ref() == b"logicalmonitor" => {
+                current_monitor = Some(GnomeLogicalMonitor::default());
+            }
+            Ok(Event::End(element)) if element.name().as_ref() == b"logicalmonitor" => {
+                if let Some(monitor) = current_monitor.take() {
+                    logical_monitors.push(monitor);
+                }
+                text_target = None;
+            }
+            Ok(Event::Start(element)) if current_monitor.is_some() => {
+                text_target = match element.name().as_ref() {
+                    b"primary" => Some(MonitorXmlText::Primary),
+                    b"scale" => Some(MonitorXmlText::Scale),
+                    _ => None,
+                };
             }
-            Ok(Event::End(element)) if element.name().as_ref() == b"scale" => {
-                in_scale = false;
+            Ok(Event::End(element)) if matches!(element.name().as_ref(), b"primary" | b"scale") => {
+                text_target = None;
             }
-            Ok(Event::Text(text)) if in_scale => {
-                if let Ok(value) = text.decode()
-                    && let Ok(scale) = value.parse::<f32>()
+            Ok(Event::Text(text)) => {
+                if let Some(monitor) = current_monitor.as_mut()
+                    && let Some(value) = text.decode().ok()
                 {
-                    scales.push(scale);
+                    match text_target {
+                        Some(MonitorXmlText::Primary) => {
+                            let normalized = value.trim();
+                            monitor.primary =
+                                normalized == "yes" || normalized == "true" || normalized == "1";
+                        }
+                        Some(MonitorXmlText::Scale) => {
+                            if let Ok(scale) = value.parse::<f32>() {
+                                monitor.scale = Some(scale);
+                            }
+                        }
+                        None => {}
+                    }
                 }
             }
             Ok(Event::Eof) => break,
-            Err(_) => return Vec::new(),
+            Err(_) => return GnomeMonitorsXml::default(),
             _ => {}
         }
     }
-    scales
+
+    GnomeMonitorsXml { logical_monitors }
+}
+
+#[cfg(target_os = "linux")]
+fn linux_config_home() -> Option<PathBuf> {
+    std::env::var_os("XDG_CONFIG_HOME")
+        .filter(|path| !path.is_empty())
+        .map(PathBuf::from)
+        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".config")))
 }
 
 #[cfg(target_os = "linux")]