neovide · OliverChao · Dec 24, 2023 · Dec 24, 2023 · Dec 24, 2023 · fredizzimo
diff --git a/src/renderer/cursor_renderer/mod.rs b/src/renderer/cursor_renderer/mod.rs
@@ -11,7 +11,7 @@ use crate::{
    editor::{Cursor, CursorShape},
    profiling::{tracy_plot, tracy_zone},
    renderer::animation_utils::*,
-    renderer::{GridRenderer, RenderedWindow},
+    renderer::{GridRenderer, Preedit, RenderedWindow},
    settings::{ParseFromValue, SETTINGS},
    window::{ShouldRender, UserEvent},
 };
@@ -284,7 +284,13 @@ impl CursorRenderer {
        self.blink_status.update_status(&self.cursor)
    }

-    pub fn draw(&mut self, grid_renderer: &mut GridRenderer, canvas: &Canvas) {
+    pub fn draw(
+        &mut self,
+        grid_renderer: &mut GridRenderer,
+        canvas: &Canvas,
+        preedit: Option<&Preedit>,
+        w: f32,
+    ) {
        tracy_zone!("cursor_draw");
        let render = self.blink_status.should_render();
        let settings = SETTINGS.get::<CursorSettings>();
@@ -341,6 +347,54 @@ impl CursorRenderer {

        canvas.restore();

+        // draw ime if possible under current cursor
+        if let Some(preedit) = preedit {
+            let factor = grid_renderer.font_dimensions.width as f32;
+            let y_adjustment = y_adjustment as f32 + factor / 5.0;
+
+            let off = if let Some(off) = preedit.cursor_offset() {
+                off as f32 * factor
+            } else {
+                0f32
+            };
+
+            let mut start = self.destination.x;
+            let mut end = self.destination.x + off;
+            if end + factor > w {
+                start = start - (end + factor - w);
+                end = w - factor;
+            }
+
+            use skia_safe::Rect;
+            let r = Rect::new(
+                start,
+                self.destination.y,
+                end,
+                self.destination.y + y_adjustment + factor / 4.0,
+            );
+
+            paint.set_color(background_color);
+            canvas.draw_rect(r, &paint);
+
+            let blobs =
+                &grid_renderer
+                    .shaper
+                    .shape_cached(preedit.preedit_text().clone(), bold, italic);
+            paint.set_color(foreground_color);
+            for blob in blobs.iter() {
+                canvas.draw_text_blob(blob, (start, self.destination.y + y_adjustment), &paint);
+            }
+
+            paint.set_color(skia_safe::colors::GREY.to_color());
+            let r = Rect::new(
+                start,
+                self.destination.y + y_adjustment,
+                end,
+                self.destination.y + y_adjustment + factor / 4.0,
+            );
+            canvas.draw_rect(r, &paint);
+        }
+
        if let Some(vfx) = self.cursor_vfx.as_ref() {
            vfx.render(&settings, canvas, grid_renderer, &self.cursor);
        }

diff --git a/src/renderer/ime.rs b/src/renderer/ime.rs
@@ -0,0 +1,82 @@
+use winit::dpi::PhysicalPosition;
+#[derive(Debug, Default)]
+pub struct Ime {
+    /// Whether the IME is enabled.
+    enabled: bool,
+
+    /// Current IME preedit.
+    preedit: Option<Preedit>,
+
+    /// IME position
+    position: PhysicalPosition<i32>,
+}
+
+impl Ime {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    #[inline]
+    pub fn set_enabled(&mut self, is_enabled: bool) {
+        if is_enabled {
+            self.enabled = is_enabled
+        } else {
+            // clear all and create new
+            *self = Default::default();
+        }
+    }
+
+    #[inline]
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+
+    #[inline]
+    pub fn set_preedit(&mut self, preedit: Option<Preedit>) {
+        self.preedit = preedit;
+    }
+
+    #[inline]
+    pub fn preedit(&self) -> Option<&Preedit> {
+        self.preedit.as_ref()
+    }
+
+    #[inline]
+    pub fn set_position(&mut self, p: PhysicalPosition<i32>) {
+        self.position = p;
+    }
+
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        return self.position;
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct Preedit {
+    /// The preedit text.
+    text: String,
+
+    /// Byte offset from cusor start
+    /// `None` means that the cursor is invisible.
+    cursor_offset: Option<usize>,
+}
+
+impl Preedit {
+    pub fn new(text: String, cursor_offset: Option<usize>) -> Self {
+        Self {
+            text,
+            cursor_offset,
+        }
+    }
+    pub fn preedit_text(&self) -> &String {
+        &self.text
+    }
+    pub fn cursor_offset(&self) -> Option<usize> {
+        if let Some(offset) = self.cursor_offset {
+            Some(offset)
+        } else {
+            None
+        }
+    }
+}
diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs
@@ -2,6 +2,7 @@ pub mod animation_utils;
 pub mod cursor_renderer;
 pub mod fonts;
 pub mod grid_renderer;
+pub mod ime;
 mod opengl;
 pub mod profiler;
 mod rendered_window;
@@ -30,6 +31,7 @@ use crate::{
 use cursor_renderer::CursorRenderer;
 pub use fonts::caching_shaper::CachingShaper;
 pub use grid_renderer::GridRenderer;
+pub use ime::{Ime, Preedit};
 pub use rendered_window::{LineFragment, RenderedWindow, WindowDrawCommand, WindowDrawDetails};

 pub use opengl::{build_context, build_window, Context as WindowedContext, GlWindow};
@@ -145,7 +147,7 @@ impl Renderer {
        self.cursor_renderer.prepare_frame()
    }

-    pub fn draw_frame(&mut self, root_canvas: &Canvas, dt: f32) {
+    pub fn draw_frame(&mut self, root_canvas: &Canvas, dt: f32, ime: &Ime, w: f32) {
        tracy_zone!("renderer_draw_frame");
        let default_background = self.grid_renderer.get_default_background();
        let font_dimensions = self.grid_renderer.font_dimensions;
@@ -195,7 +197,7 @@ impl Renderer {
            .collect();

        self.cursor_renderer
-            .draw(&mut self.grid_renderer, root_canvas);
+            .draw(&mut self.grid_renderer, root_canvas, ime.preedit(), w);

        self.profiler.draw(root_canvas, dt);


diff --git a/src/window/keyboard_manager.rs b/src/window/keyboard_manager.rs
@@ -56,10 +56,13 @@ impl KeyboardManager {
                log::trace!("Ime commit {text}");
                send_ui(SerialCommand::Keyboard(text.to_string()));
            }
-            Event::WindowEvent {
-                event: WindowEvent::Ime(Ime::Preedit(text, cursor_offset)),
-                ..
-            } => self.ime_preedit = (text.to_string(), *cursor_offset),
+            // Event::WindowEvent {
+            //     event: WindowEvent::Ime(Ime::Preedit(text, cursor_offset)),
+            //     ..
+            // } => {
+            //     self.ime_preedit = (text.to_string(), *cursor_offset);
+            //     log::trace!("Ime preedit {text}");
+            // }
            Event::WindowEvent {
                event: WindowEvent::ModifiersChanged(modifiers),
                ..

diff --git a/src/window/window_wrapper.rs b/src/window/window_wrapper.rs
@@ -9,7 +9,11 @@ use crate::{
    bridge::{send_ui, ParallelCommand, SerialCommand},
    dimensions::Dimensions,
    profiling::{tracy_frame, tracy_gpu_collect, tracy_gpu_zone, tracy_plot, tracy_zone},
-    renderer::{build_context, DrawCommand, GlWindow, Renderer, VSync, WindowedContext},
+    renderer::{
+        build_context,
+        ime::{Ime, Preedit},
+        DrawCommand, GlWindow, Renderer, VSync, WindowedContext,
+    },
    running_tracker::RUNNING_TRACKER,
    settings::{SettingsChanged, DEFAULT_GRID_SIZE, MIN_GRID_SIZE, SETTINGS},
    window::{ShouldRender, WindowSize},
@@ -57,8 +61,8 @@ pub struct WinitWindowWrapper {
    font_changed_last_frame: bool,
    saved_inner_size: PhysicalSize<u32>,
    saved_grid_size: Option<Dimensions>,
-    ime_enabled: bool,
-    ime_position: PhysicalPosition<i32>,
+    ime: Ime,
+    window_width: f32,
    requested_columns: Option<u64>,
    requested_lines: Option<u64>,
    ui_state: UIState,
@@ -119,8 +123,8 @@ impl WinitWindowWrapper {
            font_changed_last_frame: false,
            saved_inner_size,
            saved_grid_size: None,
-            ime_enabled,
-            ime_position: PhysicalPosition::new(-1, -1),
+            ime: Ime::new(),
+            window_width: 0.0,
            requested_columns: None,
            requested_lines: None,
            ui_state: UIState::Initing,
@@ -158,7 +162,7 @@ impl WinitWindowWrapper {
    }

    pub fn set_ime(&mut self, ime_enabled: bool) {
-        self.ime_enabled = ime_enabled;
+        self.ime.set_enabled(ime_enabled);
        self.windowed_context.window().set_ime_allowed(ime_enabled);
    }

@@ -204,7 +208,7 @@ impl WinitWindowWrapper {
                }
            }
            WindowSettingsChanged::InputIme(ime_enabled) => {
-                if self.ime_enabled != ime_enabled {
+                if self.ime.is_enabled() != ime_enabled {
                    self.set_ime(ime_enabled);
                }
            }
@@ -317,6 +321,32 @@ impl WinitWindowWrapper {
                tracy_zone!("Moved");
                self.vsync.update(&self.windowed_context);
            }
+
+            Event::WindowEvent {
+                event: WindowEvent::Resized(size),
+                ..
+            } => {
+                if size.width != 0 && size.height != 0 {
+                    self.window_width = size.width as f32;
+                }
+            }
+            Event::WindowEvent {
+                event: WindowEvent::Ime(ime),
+                ..
+            } => match ime {
+                winit::event::Ime::Preedit(text, cursor_offset) => {
+                    let preedit = if text.is_empty() {
+                        None
+                    } else {
+                        Some(Preedit::new(text, cursor_offset.map(|offset| offset.0)))
+                    };
+
+                    if self.ime.preedit() != preedit.as_ref() {
+                        self.ime.set_preedit(preedit);
+                    }
+                }
+                _ => {}
+            },
            Event::UserEvent(UserEvent::DrawCommandBatch(batch)) => {
                self.handle_draw_commands(batch);
            }
@@ -352,7 +382,14 @@ impl WinitWindowWrapper {

    pub fn draw_frame(&mut self, dt: f32) {
        tracy_zone!("draw_frame");
-        self.renderer.draw_frame(self.skia_renderer.canvas(), dt);
+        self.renderer.prepare_lines();
+        self.renderer.draw_frame(
+            self.skia_renderer.canvas(),
+            dt,
+            &self.ime,
+            self.window_width,
+        );
+
        {
            tracy_gpu_zone!("skia flush");
            self.skia_renderer.gr_context.flush_and_submit();
@@ -418,7 +455,7 @@ impl WinitWindowWrapper {
            }

            // Ensure that the window has the correct IME state
-            self.set_ime(self.ime_enabled);
+            self.set_ime(self.ime.is_enabled());
        };
    }

@@ -559,8 +596,9 @@ impl WinitWindowWrapper {
            cursor_position.x.round() as i32,
            cursor_position.y.round() as i32 + font_dimensions.height as i32,
        );
-        if position != self.ime_position {
-            self.ime_position = position;
+        if position != self.ime.position() {
+            // self.ime.position = position;
+            self.ime.set_position(position);
            self.windowed_context.window().set_ime_cursor_area(
                Position::Physical(position),
                PhysicalSize::new(100, font_dimensions.height as u32),