Add new IME event for desktop platforms

This commit brings new IME event to account for preedit state of input
method, also adding `Window::set_ime_allowed` to toggle IME input on
the particular window.

This commit implements API as designed in #1497 for desktop platforms.

Co-authored-by: Artur Kovacs <kovacs.artur.barnabas@gmail.com>
Co-authored-by: Murarth <murarth@gmail.com>
Co-authored-by: Yusuke Kominami <yukke.konan@gmail.com>
Co-authored-by: moko256 <koutaro.mo@gmail.com>

Author: 5 people

CHANGELOG.md

@@ -32,6 +32,9 @@ And please only add new entries to the top of this list, right below the `# Unre
 - On Wayland, fix polling during consecutive `EventLoop::run_return` invocations.
 - On Windows, fix race issue creating fullscreen windows with `WindowBuilder::with_fullscreen`
 - On Android, `virtual_keycode` for `KeyboardInput` events is now filled in where a suitable match is found.
+- **Breaking:** Added new `WindowEvent::IME` supported on desktop platforms.
+- Added `Window::set_ime_allowed` supported on desktop platforms.
+- **Breaking:** IME input on desktop platforms won't be received unless it's explicitly allowed via `Window::set_ime_allowed` and new `WindowEvent::IME` events are handled.
 
 # 0.26.1 (2022-01-05)
 

Cargo.toml

@@ -87,8 +87,8 @@ features = [
 ]
 
 [target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
-wayland-client = { version = "0.29", default_features = false,  features = ["use_system_lib"], optional = true }
-wayland-protocols = { version = "0.29", features = [ "staging_protocols"], optional = true }
+wayland-client = { version = "0.29.4", default_features = false,  features = ["use_system_lib"], optional = true }
+wayland-protocols = { version = "0.29.4", features = [ "staging_protocols"], optional = true }
 sctk = { package = "smithay-client-toolkit", version = "0.15.1", default_features = false, features = ["calloop"],  optional = true }
 mio = { version = "0.8", features = ["os-ext"], optional = true }
 x11-dl = { version = "2.18.5", optional = true }

examples/ime.rs

@@ -0,0 +1,97 @@
+use log::LevelFilter;
+use simple_logger::SimpleLogger;
+use winit::{
+    dpi::PhysicalPosition,
+    event::{ElementState, Event, VirtualKeyCode, WindowEvent, IME},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+};
+
+fn main() {
+    SimpleLogger::new()
+        .with_level(LevelFilter::Trace)
+        .init()
+        .unwrap();
+
+    println!("Ime position will system default");
+    println!("Click to set ime position to cursor's");
+    println!("Press F2 to toggle IME. See the documentation of `set_ime_allowed` for more info");
+
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_inner_size(winit::dpi::LogicalSize::new(256f64, 128f64))
+        .build(&event_loop)
+        .unwrap();
+
+    let mut ime_allowed = true;
+    window.set_ime_allowed(ime_allowed);
+
+    let mut may_show_ime = false;
+    let mut cursor_position = PhysicalPosition::new(0.0, 0.0);
+    let mut ime_pos = PhysicalPosition::new(0.0, 0.0);
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => *control_flow = ControlFlow::Exit,
+            Event::WindowEvent {
+                event: WindowEvent::CursorMoved { position, .. },
+                ..
+            } => {
+                cursor_position = position;
+            }
+            Event::WindowEvent {
+                event:
+                    WindowEvent::MouseInput {
+                        state: ElementState::Released,
+                        ..
+                    },
+                ..
+            } => {
+                println!(
+                    "Setting ime position to {}, {}",
+                    cursor_position.x, cursor_position.y
+                );
+                ime_pos = cursor_position;
+                if may_show_ime {
+                    window.set_ime_position(ime_pos);
+                }
+            }
+            Event::WindowEvent {
+                event: WindowEvent::IME(event),
+                ..
+            } => {
+                println!("{:?}", event);
+                may_show_ime = event != IME::Disabled;
+                if may_show_ime {
+                    window.set_ime_position(ime_pos);
+                }
+            }
+            Event::WindowEvent {
+                event: WindowEvent::ReceivedCharacter(ch),
+                ..
+            } => {
+                println!("ch: {:?}", ch);
+            }
+            Event::WindowEvent {
+                event: WindowEvent::KeyboardInput { input, .. },
+                ..
+            } => {
+                println!("key: {:?}", input);
+
+                if input.state == ElementState::Pressed
+                    && input.virtual_keycode == Some(VirtualKeyCode::F2)
+                {
+                    ime_allowed = !ime_allowed;
+                    window.set_ime_allowed(ime_allowed);
+                    println!("\nIME: {}\n", ime_allowed);
+                }
+            }
+            _ => (),
+        }
+    });
+}

examples/set_ime_position.rs

@@ -270,6 +270,12 @@ pub enum WindowEvent<'a> {
     ///   issue, and it should get fixed - but it's the current state of the API.
     ModifiersChanged(ModifiersState),
 
+    /// An event from input method.
+    ///
+    /// Platform-specific behavior:
+    /// - **iOS / Android / Web :** Unsupported.
+    IME(IME),
+
     /// The cursor has moved on the window.
     CursorMoved {
         device_id: DeviceId,
@@ -376,7 +382,7 @@ impl Clone for WindowEvent<'static> {
                 input: *input,
                 is_synthetic: *is_synthetic,
             },
-
+            IME(preedit_state) => IME(preedit_state.clone()),
             ModifiersChanged(modifiers) => ModifiersChanged(*modifiers),
             #[allow(deprecated)]
             CursorMoved {
@@ -468,6 +474,7 @@ impl<'a> WindowEvent<'a> {
                 is_synthetic,
             }),
             ModifiersChanged(modifiers) => Some(ModifiersChanged(modifiers)),
+            IME(event) => Some(IME(event)),
             #[allow(deprecated)]
             CursorMoved {
                 device_id,
@@ -627,6 +634,28 @@ pub struct KeyboardInput {
     pub modifiers: ModifiersState,
 }
 
+/// Describes an event from input method.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum IME {
+    /// Notifies when the IME was enabled.
+    Enabled,
+
+    /// Notifies when a new composing text should be set at the cursor position.
+    ///
+    /// The value represents a pair of the preedit string and the cursor begin position and end
+    /// position. When both indices are `None`, the cursor should be hidden.
+    ///
+    /// The cursor position is byte-wise indexed.
+    Preedit(String, Option<usize>, Option<usize>),
+
+    /// Notifies when text should be inserted into the editor widget.
+    Commit(String),
+
+    /// Notifies when the IME was disabled.
+    Disabled,
+}
+
 /// Describes touch-screen input state.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

src/event.rs

@@ -748,6 +748,8 @@ impl Window {
 
     pub fn set_ime_position(&self, _position: Position) {}
 
+    pub fn set_ime_allowed(&self, _allowed: bool) {}
+
     pub fn focus_window(&self) {}
 
     pub fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}

src/platform_impl/android/mod.rs

@@ -287,6 +287,10 @@ impl Inner {
         warn!("`Window::set_ime_position` is ignored on iOS")
     }
 
+    pub fn set_ime_allowed(&self, _allowed: bool) {
+        warn!("`Window::set_ime_allowed` is ignored on iOS")
+    }
+
     pub fn focus_window(&self) {
         warn!("`Window::set_focus` is ignored on iOS")
     }

src/platform_impl/ios/window.rs

@@ -466,6 +466,11 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.set_ime_position(position))
     }
 
+    #[inline]
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_ime_allowed(allowed))
+    }
+
     #[inline]
     pub fn focus_window(&self) {
         match self {

src/platform_impl/linux/mod.rs

@@ -32,10 +32,9 @@ mod sink;
 mod state;
 
 pub use proxy::EventLoopProxy;
+pub use sink::EventSink;
 pub use state::WinitState;
 
-use sink::EventSink;
-
 type WinitDispatcher = calloop::Dispatcher<'static, WaylandSource, WinitState>;
 
 pub struct EventLoopWindowTarget<T> {

src/platform_impl/linux/wayland/event_loop/mod.rs

@@ -5,11 +5,11 @@ use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input
     Event as TextInputEvent, ZwpTextInputV3,
 };
 
-use crate::event::WindowEvent;
+use crate::event::{WindowEvent, IME};
 use crate::platform_impl::wayland;
 use crate::platform_impl::wayland::event_loop::WinitState;
 
-use super::{TextInputHandler, TextInputInner};
+use super::{Preedit, TextInputHandler, TextInputInner};
 
 #[inline]
 pub(super) fn handle_text_input(
@@ -30,8 +30,11 @@ pub(super) fn handle_text_input(
             inner.target_window_id = Some(window_id);
 
             // Enable text input on that surface.
-            text_input.enable();
-            text_input.commit();
+            if window_handle.ime_allowed.get() {
+                text_input.enable();
+                text_input.commit();
+                event_sink.push_window_event(WindowEvent::IME(IME::Enabled), window_id);
+            }
 
             // Notify a window we're currently over about text input handler.
             let text_input_handler = TextInputHandler {
@@ -58,19 +61,41 @@ pub(super) fn handle_text_input(
                 text_input: text_input.detach(),
             };
             window_handle.text_input_left(text_input_handler);
+            event_sink.push_window_event(WindowEvent::IME(IME::Disabled), window_id);
+        }
+        TextInputEvent::PreeditString {
+            text,
+            cursor_begin,
+            cursor_end,
+        } => {
+            let cursor_begin = usize::try_from(cursor_begin).ok();
+            let cursor_end = usize::try_from(cursor_end).ok();
+            let text = text.unwrap_or_default();
+            inner.pending_preedit = Some(Preedit {
+                text,
+                cursor_begin,
+                cursor_end,
+            });
         }
         TextInputEvent::CommitString { text } => {
-            // Update currenly commited string.
-            inner.commit_string = text;
+            // Update currenly commited string and reset previous preedit.
+            inner.pending_preedit = None;
+            inner.pending_commit = Some(text.unwrap_or_default());
         }
         TextInputEvent::Done { .. } => {
-            let (window_id, text) = match (inner.target_window_id, inner.commit_string.take()) {
-                (Some(window_id), Some(text)) => (window_id, text),
+            let window_id = match inner.target_window_id {
+                Some(window_id) => window_id,
                 _ => return,
             };
 
-            for ch in text.chars() {
-                event_sink.push_window_event(WindowEvent::ReceivedCharacter(ch), window_id);
+            if let Some(text) = inner.pending_commit.take() {
+                event_sink.push_window_event(WindowEvent::IME(IME::Commit(text)), window_id);
+            }
+
+            // Push preedit string we've got after latest commit.
+            if let Some(preedit) = inner.pending_preedit.take() {
+                let event = IME::Preedit(preedit.text, preedit.cursor_begin, preedit.cursor_end);
+                event_sink.push_window_event(WindowEvent::IME(event), window_id);
             }
         }
         _ => (),

src/platform_impl/linux/wayland/seat/text_input/handlers.rs

@@ -20,6 +20,17 @@ impl TextInputHandler {
         self.text_input.set_cursor_rectangle(x, y, 0, 0);
         self.text_input.commit();
     }
+
+    #[inline]
+    pub fn set_input_allowed(&self, allowed: bool) {
+        if allowed {
+            self.text_input.enable();
+        } else {
+            self.text_input.disable();
+        }
+
+        self.text_input.commit();
+    }
 }
 
 /// A wrapper around text input to automatically destroy the object on `Drop`.
@@ -52,15 +63,25 @@ struct TextInputInner {
     /// Currently focused surface.
     target_window_id: Option<WindowId>,
 
-    /// Pending string to commit.
-    commit_string: Option<String>,
+    /// Pending commit event which will be dispatched on `text_input_v3::Done`.
+    pending_commit: Option<String>,
+
+    /// Pending preedit event which will be dispatched on `text_input_v3::Done`.
+    pending_preedit: Option<Preedit>,
+}
+
+struct Preedit {
+    text: String,
+    cursor_begin: Option<usize>,
+    cursor_end: Option<usize>,
 }
 
 impl TextInputInner {
     fn new() -> Self {
         Self {
             target_window_id: None,
-            commit_string: None,
+            pending_commit: None,
+            pending_preedit: None,
         }
     }
 }

src/platform_impl/linux/wayland/seat/text_input/mod.rs

@@ -475,6 +475,11 @@ impl Window {
         self.send_request(WindowRequest::IMEPosition(position));
     }
 
+    #[inline]
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        self.send_request(WindowRequest::AllowIME(allowed));
+    }
+
     #[inline]
     pub fn display(&self) -> &Display {
         &self.display

src/platform_impl/linux/wayland/window/mod.rs

@@ -11,10 +11,10 @@ use sctk::window::{Decorations, FallbackFrame, Window};
 
 use crate::dpi::{LogicalPosition, LogicalSize};
 
-use crate::event::WindowEvent;
+use crate::event::{WindowEvent, IME};
 use crate::platform_impl::wayland;
 use crate::platform_impl::wayland::env::WinitEnv;
-use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::event_loop::{EventSink, WinitState};
 use crate::platform_impl::wayland::seat::pointer::WinitPointer;
 use crate::platform_impl::wayland::seat::text_input::TextInputHandler;
 use crate::platform_impl::wayland::WindowId;
@@ -70,6 +70,9 @@ pub enum WindowRequest {
     /// Set IME window position.
     IMEPosition(LogicalPosition<u32>),
 
+    /// Enable IME on the given window.
+    AllowIME(bool),
+
     /// Request Attention.
     ///
     /// `None` unsets the attention request.
@@ -150,6 +153,9 @@ pub struct WindowHandle {
     /// Current cursor icon.
     pub cursor_icon: Cell<CursorIcon>,
 
+    /// Allow IME events for that window.
+    pub ime_allowed: Cell<bool>,
+
     /// Visible cursor or not.
     cursor_visible: Cell<bool>,
 
@@ -189,6 +195,7 @@ impl WindowHandle {
             text_inputs: Vec::new(),
             xdg_activation,
             attention_requested: Cell::new(false),
+            ime_allowed: Cell::new(false),
         }
     }
 
@@ -304,6 +311,27 @@ impl WindowHandle {
         }
     }
 
+    pub fn set_ime_allowed(&self, allowed: bool, event_sink: &mut EventSink) {
+        if self.ime_allowed.get() == allowed {
+            return;
+        }
+
+        self.ime_allowed.replace(allowed);
+        let window_id = wayland::make_wid(self.window.surface());
+
+        for text_input in self.text_inputs.iter() {
+            text_input.set_input_allowed(allowed);
+        }
+
+        let event = if allowed {
+            WindowEvent::IME(IME::Enabled)
+        } else {
+            WindowEvent::IME(IME::Disabled)
+        };
+
+        event_sink.push_window_event(event, window_id);
+    }
+
     pub fn set_cursor_visible(&self, visible: bool) {
         self.cursor_visible.replace(visible);
         let cursor_icon = match visible {
@@ -361,6 +389,10 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                 WindowRequest::IMEPosition(position) => {
                     window_handle.set_ime_position(position);
                 }
+                WindowRequest::AllowIME(allow) => {
+                    let event_sink = &mut winit_state.event_sink;
+                    window_handle.set_ime_allowed(allow, event_sink);
+                }
                 WindowRequest::GrabCursor(grab) => {
                     window_handle.set_cursor_grab(grab);
                 }

src/platform_impl/linux/wayland/window/shim.rs

@@ -12,10 +12,12 @@ use super::{
 
 use util::modifiers::{ModifierKeyState, ModifierKeymap};
 
+use crate::platform_impl::platform::x11::ime::{ImeEvent, ImeEventReceiver, ImeRequest};
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
     event::{
         DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, TouchPhase, WindowEvent,
+        IME,
     },
     event_loop::EventLoopWindowTarget as RootELW,
 };
@@ -26,6 +28,7 @@ const KEYCODE_OFFSET: u8 = 8;
 pub(super) struct EventProcessor<T: 'static> {
     pub(super) dnd: Dnd,
     pub(super) ime_receiver: ImeReceiver,
+    pub(super) ime_event_receiver: ImeEventReceiver,
     pub(super) randr_event_offset: c_int,
     pub(super) devices: RefCell<HashMap<DeviceId, Device>>,
     pub(super) xi2ext: XExtension,
@@ -37,6 +40,8 @@ pub(super) struct EventProcessor<T: 'static> {
     pub(super) first_touch: Option<u64>,
     // Currently focused window belonging to this process
     pub(super) active_window: Option<ffi::Window>,
+    pub(super) is_composing: bool,
+    pub(super) composed_text: Option<String>,
 }
 
 impl<T: 'static> EventProcessor<T> {
@@ -609,6 +614,10 @@ impl<T: 'static> EventProcessor<T> {
                         };
                         callback(event);
                     }
+                    if self.is_composing && !written.is_empty() {
+                        self.composed_text = Some(written);
+                        self.is_composing = false;
+                    }
                 }
             }
 
@@ -1223,8 +1232,64 @@ impl<T: 'static> EventProcessor<T> {
             }
         }
 
-        if let Ok((window_id, x, y)) = self.ime_receiver.try_recv() {
-            wt.ime.borrow_mut().send_xim_spot(window_id, x, y);
+        // Handle IME requests.
+        if let Ok(request) = self.ime_receiver.try_recv() {
+            let mut ime = wt.ime.borrow_mut();
+            match request {
+                ImeRequest::Position(window_id, x, y) => {
+                    ime.send_xim_spot(window_id, x, y);
+                }
+                ImeRequest::AllowIME(window_id, allowed) => {
+                    ime.set_ime_allowed(window_id, allowed);
+                }
+            }
+        }
+
+        match self.ime_event_receiver.try_recv() {
+            Ok((window, event)) => match event {
+                ImeEvent::Enabled => {
+                    callback(Event::WindowEvent {
+                        window_id: mkwid(window),
+                        event: WindowEvent::IME(IME::Enabled),
+                    });
+                }
+                ImeEvent::Start => {
+                    self.is_composing = true;
+                    self.composed_text = None;
+                    callback(Event::WindowEvent {
+                        window_id: mkwid(window),
+                        event: WindowEvent::IME(IME::Preedit("".to_owned(), None, None)),
+                    });
+                }
+                ImeEvent::Update(text, position) => {
+                    if self.is_composing {
+                        callback(Event::WindowEvent {
+                            window_id: mkwid(window),
+                            event: WindowEvent::IME(IME::Preedit(
+                                text,
+                                Some(position),
+                                Some(position),
+                            )),
+                        });
+                    }
+                }
+                ImeEvent::End => {
+                    self.is_composing = false;
+                    callback(Event::WindowEvent {
+                        window_id: mkwid(window),
+                        event: WindowEvent::IME(IME::Commit(
+                            self.composed_text.take().unwrap_or("".to_owned()),
+                        )),
+                    });
+                }
+                ImeEvent::Disabled => {
+                    callback(Event::WindowEvent {
+                        window_id: mkwid(window),
+                        event: WindowEvent::IME(IME::Disabled),
+                    });
+                }
+            },
+            Err(_) => (),
         }
     }
 

src/platform_impl/linux/x11/event_processor.rs

@@ -108,8 +108,19 @@ unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
     let mut new_contexts = HashMap::new();
     for (window, old_context) in (*inner).contexts.iter() {
         let spot = old_context.as_ref().map(|old_context| old_context.ic_spot);
+        let is_allowed = old_context
+            .as_ref()
+            .map(|old_context| old_context.is_allowed)
+            .unwrap_or_default();
         let new_context = {
-            let result = ImeContext::new(xconn, new_im.im, *window, spot);
+            let result = ImeContext::new(
+                xconn,
+                new_im.im,
+                *window,
+                spot,
+                is_allowed,
+                (*inner).event_sender.clone(),
+            );
             if result.is_err() {
                 let _ = close_im(xconn, new_im.im);
             }

src/platform_impl/linux/x11/ime/callbacks.rs

@@ -1,41 +1,190 @@
-use std::{
-    os::raw::{c_short, c_void},
-    ptr,
-    sync::Arc,
-};
+use std::mem::transmute;
+use std::os::raw::c_short;
+use std::ptr;
+use std::sync::Arc;
 
 use super::{ffi, util, XConnection, XError};
+use crate::platform_impl::platform::x11::ime::{ImeEvent, ImeEventSender};
+use std::ffi::CStr;
+use x11_dl::xlib::{XIMCallback, XIMPreeditCaretCallbackStruct, XIMPreeditDrawCallbackStruct};
 
+/// IME creation error.
 #[derive(Debug)]
 pub enum ImeContextCreationError {
+    /// Got the error from Xlib.
     XError(XError),
+
+    /// Got null pointer from Xlib but without exact reason.
     Null,
 }
 
-unsafe fn create_pre_edit_attr<'a>(
-    xconn: &'a Arc<XConnection>,
-    ic_spot: &'a ffi::XPoint,
-) -> util::XSmartPointer<'a, c_void> {
-    util::XSmartPointer::new(
-        xconn,
-        (xconn.xlib.XVaCreateNestedList)(
-            0,
-            ffi::XNSpotLocation_0.as_ptr() as *const _,
-            ic_spot,
-            ptr::null_mut::<()>(),
-        ),
-    )
-    .expect("XVaCreateNestedList returned NULL")
+/// The callback used by XIM preedit functions.
+type XIMProcNonnull = unsafe extern "C" fn(ffi::XIM, ffi::XPointer, ffi::XPointer);
+
+/// Wrapper for creating XIM callbacks.
+#[inline]
+fn create_xim_callback(client_data: ffi::XPointer, callback: XIMProcNonnull) -> ffi::XIMCallback {
+    XIMCallback {
+        client_data,
+        callback: Some(callback),
+    }
+}
+
+/// The server started preedit.
+extern "C" fn preedit_start_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    _call_data: ffi::XPointer,
+) -> i32 {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+
+    client_data.text.clear();
+    client_data.cursor_pos = 0;
+    client_data
+        .event_sender
+        .send((client_data.window, ImeEvent::Start))
+        .expect("failed to send preedit start event");
+    -1
+}
+
+/// Done callback is called when the user finished preedit and the text is about to be inserted into
+/// underlying widget.
+extern "C" fn preedit_done_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    _call_data: ffi::XPointer,
+) {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+
+    client_data
+        .event_sender
+        .send((client_data.window, ImeEvent::End))
+        .expect("failed to send preedit end event");
+}
+
+fn calc_byte_position(text: &Vec<char>, pos: usize) -> usize {
+    let mut byte_pos = 0;
+    for i in 0..pos {
+        byte_pos += text[i].len_utf8();
+    }
+    byte_pos
+}
+
+/// Preedit text information to be drawn inline by the client.
+extern "C" fn preedit_draw_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    call_data: ffi::XPointer,
+) {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+    let call_data = unsafe { &mut *(call_data as *mut XIMPreeditDrawCallbackStruct) };
+    client_data.cursor_pos = call_data.caret as usize;
+
+    let chg_range =
+        call_data.chg_first as usize..(call_data.chg_first + call_data.chg_length) as usize;
+    if chg_range.start > client_data.text.len() || chg_range.end > client_data.text.len() {
+        warn!(
+            "invalid chg range: buffer length={}, but chg_first={} chg_lengthg={}",
+            client_data.text.len(),
+            call_data.chg_first,
+            call_data.chg_length
+        );
+        return;
+    }
+
+    // NULL indicate text deletion
+    let mut new_chars = if call_data.text.is_null() {
+        Vec::new()
+    } else {
+        let xim_text = unsafe { &mut *(call_data.text) };
+        if xim_text.encoding_is_wchar > 0 {
+            return;
+        }
+        let new_text = unsafe { CStr::from_ptr(xim_text.string.multi_byte) };
+
+        String::from(new_text.to_str().expect("Invalid UTF-8 String from IME"))
+            .chars()
+            .collect()
+    };
+    let mut old_text_tail = client_data.text.split_off(chg_range.end);
+    client_data.text.truncate(chg_range.start);
+    client_data.text.append(&mut new_chars);
+    client_data.text.append(&mut old_text_tail);
+    let cursor_byte_pos = calc_byte_position(&client_data.text, client_data.cursor_pos);
+
+    client_data
+        .event_sender
+        .send((
+            client_data.window,
+            ImeEvent::Update(client_data.text.iter().collect(), cursor_byte_pos),
+        ))
+        .expect("failed to send preedit update event");
+}
+
+/// Handling of cursor movements in preedit text.
+extern "C" fn preedit_caret_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    call_data: ffi::XPointer,
+) {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+    let call_data = unsafe { &mut *(call_data as *mut XIMPreeditCaretCallbackStruct) };
+    client_data.cursor_pos = call_data.position as usize;
+    let cursor_byte_pos = calc_byte_position(&client_data.text, client_data.cursor_pos);
+
+    client_data
+        .event_sender
+        .send((
+            client_data.window,
+            ImeEvent::Update(client_data.text.iter().collect(), cursor_byte_pos),
+        ))
+        .expect("failed to send preedit update event");
+}
+
+/// Struct to simplify callback creation and latter passing into Xlib XIM.
+struct PreeditCallbacks {
+    start_callback: ffi::XIMCallback,
+    done_callback: ffi::XIMCallback,
+    draw_callback: ffi::XIMCallback,
+    caret_callback: ffi::XIMCallback,
+}
+
+impl PreeditCallbacks {
+    pub fn new(client_data: ffi::XPointer) -> PreeditCallbacks {
+        let start_callback = create_xim_callback(client_data, unsafe {
+            transmute(preedit_start_callback as usize)
+        });
+        let done_callback = create_xim_callback(client_data, preedit_done_callback);
+        let caret_callback = create_xim_callback(client_data, preedit_caret_callback);
+        let draw_callback = create_xim_callback(client_data, preedit_draw_callback);
+
+        PreeditCallbacks {
+            start_callback,
+            done_callback,
+            caret_callback,
+            draw_callback,
+        }
+    }
 }
 
-// WARNING: this struct doesn't destroy its XIC resource when dropped.
+struct ImeContextClientData {
+    window: ffi::Window,
+    event_sender: ImeEventSender,
+    text: Vec<char>,
+    cursor_pos: usize,
+}
+
+// XXX: this struct doesn't destroy its XIC resource when dropped.
 // This is intentional, as it doesn't have enough information to know whether or not the context
 // still exists on the server. Since `ImeInner` has that awareness, destruction must be handled
 // through `ImeInner`.
-#[derive(Debug)]
 pub struct ImeContext {
-    pub ic: ffi::XIC,
-    pub ic_spot: ffi::XPoint,
+    pub(super) ic: ffi::XIC,
+    pub(super) ic_spot: ffi::XPoint,
+    pub(super) is_allowed: bool,
+    // Since the data is passed shared between X11 XIM callbacks, but couldn't be direclty free from
+    // there we keep the pointer to automatically deallocate it.
+    _client_data: Box<ImeContextClientData>,
 }
 
 impl ImeContext {
@@ -44,66 +193,111 @@ impl ImeContext {
         im: ffi::XIM,
         window: ffi::Window,
         ic_spot: Option<ffi::XPoint>,
+        is_allowed: bool,
+        event_sender: ImeEventSender,
     ) -> Result<Self, ImeContextCreationError> {
-        let ic = if let Some(ic_spot) = ic_spot {
-            ImeContext::create_ic_with_spot(xconn, im, window, ic_spot)
+        let client_data = Box::into_raw(Box::new(ImeContextClientData {
+            window,
+            event_sender,
+            text: Vec::new(),
+            cursor_pos: 0,
+        }));
+
+        let ic = if is_allowed {
+            ImeContext::create_ic(xconn, im, window, client_data as ffi::XPointer)
+                .ok_or(ImeContextCreationError::Null)?
         } else {
-            ImeContext::create_ic(xconn, im, window)
+            ImeContext::create_none_ic(xconn, im, window).ok_or(ImeContextCreationError::Null)?
         };
 
-        let ic = ic.ok_or(ImeContextCreationError::Null)?;
         xconn
             .check_errors()
             .map_err(ImeContextCreationError::XError)?;
 
-        Ok(ImeContext {
+        let mut context = ImeContext {
             ic,
-            ic_spot: ic_spot.unwrap_or(ffi::XPoint { x: 0, y: 0 }),
-        })
+            ic_spot: ffi::XPoint { x: 0, y: 0 },
+            is_allowed,
+            _client_data: Box::from_raw(client_data),
+        };
+
+        // Set the spot location, if it's present.
+        if let Some(ic_spot) = ic_spot {
+            context.set_spot(xconn, ic_spot.x, ic_spot.y)
+        }
+
+        Ok(context)
     }
 
-    unsafe fn create_ic(
+    unsafe fn create_none_ic(
         xconn: &Arc<XConnection>,
         im: ffi::XIM,
         window: ffi::Window,
     ) -> Option<ffi::XIC> {
         let ic = (xconn.xlib.XCreateIC)(
             im,
             ffi::XNInputStyle_0.as_ptr() as *const _,
-            ffi::XIMPreeditNothing | ffi::XIMStatusNothing,
+            ffi::XIMPreeditNone | ffi::XIMStatusNone,
             ffi::XNClientWindow_0.as_ptr() as *const _,
             window,
             ptr::null_mut::<()>(),
         );
-        if ic.is_null() {
-            None
-        } else {
-            Some(ic)
-        }
+
+        (!ic.is_null()).then(|| ic)
     }
 
-    unsafe fn create_ic_with_spot(
+    unsafe fn create_ic(
         xconn: &Arc<XConnection>,
         im: ffi::XIM,
         window: ffi::Window,
-        ic_spot: ffi::XPoint,
+        client_data: ffi::XPointer,
     ) -> Option<ffi::XIC> {
-        let pre_edit_attr = create_pre_edit_attr(xconn, &ic_spot);
-        let ic = (xconn.xlib.XCreateIC)(
-            im,
-            ffi::XNInputStyle_0.as_ptr() as *const _,
-            ffi::XIMPreeditNothing | ffi::XIMStatusNothing,
-            ffi::XNClientWindow_0.as_ptr() as *const _,
-            window,
-            ffi::XNPreeditAttributes_0.as_ptr() as *const _,
-            pre_edit_attr.ptr,
-            ptr::null_mut::<()>(),
-        );
-        if ic.is_null() {
-            None
-        } else {
-            Some(ic)
-        }
+        let preedit_callbacks = PreeditCallbacks::new(client_data);
+        let preedit_attr = util::XSmartPointer::new(
+            xconn,
+            (xconn.xlib.XVaCreateNestedList)(
+                0,
+                ffi::XNPreeditStartCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.start_callback) as *const _,
+                ffi::XNPreeditDoneCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.done_callback) as *const _,
+                ffi::XNPreeditCaretCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.caret_callback) as *const _,
+                ffi::XNPreeditDrawCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.draw_callback) as *const _,
+                ptr::null_mut::<()>(),
+            ),
+        )
+        .expect("XVaCreateNestedList returned NULL");
+
+        let ic = {
+            let ic = (xconn.xlib.XCreateIC)(
+                im,
+                ffi::XNInputStyle_0.as_ptr() as *const _,
+                ffi::XIMPreeditCallbacks | ffi::XIMStatusNothing,
+                ffi::XNClientWindow_0.as_ptr() as *const _,
+                window,
+                ffi::XNPreeditAttributes_0.as_ptr() as *const _,
+                preedit_attr.ptr,
+                ptr::null_mut::<()>(),
+            );
+
+            // If we've failed to create IC with preedit callbacks fallback to normal one.
+            if ic.is_null() {
+                (xconn.xlib.XCreateIC)(
+                    im,
+                    ffi::XNInputStyle_0.as_ptr() as *const _,
+                    ffi::XIMPreeditNothing | ffi::XIMStatusNothing,
+                    ffi::XNClientWindow_0.as_ptr() as *const _,
+                    window,
+                    ptr::null_mut::<()>(),
+                )
+            } else {
+                ic
+            }
+        };
+
+        (!ic.is_null()).then(|| ic)
     }
 
     pub fn focus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
@@ -120,18 +314,34 @@ impl ImeContext {
         xconn.check_errors()
     }
 
+    // Set the spot for preedit text. Setting spot isn't working with libX11 when preedit callbacks
+    // are being used. Certain IMEs do show selection window, but it's placed in bottom left of the
+    // window and couldn't be changed.
+    //
+    // For me see: https://bugs.freedesktop.org/show_bug.cgi?id=1580.
     pub fn set_spot(&mut self, xconn: &Arc<XConnection>, x: c_short, y: c_short) {
-        if self.ic_spot.x == x && self.ic_spot.y == y {
+        if !self.is_allowed || self.ic_spot.x == x && self.ic_spot.y == y {
             return;
         }
+
         self.ic_spot = ffi::XPoint { x, y };
 
         unsafe {
-            let pre_edit_attr = create_pre_edit_attr(xconn, &self.ic_spot);
+            let preedit_attr = util::XSmartPointer::new(
+                xconn,
+                (xconn.xlib.XVaCreateNestedList)(
+                    0,
+                    ffi::XNSpotLocation_0.as_ptr(),
+                    &self.ic_spot,
+                    ptr::null_mut::<()>(),
+                ),
+            )
+            .expect("XVaCreateNestedList returned NULL");
+
             (xconn.xlib.XSetICValues)(
                 self.ic,
                 ffi::XNPreeditAttributes_0.as_ptr() as *const _,
-                pre_edit_attr.ptr,
+                preedit_attr.ptr,
                 ptr::null_mut::<()>(),
             );
         }

src/platform_impl/linux/x11/ime/context.rs

@@ -3,6 +3,7 @@ use std::{collections::HashMap, mem, ptr, sync::Arc};
 use super::{ffi, XConnection, XError};
 
 use super::{context::ImeContext, input_method::PotentialInputMethods};
+use crate::platform_impl::platform::x11::ime::ImeEventSender;
 
 pub unsafe fn close_im(xconn: &Arc<XConnection>, im: ffi::XIM) -> Result<(), XError> {
     (xconn.xlib.XCloseIM)(im);
@@ -22,20 +23,26 @@ pub struct ImeInner {
     pub contexts: HashMap<ffi::Window, Option<ImeContext>>,
     // WARNING: this is initially zeroed!
     pub destroy_callback: ffi::XIMCallback,
+    pub event_sender: ImeEventSender,
     // Indicates whether or not the the input method was destroyed on the server end
     // (i.e. if ibus/fcitx/etc. was terminated/restarted)
     pub is_destroyed: bool,
     pub is_fallback: bool,
 }
 
 impl ImeInner {
-    pub fn new(xconn: Arc<XConnection>, potential_input_methods: PotentialInputMethods) -> Self {
+    pub fn new(
+        xconn: Arc<XConnection>,
+        potential_input_methods: PotentialInputMethods,
+        event_sender: ImeEventSender,
+    ) -> Self {
         ImeInner {
             xconn,
             im: ptr::null_mut(),
             potential_input_methods,
             contexts: HashMap::new(),
             destroy_callback: unsafe { mem::zeroed() },
+            event_sender,
             is_destroyed: false,
             is_fallback: false,
         }

src/platform_impl/linux/x11/ime/inner.rs

@@ -19,9 +19,29 @@ use self::{
     inner::{close_im, ImeInner},
     input_method::PotentialInputMethods,
 };
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ImeEvent {
+    Enabled,
+    Start,
+    Update(String, usize),
+    End,
+    Disabled,
+}
+
+pub type ImeReceiver = Receiver<ImeRequest>;
+pub type ImeSender = Sender<ImeRequest>;
+pub type ImeEventReceiver = Receiver<(ffi::Window, ImeEvent)>;
+pub type ImeEventSender = Sender<(ffi::Window, ImeEvent)>;
 
-pub type ImeReceiver = Receiver<(ffi::Window, i16, i16)>;
-pub type ImeSender = Sender<(ffi::Window, i16, i16)>;
+/// Request to control XIM handler from the window.
+pub enum ImeRequest {
+    /// Set IME spot position for given `window_id`.
+    Position(ffi::Window, i16, i16),
+
+    /// Allow IME input for the given `window_id`.
+    AllowIME(ffi::Window, bool),
+}
 
 #[derive(Debug)]
 pub enum ImeCreationError {
@@ -37,11 +57,14 @@ pub struct Ime {
 }
 
 impl Ime {
-    pub fn new(xconn: Arc<XConnection>) -> Result<Self, ImeCreationError> {
+    pub fn new(
+        xconn: Arc<XConnection>,
+        event_sender: ImeEventSender,
+    ) -> Result<Self, ImeCreationError> {
         let potential_input_methods = PotentialInputMethods::new(&xconn);
 
         let (mut inner, client_data) = {
-            let mut inner = Box::new(ImeInner::new(xconn, potential_input_methods));
+            let mut inner = Box::new(ImeInner::new(xconn, potential_input_methods, event_sender));
             let inner_ptr = Box::into_raw(inner);
             let client_data = inner_ptr as _;
             let destroy_callback = ffi::XIMCallback {
@@ -88,12 +111,37 @@ impl Ime {
     // Ok(_) indicates that nothing went wrong internally
     // Ok(true) indicates that the action was actually performed
     // Ok(false) indicates that the action is not presently applicable
-    pub fn create_context(&mut self, window: ffi::Window) -> Result<bool, ImeContextCreationError> {
+    pub fn create_context(
+        &mut self,
+        window: ffi::Window,
+        with_preedit: bool,
+    ) -> Result<bool, ImeContextCreationError> {
         let context = if self.is_destroyed() {
             // Create empty entry in map, so that when IME is rebuilt, this window has a context.
             None
         } else {
-            Some(unsafe { ImeContext::new(&self.inner.xconn, self.inner.im, window, None) }?)
+            let event = if with_preedit {
+                ImeEvent::Enabled
+            } else {
+                // There's no IME without preedit.
+                ImeEvent::Disabled
+            };
+
+            self.inner
+                .event_sender
+                .send((window, event))
+                .expect("Failed to send enabled event");
+
+            Some(unsafe {
+                ImeContext::new(
+                    &self.inner.xconn,
+                    self.inner.im,
+                    window,
+                    None,
+                    with_preedit,
+                    self.inner.event_sender.clone(),
+                )
+            }?)
         };
         self.inner.contexts.insert(window, context);
         Ok(!self.is_destroyed())
@@ -151,6 +199,24 @@ impl Ime {
             context.set_spot(&self.xconn, x as _, y as _);
         }
     }
+
+    pub fn set_ime_allowed(&mut self, window: ffi::Window, allowed: bool) {
+        if self.is_destroyed() {
+            return;
+        }
+
+        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
+            if allowed == context.is_allowed {
+                return;
+            }
+        }
+
+        // Remove context for that window.
+        let _ = self.remove_context(window);
+
+        // Create new context supporting IME input.
+        let _ = self.create_context(window, allowed);
+    }
 }
 
 impl Drop for Ime {

src/platform_impl/linux/x11/ime/mod.rs

@@ -44,7 +44,7 @@ use mio::{unix::SourceFd, Events, Interest, Poll, Token, Waker};
 use self::{
     dnd::{Dnd, DndState},
     event_processor::EventProcessor,
-    ime::{Ime, ImeCreationError, ImeReceiver, ImeSender},
+    ime::{Ime, ImeCreationError, ImeReceiver, ImeRequest, ImeSender},
     util::modifiers::ModifierKeymap,
 };
 use crate::{
@@ -144,6 +144,7 @@ impl<T: 'static> EventLoop<T> {
             .expect("Failed to call XInternAtoms when initializing drag and drop");
 
         let (ime_sender, ime_receiver) = mpsc::channel();
+        let (ime_event_sender, ime_event_receiver) = mpsc::channel();
         // Input methods will open successfully without setting the locale, but it won't be
         // possible to actually commit pre-edit sequences.
         unsafe {
@@ -168,7 +169,7 @@ impl<T: 'static> EventLoop<T> {
             }
         }
         let ime = RefCell::new({
-            let result = Ime::new(Arc::clone(&xconn));
+            let result = Ime::new(Arc::clone(&xconn), ime_event_sender);
             if let Err(ImeCreationError::OpenFailure(ref state)) = result {
                 panic!("Failed to open input method: {:#?}", state);
             }
@@ -252,12 +253,15 @@ impl<T: 'static> EventLoop<T> {
             devices: Default::default(),
             randr_event_offset,
             ime_receiver,
+            ime_event_receiver,
             xi2ext,
             mod_keymap,
             device_mod_state: Default::default(),
             num_touch: 0,
             first_touch: None,
             active_window: None,
+            is_composing: false,
+            composed_text: None,
         };
 
         // Register for device hotplug events

src/platform_impl/linux/x11/mod.rs

@@ -26,7 +26,8 @@ use crate::{
 };
 
 use super::{
-    ffi, util, EventLoopWindowTarget, ImeSender, WakeSender, WindowId, XConnection, XError,
+    ffi, util, EventLoopWindowTarget, ImeRequest, ImeSender, WakeSender, WindowId, XConnection,
+    XError,
 };
 
 #[derive(Debug)]
@@ -449,7 +450,10 @@ impl UnownedWindow {
                 .queue();
 
             {
-                let result = event_loop.ime.borrow_mut().create_context(window.xwindow);
+                let result = event_loop
+                    .ime
+                    .borrow_mut()
+                    .create_context(window.xwindow, false);
                 if let Err(err) = result {
                     let e = match err {
                         ImeContextCreationError::XError(err) => OsError::XError(err),
@@ -1392,17 +1396,21 @@ impl UnownedWindow {
             .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err))))
     }
 
-    pub(crate) fn set_ime_position_physical(&self, x: i32, y: i32) {
+    #[inline]
+    pub fn set_ime_position(&self, spot: Position) {
+        let (x, y) = spot.to_physical::<i32>(self.scale_factor()).into();
         let _ = self
             .ime_sender
             .lock()
-            .send((self.xwindow, x as i16, y as i16));
+            .send(ImeRequest::Position(self.xwindow, x, y));
     }
 
     #[inline]
-    pub fn set_ime_position(&self, spot: Position) {
-        let (x, y) = spot.to_physical::<i32>(self.scale_factor()).into();
-        self.set_ime_position_physical(x, y);
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        let _ = self
+            .ime_sender
+            .lock()
+            .send(ImeRequest::AllowIME(self.xwindow, allowed));
     }
 
     #[inline]

src/platform_impl/linux/x11/window.rs

@@ -4,14 +4,15 @@ mod cursor;
 pub use self::{cursor::*, r#async::*};
 
 use std::ops::{BitAnd, Deref};
+use std::os::raw::c_uchar;
 
 use cocoa::{
     appkit::{NSApp, NSWindowStyleMask},
     base::{id, nil},
     foundation::{NSPoint, NSRect, NSString, NSUInteger},
 };
 use core_graphics::display::CGDisplay;
-use objc::runtime::{Class, Object};
+use objc::runtime::{Class, Object, BOOL, NO};
 
 use crate::dpi::LogicalPosition;
 use crate::platform_impl::platform::ffi;
@@ -165,3 +166,21 @@ pub unsafe fn toggle_style_mask(window: id, view: id, mask: NSWindowStyleMask, o
     // If we don't do this, key handling will break. Therefore, never call `setStyleMask` directly!
     window.makeFirstResponder_(view);
 }
+
+/// For invalid utf8 sequences potentially returned by `UTF8String`,
+/// it behaves identically to `String::from_utf8_lossy`
+///
+/// Safety: Assumes that `string` is an instance of `NSAttributedString` or `NSString`
+pub unsafe fn id_to_string_lossy(string: id) -> String {
+    let has_attr: BOOL = msg_send![string, isKindOfClass: class!(NSAttributedString)];
+    let characters = if has_attr != NO {
+        // This is a *mut NSAttributedString
+        msg_send![string, string]
+    } else {
+        // This is already a *mut NSString
+        string
+    };
+    let utf8_sequence =
+        std::slice::from_raw_parts(characters.UTF8String() as *const c_uchar, characters.len());
+    String::from_utf8_lossy(utf8_sequence).into_owned()
+}

src/platform_impl/macos/util/mod.rs

@@ -461,7 +461,7 @@ impl UnownedWindow {
         if maximized {
             window.set_maximized(maximized);
         }
-
+        trace!("Done unowned window::new");
         Ok((window, delegate))
     }
 
@@ -1045,6 +1045,13 @@ impl UnownedWindow {
         unsafe { view::set_ime_position(*self.ns_view, logical_spot) };
     }
 
+    #[inline]
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        unsafe {
+            view::set_ime_allowed(*self.ns_view, allowed);
+        }
+    }
+
     #[inline]
     pub fn focus_window(&self) {
         let is_minimized: BOOL = unsafe { msg_send![*self.ns_window, isMiniaturized] };

src/platform_impl/macos/view.rs

@@ -297,6 +297,11 @@ impl Window {
         // Currently a no-op as it does not seem there is good support for this on web
     }
 
+    #[inline]
+    pub fn set_ime_allowed(&self, _allowed: bool) {
+        // Currently not implemented
+    }
+
     #[inline]
     pub fn focus_window(&self) {
         // Currently a no-op as it does not seem there is good support for this on web

src/platform_impl/macos/window.rs

@@ -34,6 +34,7 @@ use windows_sys::Win32::{
     UI::{
         Controls::{HOVER_DEFAULT, WM_MOUSELEAVE},
         Input::{
+            Ime::{GCS_COMPSTR, GCS_RESULTSTR, ISC_SHOWUICOMPOSITIONWINDOW},
             KeyboardAndMouse::{
                 MapVirtualKeyA, ReleaseCapture, SetCapture, TrackMouseEvent, TME_LEAVE,
                 TRACKMOUSEEVENT, VK_F4,
@@ -59,6 +60,7 @@ use windows_sys::Win32::{
             SC_MINIMIZE, SC_RESTORE, SIZE_MAXIMIZED, SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOZORDER,
             WHEEL_DELTA, WINDOWPOS, WM_CAPTURECHANGED, WM_CHAR, WM_CLOSE, WM_CREATE, WM_DESTROY,
             WM_DPICHANGED, WM_DROPFILES, WM_ENTERSIZEMOVE, WM_EXITSIZEMOVE, WM_GETMINMAXINFO,
+            WM_IME_COMPOSITION, WM_IME_ENDCOMPOSITION, WM_IME_SETCONTEXT, WM_IME_STARTCOMPOSITION,
             WM_INPUT, WM_INPUT_DEVICE_CHANGE, WM_KEYDOWN, WM_KEYUP, WM_KILLFOCUS, WM_LBUTTONDOWN,
             WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEHWHEEL, WM_MOUSEMOVE,
             WM_MOUSEWHEEL, WM_NCCREATE, WM_NCDESTROY, WM_NCLBUTTONDOWN, WM_PAINT, WM_POINTERDOWN,
@@ -73,18 +75,19 @@ use windows_sys::Win32::{
 
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
-    event::{DeviceEvent, Event, Force, KeyboardInput, Touch, TouchPhase, WindowEvent},
+    event::{DeviceEvent, Event, Force, KeyboardInput, Touch, TouchPhase, WindowEvent, IME},
     event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootELW},
     monitor::MonitorHandle as RootMonitorHandle,
     platform_impl::platform::{
         dark_mode::try_theme,
         dpi::{become_dpi_aware, dpi_to_scale_factor},
         drop_handler::FileDropHandler,
         event::{self, handle_extended_keys, process_key_params, vkey_to_winit_vkey},
+        ime::ImeContext,
         monitor::{self, MonitorHandle},
         raw_input, util,
         window::InitData,
-        window_state::{CursorFlags, WindowFlags, WindowState},
+        window_state::{CursorFlags, ImeState, WindowFlags, WindowState},
         wrap_device_id, WindowId, DEVICE_ID,
     },
     window::{Fullscreen, WindowId as RootWindowId},
@@ -1095,6 +1098,103 @@ unsafe fn public_window_callback_inner<T: 'static>(
             0
         }
 
+        WM_IME_STARTCOMPOSITION => {
+            let ime_allowed = userdata.window_state.lock().ime_allowed;
+            if ime_allowed {
+                userdata.window_state.lock().ime_state = ImeState::Enabled;
+
+                userdata.send_event(Event::WindowEvent {
+                    window_id: RootWindowId(WindowId(window)),
+                    event: WindowEvent::IME(IME::Enabled),
+                });
+            }
+
+            DefWindowProcW(window, msg, wparam, lparam)
+        }
+
+        WM_IME_COMPOSITION => {
+            let ime_allowed_and_composing = {
+                let w = userdata.window_state.lock();
+                w.ime_allowed && w.ime_state != ImeState::Disabled
+            };
+            // Windows Hangul IME sends WM_IME_COMPOSITION after WM_IME_ENDCOMPOSITION, so
+            // check whether composing.
+            if ime_allowed_and_composing {
+                let ime_context = ImeContext::current(window);
+
+                if lparam == 0 {
+                    userdata.send_event(Event::WindowEvent {
+                        window_id: RootWindowId(WindowId(window)),
+                        event: WindowEvent::IME(IME::Preedit(String::new(), None, None)),
+                    });
+                }
+
+                // Google Japanese Input and ATOK have both flags, so
+                // first, receive composing result if exist.
+                if (lparam as u32 & GCS_RESULTSTR) != 0 {
+                    if let Some(text) = ime_context.get_composed_text() {
+                        userdata.window_state.lock().ime_state = ImeState::Enabled;
+
+                        userdata.send_event(Event::WindowEvent {
+                            window_id: RootWindowId(WindowId(window)),
+                            event: WindowEvent::IME(IME::Commit(text)),
+                        });
+                    }
+                }
+
+                // Next, receive preedit range for next composing if exist.
+                if (lparam as u32 & GCS_COMPSTR) != 0 {
+                    if let Some((text, first, last)) = ime_context.get_composing_text_and_cursor() {
+                        userdata.window_state.lock().ime_state = ImeState::Preedit;
+
+                        userdata.send_event(Event::WindowEvent {
+                            window_id: RootWindowId(WindowId(window)),
+                            event: WindowEvent::IME(IME::Preedit(text, first, last)),
+                        });
+                    }
+                }
+            }
+
+            // Not calling DefWindowProc to hide composing text drawn by IME.
+            0
+        }
+
+        WM_IME_ENDCOMPOSITION => {
+            let ime_allowed_or_composing = {
+                let w = userdata.window_state.lock();
+                w.ime_allowed || w.ime_state != ImeState::Disabled
+            };
+            if ime_allowed_or_composing {
+                if userdata.window_state.lock().ime_state == ImeState::Preedit {
+                    // Windows Hangul IME sends WM_IME_COMPOSITION after WM_IME_ENDCOMPOSITION, so
+                    // trying receiving composing result and commit if exists.
+                    let ime_context = ImeContext::current(window);
+                    if let Some(text) = ime_context.get_composed_text() {
+                        userdata.send_event(Event::WindowEvent {
+                            window_id: RootWindowId(WindowId(window)),
+                            event: WindowEvent::IME(IME::Commit(text)),
+                        });
+                    }
+                }
+
+                userdata.window_state.lock().ime_state = ImeState::Disabled;
+
+                userdata.send_event(Event::WindowEvent {
+                    window_id: RootWindowId(WindowId(window)),
+                    event: WindowEvent::IME(IME::Disabled),
+                });
+            }
+
+            DefWindowProcW(window, msg, wparam, lparam)
+        }
+
+        WM_IME_SETCONTEXT => {
+            // Hide composing text drawn by IME.
+            let wparam = wparam & (!ISC_SHOWUICOMPOSITIONWINDOW as usize);
+
+            DefWindowProcW(window, msg, wparam, lparam)
+        }
+
         // this is necessary for us to maintain minimize/restore state
         WM_SYSCOMMAND => {
             if wparam == SC_RESTORE as usize {

src/platform_impl/web/window.rs

@@ -0,0 +1,150 @@
+use std::{
+    ffi::{c_void, OsString},
+    mem::zeroed,
+    os::windows::prelude::OsStringExt,
+    ptr::null_mut,
+};
+
+use windows_sys::Win32::{
+    Foundation::POINT,
+    Globalization::HIMC,
+    UI::{
+        Input::Ime::{
+            ImmAssociateContextEx, ImmGetCompositionStringW, ImmGetContext, ImmReleaseContext,
+            ImmSetCandidateWindow, ATTR_TARGET_CONVERTED, ATTR_TARGET_NOTCONVERTED, CANDIDATEFORM,
+            CFS_EXCLUDE, GCS_COMPATTR, GCS_COMPSTR, GCS_CURSORPOS, GCS_RESULTSTR, IACE_CHILDREN,
+            IACE_DEFAULT,
+        },
+        WindowsAndMessaging::{GetSystemMetrics, SM_IMMENABLED},
+    },
+};
+
+use crate::{dpi::Position, platform::windows::HWND};
+
+pub struct ImeContext {
+    hwnd: HWND,
+    himc: HIMC,
+}
+
+impl ImeContext {
+    pub unsafe fn current(hwnd: HWND) -> Self {
+        let himc = ImmGetContext(hwnd);
+        ImeContext { hwnd, himc }
+    }
+
+    pub unsafe fn get_composing_text_and_cursor(
+        &self,
+    ) -> Option<(String, Option<usize>, Option<usize>)> {
+        let text = self.get_composition_string(GCS_COMPSTR)?;
+        let attrs = self.get_composition_data(GCS_COMPATTR).unwrap_or_default();
+
+        let mut first = None;
+        let mut last = None;
+        let mut boundary_before_char = 0;
+
+        for (attr, chr) in attrs.into_iter().zip(text.chars()) {
+            let char_is_targetted =
+                attr as u32 == ATTR_TARGET_CONVERTED || attr as u32 == ATTR_TARGET_NOTCONVERTED;
+
+            if first.is_none() && char_is_targetted {
+                first = Some(boundary_before_char);
+            } else if first.is_some() && last.is_none() && !char_is_targetted {
+                last = Some(boundary_before_char);
+            }
+
+            boundary_before_char += chr.len_utf8();
+        }
+
+        if first.is_some() && last.is_none() {
+            last = Some(text.len());
+        } else if first.is_none() {
+            // IME haven't split words and select any clause yet, so trying to retrieve normal cursor.
+            let cursor = self.get_composition_cursor(&text);
+            first = cursor;
+            last = cursor;
+        }
+
+        Some((text, first, last))
+    }
+
+    pub unsafe fn get_composed_text(&self) -> Option<String> {
+        self.get_composition_string(GCS_RESULTSTR)
+    }
+
+    unsafe fn get_composition_cursor(&self, text: &str) -> Option<usize> {
+        let cursor = ImmGetCompositionStringW(self.himc, GCS_CURSORPOS, null_mut(), 0);
+        (cursor >= 0).then(|| text.chars().take(cursor as _).map(|c| c.len_utf8()).sum())
+    }
+
+    unsafe fn get_composition_string(&self, gcs_mode: u32) -> Option<String> {
+        let data = self.get_composition_data(gcs_mode)?;
+        let (prefix, shorts, suffix) = data.align_to::<u16>();
+        if prefix.is_empty() && suffix.is_empty() {
+            OsString::from_wide(&shorts).into_string().ok()
+        } else {
+            None
+        }
+    }
+
+    unsafe fn get_composition_data(&self, gcs_mode: u32) -> Option<Vec<u8>> {
+        let size = ImmGetCompositionStringW(self.himc, gcs_mode, null_mut(), 0);
+        if size < 0 {
+            return None;
+        } else if size == 0 {
+            return Some(Vec::new());
+        }
+
+        let mut buf = Vec::<u8>::with_capacity(size as _);
+        let size = ImmGetCompositionStringW(
+            self.himc,
+            gcs_mode,
+            buf.as_mut_ptr() as *mut c_void,
+            size as _,
+        );
+
+        if size < 0 {
+            None
+        } else {
+            buf.set_len(size as _);
+            Some(buf)
+        }
+    }
+
+    pub unsafe fn set_ime_position(&self, spot: Position, scale_factor: f64) {
+        if !ImeContext::system_has_ime() {
+            return;
+        }
+
+        let (x, y) = spot.to_physical::<i32>(scale_factor).into();
+        let candidate_form = CANDIDATEFORM {
+            dwIndex: 0,
+            dwStyle: CFS_EXCLUDE,
+            ptCurrentPos: POINT { x, y },
+            rcArea: zeroed(),
+        };
+
+        ImmSetCandidateWindow(self.himc, &candidate_form);
+    }
+
+    pub unsafe fn set_ime_allowed(hwnd: HWND, allowed: bool) {
+        if !ImeContext::system_has_ime() {
+            return;
+        }
+
+        if allowed {
+            ImmAssociateContextEx(hwnd, 0, IACE_DEFAULT);
+        } else {
+            ImmAssociateContextEx(hwnd, 0, IACE_CHILDREN);
+        }
+    }
+
+    unsafe fn system_has_ime() -> bool {
+        return GetSystemMetrics(SM_IMMENABLED) != 0;
+    }
+}
+
+impl Drop for ImeContext {
+    fn drop(&mut self) {
+        unsafe { ImmReleaseContext(self.hwnd, self.himc) };
+    }
+}

src/platform_impl/windows/event_loop.rs

@@ -154,6 +154,7 @@ mod drop_handler;
 mod event;
 mod event_loop;
 mod icon;
+mod ime;
 mod monitor;
 mod raw_input;
 mod window;

src/platform_impl/windows/ime.rs

@@ -31,10 +31,6 @@ use windows_sys::Win32::{
     },
     UI::{
         Input::{
-            Ime::{
-                ImmGetContext, ImmReleaseContext, ImmSetCompositionWindow, CFS_POINT,
-                COMPOSITIONFORM,
-            },
             KeyboardAndMouse::{
                 EnableWindow, GetActiveWindow, MapVirtualKeyW, ReleaseCapture, SendInput, INPUT,
                 INPUT_0, INPUT_KEYBOARD, KEYBDINPUT, KEYEVENTF_EXTENDEDKEY, KEYEVENTF_KEYUP,
@@ -49,8 +45,8 @@ use windows_sys::Win32::{
             SetWindowPlacement, SetWindowPos, SetWindowTextW, CS_HREDRAW, CS_VREDRAW,
             CW_USEDEFAULT, FLASHWINFO, FLASHW_ALL, FLASHW_STOP, FLASHW_TIMERNOFG, FLASHW_TRAY,
             GWLP_HINSTANCE, HTCAPTION, MAPVK_VK_TO_VSC, NID_READY, PM_NOREMOVE, SM_DIGITIZER,
-            SM_IMMENABLED, SWP_ASYNCWINDOWPOS, SWP_NOACTIVATE, SWP_NOSIZE, SWP_NOZORDER,
-            WM_NCLBUTTONDOWN, WNDCLASSEXW,
+            SWP_ASYNCWINDOWPOS, SWP_NOACTIVATE, SWP_NOSIZE, SWP_NOZORDER, WM_NCLBUTTONDOWN,
+            WNDCLASSEXW,
         },
     },
 };
@@ -69,6 +65,7 @@ use crate::{
         drop_handler::FileDropHandler,
         event_loop::{self, EventLoopWindowTarget, DESTROY_MSG_ID},
         icon::{self, IconType},
+        ime::ImeContext,
         monitor, util,
         window_state::{CursorFlags, SavedWindow, WindowFlags, WindowState},
         Parent, PlatformSpecificWindowBuilderAttributes, WindowId,
@@ -613,25 +610,19 @@ impl Window {
         self.window_state.lock().taskbar_icon = taskbar_icon;
     }
 
-    pub(crate) fn set_ime_position_physical(&self, x: i32, y: i32) {
-        if unsafe { GetSystemMetrics(SM_IMMENABLED) } != 0 {
-            let composition_form = COMPOSITIONFORM {
-                dwStyle: CFS_POINT,
-                ptCurrentPos: POINT { x, y },
-                rcArea: unsafe { mem::zeroed() },
-            };
-            unsafe {
-                let himc = ImmGetContext(self.hwnd());
-                ImmSetCompositionWindow(himc, &composition_form);
-                ImmReleaseContext(self.hwnd(), himc);
-            }
+    #[inline]
+    pub fn set_ime_position(&self, spot: Position) {
+        unsafe {
+            ImeContext::current(self.hwnd()).set_ime_position(spot, self.scale_factor());
         }
     }
 
     #[inline]
-    pub fn set_ime_position(&self, spot: Position) {
-        let (x, y) = spot.to_physical::<i32>(self.scale_factor()).into();
-        self.set_ime_position_physical(x, y);
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        self.window_state.lock().ime_allowed = allowed;
+        unsafe {
+            ImeContext::set_ime_allowed(self.hwnd(), allowed);
+        }
     }
 
     #[inline]
@@ -785,6 +776,8 @@ impl<'a, T: 'static> InitData<'a, T> {
 
         enable_non_client_dpi_scaling(window);
 
+        ImeContext::set_ime_allowed(window, false);
+
         Window {
             window: WindowWrapper(window),
             window_state,

src/platform_impl/windows/mod.rs

@@ -42,6 +42,9 @@ pub struct WindowState {
     pub preferred_theme: Option<Theme>,
     pub high_surrogate: Option<u16>,
     pub window_flags: WindowFlags,
+
+    pub ime_state: ImeState,
+    pub ime_allowed: bool,
 }
 
 #[derive(Clone)]
@@ -99,6 +102,13 @@ bitflags! {
     }
 }
 
+#[derive(Eq, PartialEq)]
+pub enum ImeState {
+    Disabled,
+    Enabled,
+    Preedit,
+}
+
 impl WindowState {
     pub fn new(
         attributes: &WindowAttributes,
@@ -130,6 +140,9 @@ impl WindowState {
             preferred_theme,
             high_surrogate: None,
             window_flags: WindowFlags::empty(),
+
+            ime_state: ImeState::Disabled,
+            ime_allowed: false,
         }
     }
 

src/platform_impl/windows/window.rs

@@ -834,6 +834,33 @@ impl Window {
         self.window.set_ime_position(position.into())
     }
 
+    /// Sets whether the window should get IME events
+    ///
+    /// When IME is allowed, the window will receive [`IME`] events, and during the
+    /// preedit phase the window will NOT get [`KeyboardInput`] or
+    /// [`ReceivedCharacter`] events. The window should allow IME while it is
+    /// expecting text input.
+    ///
+    /// When IME is not allowed, the window won't receive [`IME`] events, and will
+    /// receive [`KeyboardInput`] events for every keypress instead. Without
+    /// allowing IME, the window will also get [`ReceivedCharacter`] events for
+    /// certain keyboard input. Not allowing IME is useful for games for example.
+    ///
+    /// IME is **not** allowed by default.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **macOS:** IME must be enabled to receive text-input where dead-key sequences are combined.
+    /// - ** iOS / Android / Web :** Unsupported.
+    ///
+    /// [`IME`]: crate::event::WindowEvent::IME
+    /// [`KeyboardInput`]: crate::event::WindowEvent::KeyboardInput
+    /// [`ReceivedCharacter`]: crate::event::WindowEvent::ReceivedCharacter
+    #[inline]
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        self.window.set_ime_allowed(allowed);
+    }
+
     /// Brings the window to the front and sets input focus. Has no effect if the window is
     /// already in focus, minimized, or not visible.
     ///