chore: almost finished

Author: Decodetalkers

iced_layershell/src/actions.rs

@@ -16,8 +16,9 @@ pub(crate) enum LayerShellAction {
     CustomActionsWithId(LayershellCustomActionsWithIdInner),
     RedrawAll,
     RedrawWindow(LayerId), // maybe one day it is useful, but now useless
-    NewMenu((IcedNewPopupSettings, iced_core::window::Id)),
-    Ime(input_method::InputMethod)
+    NewMenu(IcedNewPopupSettings, iced_core::window::Id),
+    Ime(input_method::InputMethod),
+    ImeWithId(LayerId, input_method::InputMethod)
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

iced_layershell/src/multi_window.rs

@@ -467,7 +467,26 @@ where
                         }
                     }
                 }
-                LayerShellAction::NewMenu((menusettings, info)) => 'out: {
+                LayerShellAction::ImeWithId(id, ime) => match ime{
+                    iced_core::InputMethod::Disabled => {
+                        ev.set_ime_allowed(false);
+                    }
+                    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,
+                        );
+                    }
+                },
+                LayerShellAction::NewMenu(menusettings, info) => 'out: {
                     let IcedNewPopupSettings { size, position } = menusettings;
                     let Some(id) = ev.current_surface_id() else {
                         break 'out;
@@ -578,7 +597,7 @@ async fn run_instance<A, E, C>(
         });
         match event {
             MultiWindowIcedLayerEvent(
-                _id,
+                oid,
                 IcedLayerEvent::RequestRefreshWithWrapper {
                     width,
                     height,
@@ -660,14 +679,27 @@ async fn run_instance<A, E, C>(
                 let cursor = window.state.cursor();
 
                 events.push((Some(id), redraw_event.clone()));
-                ui.update(
+                let (ui_state, _) = ui.update(
                     &[redraw_event.clone()],
                     cursor,
                     &mut window.renderer,
                     &mut clipboard,
                     &mut messages,
                 );
+                if let user_interface::State::Updated {
+                    redraw_request: _, // NOTE: I do not know how to use it now
+                    input_method,
+                } = ui_state
+                {
+                    events.push((Some(id), redraw_event.clone()));
+                    custom_actions.push(LayerShellAction::ImeWithId(
+                        oid.unwrap(),
+                        input_method.clone(),
+                    ));
+                    window.request_input_method(input_method);
+                }
 
+                window.draw_preedit();
                 debug.draw_started();
                 let new_mouse_interaction = ui.draw(
                     &mut window.renderer,
@@ -934,13 +966,13 @@ async fn run_instance<A, E, C>(
                 if let MenuDirection::Up = direction {
                     y -= height as i32;
                 }
-                custom_actions.push(LayerShellAction::NewMenu((
+                custom_actions.push(LayerShellAction::NewMenu(
                     IcedNewPopupSettings {
                         size: (width, height),
                         position: (x, y),
                     },
                     info,
-                )));
+                ));
             }
             _ => {}
         }

iced_layershell/src/multi_window/window_manager.rs

@@ -2,7 +2,10 @@ use std::{collections::BTreeMap, sync::Arc};
 
 use super::state::State;
 use crate::DefaultStyle;
+use crate::ime_preedit::Preedit;
 use crate::multi_window::Application;
+use iced_core::InputMethod;
+use iced_core::input_method;
 use iced_graphics::Compositor;
 use layershellev::{WindowWrapper, id::Id as LayerId};
 
@@ -20,6 +23,8 @@ where
     pub surface: C::Surface,
     pub state: State<A>,
     pub mouse_interaction: mouse::Interaction,
+    preedit: Option<Preedit<A::Renderer>>,
+    ime_state: Option<(iced_core::Point, input_method::Purpose)>,
 }
 
 pub struct WindowManager<A: Application, C: Compositor>
@@ -95,6 +100,8 @@ where
                 surface,
                 state,
                 mouse_interaction: mouse::Interaction::Idle,
+                preedit: None,
+                ime_state: None,
             },
         );
         self.entries
@@ -135,3 +142,71 @@ where
         self.entries.get(&id)
     }
 }
+
+impl<A, C> Window<A, C>
+where
+    A: Application,
+    C: Compositor<Renderer = A::Renderer>,
+    A::Theme: DefaultStyle,
+{
+    pub fn request_input_method(&mut self, input_method: InputMethod) {
+        match input_method {
+            InputMethod::Disabled => {
+                self.disable_ime();
+            }
+            InputMethod::Enabled {
+                position,
+                purpose,
+                preedit,
+            } => {
+                self.enable_ime(position, purpose);
+
+                if let Some(preedit) = preedit {
+                    if preedit.content.is_empty() {
+                        self.preedit = None;
+                    } else {
+                        let mut overlay = self.preedit.take().unwrap_or_else(Preedit::new);
+
+                        overlay.update(
+                            position,
+                            &preedit,
+                            self.state.background_color(),
+                            &self.renderer,
+                        );
+
+                        self.preedit = Some(overlay);
+                    }
+                } else {
+                    self.preedit = None;
+                }
+            }
+        }
+    }
+
+    pub fn draw_preedit(&mut self) {
+        use iced_core::Point;
+        use iced_core::Rectangle;
+        if let Some(preedit) = &self.preedit {
+            preedit.draw(
+                &mut self.renderer,
+                self.state.text_color(),
+                self.state.background_color(),
+                &Rectangle::new(Point::ORIGIN, self.state.viewport().logical_size()),
+            );
+        }
+    }
+
+    fn enable_ime(&mut self, position: iced_core::Point, purpose: input_method::Purpose) {
+        if self.ime_state != Some((position, purpose)) {
+            self.ime_state = Some((position, purpose));
+        }
+    }
+
+    fn disable_ime(&mut self) {
+        if self.ime_state.is_some() {
+            self.ime_state = None;
+        }
+
+        self.preedit = None;
+    }
+}