Winit version 0.29.10

See rust-lang/rust#118297

CHANGELOG.md

@@ -11,6 +11,18 @@ Unreleased` header.
 
 # Unreleased
 
+# 0.29.10
+
+- On Web, account for canvas being focused already before event loop starts.
+- On Web, increase cursor position accuracy.
+
+# 0.29.9
+
+- On X11, fix `NotSupported` error not propagated when creating event loop.
+- On Wayland, fix resize not issued when scale changes
+- On X11 and Wayland, fix arrow up on keypad reported as `ArrowLeft`.
+- On macOS, report correct logical key when Ctrl or Cmd is pressed.
+
 # 0.29.8
 
 - On X11, fix IME input lagging behind.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.8"
+version = "0.29.10"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"

README.md

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.8"
+winit = "0.29.10"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -156,7 +156,7 @@ For more details, refer to these `android-activity` [example applications](https
 
 If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building with `cargo apk`, then the minimal changes would be:
 1. Remove `ndk-glue` from your `Cargo.toml`
-2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.8", features = [ "android-native-activity" ] }`
+2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.10", features = [ "android-native-activity" ] }`
 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize logging as above).
 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your event loop (as shown above).
 

src/platform_impl/linux/common/keymap.rs

@@ -504,7 +504,7 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         keysyms::KP_F4 => NamedKey::F4,
         keysyms::KP_Home => NamedKey::Home,
         keysyms::KP_Left => NamedKey::ArrowLeft,
-        keysyms::KP_Up => NamedKey::ArrowLeft,
+        keysyms::KP_Up => NamedKey::ArrowUp,
         keysyms::KP_Right => NamedKey::ArrowRight,
         keysyms::KP_Down => NamedKey::ArrowDown,
         // keysyms::KP_Prior => NamedKey::PageUp,

src/platform_impl/linux/mod.rs

@@ -784,7 +784,7 @@ impl<T: 'static> EventLoop<T> {
             #[cfg(wayland_platform)]
             Backend::Wayland => EventLoop::new_wayland_any_thread().map_err(Into::into),
             #[cfg(x11_platform)]
-            Backend::X => Ok(EventLoop::new_x11_any_thread().unwrap()),
+            Backend::X => EventLoop::new_x11_any_thread().map_err(Into::into),
         }
     }
 
@@ -794,10 +794,10 @@ impl<T: 'static> EventLoop<T> {
     }
 
     #[cfg(x11_platform)]
-    fn new_x11_any_thread() -> Result<EventLoop<T>, XNotSupported> {
+    fn new_x11_any_thread() -> Result<EventLoop<T>, EventLoopError> {
         let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
             Ok(xconn) => xconn.clone(),
-            Err(err) => return Err(err.clone()),
+            Err(_) => return Err(EventLoopError::NotSupported(NotSupportedError::new())),
         };
 
         Ok(EventLoop::X(x11::EventLoop::new(xconn)))

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

@@ -401,7 +401,9 @@ impl<T: 'static> EventLoop<T> {
                 }
             }
 
-            if compositor_update.resized {
+            // NOTE: Rescale changed the physical size which winit operates in, thus we should
+            // resize.
+            if compositor_update.resized || compositor_update.scale_changed {
                 let physical_size = self.with_state(|state| {
                     let windows = state.windows.get_mut();
                     let window = windows.get(&window_id).unwrap().lock().unwrap();

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

@@ -79,9 +79,9 @@ pub(crate) unsafe fn set_destroy_callback(
 #[allow(clippy::enum_variant_names)]
 enum ReplaceImError {
     // Boxed to prevent large error type
-    MethodOpenFailed(Box<PotentialInputMethods>),
-    ContextCreationFailed(ImeContextCreationError),
-    SetDestroyCallbackFailed(XError),
+    MethodOpenFailed(#[allow(dead_code)] Box<PotentialInputMethods>),
+    ContextCreationFailed(#[allow(dead_code)] ImeContextCreationError),
+    SetDestroyCallbackFailed(#[allow(dead_code)] XError),
 }
 
 // Attempt to replace current IM (which may or may not be presently valid) with a new one. This

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

@@ -159,9 +159,9 @@ impl InputMethodResult {
 
 #[derive(Debug, Clone)]
 enum GetXimServersError {
-    XError(XError),
-    GetPropertyError(util::GetPropertyError),
-    InvalidUtf8(IntoStringError),
+    XError(#[allow(dead_code)] XError),
+    GetPropertyError(#[allow(dead_code)] util::GetPropertyError),
+    InvalidUtf8(#[allow(dead_code)] IntoStringError),
 }
 
 impl From<util::GetPropertyError> for GetXimServersError {

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

@@ -48,7 +48,7 @@ pub enum ImeRequest {
 pub(crate) enum ImeCreationError {
     // Boxed to prevent large error type
     OpenFailure(Box<PotentialInputMethods>),
-    SetDestroyCallbackFailed(XError),
+    SetDestroyCallbackFailed(#[allow(dead_code)] XError),
 }
 
 pub(crate) struct Ime {

src/platform_impl/macos/event.rs

@@ -39,6 +39,7 @@ impl KeyEventExtModifierSupplement for KeyEvent {
     }
 }
 
+/// Ignores ALL modifiers.
 pub fn get_modifierless_char(scancode: u16) -> Key {
     let mut string = [0; 16];
     let input_source;
@@ -97,6 +98,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
     Key::Character(SmolStr::new(chars))
 }
 
+// Ignores all modifiers except for SHIFT (yes, even ALT is ignored).
 fn get_logical_key_char(ns_event: &NSEvent, modifierless_chars: &str) -> Key {
     let string = ns_event
         .charactersIgnoringModifiers()
@@ -126,6 +128,13 @@ pub(crate) fn create_key_event(
     let mut physical_key =
         key_override.unwrap_or_else(|| PhysicalKey::from_scancode(scancode as u32));
 
+    // NOTE: The logical key should heed both SHIFT and ALT if possible.
+    // For instance:
+    // * Pressing the A key: logical key should be "a"
+    // * Pressing SHIFT A: logical key should be "A"
+    // * Pressing CTRL SHIFT A: logical key should also be "A"
+    // This is not easy to tease out of `NSEvent`, but we do our best.
+
     let text_with_all_modifiers: Option<SmolStr> = if key_override.is_some() {
         None
     } else {
@@ -146,21 +155,29 @@ pub(crate) fn create_key_event(
 
     let key_from_code = code_to_key(physical_key, scancode);
     let (logical_key, key_without_modifiers) = if matches!(key_from_code, Key::Unidentified(_)) {
+        // `get_modifierless_char/key_without_modifiers` ignores ALL modifiers.
         let key_without_modifiers = get_modifierless_char(scancode);
 
         let modifiers = NSEvent::modifierFlags(ns_event);
         let has_ctrl = modifiers.contains(NSEventModifierFlags::NSControlKeyMask);
+        let has_cmd = modifiers.contains(NSEventModifierFlags::NSCommandKeyMask);
 
         let logical_key = match text_with_all_modifiers.as_ref() {
-            // Only checking for ctrl here, not checking for alt because we DO want to
+            // Only checking for ctrl and cmd here, not checking for alt because we DO want to
             // include its effect in the key. For example if -on the Germay layout- one
             // presses alt+8, the logical key should be "{"
             // Also not checking if this is a release event because then this issue would
             // still affect the key release.
-            Some(text) if !has_ctrl => Key::Character(text.clone()),
+            Some(text) if !has_ctrl && !has_cmd => {
+                // Character heeding both SHIFT and ALT.
+                Key::Character(text.clone())
+            }
+
             _ => match key_without_modifiers.as_ref() {
+                // Character heeding just SHIFT, ignoring ALT.
                 Key::Character(ch) => get_logical_key_char(ns_event, ch),
-                // Don't try to get text for events which likely don't have it.
+
+                // Character ignoring ALL modifiers.
                 _ => key_without_modifiers.clone(),
             },
         };

src/platform_impl/web/event_loop/window_target.rs

@@ -5,6 +5,8 @@ use std::iter;
 use std::marker::PhantomData;
 use std::rc::{Rc, Weak};
 
+use web_sys::Element;
+
 use super::runner::{EventWrapper, Execution};
 use super::{
     super::{monitor::MonitorHandle, KeyEventExtra},
@@ -122,6 +124,25 @@ impl<T> EventLoopWindowTarget<T> {
             }
         });
 
+        // It is possible that at this point the canvas has
+        // been focused before the callback can be called.
+        let focused = canvas
+            .document()
+            .active_element()
+            .filter(|element| {
+                let canvas: &Element = canvas.raw();
+                element == canvas
+            })
+            .is_some();
+
+        if focused {
+            canvas.has_focus.set(true);
+            self.runner.send_event(Event::WindowEvent {
+                window_id: RootWindowId(id),
+                event: WindowEvent::Focused(true),
+            })
+        }
+
         let runner = self.runner.clone();
         let modifiers = self.modifiers.clone();
         canvas.on_keyboard_press(

src/platform_impl/web/web_sys/event.rs

@@ -81,9 +81,22 @@ impl MouseButton {
 }
 
 pub fn mouse_position(event: &MouseEvent) -> LogicalPosition<f64> {
+    #[wasm_bindgen]
+    extern "C" {
+        type MouseEventExt;
+
+        #[wasm_bindgen(method, getter, js_name = offsetX)]
+        fn offset_x(this: &MouseEventExt) -> f64;
+
+        #[wasm_bindgen(method, getter, js_name = offsetY)]
+        fn offset_y(this: &MouseEventExt) -> f64;
+    }
+
+    let event: &MouseEventExt = event.unchecked_ref();
+
     LogicalPosition {
-        x: event.offset_x() as f64,
-        y: event.offset_y() as f64,
+        x: event.offset_x(),
+        y: event.offset_y(),
     }
 }
 

src/platform_impl/windows/window.rs

@@ -1375,7 +1375,7 @@ unsafe fn register_window_class<T: 'static>(class_name: &[u16]) {
     unsafe { RegisterClassExW(&class) };
 }
 
-struct ComInitialized(*mut ());
+struct ComInitialized(#[allow(dead_code)] *mut ());
 impl Drop for ComInitialized {
     fn drop(&mut self) {
         unsafe { CoUninitialize() };