chore: ime base

Author: Decodetalkers

iced_examples/counter/src/main.rs

@@ -79,8 +79,8 @@ impl Application for Counter {
 
     fn update(&mut self, message: Message) -> Command<Message> {
         match message {
-            Message::IcedEvent(event) => {
-                println!("hello {event:?}");
+            Message::IcedEvent(_event) => {
+                //println!("hello {event:?}");
                 Command::none()
             }
             Message::IncrementPressed => {

iced_layershell/src/application.rs

@@ -7,14 +7,18 @@ use crate::{
     clipboard::LayerShellClipboard,
     conversion,
     error::Error,
+    ime_preedit::Preedit,
     settings::VirtualKeyboardSettings,
 };
 
 use super::{Appearance, DefaultStyle};
 use iced_graphics::{Compositor, compositor};
 use state::State;
 
-use iced_core::{input_method, time::Instant, window as IcedCoreWindow, Event as IcedCoreEvent, Size};
+use iced_core::{
+    Event as IcedCoreEvent, InputMethod, Size, input_method, time::Instant,
+    window as IcedCoreWindow,
+};
 
 use iced_runtime::{Action, Debug, Program, UserInterface, task::Task, user_interface};
 
@@ -337,8 +341,11 @@ where
                     iced_core::InputMethod::Disabled => {
                         ev.set_ime_allowed(false);
                     }
-                    iced_core::InputMethod::Enabled { position, .. } => {
+                    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 {
@@ -357,6 +364,94 @@ where
     Ok(())
 }
 
+struct IMDrawer<A>
+where
+    A: Application,
+    A::Theme: iced_core::theme::Base,
+{
+    preedit: Option<Preedit<A::Renderer>>,
+    ime_state: Option<(iced_core::Point, input_method::Purpose)>,
+}
+
+impl<A> IMDrawer<A>
+where
+    A: Application,
+    A::Theme: iced_core::theme::Base,
+{
+    fn new() -> Self {
+        Self {
+            preedit: None,
+            ime_state: None,
+        }
+    }
+    pub fn request_input_method(
+        &mut self,
+        background_color: iced_core::Color,
+        input_method: InputMethod,
+        renderer: &A::Renderer,
+    ) {
+        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, background_color, renderer);
+
+                        self.preedit = Some(overlay);
+                    }
+                } else {
+                    self.preedit = None;
+                }
+            }
+        }
+    }
+
+    pub fn draw_preedit(
+        &mut self,
+        renderer: &mut A::Renderer,
+        text_color: iced_core::Color,
+        background_color: iced_core::Color,
+        logical_size: iced_core::Size,
+    ) {
+        use iced_core::Point;
+        use iced_core::Rectangle;
+        if let Some(preedit) = &self.preedit {
+            preedit.draw(
+                renderer,
+                text_color,
+                background_color,
+                &Rectangle::new(Point::ORIGIN, 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;
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 async fn run_instance<A, E, C>(
     mut application: A,
@@ -386,6 +481,7 @@ async fn run_instance<A, E, C>(
     }
 
     let mut renderer = compositor.create_renderer();
+    let mut im_drawer: IMDrawer<A> = IMDrawer::new();
 
     let cache = user_interface::Cache::default();
 
@@ -464,9 +560,19 @@ async fn run_instance<A, E, C>(
                 } = ui_state
                 {
                     events.push(redraw_event.clone());
-                    println!("ime: ?{input_method:?}");
-                    //   window.request_input_method(input_method);
+                    custom_actions.push(LayerShellAction::Ime(input_method.clone()));
+                    im_drawer.request_input_method(
+                        state.background_color(),
+                        input_method,
+                        &renderer,
+                    );
                 }
+                im_drawer.draw_preedit(
+                    &mut renderer,
+                    state.text_color(),
+                    state.background_color(),
+                    state.viewport().logical_size(),
+                );
 
                 runtime.broadcast(iced_futures::subscription::Event::Interaction {
                     window: main_id,

iced_layershell/src/ime_preedit.rs

@@ -15,15 +15,15 @@ impl<Renderer> Preedit<Renderer>
 where
     Renderer: text::Renderer,
 {
-    fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             position: Point::ORIGIN,
             spans: Vec::new(),
             content: Renderer::Paragraph::default(),
         }
     }
 
-    fn update(
+    pub fn update(
         &mut self,
         position: Point,
         preedit: &input_method::Preedit,
@@ -65,7 +65,13 @@ where
         }
     }
 
-    fn draw(&self, renderer: &mut Renderer, color: Color, background: Color, viewport: &Rectangle) {
+    pub fn draw(
+        &self,
+        renderer: &mut Renderer,
+        color: Color,
+        background: Color,
+        viewport: &Rectangle,
+    ) {
         use text::Paragraph as _;
 
         if self.content.min_width() < 1.0 {

layershellev/src/lib.rs

@@ -788,23 +788,38 @@ impl<T> WindowState<T> {
     pub fn gen_mainwindow_wrapper(&self) -> WindowWrapper {
         self.main_window().gen_wrapper()
     }
+
     pub fn is_active(&self) -> bool {
         self.start_mode.is_active()
     }
+
     pub fn is_background(&self) -> bool {
         self.start_mode.is_background()
     }
+
     pub fn is_allscreens(&self) -> bool {
         self.start_mode.is_allscreens()
     }
+
     pub fn is_with_target(&self) -> bool {
         self.start_mode.is_with_target()
     }
+
     pub fn ime_allowed(&self) -> bool {
         self.ime_allowed
     }
+
     pub fn set_ime_allowed(&mut self, ime_allowed: bool) {
-        self.ime_allowed = ime_allowed
+        self.ime_allowed = ime_allowed;
+        for text_input in &self.text_inputs {
+            if ime_allowed {
+                text_input.enable();
+                text_input.set_content_type_by_purpose(self.ime_purpose);
+            } else {
+                text_input.disable();
+            }
+            text_input.commit();
+        }
     }
 
     // TODO: maybe I should put text_inputs to unit
@@ -833,12 +848,21 @@ impl<T> WindowState<T> {
         }
     }
 
+    pub fn set_ime_purpose(&mut self, purpose: ImePurpose) {
+        self.ime_purpose = purpose;
+        self.text_input.iter().for_each(|text_input| {
+            text_input.set_content_type_by_purpose(purpose);
+            text_input.commit();
+        });
+    }
+
     #[inline]
     pub fn text_input_entered(&mut self, text_input: &ZwpTextInputV3) {
         if !self.text_inputs.iter().any(|t| t == text_input) {
             self.text_inputs.push(text_input.clone());
         }
     }
+
     #[inline]
     pub fn text_input_left(&mut self, text_input: &ZwpTextInputV3) {
         if let Some(position) = self.text_inputs.iter().position(|t| t == text_input) {
@@ -1234,6 +1258,11 @@ impl<T: 'static> Dispatch<wl_seat::WlSeat, ()> for WindowState<T> {
             if capabilities.contains(wl_seat::Capability::Touch) {
                 state.touch = Some(seat.get_touch(qh, ()));
             }
+            let text_input = state
+                .text_input_manager
+                .as_ref()
+                .map(|manager| manager.get_text_input(seat, qh, TextInputData::default()));
+            state.text_input = text_input;
         }
     }
 }
@@ -1887,6 +1916,7 @@ struct Preedit {
     cursor_begin: Option<usize>,
     cursor_end: Option<usize>,
 }
+
 impl<T> Dispatch<zwp_text_input_v3::ZwpTextInputV3, TextInputData> for WindowState<T> {
     fn event(
         state: &mut Self,
@@ -2069,10 +2099,8 @@ impl<T: 'static> WindowState<T> {
         let text_input_manager = globals
             .bind::<ZwpTextInputManagerV3, _, _>(&qh, 1..=1, ())
             .ok();
-        let text_input = text_input_manager
-            .as_ref()
-            .map(|manager| manager.get_text_input(self.get_seat(), &qh, TextInputData::default()));
 
+        self.text_input_manager = text_input_manager;
         event_queue.blocking_dispatch(&mut self)?; // then make a dispatch
 
         // do the step before, you get empty list
@@ -2255,9 +2283,6 @@ impl<T: 'static> WindowState<T> {
         self.xdg_output_manager = Some(xdg_output_manager);
         self.connection = Some(connection);
 
-        self.text_input = text_input;
-        self.text_input_manager = text_input_manager;
-
         Ok(self)
     }
     /// main event loop, every time dispatch, it will store the messages, and do callback. it will