On X11, don't require XIM to be present

In general, we may want to use xinput v2 for keyboard input in such
cases, so we have compose going, but for now just don't crash if
there's no XIM.

CHANGELOG.md

@@ -11,6 +11,7 @@ Unreleased` header.
 
 # Unreleased
 
+- On X11, don't require XIM to run.
 - Fix compatibility with 32-bit platforms without 64-bit atomics.
 - On macOS, fix incorrect IME cursor rect origin.
 - On X11, fix swapped instance and general class names.

src/platform_impl/linux/x11/event_processor.rs

@@ -74,7 +74,11 @@ impl<T: 'static> EventProcessor<T> {
 
         // Handle IME requests.
         while let Ok(request) = self.ime_receiver.try_recv() {
-            let ime = window_target.ime.get_mut();
+            let ime = match window_target.ime.as_mut() {
+                Some(ime) => ime,
+                None => continue,
+            };
+            let ime = ime.get_mut();
             match request {
                 ImeRequest::Position(window_id, x, y) => {
                     ime.send_xim_spot(window_id, x, y);
@@ -792,10 +796,11 @@ impl<T: 'static> EventProcessor<T> {
 
         // Since all XIM stuff needs to happen from the same thread, we destroy the input
         // context here instead of when dropping the window.
-        wt.ime
+        if let Some(ime) = wt.ime.as_ref() {
-            .borrow_mut()
+            ime.borrow_mut()
-            .remove_context(window as XWindow)
+                .remove_context(window as XWindow)
-            .expect("Failed to destroy input context");
+                .expect("Failed to destroy input context");
+        }
 
         callback(
             &self.target,
@@ -918,7 +923,11 @@ impl<T: 'static> EventProcessor<T> {
                     },
                 },
             );
-        } else if let Some(ic) = wt.ime.borrow().get_context(window as XWindow) {
+        } else if let Some(ic) = wt
+            .ime
+            .as_ref()
+            .and_then(|ime| ime.borrow().get_context(window as XWindow))
+        {
             let written = wt.xconn.lookup_utf8(ic, xev);
             if !written.is_empty() {
                 let event = Event::WindowEvent {
@@ -1183,10 +1192,11 @@ impl<T: 'static> EventProcessor<T> {
         // Set the timestamp.
         wt.xconn.set_timestamp(xev.time as xproto::Timestamp);
 
-        wt.ime
+        if let Some(ime) = wt.ime.as_ref() {
-            .borrow_mut()
+            ime.borrow_mut()
-            .focus(xev.event)
+                .focus(xev.event)
-            .expect("Failed to focus input context");
+                .expect("Failed to focus input context");
+        }
 
         if self.active_window == Some(window) {
             return;
@@ -1254,10 +1264,11 @@ impl<T: 'static> EventProcessor<T> {
             return;
         }
 
-        wt.ime
+        if let Some(ime) = wt.ime.as_ref() {
-            .borrow_mut()
+            ime.borrow_mut()
-            .unfocus(xev.event)
+                .unfocus(xev.event)
-            .expect("Failed to unfocus input context");
+                .expect("Failed to unfocus input context");
+        }
 
         if self.active_window.take() == Some(window) {
             let window_id = mkwid(window);

src/platform_impl/linux/x11/mod.rs

@@ -136,7 +136,7 @@ pub struct EventLoopWindowTarget<T> {
     control_flow: Cell<ControlFlow>,
     exit: Cell<Option<i32>>,
     root: xproto::Window,
-    ime: RefCell<Ime>,
+    ime: Option<RefCell<Ime>>,
     windows: RefCell<HashMap<WindowId, Weak<UnownedWindow>>>,
     redraw_sender: WakeSender<WindowId>,
     activation_sender: WakeSender<ActivationToken>,
@@ -213,13 +213,15 @@ impl<T: 'static> EventLoop<T> {
                 setlocale(LC_CTYPE, default_locale);
             }
         }
-        let ime = RefCell::new({
+
-            let result = Ime::new(Arc::clone(&xconn), ime_event_sender);
+        let ime = Ime::new(Arc::clone(&xconn), ime_event_sender);
-            if let Err(ImeCreationError::OpenFailure(ref state)) = result {
+        if let Err(ImeCreationError::OpenFailure(state)) = ime.as_ref() {
-                panic!("Failed to open input method: {state:#?}");
+            warn!("Failed to open input method: {state:#?}");
-            }
+        } else if let Err(err) = ime.as_ref() {
-            result.expect("Failed to set input method destruction callback")
+            warn!("Failed to set input method destruction callback: {err:?}");
-        });
+        }
+
+        let ime = ime.ok().map(RefCell::new);
 
         let randr_event_offset = xconn
             .select_xrandr_input(root)

src/platform_impl/linux/x11/window.rs

@@ -541,9 +541,9 @@ impl UnownedWindow {
             leap!(xconn.select_xinput_events(window.xwindow, super::ALL_MASTER_DEVICES, mask))
                 .ignore_error();
 
-            {
+            // Try to create input context for the window.
-                let result = event_loop
+            if let Some(ime) = event_loop.ime.as_ref() {
-                    .ime
+                let result = ime
                     .borrow_mut()
                     .create_context(window.xwindow as ffi::Window, false);
                 leap!(result);