chore: ime bug in multi_window fixed

Author: Decodetalkers

Cargo.lock

@@ -78,6 +78,7 @@ window_clipboard = "0.4.1"
 
 bitflags = "2.9.0"
 log = "0.4.22"
+enumflags2 = "0.7.11"
 
 xkbcommon-dl = "0.4.2"
 smol_str = "0.2.2" #NOTE: follow iced

Cargo.toml

@@ -24,3 +24,4 @@ layershellev.workspace = true
 window_clipboard.workspace = true
 log.workspace = true
 futures.workspace = true
+enumflags2.workspace = true

iced_layershell/Cargo.toml

@@ -1,4 +1,6 @@
+use crate::ime_preedit::ImeState;
 use crate::reexport::{Anchor, Layer, WlRegion};
+use enumflags2::BitFlags;
 use iced::window::Id as IcedId;
 use iced_core::input_method;
 use iced_core::mouse::Interaction;
@@ -18,7 +20,7 @@ pub(crate) enum LayerShellAction {
     RedrawWindow(LayerId), // maybe one day it is useful, but now useless
     NewMenu(IcedNewPopupSettings, iced_core::window::Id),
     Ime(input_method::InputMethod),
-    ImeWithId(LayerId, input_method::InputMethod),
+    ImeWithId(LayerId, input_method::InputMethod, BitFlags<ImeState>),
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

iced_layershell/src/actions.rs

@@ -2,6 +2,8 @@ use iced_core::{
     Color, Padding, Point, Rectangle, Size, Text, Vector, alignment, input_method, renderer, text,
 };
 
+use enumflags2::bitflags;
+
 pub struct Preedit<Renderer>
 where
     Renderer: text::Renderer,
@@ -11,6 +13,14 @@ where
     spans: Vec<text::Span<'static, (), Renderer::Font>>,
 }
 
+#[bitflags]
+#[derive(Debug, Clone, Copy)]
+#[repr(u64)]
+pub enum ImeState {
+    ToBeAllowed = 1,
+    ToBeUpdate = 2,
+}
+
 impl<Renderer> Preedit<Renderer>
 where
     Renderer: text::Renderer,

iced_layershell/src/ime_preedit.rs

@@ -467,23 +467,30 @@ where
                         }
                     }
                 }
-                LayerShellAction::ImeWithId(id, ime) => match ime{
+                LayerShellAction::ImeWithId(id, ime, ime_flags) => match ime{
+
                     iced_core::InputMethod::Disabled => {
-                        ev.set_ime_allowed(false);
+                        ev.set_ime_allowed_with_id(false, id);
                     }
                     iced_core::InputMethod::Enabled {
                         position, purpose, ..
                     } => {
-                        ev.set_ime_allowed(true);
-                        ev.set_ime_purpose(conversion::ime_purpose(purpose));
-                        ev.set_ime_cursor_area(
-                            layershellev::dpi::LogicalPosition::new(position.x, position.y),
-                            layershellev::dpi::LogicalSize {
-                                width: 10,
-                                height: 10,
-                            },
-                            id,
-                        );
+                        use crate::ime_preedit::ImeState;
+                        if ime_flags.contains(ImeState::ToBeAllowed) {
+                            ev.set_ime_allowed(true);
+                        }
+
+                        if ime_flags.contains(ImeState::ToBeUpdate) {
+                            ev.set_ime_purpose(conversion::ime_purpose(purpose));
+                            ev.set_ime_cursor_area(
+                                layershellev::dpi::LogicalPosition::new(position.x, position.y),
+                                layershellev::dpi::LogicalSize {
+                                    width: 10,
+                                    height: 10,
+                                },
+                                id,
+                            );
+                        }
                     }
                 },
                 LayerShellAction::NewMenu(menusettings, info) => 'out: {
@@ -693,11 +700,12 @@ async fn run_instance<A, E, C>(
                 } = ui_state
                 {
                     events.push((Some(id), redraw_event.clone()));
+                    let need_update_ime = window.request_input_method(input_method.clone());
                     custom_actions.push(LayerShellAction::ImeWithId(
                         oid.expect("id should exist when refreshing"),
-                        input_method.clone(),
+                        input_method,
+                        need_update_ime,
                     ));
-                    window.request_input_method(input_method);
                 }
 
                 window.draw_preedit();

iced_layershell/src/multi_window.rs

@@ -2,8 +2,9 @@ use std::{collections::BTreeMap, sync::Arc};
 
 use super::state::State;
 use crate::DefaultStyle;
-use crate::ime_preedit::Preedit;
+use crate::ime_preedit::{ImeState, Preedit};
 use crate::multi_window::Application;
+use enumflags2::{BitFlag, BitFlags};
 use iced_core::InputMethod;
 use iced_core::input_method;
 use iced_graphics::Compositor;
@@ -149,17 +150,25 @@ where
     C: Compositor<Renderer = A::Renderer>,
     A::Theme: DefaultStyle,
 {
-    pub fn request_input_method(&mut self, input_method: InputMethod) {
+    pub fn request_input_method(&mut self, input_method: InputMethod) -> BitFlags<ImeState> {
         match input_method {
             InputMethod::Disabled => {
                 self.disable_ime();
+                ImeState::empty()
             }
             InputMethod::Enabled {
                 position,
                 purpose,
                 preedit,
             } => {
-                self.enable_ime(position, purpose);
+                let mut flags = ImeState::empty();
+                if self.ime_state.is_none() {
+                    flags.insert(ImeState::ToBeAllowed);
+                }
+                if self.ime_state != Some((position, purpose)) {
+                    flags.insert(ImeState::ToBeUpdate);
+                }
+                self.update_ime(position, purpose);
 
                 if let Some(preedit) = preedit {
                     if preedit.content.is_empty() {
@@ -179,6 +188,8 @@ where
                 } else {
                     self.preedit = None;
                 }
+
+                flags
             }
         }
     }
@@ -196,7 +207,7 @@ where
         }
     }
 
-    fn enable_ime(&mut self, position: iced_core::Point, purpose: input_method::Purpose) {
+    fn update_ime(&mut self, position: iced_core::Point, purpose: input_method::Purpose) {
         if self.ime_state != Some((position, purpose)) {
             self.ime_state = Some((position, purpose));
         }

iced_layershell/src/multi_window/window_manager.rs

@@ -767,22 +767,6 @@ impl<T> WindowState<T> {
 }
 
 impl<T> WindowState<T> {
-    /// gen the wrapper for the main window
-    /// if there is none, it will create a fake wrapper
-    /// used to get display and etc
-    /// It is not suggested to use this one, We will remove this one in next version
-    #[deprecated(note = "use gen_mainwindow_wrapper instead")]
-    pub fn gen_main_wrapper(&self) -> WindowWrapper {
-        if self.is_background() {
-            return WindowWrapper {
-                id: id::Id::MAIN,
-                display: self.display.as_ref().unwrap().clone(),
-                wl_surface: self.background_surface.as_ref().unwrap().clone(),
-                viewport: None,
-            };
-        }
-        self.main_window().gen_wrapper()
-    }
     /// gen the wrapper to the main window
     /// used to get display and etc
     pub fn gen_mainwindow_wrapper(&self) -> WindowWrapper {
@@ -822,6 +806,15 @@ impl<T> WindowState<T> {
         }
     }
 
+    /// In case when the focused surface is not the request surface, but it is still be disabled
+    /// So this time, we need to use a id to ensure this won't happen
+    pub fn set_ime_allowed_with_id(&mut self, ime_allowed: bool, id: id::Id) {
+        if self.current_surface_id().is_none_or(|cid| cid != id) {
+            return;
+        }
+        self.set_ime_allowed(ime_allowed);
+    }
+
     // TODO: maybe I should put text_inputs to unit
     pub fn set_ime_cursor_area<P: Into<dpi::Position>, S: Into<dpi::Size>>(
         &self,
@@ -1735,6 +1728,7 @@ impl<T> Dispatch<xdg_surface::XdgSurface, ()> for WindowState<T> {
         }
     }
 }
+
 impl<T> Dispatch<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1, ()> for WindowState<T> {
     fn event(
         state: &mut Self,