fix: session lock fractional scaling minor fix

crates/adapters/src/wayland/event_handling/app_dispatcher.rs

@@ -95,7 +95,12 @@ impl Dispatch<WlOutput, ()> for AppState {
         qhandle: &QueueHandle<Self>,
     ) {
         let output_id = proxy.id();
-        let handle = state.get_handle_by_output_id(&output_id);
+
+        let handle = if state.output_manager().is_none() {
+            Some(state.ensure_output_registered(&output_id))
+        } else {
+            state.get_handle_by_output_id(&output_id)
+        };
 
         match event {
             wl_output::Event::Mode {

crates/adapters/src/wayland/session_lock/manager/mod.rs

@@ -11,6 +11,7 @@ use crate::wayland::session_lock::lock_context::SessionLockContext;
 use crate::wayland::session_lock::lock_surface::LockSurface;
 use crate::wayland::surfaces::app_state::AppState;
 use crate::wayland::surfaces::keyboard_state::KeyboardState;
+use layer_shika_domain::prelude::OutputInfo;
 use layer_shika_domain::value_objects::lock_config::LockConfig;
 use layer_shika_domain::value_objects::lock_state::LockState;
 use log::info;
@@ -238,8 +239,16 @@ impl SessionLockManager {
     ) -> Result<()> {
         let component_name = self.component_definition.name().to_string();
 
+        // Use output's integer scale as fallback when fractional scale isn't available
+        #[allow(clippy::cast_precision_loss)]
+        let scale_factor = output_ctx
+            .output_info
+            .as_ref()
+            .and_then(OutputInfo::scale)
+            .map_or(self.config.scale_factor.value(), |s| s as f32);
+
         let context = LockConfigureContext {
-            scale_factor: self.config.scale_factor.value(),
+            scale_factor,
             component_definition: self.component_definition.clone(),
             compilation_result: self.compilation_result.clone(),
             platform: Rc::clone(&self.platform),
@@ -269,8 +278,17 @@ impl SessionLockManager {
     ) {
         let component_name = self.component_definition.name().to_string();
 
+        let output_scale = output_ctx.output_info.as_ref().and_then(OutputInfo::scale);
+        info!(
+            "Lock configure: output_info present={}, output_scale={:?}",
+            output_ctx.output_info.is_some(),
+            output_scale
+        );
+        #[allow(clippy::cast_precision_loss)]
+        let scale_factor = output_scale.map_or(self.config.scale_factor.value(), |s| s as f32);
+
         let context = LockConfigureContext {
-            scale_factor: self.config.scale_factor.value(),
+            scale_factor,
             component_definition: self.component_definition.clone(),
             compilation_result: self.compilation_result.clone(),
             platform: Rc::clone(&self.platform),
@@ -299,8 +317,16 @@ impl SessionLockManager {
                     continue;
                 };
 
+                // Use output's integer scale as fallback when fractional scale isn't available
+                #[allow(clippy::cast_precision_loss)]
+                let scale_factor = surface
+                    .output_info
+                    .as_ref()
+                    .and_then(OutputInfo::scale)
+                    .map_or(self.config.scale_factor.value(), |s| s as f32);
+
                 let context = LockConfigureContext {
-                    scale_factor: self.config.scale_factor.value(),
+                    scale_factor,
                     component_definition: self.component_definition.clone(),
                     compilation_result: self.compilation_result.clone(),
                     platform: Rc::clone(&self.platform),

crates/adapters/src/wayland/surfaces/app_state.rs

@@ -547,6 +547,17 @@ impl AppState {
         self.output_mapping.get(output_id)
     }
 
+    pub fn ensure_output_registered(&mut self, output_id: &ObjectId) -> OutputHandle {
+        self.output_mapping.get(output_id).unwrap_or_else(|| {
+            let h = self.output_mapping.insert(output_id.clone());
+            let is_primary = self.output_registry.is_empty();
+            let mut info = OutputInfo::new(h);
+            info.set_primary(is_primary);
+            self.output_registry.add(info);
+            h
+        })
+    }
+
     pub fn set_active_output_handle(&mut self, handle: Option<OutputHandle>) {
         self.output_registry.set_active(handle);
     }