Rename window example to full, to signify that it's a large example

It is more clear what's happening when you don't have to jump to the bottom of the file to look at the implementation.

.cspell.json

@@ -1,13 +0,0 @@
-{
-    "$schema": "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json",
-    "version": "0.2",
-    "dictionaryDefinitions": [
-      {
-        "name": "project-words",
-        "path": "./project-words.txt",
-        "addWords": true
-      }
-    ],
-    "dictionaries": ["project-words"],
-    "ignorePaths": ["/target", "/project-words.txt"]
-  }

.github/workflows/ci.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   fmt:
-    name: Tidy Code
+    name: Check formatting
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
@@ -16,13 +16,10 @@ jobs:
         components: rustfmt
     - name: Check Formatting
       run: cargo fmt -- --check
-    - name: Check Spelling
-      run: npx -y cspell --no-progress --no-summary '**/*.rs' '**/*.md'
 
   tests:
     name: Test ${{ matrix.toolchain }} ${{ matrix.platform.name }}
     runs-on: ${{ matrix.platform.os }}
-    needs: fmt
 
     strategy:
       fail-fast: false

CHANGELOG.md

@@ -46,16 +46,6 @@ Unreleased` header.
 - **Breaking:** Changed the signature of `EventLoop::with_user_event` to return a builder.
 - **Breaking:** Removed `EventLoopBuilder::with_user_event`, the functionality is now available in `EventLoop::with_user_event`.
 - Add `Window::default_attributes` to get default `WindowAttributes`.
-- `log` has been replaced with `tracing`. The old behavior can be emulated by setting the `log` feature on the `tracing` crate.
-
-# 0.29.13
-
-- On Web, fix possible crash with `ControlFlow::Wait` and `ControlFlow::WaitUntil`.
-
-# 0.29.12
-
-- On X11, fix use after free during xinput2 handling.
-- On X11, filter close to zero values in mouse device events
 
 # 0.29.11
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.13"
+version = "0.29.11"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 keywords = ["windowing"]
@@ -64,18 +64,17 @@ cfg_aliases = "0.2.0"
 [dependencies]
 bitflags = "2"
 cursor-icon = "1.1.0"
+log = "0.4"
 rwh_04 = { package = "raw-window-handle", version = "0.4", optional = true }
 rwh_05 = { package = "raw-window-handle", version = "0.5.2", features = ["std"], optional = true }
 rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"], optional = true }
 serde = { workspace = true, optional = true }
 smol_str = "0.2.0"
 dpi = { path = "dpi" }
-tracing = { version = "0.1.40", default_features = false }
 
 [dev-dependencies]
 image = { version = "0.24.0", default-features = false, features = ["png"] }
-tracing = { version = "0.1.40", default_features = false, features = ["log"] }
+simple_logger = { version = "4.2.0", default_features = false }
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 winit = { path = ".", features = ["rwh_05"] }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dev-dependencies]
@@ -258,7 +257,7 @@ web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
 
 [[example]]
 doc-scrape-examples = true
-name = "window"
+name = "full"
 
 [workspace]
 resolver = "2"

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.13"
+winit = "0.29.11"
 ```
 
 ## [Documentation](https://docs.rs/winit)

examples/control_flow.rs

@@ -6,6 +6,7 @@ use std::time;
 #[cfg(web_platform)]
 use web_time as time;
 
+use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
@@ -27,7 +28,7 @@ const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
 const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);
 
 fn main() -> Result<(), impl std::error::Error> {
-    tracing_subscriber::fmt::init();
+    SimpleLogger::new().init().unwrap();
 
     println!("Press '1' to switch to Wait mode.");
     println!("Press '2' to switch to WaitUntil mode.");

examples/monitors.rs

@@ -0,0 +1,62 @@
+use std::error::Error;
+use winit::{
+    event::{Event, StartCause},
+    event_loop::{ActiveEventLoop, EventLoop},
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let event_loop = EventLoop::new()?;
+
+    Ok(event_loop.run(|event, event_loop| match event {
+        Event::NewEvents(StartCause::Init) => {
+            dump_monitors(event_loop);
+            event_loop.exit()
+        }
+        _ => {}
+    })?)
+}
+
+fn dump_monitors(event_loop: &ActiveEventLoop) {
+    println!("Monitors information");
+    let primary_monitor = event_loop.primary_monitor();
+    for monitor in event_loop.available_monitors() {
+        let intro = if primary_monitor.as_ref() == Some(&monitor) {
+            "Primary monitor"
+        } else {
+            "Monitor"
+        };
+
+        if let Some(name) = monitor.name() {
+            println!("{intro}: {name}");
+        } else {
+            println!("{intro}: [no name]");
+        }
+
+        let size = monitor.size();
+        print!("  Current mode: {}x{}", size.width, size.height);
+        if let Some(m_hz) = monitor.refresh_rate_millihertz() {
+            println!(" @ {}.{} Hz", m_hz / 1000, m_hz % 1000);
+        } else {
+            println!();
+        }
+
+        let position = monitor.position();
+        println!("  Position: {}, {}", position.x, position.y);
+
+        println!("  Scale factor: {}", monitor.scale_factor());
+
+        println!("  Available modes (width x height x bit-depth):");
+        for mode in monitor.video_modes() {
+            let size = mode.size();
+            let m_hz = mode.refresh_rate_millihertz();
+            println!(
+                "    {:04}x{:04}x{:02} @ {:>3}.{} Hz",
+                size.width,
+                size.height,
+                mode.bit_depth(),
+                m_hz / 1000,
+                m_hz % 1000
+            );
+        }
+    }
+}

examples/pump_events.rs

@@ -11,6 +11,7 @@
 fn main() -> std::process::ExitCode {
     use std::{process::ExitCode, thread::sleep, time::Duration};
 
+    use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
         event_loop::EventLoop,
@@ -23,7 +24,7 @@ fn main() -> std::process::ExitCode {
 
     let mut event_loop = EventLoop::new().unwrap();
 
-    tracing_subscriber::fmt::init();
+    SimpleLogger::new().init().unwrap();
 
     let mut window = None;
 

examples/run_on_demand.rs

@@ -5,6 +5,8 @@
 fn main() -> Result<(), impl std::error::Error> {
     use std::time::Duration;
 
+    use simple_logger::SimpleLogger;
+
     use winit::{
         error::EventLoopError,
         event::{Event, WindowEvent},
@@ -22,7 +24,7 @@ fn main() -> Result<(), impl std::error::Error> {
         window: Option<Window>,
     }
 
-    tracing_subscriber::fmt::init();
+    SimpleLogger::new().init().unwrap();
     let mut event_loop = EventLoop::new().unwrap();
 
     fn run_app(event_loop: &mut EventLoop<()>, idx: usize) -> Result<(), EventLoopError> {

examples/x11_embed.rs

@@ -3,6 +3,8 @@ use std::error::Error;
 
 #[cfg(x11_platform)]
 fn main() -> Result<(), Box<dyn Error>> {
+    use simple_logger::SimpleLogger;
+
     use winit::{
         event::{Event, WindowEvent},
         event_loop::EventLoop,
@@ -19,7 +21,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         .ok_or("Expected a 32-bit X11 window ID as the first argument.")?
         .parse::<u32>()?;
 
-    tracing_subscriber::fmt::init();
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new()?;
 
     let mut window = None;

project-words.txt

@@ -1,707 +0,0 @@
-ABNT
-ACCEPTFILES
-ALTERASE
-APPCOMMAND
-APPSTARTING
-APPWINDOW
-ASYNCWINDOWPOS
-ATOK
-AZERTY
-Abortable
-Artur
-Autorotate
-BACKTAB
-BADFLAGS
-BADMODE
-BADPARAM
-BASSBOOST
-BITSPERPEL
-BKSP
-BLURBEHIND
-BOTTOMLEFT
-BOTTOMRIGHT
-BRIGHTNESSDOW
-BRIGHTNESSU
-BYCOMMAND
-Backquote
-Bangou
-Blackbox
-CAEAGL
-CANDIDATEFORM
-CAPTURECHANGED
-CFUUID
-CLIPSIBLINGS
-CLOEXEC
-CLOSECD
-CODEOWNERS
-COLORSYNC
-COMPATTR
-COMPOSITIONFORM
-COMPSTR
-CREATESTRUCTW
-CRSEL
-CRTC
-CTYPE
-CURSORPOS
-CUSEL
-CXVIRTUALSCREEN
-CYCLEWINDOWS
-CYVIRTUALSCREEN
-Calculater
-Codeinput
-Colormap
-Compiz
-Condvar
-Crtc
-DEADCHAR
-DEFAULTSIZE
-DEFAULTTONEAREST
-DEFAULTTONULL
-DEFAULTTOPRIMARY
-DELETEFILE
-DEVICEINFO
-DEVICELALTKEYMASK
-DEVICELCMDKEYMASK
-DEVICELCTLKEYMASK
-DEVICELSHIFTKEYMASK
-DEVICENAME
-DEVICERALTKEYMASK
-DEVICERCMDKEYMASK
-DEVICERCTLKEYMASK
-DEVICERSHIFTKEYMASK
-DEVMODEW
-DEVNOTIFY
-DISP
-DISPLAYFREQUENCY
-DPAD
-DPICHANGED
-DROPEFFECT
-DVASPECT
-DWMCOMPOSITIONCHANGED
-DWMWA
-Deque
-Dflt
-EINTR
-EINVAL
-EJECTCD
-EJECTCLOSECD
-ENDCALL
-ENDCOMPOSITION
-ENLW
-ENTERSIZEMOVE
-ERCIM
-EREOF
-EWMH
-EXITSIZEMOVE
-EXSEL
-EXSTYLE
-EXTENDEDKEY
-Eisu
-Eisuu
-Endcall
-Endianness
-FASTFORWARD
-FLASHW
-FLASHWINFO
-FORMATETC
-FORWARDMAIL
-FRAMECHANGED
-FVWM
-GAMEPAD
-GETHIGHCONTRAST
-GETMINMAXINFO
-GIDC
-GLES
-GWLP
-HANGEUL
-HANJA
-HCURSOR
-HDROP
-HEADSETHOOK
-HGLOBAL
-HICON
-HIGHCONTRASTA
-HIGHCONTRASTON
-HIMC
-HINSTANCE
-HMODULE
-HORZ
-HRAWINPUT
-HTBOTTOM
-HTBOTTOMLEFT
-HTBOTTOMRIGHT
-HTCAPTION
-HTCLIENT
-HTLEFT
-HTRIGHT
-HTTOP
-HTTOPLEFT
-HTTOPRIGHT
-HWHEEL
-Hanja
-Hankaku
-Headsethook
-Henkan
-Himetric
-Hotspot
-IACE
-IBEAM
-ICCCM
-ICONINFO
-IMEs
-IMMENABLED
-INPUTSINK
-INTERNALPAINT
-IOYUV
-Impls
-Ivars
-JISHO
-JUNJA
-Junja
-KBDILLUMDOWN
-KBDILLUMTOGGLE
-KBDILLUMUP
-KEYDOWN
-KEYFIRST
-KEYLAST
-KEYMAP
-KEYUP
-KILLFOCUS
-KPJPCOMMA
-KPLEFTPAREN
-KPPLUSMINUS
-KPRIGHTPAREN
-Kanna
-Keymap
-Koho
-LALT
-LBUTTON
-LBUTTONDOWN
-LBUTTONUP
-LCONTROL
-LCTRL
-LEFTALIGN
-LOADFROMFILE
-LOGPIXELSX
-LOYA
-LRESULT
-LSHIFT
-LSUPER
-LWIN
-Lcdfilter
-Libera
-MASSHOU
-MAXIMIZABLE
-MAXIMIZEBOX
-MBUTTON
-MBUTTONDOWN
-MBUTTONUP
-MENUCHAR
-MICMUTE
-MINIMIZABLE
-MINIMIZEBOX
-MINMAXINFO
-MODECHANGE
-MONITORINFO
-MONITORINFOEXW
-MOUSEHWHEEL
-MOUSELEAVE
-MOUSEMOVE
-MOUSEWHEEL
-MOVERESIZE
-MSDOS
-MSRV
-Massyo
-Miniaturizable
-Mmap
-Modifiermap
-Muhenkan
-Multitouch
-NCACTIVATE
-NCCALCSIZE
-NCDESTROY
-NCHITTEST
-NCLBUTTONDOWN
-NEXTTRACK
-NOACTIVATE
-NOMOVE
-NONAME
-NONCONVERT
-NOREMOVE
-NOREPOSITION
-NOSIZE
-NOTCONVERTED
-NOTOPMOST
-NOZORDER
-NTSTATUS
-NUMLOCK
-Nesw
-Nonnull
-Nunley
-OSVERSIONINFOW
-OVERLAPPEDWINDOW
-Overscan
-PAUSECD
-PCSTR
-PCWSTR
-PELSHEIGHT
-PELSWIDTH
-PGDN
-PGUP
-PINP
-PLAYCD
-POINTERDOWN
-POINTERUP
-POINTERUPDATE
-POINTL
-PQRS
-PREVIOUSTRACK
-PROCESSKEY
-Pboard
-Peekable
-Pels
-Pictsymbols
-Pixmap
-Premultiply
-QERTZ
-QWERTZ
-RALT
-RAWINPUT
-RAWINPUTDEVICE
-RAWINPUTDEVICELIST
-RAWINPUTHEADER
-RAWKEYBOARD
-RBUTTON
-RBUTTONDOWN
-RBUTTONUP
-RCONTROL
-RCTRL
-RDWR
-RESULTSTR
-RETURNCMD
-RFKILL
-RGBA
-RIDEV
-RIDI
-RMENU
-ROYA
-RRRRRGGGGGBBBBB
-RRRRRRRRGGGGGGGGBBBBBBBB
-RRRRRRRRRRGGGGGGGGGGBBBBBBBBBB
-RSHIFT
-RSUPER
-RUSTDOCFLAGS
-RWIN
-Raii
-Reentrancy
-Reparent
-Romaji
-SCREENSAVE
-SCROLLDOWN
-SCROLLUP
-SENDFILE
-SETCONTEXT
-SETCURSOR
-SETFOCUS
-SETICON
-SETTINGCHANGE
-SHOULDAPPSUSEDARKMODE
-SHOWNOACTIVATE
-SHOWUICOMPOSITIONWINDOW
-SIGILL
-SIGSEGV
-SIZEALL
-SIZEBOX
-SIZENESW
-SIZENS
-SIZENWSE
-SIZEWE
-STARTCOMPOSITION
-STATDATA
-STGMEDIUM
-SWITCHVIDEOMODE
-SYSCHAR
-SYSCOMMAND
-SYSDEADCHAR
-SYSKEYDOWN
-SYSKEYUP
-SYSMENU
-Smol
-Sonoma
-Subcompositor
-Sublayer
-Subviews
-Sysrq
-THUMBSTICK
-TIMERNOFG
-TOOLWINDOW
-TOPLEFT
-TOPRIGHT
-TOUCHEVENTF
-TOUCHINPUT
-TOUROKU
-TRACKMOUSEEVENT
-TYMED
-TYPEHID
-TYPEKEYBOARD
-TYPEMOUSE
-Thumbl
-Thumbr
-Tomiĉo
-UNICHAR
-USEDARKMODECOLORS
-UXTHEME
-Unadjust
-Unadvise
-Ungrab
-Unminimizing
-VKEY
-VKEYS
-Viewporter
-Visualid
-Vulkan
-WINDOWCOMPOSITIONATTRIB
-WINDOWCOMPOSITIONATTRIBDATA
-WINDOWEDGE
-WINDOWPLACEMENT
-WINDOWPOS
-WINDOWPOSCHANGED
-WINDOWPOSCHANGING
-WLAN
-WNDPROC
-WSCTRL
-WXYZ
-XBUTTONDOWN
-XBUTTONUP
-XEMBED
-XFER
-XKBCH
-XKBH
-XKBXH
-XMODIFIERS
-XSETTINGS
-XVIRTUALSCREEN
-Xcursor
-Xdnd
-Xfer
-Xids
-Xorg
-Xutf
-YVIRTUALSCREEN
-Zenkaku
-aarch
-abortable
-adwaita
-ahash
-altgr
-apartmentthreaded
-argb
-armv
-atleast
-attribs
-autoreleasepool
-autoreleases
-autorotate
-beachball
-beforeunload
-behaviour
-bfcache
-bgra
-bindgen
-bitflags
-bitmaprenderer
-blackbox
-blurregion
-borderless
-busybutclickable
-bytemuck
-bytewise
-calloop
-callstack
-cdylib
-cgfloat
-clicky
-clipchildren
-clonable
-clsctx
-clsid
-codepaths
-coinit
-colormap
-contextmenu
-crossfont
-crtc
-crtcs
-curr
-darkmode
-dbus
-deminiaturize
-deviceid
-dlopen
-docsrs
-donotround
-doubletap
-downscaling
-dppx
-dwmsbt
-dwmwcp
-elwt
-emscripten
-endianness
-entrancy
-entrantly
-evdev
-eventloop
-evlp
-evtype
-exclam
-excludefromcapture
-fcitx
-forcetouch
-fpath
-fract
-fsecs
-fullscreen
-fullscreened
-fullsize
-gamepads
-getpid
-gettid
-glutin
-gotchyas
-hdrop
-henkan
-hidpi
-himc
-himetric
-hinstance
-hittest
-hiword
-hmenu
-hmonitor
-horz
-hotplug
-hotspot
-hotx
-hredraw
-hresult
-htotal
-hwnd
-ibus
-icrate
-impls
-initer
-inputmethod
-isize
-ivars
-kcav
-kchibisov
-keybdinput
-keybinds
-keyevent
-keyeventf
-keymap
-keypermod
-keypresses
-keysym
-keysyms
-kunddaliya
-kwin
-lcddefault
-lgid
-libc
-libwayland
-libxkbcommon
-lindex
-lmenu
-longjmp
-longsolidusoverlay
-lowline
-loword
-lparam
-lpfn
-lpsz
-lshift
-macbooks
-madsmtm
-mainloop
-maintainership
-mainwindow
-mapvk
-memmap
-millihertz
-minwindef
-mkdid
-mkwid
-modifierless
-modifiermap
-msiglreith
-muhenkan
-multitouch
-nanos
-nccreate
-netwm
-newtype
-nodename
-nonminimal
-noredirectionbitmap
-notgull
-notitle
-nsec
-nsscreen
-nsstring
-nsview
-ntdll
-numpad
-numpads
-objc
-offcenter
-onpointerrawupdate
-opengl
-oppsite
-orbclient
-ossi
-overscan
-overtyping
-pagehide
-pageshow
-physicalkey
-pixmap
-pointercancel
-pointermove
-pointerout
-pointerover
-pointerrawupdate
-polonius
-ppmm
-preedit
-premultiply
-primarylangid
-pthread
-qhandle
-randr
-reallocs
-rects
-reentrancy
-reparent
-reparenting
-replugs
-repr
-resizeable
-retval
-rgba
-rgrc
-rightclick
-riid
-roundsmall
-rshift
-runloop
-rustc
-rustdoc
-rustix
-scancode
-scancodes
-sctk
-serde
-setjmp
-setlocale
-shcore
-smithay
-smol
-softbuffer
-sourceid
-splitn
-standardised
-stdweb
-struct
-structfield
-subcompositor
-subframework
-subsec
-subviews
-syms
-syscall
-systembackdrop
-sythesize
-sythesized
-sythetic
-tabbedwindow
-tabindex
-throghout
-timespec
-titlebar
-touchpad
-touchstart
-trackpad
-transientwindow
-tymed
-uapi
-uiscreen
-uiscreens
-ulong
-unaccel
-unaccelerated
-uncoalesced
-unconfine
-undropped
-unfocusing
-ungrab
-ungrabs
-uninit
-uninitialize
-unmark
-unmaximized
-unminimize
-unobserve
-unparameterised
-unref
-unresizable
-usedefault
-userdata
-uxtheme
-viewporter
-visibilitychange
-visualid
-visualtype
-vkey
-vredraw
-vsync
-vtbl
-vtotal
-vulkano
-wakeup
-wakeups
-wantpalm
-wgpu
-winapi
-windef
-winit
-winuser
-wndclassexw
-wparam
-wrongcompobj
-xbutton
-xconn
-xconnection
-xcursor
-xdisplay
-xevent
-xext
-xfiltered
-xfixes
-xhot
-ximage
-xkbcommon
-xkbext
-xlib
-xmodifiers
-xmonad
-xpresent
-xrandr
-xrender
-xresources
-xscrnsaver
-xsettings
-xwindow
-yeong
-yhot

src/cursor.rs

@@ -88,15 +88,6 @@ impl CustomCursor {
         hotspot_x: u16,
         hotspot_y: u16,
     ) -> Result<CustomCursorSource, BadImage> {
-        let _span = tracing::debug_span!(
-            "winit::Cursor::from_rgba",
-            width,
-            height,
-            hotspot_x,
-            hotspot_y
-        )
-        .entered();
-
         Ok(CustomCursorSource {
             inner: PlatformCustomCursorSource::from_rgba(
                 rgba.into(),

src/event.rs

@@ -561,7 +561,7 @@ pub enum WindowEvent {
     /// The window has been occluded (completely hidden from view).
     ///
     /// This is different to window visibility as it depends on whether the window is closed,
-    /// minimized, set invisible, or fully occluded by another window.
+    /// minimised, set invisible, or fully occluded by another window.
     ///
     /// ## Platform-specific
     ///
@@ -781,31 +781,6 @@ pub struct KeyEvent {
     /// On some systems, holding down a key for some period of time causes that key to be repeated
     /// as though it were being pressed and released repeatedly. This field is `true` if and only if
     /// this event is the result of one of those repeats.
-    ///
-    /// # Example
-    ///
-    /// In games, you often want to ignore repeated key events - this can be
-    /// done by ignoring events where this property is set.
-    ///
-    /// ```
-    /// use winit::event::{WindowEvent, KeyEvent, ElementState};
-    /// use winit::keyboard::{KeyCode, PhysicalKey};
-    /// # let window_event = WindowEvent::RedrawRequested; // To make the example compile
-    /// match window_event {
-    ///     WindowEvent::KeyboardInput {
-    ///         event: KeyEvent {
-    ///             physical_key: PhysicalKey::Code(KeyCode::KeyW),
-    ///             state: ElementState::Pressed,
-    ///             repeat: false,
-    ///             ..
-    ///         },
-    ///         ..
-    ///     } => {
-    ///          // The physical key `W` was pressed, and it was not a repeat
-    ///     }
-    ///     _ => {} // Handle other events
-    /// }
-    /// ```
     pub repeat: bool,
 
     /// Platform-specific key event information.

src/event_loop.rs

@@ -80,7 +80,7 @@ impl<T> EventLoopBuilder<T> {
     /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
     /// and only once per application.***
     ///
-    /// Calling this function will result in display backend initialization.
+    /// Calling this function will result in display backend initialisation.
     ///
     /// ## Panics
     ///
@@ -109,8 +109,6 @@ impl<T> EventLoopBuilder<T> {
     )]
     #[inline]
     pub fn build(&mut self) -> Result<EventLoop<T>, EventLoopError> {
-        let _span = tracing::debug_span!("winit::EventLoopBuilder::build").entered();
-
         if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
             return Err(EventLoopError::RecreationAttempt);
         }
@@ -250,8 +248,6 @@ impl<T> EventLoop<T> {
     where
         F: FnMut(Event<T>, &ActiveEventLoop),
     {
-        let _span = tracing::debug_span!("winit::EventLoop::run").entered();
-
         self.event_loop.run(event_handler)
     }
 
@@ -278,12 +274,6 @@ impl<T> EventLoop<T> {
     ///
     /// [`DeviceEvent`]: crate::event::DeviceEvent
     pub fn listen_device_events(&self, allowed: DeviceEvents) {
-        let _span = tracing::debug_span!(
-            "winit::EventLoop::listen_device_events",
-            allowed = ?allowed
-        )
-        .entered();
-
         self.event_loop
             .window_target()
             .p
@@ -305,12 +295,6 @@ impl<T> EventLoop<T> {
     #[deprecated = "use `ActiveEventLoop::create_window` instead"]
     #[inline]
     pub fn create_window(&self, window_attributes: WindowAttributes) -> Result<Window, OsError> {
-        let _span = tracing::debug_span!(
-            "winit::EventLoop::create_window",
-            window_attributes = ?window_attributes
-        )
-        .entered();
-
         let window =
             platform_impl::Window::new(&self.event_loop.window_target().p, window_attributes)?;
         Ok(Window { window })
@@ -379,28 +363,18 @@ impl ActiveEventLoop {
     ///   see the web platform module for more information.
     #[inline]
     pub fn create_window(&self, window_attributes: WindowAttributes) -> Result<Window, OsError> {
-        let _span = tracing::debug_span!(
-            "winit::ActiveEventLoop::create_window",
-            window_attributes = ?window_attributes
-        )
-        .entered();
-
         let window = platform_impl::Window::new(&self.p, window_attributes)?;
         Ok(Window { window })
     }
 
     /// Create custom cursor.
     pub fn create_custom_cursor(&self, custom_cursor: CustomCursorSource) -> CustomCursor {
-        let _span = tracing::debug_span!("winit::ActiveEventLoop::create_custom_cursor",).entered();
-
         self.p.create_custom_cursor(custom_cursor)
     }
 
     /// Returns the list of all the monitors available on the system.
     #[inline]
     pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
-        let _span = tracing::debug_span!("winit::ActiveEventLoop::available_monitors",).entered();
-
         #[allow(clippy::useless_conversion)] // false positive on some platforms
         self.p
             .available_monitors()
@@ -417,8 +391,6 @@ impl ActiveEventLoop {
     /// **Wayland / Web:** Always returns `None`.
     #[inline]
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        let _span = tracing::debug_span!("winit::ActiveEventLoop::primary_monitor",).entered();
-
         self.p
             .primary_monitor()
             .map(|inner| MonitorHandle { inner })
@@ -436,12 +408,6 @@ impl ActiveEventLoop {
     ///
     /// [`DeviceEvent`]: crate::event::DeviceEvent
     pub fn listen_device_events(&self, allowed: DeviceEvents) {
-        let _span = tracing::debug_span!(
-            "winit::ActiveEventLoop::listen_device_events",
-            allowed = ?allowed
-        )
-        .entered();
-
         self.p.listen_device_events(allowed);
     }
 
@@ -459,8 +425,6 @@ impl ActiveEventLoop {
     ///
     /// See [`LoopExiting`](Event::LoopExiting).
     pub fn exit(&self) {
-        let _span = tracing::debug_span!("winit::ActiveEventLoop::exit",).entered();
-
         self.p.exit()
     }
 
@@ -566,8 +530,6 @@ impl<T: 'static> EventLoopProxy<T> {
     ///
     /// [`UserEvent(event)`]: Event::UserEvent
     pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        let _span = tracing::debug_span!("winit::EventLoopProxy::send_event",).entered();
-
         self.event_loop_proxy.send_event(event)
     }
 }

src/icon.rs

@@ -118,8 +118,6 @@ impl Icon {
     /// The length of `rgba` must be divisible by 4, and `width * height` must equal
     /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
     pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-        let _span = tracing::debug_span!("winit::Icon::from_rgba", width, height).entered();
-
         Ok(Icon {
             inner: PlatformIcon::from_rgba(rgba, width, height)?,
         })

src/keyboard.rs

@@ -1229,7 +1229,7 @@ pub enum NamedKey {
     Dimmer,
     /// Swap video sources. (`VK_DISPLAY_SWAP`)
     DisplaySwap,
-    /// Select Digital Video Recorder. (`KEYCODE_DVR`)
+    /// Select Digital Video Rrecorder. (`KEYCODE_DVR`)
     DVR,
     /// Exit the current application. (`VK_EXIT`)
     Exit,

src/platform/android.rs

@@ -45,13 +45,13 @@
 //! | Base Class       | Feature Flag      |  Notes  |
 //! | :--------------: | :---------------: | :-----: |
 //! | `NativeActivity` | `android-native-activity` | Built-in to Android - it is possible to use without compiling any Java or Kotlin code. Java or Kotlin code may be needed to subclass `NativeActivity` to access some platform features. It does not derive from the [`AndroidAppCompat`] base class.|
-//! | [`GameActivity`] | `android-game-activity`   | Derives from [`AndroidAppCompat`], a defacto standard `Activity` base class that helps support a wider range of Android versions. Requires a build system that can compile Java or Kotlin and fetch Android dependencies from a [Maven repository][android_jet] (or link with an embedded [release][android_releases] of [`GameActivity`]) |
+//! | [`GameActivity`] | `android-game-activity`   | Derives from [`AndroidAppCompat`], a defacto standard `Activity` base class that helps support a wider range of Android versions. Requires a build system that can compile Java or Kotlin and fetch Android dependencies from a [Maven repository][agdk_jetpack] (or link with an embedded [release][agdk_releases] of [`GameActivity`]) |
 //!
 //! [`GameActivity`]: https://developer.android.com/games/agdk/game-activity
 //! [`GameTextInput`]: https://developer.android.com/games/agdk/add-support-for-text-input
 //! [`AndroidAppCompat`]: https://developer.android.com/reference/androidx/appcompat/app/AppCompatActivity
-//! [android_jet]: https://developer.android.com/jetpack/androidx/releases/games
+//! [agdk_jetpack]: https://developer.android.com/jetpack/androidx/releases/games
-//! [android_releases]: https://developer.android.com/games/agdk/download#agdk-libraries
+//! [agdk_releases]: https://developer.android.com/games/agdk/download#agdk-libraries
 //! [Gradle]: https://developer.android.com/studio/build
 //!
 //! For more details, refer to these `android-activity` [example applications](https://github.com/rust-mobile/android-activity/tree/main/examples).
@@ -60,7 +60,7 @@
 //!
 //! 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.13", features = [ "android-native-activity" ] }`
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.11", 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/run_on_demand.rs

@@ -94,7 +94,7 @@ impl ActiveEventLoop {
 ///
 /// let mut event_loop = EventLoop::new().unwrap();
 /// event_loop.run_on_demand(|_, _| {
-///     // Attempt to run the event loop in a re-entrant manner; this must fail.
+///     // Attempt to run the event loop re-entrantly; this must fail.
 ///     event_loop.run_on_demand(|_, _| {});
 /// });
 /// ```

src/platform/scancode.rs

@@ -29,11 +29,11 @@ pub trait PhysicalKeyExtScancode {
 
 impl PhysicalKeyExtScancode for PhysicalKey {
     fn to_scancode(self) -> Option<u32> {
-        crate::platform_impl::physical_key_to_scancode(self)
+        crate::platform_impl::physicalkey_to_scancode(self)
     }
 
     fn from_scancode(scancode: u32) -> PhysicalKey {
-        crate::platform_impl::scancode_to_physical_key(scancode)
+        crate::platform_impl::scancode_to_physicalkey(scancode)
     }
 }
 

src/platform/startup_notify.rs

@@ -2,7 +2,7 @@
 //!
 //! The [`ActivationToken`] is essential to ensure that your newly
 //! created window will obtain the focus, otherwise the user could
-//! be required to click on the window.
+//! be requered to click on the window.
 //!
 //! Such token is usually delivered via the environment variable and
 //! could be read from it with the [`EventLoopExtStartupNotify::read_token_from_env`].

src/platform/web.rs

@@ -330,7 +330,7 @@ impl fmt::Display for BadAnimation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Empty => write!(f, "No cursors supplied"),
-            Self::Animation => write!(f, "A supplied cursor is an animation"),
+            Self::Animation => write!(f, "A supplied cursor is an animtion"),
         }
     }
 }

src/platform/windows.rs

@@ -157,11 +157,11 @@ pub trait EventLoopBuilderExtWindows {
     /// #[cfg(target_os = "windows")]
     /// builder.with_msg_hook(|msg|{
     ///     let msg = msg as *const MSG;
-    /// #   let accelerators: Vec<ACCEL> = Vec::new();
+    /// #   let accels: Vec<ACCEL> = Vec::new();
     ///     let translated = unsafe {
     ///         TranslateAcceleratorW(
     ///             (*msg).hwnd,
-    ///             CreateAcceleratorTableW(accelerators.as_ptr() as _, 1),
+    ///             CreateAcceleratorTableW(accels.as_ptr() as _, 1),
     ///             msg,
     ///         ) == 1
     ///     };

src/platform/x11.rs

@@ -16,14 +16,14 @@ use crate::dpi::Size;
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum WindowType {
     /// A desktop feature. This can include a single window containing desktop icons with the same dimensions as the
-    /// screen, allowing the desktop environment to have full control of the desktop, without the need for proxy-ing
+    /// screen, allowing the desktop environment to have full control of the desktop, without the need for proxying
     /// root window clicks.
     Desktop,
     /// A dock or panel feature. Typically a Window Manager would keep such windows on top of all other windows.
     Dock,
     /// Toolbar windows. "Torn off" from the main application.
     Toolbar,
-    /// Pin-able menu windows. "Torn off" from the main application.
+    /// Pinnable menu windows. "Torn off" from the main application.
     Menu,
     /// A small persistent utility window, such as a palette or toolbox.
     Utility,

src/platform_impl/android/keycodes.rs

@@ -174,7 +174,7 @@ pub fn character_map_and_combine_key(
     let key_map = match app.device_key_character_map(device_id) {
         Ok(key_map) => key_map,
         Err(err) => {
-            tracing::warn!("Failed to look up `KeyCharacterMap` for device {device_id}: {err:?}");
+            log::warn!("Failed to look up `KeyCharacterMap` for device {device_id}: {err:?}");
             return None;
         }
     };
@@ -188,7 +188,7 @@ pub fn character_map_and_combine_key(
                         Ok(Some(key)) => Some(key),
                         Ok(None) => None,
                         Err(err) => {
-                            tracing::warn!("KeyEvent: Failed to combine 'dead key' accent '{accent}' with '{unicode}': {err:?}");
+                            log::warn!("KeyEvent: Failed to combine 'dead key' accent '{accent}' with '{unicode}': {err:?}");
                             None
                         }
                     }
@@ -213,7 +213,7 @@ pub fn character_map_and_combine_key(
             None
         }
         Err(err) => {
-            tracing::warn!("KeyEvent: Failed to get key map character: {err:?}");
+            log::warn!("KeyEvent: Failed to get key map character: {err:?}");
             *combining_accent = None;
             None
         }

src/platform_impl/android/mod.rs

@@ -16,7 +16,7 @@ use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
 use android_activity::{
     AndroidApp, AndroidAppWaker, ConfigurationRef, InputStatus, MainEvent, Rect,
 };
-use tracing::{debug, trace, warn};
+use log::{debug, trace, warn};
 
 use crate::{
     cursor::Cursor,
@@ -330,7 +330,7 @@ impl<T: 'static> EventLoop<T> {
                 }
             },
             Err(err) => {
-                tracing::warn!("Failed to get input events iterator: {err:?}");
+                log::warn!("Failed to get input events iterator: {err:?}");
             }
         }
 
@@ -1014,7 +1014,7 @@ impl Window {
         if let Some(native_window) = self.app.native_window().as_ref() {
             native_window.raw_window_handle()
         } else {
-            tracing::error!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
+            log::error!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
             Err(rwh_06::HandleError::Unavailable)
         }
     }

src/platform_impl/ios/app_state.rs

@@ -622,9 +622,9 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
         match wrapper {
             EventWrapper::StaticEvent(event) => {
                 if !processing_redraws && event.is_redraw() {
-                    tracing::info!("processing `RedrawRequested` during the main event loop");
+                    log::info!("processing `RedrawRequested` during the main event loop");
                 } else if processing_redraws && !event.is_redraw() {
-                    tracing::warn!(
+                    log::warn!(
                         "processing non `RedrawRequested` event after the main event loop: {:#?}",
                         event
                     );
@@ -676,9 +676,9 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
             match wrapper {
                 EventWrapper::StaticEvent(event) => {
                     if !processing_redraws && event.is_redraw() {
-                        tracing::info!("processing `RedrawRequested` during the main event loop");
+                        log::info!("processing `RedrawRequested` during the main event loop");
                     } else if processing_redraws && !event.is_redraw() {
-                        tracing::warn!(
+                        log::warn!(
                             "processing non-`RedrawRequested` event after the main event loop: {:#?}",
                             event
                         );
@@ -911,7 +911,7 @@ macro_rules! os_capabilities {
         impl OSCapabilities {$(
             $(#[$attr])*
             pub fn $error_name(&self, extra_msg: &str) {
-                tracing::warn!(
+                log::warn!(
                     concat!("`", $objc_call, "` requires iOS {}.{}+. This device is running iOS {}.{}.{}. {}"),
                     $major, $minor, self.os_version.majorVersion, self.os_version.minorVersion, self.os_version.patchVersion,
                     extra_msg

src/platform_impl/ios/event_loop.rs

@@ -85,7 +85,7 @@ impl ActiveEventLoop {
     pub(crate) fn exit(&self) {
         // https://developer.apple.com/library/archive/qa/qa1561/_index.html
         // it is not possible to quit an iOS app gracefully and programmatically
-        tracing::warn!("`ControlFlow::Exit` ignored on iOS");
+        log::warn!("`ControlFlow::Exit` ignored on iOS");
     }
 
     pub(crate) fn exiting(&self) -> bool {

src/platform_impl/ios/window.rs

@@ -3,10 +3,10 @@
 use std::collections::VecDeque;
 
 use icrate::Foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker};
+use log::{debug, warn};
 use objc2::rc::Id;
 use objc2::runtime::{AnyObject, NSObject};
 use objc2::{class, declare_class, msg_send, msg_send_id, mutability, ClassType, DeclaredClass};
-use tracing::{debug, warn};
 
 use super::app_state::EventWrapper;
 use super::uikit::{

src/platform_impl/linux/common/xkb/keymap.rs

@@ -24,13 +24,13 @@ use crate::platform_impl::common::xkb::{XkbContext, XKBH};
 ///
 /// X11-style keycodes are offset by 8 from the keycodes the Linux kernel uses.
 pub fn raw_keycode_to_physicalkey(keycode: u32) -> PhysicalKey {
-    scancode_to_physical_key(keycode.saturating_sub(8))
+    scancode_to_physicalkey(keycode.saturating_sub(8))
 }
 
 /// Map the linux scancode to Keycode.
 ///
 /// Both X11 and Wayland use keys with `+ 8` offset to linux scancode.
-pub fn scancode_to_physical_key(scancode: u32) -> PhysicalKey {
+pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
     // The keycode values are taken from linux/include/uapi/linux/input-event-codes.h, as
     // libxkbcommon's documentation seems to suggest that the keycode values we're interested in
     // are defined by the Linux kernel. If Winit programs end up being run on other Unix-likes,
@@ -287,7 +287,7 @@ pub fn scancode_to_physical_key(scancode: u32) -> PhysicalKey {
     })
 }
 
-pub fn physical_key_to_scancode(key: PhysicalKey) -> Option<u32> {
+pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
     let code = match key {
         PhysicalKey::Code(code) => code,
         PhysicalKey::Unidentified(code) => {

src/platform_impl/linux/common/xkb/mod.rs

@@ -4,10 +4,10 @@ use std::ptr::{self, NonNull};
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use crate::utils::Lazy;
+use log::warn;
 use smol_str::SmolStr;
 #[cfg(wayland_platform)]
 use std::os::unix::io::OwnedFd;
-use tracing::warn;
 use xkbcommon_dl::{
     self as xkb, xkb_compose_status, xkb_context, xkb_context_flags, xkbcommon_compose_handle,
     xkbcommon_handle, XkbCommon, XkbCommonCompose,
@@ -29,7 +29,7 @@ use keymap::XkbKeymap;
 
 #[cfg(x11_platform)]
 pub use keymap::raw_keycode_to_physicalkey;
-pub use keymap::{physical_key_to_scancode, scancode_to_physical_key};
+pub use keymap::{physicalkey_to_scancode, scancode_to_physicalkey};
 pub use state::XkbState;
 
 // TODO: Wire this up without using a static `AtomicBool`.
@@ -451,7 +451,7 @@ fn byte_slice_to_smol_str(bytes: &[u8]) -> Option<SmolStr> {
     std::str::from_utf8(bytes)
         .map(SmolStr::new)
         .map_err(|e| {
-            tracing::warn!(
+            log::warn!(
                 "UTF-8 received from libxkbcommon ({:?}) was invalid: {e}",
                 bytes
             )

src/platform_impl/linux/mod.rs

@@ -34,7 +34,7 @@ use crate::{
     },
 };
 
-pub(crate) use self::common::xkb::{physical_key_to_scancode, scancode_to_physical_key};
+pub(crate) use self::common::xkb::{physicalkey_to_scancode, scancode_to_physicalkey};
 pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
@@ -687,7 +687,7 @@ unsafe extern "C" fn x_error_callback(
 
         // Don't log error.
         if !error_handled {
-            tracing::error!("X11 error: {:#?}", error);
+            log::error!("X11 error: {:#?}", error);
             // XXX only update the error, if it wasn't handled by any of the hooks.
             *xconn.latest_error.lock().unwrap() = Some(error);
         }

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

@@ -584,7 +584,7 @@ impl<T: 'static> EventLoop<T> {
         };
 
         self.event_loop.dispatch(timeout, state).map_err(|error| {
-            tracing::error!("Error dispatching event loop: {}", error);
+            log::error!("Error dispatching event loop: {}", error);
             error.into()
         })
     }

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

@@ -5,7 +5,7 @@ use std::time::Duration;
 
 use calloop::timer::{TimeoutAction, Timer};
 use calloop::{LoopHandle, RegistrationToken};
-use tracing::warn;
+use log::warn;
 
 use sctk::reexports::client::protocol::wl_keyboard::WlKeyboard;
 use sctk::reexports::client::protocol::wl_keyboard::{
@@ -94,7 +94,7 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
             WlKeyboardEvent::Leave { surface, .. } => {
                 let window_id = wayland::make_wid(&surface);
 
-                // NOTE: we should drop the repeat regardless whether it was for the present
+                // NOTE: we should drop the repeat regardless whethere it was for the present
                 // window of for the window which just went gone.
                 let keyboard_state = seat_state.keyboard_state.as_mut().unwrap();
                 keyboard_state.current_repeat = None;

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

@@ -207,7 +207,7 @@ impl PointerHandler for WinitState {
                     pointer_data.phase = phase;
 
                     // Mice events have both pixel and discrete delta's at the same time. So prefer
-                    // the discrete values if they are present.
+                    // the descrite values if they are present.
                     let delta = if has_discrete_scroll {
                         // XXX Wayland sign convention is the inverse of winit.
                         MouseScrollDelta::LineDelta(

src/platform_impl/linux/wayland/state.rs

@@ -133,7 +133,7 @@ impl WinitState {
         ) {
             Ok(c) => Some(c),
             Err(e) => {
-                tracing::warn!("Subcompositor protocol not available, ignoring CSD: {e:?}");
+                log::warn!("Subcompositor protocol not available, ignoring CSD: {e:?}");
                 None
             }
         };

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

@@ -14,7 +14,7 @@ use sctk::shell::xdg::window::Window as SctkWindow;
 use sctk::shell::xdg::window::WindowDecorations;
 use sctk::shell::WaylandSurface;
 
-use tracing::warn;
+use log::warn;
 
 use crate::dpi::{LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};

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

@@ -5,7 +5,7 @@ use std::sync::{Arc, Mutex, Weak};
 use std::time::Duration;
 
 use ahash::HashSet;
-use tracing::{info, warn};
+use log::{info, warn};
 
 use sctk::reexports::client::backend::ObjectId;
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
@@ -727,7 +727,7 @@ impl WindowState {
             RootCustomCursor {
                 inner: PlatformCustomCursor::X(_),
             } => {
-                tracing::error!("passed a X11 cursor to Wayland backend");
+                log::error!("passed a X11 cursor to Wayland backend");
                 return;
             }
         };

src/platform_impl/linux/x11/event_processor.rs

@@ -33,10 +33,9 @@ use crate::platform_impl::platform::common::xkb::Context;
 use crate::platform_impl::platform::x11::ime::{ImeEvent, ImeEventReceiver, ImeRequest};
 use crate::platform_impl::platform::x11::ActiveEventLoop;
 use crate::platform_impl::platform::ActiveEventLoop as PlatformActiveEventLoop;
-use crate::platform_impl::x11::util::cookie::GenericEventCookie;
 use crate::platform_impl::x11::{
     atoms::*, mkdid, mkwid, util, CookieResultExt, Device, DeviceId, DeviceInfo, Dnd, DndState,
-    ImeReceiver, ScrollOrientation, UnownedWindow, WindowId,
+    GenericEventCookie, ImeReceiver, ScrollOrientation, UnownedWindow, WindowId,
 };
 
 /// The maximum amount of X modifiers to replay.
@@ -185,15 +184,14 @@ impl EventProcessor {
             }
             xlib::GenericEvent => {
                 let wt = Self::window_target(&self.target);
-                let xev: GenericEventCookie =
+                let xev = match GenericEventCookie::from_event(&wt.xconn, *xev) {
-                    match GenericEventCookie::from_event(wt.xconn.clone(), *xev) {
+                    Some(xev) if xev.cookie.extension as u8 == self.xi2ext.major_opcode => {
-                        Some(xev) if xev.extension() == self.xi2ext.major_opcode => xev,
+                        xev.cookie
+                    }
                     _ => return,
                 };
 
-                let evtype = xev.evtype();
+                match xev.evtype {
-
-                match evtype {
                     ty @ xinput2::XI_ButtonPress | ty @ xinput2::XI_ButtonRelease => {
                         let state = if ty == xinput2::XI_ButtonPress {
                             ElementState::Pressed
@@ -201,7 +199,7 @@ impl EventProcessor {
                             ElementState::Released
                         };
 
-                        let xev: &XIDeviceEvent = unsafe { xev.as_event() };
+                        let xev: &XIDeviceEvent = unsafe { &*(xev.data as *const _) };
                         self.update_mods_from_xinput2_event(
                             &xev.mods,
                             &xev.group,
@@ -211,7 +209,7 @@ impl EventProcessor {
                         self.xinput2_button_input(xev, state, &mut callback);
                     }
                     xinput2::XI_Motion => {
-                        let xev: &XIDeviceEvent = unsafe { xev.as_event() };
+                        let xev: &XIDeviceEvent = unsafe { &*(xev.data as *const _) };
                         self.update_mods_from_xinput2_event(
                             &xev.mods,
                             &xev.group,
@@ -221,11 +219,11 @@ impl EventProcessor {
                         self.xinput2_mouse_motion(xev, &mut callback);
                     }
                     xinput2::XI_Enter => {
-                        let xev: &XIEnterEvent = unsafe { xev.as_event() };
+                        let xev: &XIEnterEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_mouse_enter(xev, &mut callback);
                     }
                     xinput2::XI_Leave => {
-                        let xev: &XILeaveEvent = unsafe { xev.as_event() };
+                        let xev: &XILeaveEvent = unsafe { &*(xev.data as *const _) };
                         self.update_mods_from_xinput2_event(
                             &xev.mods,
                             &xev.group,
@@ -235,51 +233,51 @@ impl EventProcessor {
                         self.xinput2_mouse_left(xev, &mut callback);
                     }
                     xinput2::XI_FocusIn => {
-                        let xev: &XIFocusInEvent = unsafe { xev.as_event() };
+                        let xev: &XIFocusInEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_focused(xev, &mut callback);
                     }
                     xinput2::XI_FocusOut => {
-                        let xev: &XIFocusOutEvent = unsafe { xev.as_event() };
+                        let xev: &XIFocusOutEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_unfocused(xev, &mut callback);
                     }
                     xinput2::XI_TouchBegin | xinput2::XI_TouchUpdate | xinput2::XI_TouchEnd => {
-                        let phase = match evtype {
+                        let phase = match xev.evtype {
                             xinput2::XI_TouchBegin => TouchPhase::Started,
                             xinput2::XI_TouchUpdate => TouchPhase::Moved,
                             xinput2::XI_TouchEnd => TouchPhase::Ended,
                             _ => unreachable!(),
                         };
 
-                        let xev: &XIDeviceEvent = unsafe { xev.as_event() };
+                        let xev: &XIDeviceEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_touch(xev, phase, &mut callback);
                     }
                     xinput2::XI_RawButtonPress | xinput2::XI_RawButtonRelease => {
-                        let state = match evtype {
+                        let state = match xev.evtype {
                             xinput2::XI_RawButtonPress => ElementState::Pressed,
                             xinput2::XI_RawButtonRelease => ElementState::Released,
                             _ => unreachable!(),
                         };
 
-                        let xev: &XIRawEvent = unsafe { xev.as_event() };
+                        let xev: &XIRawEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_raw_button_input(xev, state, &mut callback);
                     }
                     xinput2::XI_RawMotion => {
-                        let xev: &XIRawEvent = unsafe { xev.as_event() };
+                        let xev: &XIRawEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_raw_mouse_motion(xev, &mut callback);
                     }
                     xinput2::XI_RawKeyPress | xinput2::XI_RawKeyRelease => {
-                        let state = match evtype {
+                        let state = match xev.evtype {
                             xinput2::XI_RawKeyPress => ElementState::Pressed,
                             xinput2::XI_RawKeyRelease => ElementState::Released,
                             _ => unreachable!(),
                         };
 
-                        let xev: &xinput2::XIRawEvent = unsafe { xev.as_event() };
+                        let xev: &xinput2::XIRawEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_raw_key_input(xev, state, &mut callback);
                     }
 
                     xinput2::XI_HierarchyChanged => {
-                        let xev: &XIHierarchyEvent = unsafe { xev.as_event() };
+                        let xev: &XIHierarchyEvent = unsafe { &*(xev.data as *const _) };
                         self.xinput2_hierarchy_changed(xev, &mut callback);
                     }
                     _ => {}
@@ -981,13 +979,13 @@ impl EventProcessor {
 
         // Always update the modifiers when we're not replaying.
         if !replay {
-            self.update_mods_from_core_event(window_id, xev.state as u16, &mut callback);
+            self.udpate_mods_from_core_event(window_id, xev.state as u16, &mut callback);
         }
 
         if keycode != 0 && !self.is_composing {
             // Don't alter the modifiers state from replaying.
             if replay {
-                self.send_synthetic_modifier_from_core(window_id, xev.state as u16, &mut callback);
+                self.send_synthic_modifier_from_core(window_id, xev.state as u16, &mut callback);
             }
 
             if let Some(mut key_processor) = self.xkb_context.key_context() {
@@ -1037,7 +1035,7 @@ impl EventProcessor {
         }
     }
 
-    fn send_synthetic_modifier_from_core<T: 'static, F>(
+    fn send_synthic_modifier_from_core<T: 'static, F>(
         &mut self,
         window_id: crate::window::WindowId,
         state: u16,
@@ -1520,8 +1518,8 @@ impl EventProcessor {
         let mask =
             unsafe { slice::from_raw_parts(xev.valuators.mask, xev.valuators.mask_len as usize) };
         let mut value = xev.raw_values;
-        let mut mouse_delta = util::Delta::default();
+        let mut mouse_delta = (0.0, 0.0);
-        let mut scroll_delta = util::Delta::default();
+        let mut scroll_delta = (0.0, 0.0);
         for i in 0..xev.valuators.mask_len * 8 {
             if !xinput2::XIMaskIsSet(mask, i) {
                 continue;
@@ -1531,10 +1529,10 @@ impl EventProcessor {
             // We assume that every XInput2 device with analog axes is a pointing device emitting
             // relative coordinates.
             match i {
-                0 => mouse_delta.set_x(x),
+                0 => mouse_delta.0 = x,
-                1 => mouse_delta.set_y(x),
+                1 => mouse_delta.1 = x,
-                2 => scroll_delta.set_x(x as f32),
+                2 => scroll_delta.0 = x as f32,
-                3 => scroll_delta.set_y(x as f32),
+                3 => scroll_delta.1 = x as f32,
                 _ => {}
             }
 
@@ -1550,7 +1548,7 @@ impl EventProcessor {
             value = unsafe { value.offset(1) };
         }
 
-        if let Some(mouse_delta) = mouse_delta.consume() {
+        if mouse_delta != (0.0, 0.0) {
             let event = Event::DeviceEvent {
                 device_id: did,
                 event: DeviceEvent::MouseMotion { delta: mouse_delta },
@@ -1558,7 +1556,7 @@ impl EventProcessor {
             callback(&self.target, event);
         }
 
-        if let Some(scroll_delta) = scroll_delta.consume() {
+        if scroll_delta != (0.0, 0.0) {
             let event = Event::DeviceEvent {
                 device_id: did,
                 event: DeviceEvent::MouseWheel {
@@ -1778,7 +1776,7 @@ impl EventProcessor {
         self.send_modifiers(window_id, mods.into(), true, &mut callback)
     }
 
-    pub fn update_mods_from_core_event<T: 'static, F>(
+    pub fn udpate_mods_from_core_event<T: 'static, F>(
         &mut self,
         window_id: crate::window::WindowId,
         state: u16,

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

@@ -166,7 +166,7 @@ unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
 pub unsafe extern "C" fn xim_instantiate_callback(
     _display: *mut ffi::Display,
     client_data: ffi::XPointer,
-    // This field is un-supplied.
+    // This field is unsupplied.
     _call_data: ffi::XPointer,
 ) {
     let inner: *mut ImeInner = client_data as _;
@@ -193,7 +193,7 @@ pub unsafe extern "C" fn xim_instantiate_callback(
 pub unsafe extern "C" fn xim_destroy_callback(
     _xim: ffi::XIM,
     client_data: ffi::XPointer,
-    // This field is un-supplied.
+    // This field is unsupplied.
     _call_data: ffi::XPointer,
 ) {
     let inner: *mut ImeInner = client_data as _;

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

@@ -86,8 +86,8 @@ extern "C" fn preedit_draw_callback(
     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() {
-        tracing::warn!(
+        log::warn!(
-            "invalid chg range: buffer length={}, but chg_first={} chg_length={}",
+            "invalid chg range: buffer length={}, but chg_first={} chg_lengthg={}",
             client_data.text.len(),
             call_data.chg_first,
             call_data.chg_length

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

@@ -170,7 +170,7 @@ impl From<util::GetPropertyError> for GetXimServersError {
 }
 
 // The root window has a property named XIM_SERVERS, which contains a list of atoms representing
-// the available XIM servers. For instance, if you're using ibus, it would contain an atom named
+// the availabile XIM servers. For instance, if you're using ibus, it would contain an atom named
 // "@server=ibus". It's possible for this property to contain multiple atoms, though presumably
 // rare. Note that we replace "@server=" with "@im=" in order to match the format of locale
 // modifiers, since we don't want a user who's looking at logs to ask "am I supposed to set

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

@@ -10,9 +10,9 @@ use std::sync::{
     Arc,
 };
 
+use log::debug;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use tracing::debug;
 
 use super::{ffi, util, XConnection, XError};
 

src/platform_impl/linux/x11/mod.rs

@@ -18,7 +18,7 @@ use calloop::generic::Generic;
 use calloop::EventLoop as Loop;
 use calloop::{ping::Ping, Readiness};
 use libc::{setlocale, LC_CTYPE};
-use tracing::warn;
+use log::warn;
 
 use x11rb::connection::RequestConnection;
 use x11rb::errors::{ConnectError, ConnectionError, IdsExhausted, ReplyError};
@@ -66,9 +66,6 @@ const ALL_DEVICES: u16 = 0;
 const ALL_MASTER_DEVICES: u16 = 1;
 const ICONIC_STATE: u32 = 3;
 
-/// The underlying x11rb connection that we are using.
-type X11rbConnection = x11rb::xcb_ffi::XCBConnection;
-
 type X11Source = Generic<BorrowedFd<'static>>;
 
 struct WakeSender<T> {
@@ -483,7 +480,7 @@ impl<T: 'static> EventLoop<T> {
             .dispatch(timeout, &mut self.state)
             .map_err(std::io::Error::from)
         {
-            tracing::error!("Failed to poll for events: {error:?}");
+            log::error!("Failed to poll for events: {error:?}");
             let exit_code = error.raw_os_error().unwrap_or(1);
             self.set_exit_code(exit_code);
             return;
@@ -567,7 +564,7 @@ impl<T: 'static> EventLoop<T> {
                     callback(event, &self.event_processor.target)
                 }
                 Some(Err(e)) => {
-                    tracing::error!("Failed to get activation token: {}", e);
+                    log::error!("Failed to get activation token: {}", e);
                 }
                 None => {}
             }
@@ -988,6 +985,9 @@ impl From<xsettings::ParserError> for X11Error {
     }
 }
 
+/// The underlying x11rb connection that we are using.
+type X11rbConnection = x11rb::xcb_ffi::XCBConnection;
+
 /// Type alias for a void cookie.
 type VoidCookie<'a> = x11rb::cookie::VoidCookie<'a, X11rbConnection>;
 
@@ -1003,6 +1003,34 @@ impl<'a, E: fmt::Debug> CookieResultExt for Result<VoidCookie<'a>, E> {
     }
 }
 
+/// XEvents of type GenericEvent store their actual data in an XGenericEventCookie data structure. This is a wrapper to
+/// extract the cookie from a GenericEvent XEvent and release the cookie data once it has been processed
+struct GenericEventCookie<'a> {
+    xconn: &'a XConnection,
+    cookie: ffi::XGenericEventCookie,
+}
+
+impl<'a> GenericEventCookie<'a> {
+    fn from_event(xconn: &XConnection, event: ffi::XEvent) -> Option<GenericEventCookie<'_>> {
+        unsafe {
+            let mut cookie: ffi::XGenericEventCookie = From::from(event);
+            if (xconn.xlib.XGetEventData)(xconn.display, &mut cookie) == ffi::True {
+                Some(GenericEventCookie { xconn, cookie })
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl<'a> Drop for GenericEventCookie<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            (self.xconn.xlib.XFreeEventData)(self.xconn.display, &mut self.cookie);
+        }
+    }
+}
+
 fn mkwid(w: xproto::Window) -> crate::window::WindowId {
     crate::window::WindowId(crate::platform_impl::platform::WindowId(w as _))
 }

src/platform_impl/linux/x11/util/cookie.rs

@@ -1,55 +0,0 @@
-use std::ffi::c_int;
-use std::sync::Arc;
-
-use x11_dl::xlib::{self, XEvent, XGenericEventCookie};
-
-use crate::platform_impl::x11::XConnection;
-
-/// XEvents of type GenericEvent store their actual data in an XGenericEventCookie data structure.
-/// This is a wrapper to extract the cookie from a GenericEvent XEvent and release the cookie data
-/// once it has been processed
-pub struct GenericEventCookie {
-    cookie: XGenericEventCookie,
-    xconn: Arc<XConnection>,
-}
-
-impl GenericEventCookie {
-    pub fn from_event(xconn: Arc<XConnection>, event: XEvent) -> Option<GenericEventCookie> {
-        unsafe {
-            let mut cookie: XGenericEventCookie = From::from(event);
-            if (xconn.xlib.XGetEventData)(xconn.display, &mut cookie) == xlib::True {
-                Some(GenericEventCookie { cookie, xconn })
-            } else {
-                None
-            }
-        }
-    }
-
-    #[inline]
-    pub fn extension(&self) -> u8 {
-        self.cookie.extension as u8
-    }
-
-    #[inline]
-    pub fn evtype(&self) -> c_int {
-        self.cookie.evtype
-    }
-
-    /// Borrow inner event data as `&T`.
-    ///
-    /// ## SAFETY
-    ///
-    /// The caller must ensure that the event has the `T` inside of it.
-    #[inline]
-    pub unsafe fn as_event<T>(&self) -> &T {
-        unsafe { &*(self.cookie.data as *const _) }
-    }
-}
-
-impl Drop for GenericEventCookie {
-    fn drop(&mut self) {
-        unsafe {
-            (self.xconn.xlib.XFreeEventData)(self.xconn.display, &mut self.cookie);
-        }
-    }
-}

src/platform_impl/linux/x11/util/geometry.rs

@@ -44,7 +44,7 @@ impl AaRect {
 pub struct Geometry {
     pub root: xproto::Window,
     // If you want positions relative to the root window, use translate_coords.
-    // Note that the overwhelming majority of window managers are re-parenting WMs, thus the window
+    // Note that the overwhelming majority of window managers are reparenting WMs, thus the window
     // ID we get from window creation is for a nested window used as the window's client area. If
     // you call get_geometry with that window ID, then you'll get the position of that client area
     // window relative to the parent it's nested in (the frame), which isn't helpful if you want

src/platform_impl/linux/x11/util/input.rs

@@ -45,7 +45,7 @@ impl XConnection {
             self.flush_requests()?;
             Ok(true)
         } else {
-            tracing::error!("Could not select XKB events: The XKB extension is not initialized!");
+            log::error!("Could not select XKB events: The XKB extension is not initialized!");
             Ok(false)
         }
     }

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

@@ -8,7 +8,6 @@ use std::{
 };
 
 mod client_msg;
-pub mod cookie;
 mod cursor;
 mod geometry;
 mod hint;
@@ -16,15 +15,13 @@ mod icon;
 mod input;
 pub mod keys;
 pub(crate) mod memory;
-mod mouse;
 mod randr;
 mod window_property;
 mod wm;
 mod xmodmap;
 
 pub use self::{
-    cursor::*, geometry::*, hint::*, input::*, mouse::*, window_property::*, wm::*,
+    cursor::*, geometry::*, hint::*, input::*, window_property::*, wm::*, xmodmap::ModifierKeymap,
-    xmodmap::ModifierKeymap,
 };
 
 use super::{atoms::*, ffi, VoidCookie, X11Error, XConnection, XError};
@@ -48,7 +45,7 @@ where
 }
 
 impl XConnection {
-    // This is important, so pay attention!
+    // This is impoartant, so pay attention!
     // Xlib has an output buffer, and tries to hide the async nature of X from you.
     // This buffer contains the requests you make, and is flushed under various circumstances:
     // 1. `XPending`, `XNextEvent`, and `XWindowEvent` flush "as needed"

src/platform_impl/linux/x11/util/mouse.rs

@@ -1,52 +0,0 @@
-//! Utilities for handling mouse events.
-
-/// Recorded mouse delta designed to filter out noise.
-pub struct Delta<T> {
-    x: T,
-    y: T,
-}
-
-impl<T: Default> Default for Delta<T> {
-    fn default() -> Self {
-        Self {
-            x: Default::default(),
-            y: Default::default(),
-        }
-    }
-}
-
-impl<T: Default> Delta<T> {
-    pub(crate) fn set_x(&mut self, x: T) {
-        self.x = x;
-    }
-
-    pub(crate) fn set_y(&mut self, y: T) {
-        self.y = y;
-    }
-}
-
-macro_rules! consume {
-    ($this:expr, $ty:ty) => {{
-        let this = $this;
-        let (x, y) = match (this.x.abs() < <$ty>::EPSILON, this.y.abs() < <$ty>::EPSILON) {
-            (true, true) => return None,
-            (true, false) => (this.x, 0.0),
-            (false, true) => (0.0, this.y),
-            (false, false) => (this.x, this.y),
-        };
-
-        Some((x, y))
-    }};
-}
-
-impl Delta<f32> {
-    pub(crate) fn consume(self) -> Option<(f32, f32)> {
-        consume!(self, f32)
-    }
-}
-
-impl Delta<f64> {
-    pub(crate) fn consume(self) -> Option<(f64, f64)> {
-        consume!(self, f64)
-    }
-}

src/platform_impl/linux/x11/util/randr.rs

@@ -4,7 +4,7 @@ use super::*;
 use crate::platform_impl::platform::x11::monitor;
 use crate::{dpi::validate_scale_factor, platform_impl::platform::x11::VideoModeHandle};
 
-use tracing::warn;
+use log::warn;
 use x11rb::protocol::randr::{self, ConnectionExt as _};
 
 /// Represents values of `WINIT_HIDPI_FACTOR`.
@@ -44,7 +44,7 @@ impl XConnection {
                 Ok(Some(dpi)) => return Some(dpi),
                 Ok(None) => {}
                 Err(err) => {
-                    tracing::warn!("failed to fetch XSettings: {err}");
+                    log::warn!("failed to fetch XSettings: {err}");
                 }
             }
         }

src/platform_impl/linux/x11/util/wm.rs

@@ -54,7 +54,7 @@ impl XConnection {
 
         // Mutter/Muffin/Budgie doesn't have _NET_SUPPORTING_WM_CHECK in its _NET_SUPPORTED, despite
         // it working and being supported. This has been reported upstream, but due to the
-        // unavailability of time machines, we'll just try to get _NET_SUPPORTING_WM_CHECK
+        // inavailability of time machines, we'll just try to get _NET_SUPPORTING_WM_CHECK
         // regardless of whether or not the WM claims to support it.
         //
         // Blackbox 0.70 also incorrectly reports not supporting this, though that appears to be fixed

src/platform_impl/linux/x11/util/xmodmap.rs

@@ -16,7 +16,7 @@ const NUM_MODS: usize = 8;
 #[derive(Debug, Default)]
 pub struct ModifierKeymap {
     // Maps keycodes to modifiers
-    modifiers: HashSet<XKeyCode>,
+    modifers: HashSet<XKeyCode>,
 }
 
 impl ModifierKeymap {
@@ -25,7 +25,7 @@ impl ModifierKeymap {
     }
 
     pub fn is_modifier(&self, keycode: XKeyCode) -> bool {
-        self.modifiers.contains(&keycode)
+        self.modifers.contains(&keycode)
     }
 
     pub fn reload_from_x_connection(&mut self, xconn: &super::XConnection) {
@@ -48,9 +48,9 @@ impl ModifierKeymap {
         let keys = unsafe {
             slice::from_raw_parts(keymap.modifiermap as *const _, keys_per_mod * NUM_MODS)
         };
-        self.modifiers.clear();
+        self.modifers.clear();
         for key in keys {
-            self.modifiers.insert(*key);
+            self.modifers.insert(*key);
         }
     }
 }

src/platform_impl/linux/x11/window.rs

@@ -7,7 +7,7 @@ use std::{
     sync::{Arc, Mutex, MutexGuard},
 };
 
-use tracing::{debug, info, warn};
+use log::{debug, info, warn};
 use x11rb::{
     connection::Connection,
     properties::{WmHints, WmSizeHints, WmSizeHintsSpecification},
@@ -391,7 +391,7 @@ impl UnownedWindow {
         }
 
         {
-            // Enable drag and drop (TODO: extend API to make this toggle-able)
+            // Enable drag and drop (TODO: extend API to make this toggleable)
             {
                 let dnd_aware_atom = atoms[XdndAware];
                 let version = &[5u32]; // Latest version; hasn't changed since 2002
@@ -1038,10 +1038,9 @@ impl UnownedWindow {
         let vert_atom = atoms[_NET_WM_STATE_MAXIMIZED_VERT];
         match state {
             Ok(atoms) => {
-                let horizontal_maximized =
+                let horz_maximized = atoms.iter().any(|atom: &xproto::Atom| *atom == horz_atom);
-                    atoms.iter().any(|atom: &xproto::Atom| *atom == horz_atom);
                 let vert_maximized = atoms.iter().any(|atom: &xproto::Atom| *atom == vert_atom);
-                horizontal_maximized && vert_maximized
+                horz_maximized && vert_maximized
             }
             _ => false,
         }
@@ -1049,10 +1048,10 @@ impl UnownedWindow {
 
     fn set_maximized_inner(&self, maximized: bool) -> Result<VoidCookie<'_>, X11Error> {
         let atoms = self.xconn.atoms();
-        let horizontal_atom = atoms[_NET_WM_STATE_MAXIMIZED_HORZ];
+        let horz_atom = atoms[_NET_WM_STATE_MAXIMIZED_HORZ];
         let vert_atom = atoms[_NET_WM_STATE_MAXIMIZED_VERT];
 
-        self.set_netwm(maximized.into(), (horizontal_atom, vert_atom, 0, 0))
+        self.set_netwm(maximized.into(), (horz_atom, vert_atom, 0, 0))
     }
 
     #[inline]
@@ -1574,7 +1573,7 @@ impl UnownedWindow {
             #[cfg(wayland_platform)]
             Cursor::Custom(RootCustomCursor {
                 inner: PlatformCustomCursor::Wayland(_),
-            }) => tracing::error!("passed a Wayland cursor to X11 backend"),
+            }) => log::error!("passed a Wayland cursor to X11 backend"),
         }
     }
 
@@ -1858,7 +1857,7 @@ impl UnownedWindow {
                 )
                 .expect_then_ignore_error("Failed to send client message");
             if let Err(e) = self.xconn.flush_requests() {
-                tracing::error!(
+                log::error!(
                     "`flush` returned an error when focusing the window. Error was: {}",
                     e
                 );

src/platform_impl/linux/x11/xdisplay.rs

@@ -121,7 +121,7 @@ impl XConnection {
 
         let xsettings_screen = Self::new_xsettings_screen(&xcb, default_screen);
         if xsettings_screen.is_none() {
-            tracing::warn!("error setting XSETTINGS; Xft options won't reload automatically")
+            log::warn!("error setting XSETTINGS; Xft options won't reload automatically")
         }
 
         // Fetch atoms.
@@ -159,7 +159,7 @@ impl XConnection {
 
         // Get PropertyNotify events from the XSETTINGS window.
         // TODO: The XSETTINGS window here can change. In the future, listen for DestroyNotify on this window
-        // in order to accommodate for a changed window here.
+        // in order to accomodate for a changed window here.
         let selector_window = xcb
             .get_selection_owner(xsettings_screen)
             .ok()?

src/platform_impl/macos/app_delegate.rs

@@ -471,10 +471,10 @@ fn window_activation_hack(app: &NSApplication) {
         // This way we preserve the user's desired initial visibility status
         // TODO: Also filter on the type/"level" of the window, and maybe other things?
         if window.isVisible() {
-            tracing::trace!("Activating visible window");
+            log::trace!("Activating visible window");
             window.makeKeyAndOrderFront(None);
         } else {
-            tracing::trace!("Skipping activating invisible window");
+            log::trace!("Skipping activating invisible window");
         }
     })
 }

src/platform_impl/macos/cursor.rs

@@ -71,7 +71,7 @@ unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Id<NSCursor>> {
         let cursor: Id<NSCursor> = unsafe { msg_send_id![cls, performSelector: sel] };
         Some(cursor)
     } else {
-        tracing::warn!("cursor `{sel}` appears to be invalid");
+        log::warn!("cursor `{sel}` appears to be invalid");
         None
     }
 }

src/platform_impl/macos/event.rs

@@ -36,14 +36,14 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
     unsafe {
         input_source = ffi::TISCopyCurrentKeyboardLayoutInputSource();
         if input_source.is_null() {
-            tracing::error!("`TISCopyCurrentKeyboardLayoutInputSource` returned null ptr");
+            log::error!("`TISCopyCurrentKeyboardLayoutInputSource` returned null ptr");
             return Key::Unidentified(NativeKey::MacOS(scancode));
         }
         let layout_data =
             ffi::TISGetInputSourceProperty(input_source, ffi::kTISPropertyUnicodeKeyLayoutData);
         if layout_data.is_null() {
             CFRelease(input_source as *mut c_void);
-            tracing::error!("`TISGetInputSourceProperty` returned null ptr");
+            log::error!("`TISGetInputSourceProperty` returned null ptr");
             return Key::Unidentified(NativeKey::MacOS(scancode));
         }
         layout = CFDataGetBytePtr(layout_data as CFDataRef) as *const ffi::UCKeyboardLayout;
@@ -71,7 +71,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
         CFRelease(input_source as *mut c_void);
     }
     if translate_result != 0 {
-        tracing::error!(
+        log::error!(
             "`UCKeyTranslate` returned with the non-zero value: {}",
             translate_result
         );
@@ -113,8 +113,7 @@ pub(crate) fn create_key_event(
     let state = if is_press { Pressed } else { Released };
 
     let scancode = unsafe { ns_event.keyCode() };
-    let mut physical_key =
+    let mut physical_key = key_override.unwrap_or_else(|| scancode_to_physicalkey(scancode as u32));
-        key_override.unwrap_or_else(|| scancode_to_physical_key(scancode as u32));
 
     // NOTE: The logical key should heed both SHIFT and ALT if possible.
     // For instance:
@@ -151,7 +150,7 @@ pub(crate) fn create_key_event(
 
         let logical_key = match text_with_all_modifiers.as_ref() {
             // 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 Germany layout- one
+            // 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.
@@ -416,7 +415,7 @@ pub(super) fn dummy_event() -> Option<Id<NSEvent>> {
     }
 }
 
-pub(crate) fn physical_key_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
+pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
     let code = match physical_key {
         PhysicalKey::Code(code) => code,
         PhysicalKey::Unidentified(_) => return None,
@@ -538,7 +537,7 @@ pub(crate) fn physical_key_to_scancode(physical_key: PhysicalKey) -> Option<u32>
     }
 }
 
-pub(crate) fn scancode_to_physical_key(scancode: u32) -> PhysicalKey {
+pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
     PhysicalKey::Code(match scancode {
         0x00 => KeyCode::KeyA,
         0x01 => KeyCode::KeyS,

src/platform_impl/macos/event_handler.rs

@@ -71,7 +71,7 @@ impl EventHandler {
                         *data = None;
                     }
                     Ok(None) => {
-                        tracing::error!("tried to clear handler, but no handler was set");
+                        log::error!("tried to clear handler, but no handler was set");
                     }
                     Err(_) => {
                         // Note: This is not expected to ever happen, this
@@ -125,7 +125,7 @@ impl EventHandler {
                 // `NSApplication`, our app delegate and this handler are all
                 // global state and so it's not impossible that we could get
                 // an event after the application has exited the `EventLoop`.
-                tracing::error!("tried to run event handler, but no handler was set");
+                log::error!("tried to run event handler, but no handler was set");
             }
             Err(_) => {
                 // Prevent re-entrancy.

src/platform_impl/macos/event_loop.rs

@@ -60,7 +60,7 @@ impl PanicInfo {
         self.inner.set(inner);
         result
     }
-    /// Overwrites the current state if the current state is not panicking
+    /// Overwrites the curret state if the current state is not panicking
     pub fn set_panic(&self, p: Box<dyn Any + Send + 'static>) {
         if !self.is_panicking() {
             self.inner.set(Some(p));

src/platform_impl/macos/mod.rs

@@ -18,7 +18,7 @@ mod window_delegate;
 use std::fmt;
 
 pub(crate) use self::{
-    event::{physical_key_to_scancode, scancode_to_physical_key, KeyEventExtra},
+    event::{physicalkey_to_scancode, scancode_to_physicalkey, KeyEventExtra},
     event_loop::{
         ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
         PlatformSpecificEventLoopAttributes,

src/platform_impl/macos/util.rs

@@ -1,5 +1,5 @@
 use icrate::Foundation::{NSNotFound, NSRange, NSUInteger};
-use tracing::trace;
+use log::trace;
 
 pub const EMPTY_RANGE: NSRange = NSRange {
     location: NSNotFound as NSUInteger,
@@ -20,7 +20,7 @@ pub(crate) struct TraceGuard {
 impl TraceGuard {
     #[inline]
     pub(crate) fn new(module_path: &'static str, called_from_fn: &'static str) -> Self {
-        trace!(target = module_path, "Triggered `{}`", called_from_fn);
+        trace!(target: module_path, "Triggered `{}`", called_from_fn);
         Self {
             module_path,
             called_from_fn,
@@ -31,10 +31,6 @@ impl TraceGuard {
 impl Drop for TraceGuard {
     #[inline]
     fn drop(&mut self) {
-        trace!(
+        trace!(target: self.module_path, "Completed `{}`", self.called_from_fn);
-            target = self.module_path,
-            "Completed `{}`",
-            self.called_from_fn
-        );
     }
 }

src/platform_impl/macos/view.rs

@@ -23,7 +23,7 @@ use super::app_delegate::ApplicationDelegate;
 use super::cursor::{default_cursor, invisible_cursor};
 use super::event::{
     code_to_key, code_to_location, create_key_event, event_mods, lalt_pressed, ralt_pressed,
-    scancode_to_physical_key,
+    scancode_to_physicalkey,
 };
 use super::window::WinitWindow;
 use super::{util, DEVICE_ID};
@@ -338,7 +338,7 @@ declare_class!(
                 // Leave the Preedit self.ivars()
                 self.ivars().ime_state.set(ImeState::Ground);
             } else {
-                tracing::warn!("Expected to have IME enabled when receiving unmarkText");
+                log::warn!("Expected to have IME enabled when receiving unmarkText");
             }
         }
 
@@ -918,7 +918,7 @@ impl WinitView {
         'send_event: {
             if is_flags_changed_event && unsafe { ns_event.keyCode() } != 0 {
                 let scancode = unsafe { ns_event.keyCode() };
-                let physical_key = scancode_to_physical_key(scancode as u32);
+                let physical_key = scancode_to_physicalkey(scancode as u32);
 
                 // We'll correct the `is_press` later.
                 let mut event = create_key_event(ns_event, false, false, Some(physical_key));

src/platform_impl/macos/window_delegate.rs

@@ -594,7 +594,7 @@ fn new_window(attrs: &WindowAttributes, mtm: MainThreadMarker) -> Option<Id<Wini
         view.setWantsBestResolutionOpenGLSurface(!attrs.platform_specific.disallow_hidpi);
 
         // On Mojave, views automatically become layer-backed shortly after being added to
-        // a window. Changing the layer-backed-ness of a view breaks the association between
+        // a window. Changing the layer-backedness of a view breaks the association between
         // the view and its associated OpenGL context. To work around this, on Mojave we
         // explicitly make the view layer-backed up front so that AppKit doesn't do it
         // itself and break the association with its context.
@@ -1012,7 +1012,7 @@ impl WindowDelegate {
         self.set_style_mask(mask);
 
         // We edit the button directly instead of using `NSResizableWindowMask`,
-        // since that mask also affect the resize ability of the window (which is
+        // since that mask also affect the resizability of the window (which is
         // controllable by other means in `winit`).
         if let Some(button) = self.window().standardWindowButton(NSWindowZoomButton) {
             button.setEnabled(buttons.contains(WindowButtons::MAXIMIZE));

src/platform_impl/orbital/event_loop.rs

@@ -537,7 +537,7 @@ impl<T: 'static> EventLoop<T> {
                 }
             }
             other => {
-                tracing::warn!("unhandled event: {:?}", other);
+                log::warn!("unhandled event: {:?}", other);
             }
         }
     }

src/platform_impl/web/cursor.rs

@@ -301,9 +301,7 @@ impl CursorHandler {
                         };
                     }
                     ImageState::Failed(error) => {
-                        tracing::error!(
+                        log::error!("trying to load custom cursor that has failed to load: {error}")
-                            "trying to load custom cursor that has failed to load: {error}"
-                        )
                     }
                     ImageState::Image(_) => {
                         drop(state);
@@ -415,7 +413,7 @@ impl Inner {
                 self.set_style();
             }
             ImageState::Failed(error) => {
-                tracing::error!("custom cursor failed to load: {error}");
+                log::error!("custom cursor failed to load: {error}");
                 self.cursor = previous.into()
             }
             ImageState::Loading { .. } => unreachable!("notified without being ready"),

src/platform_impl/web/keyboard.rs

@@ -321,8 +321,8 @@ impl Key {
 }
 
 impl PhysicalKey {
-    pub fn from_key_code_attribute_value(k_code: &str) -> Self {
+    pub fn from_key_code_attribute_value(kcav: &str) -> Self {
-        PhysicalKey::Code(match k_code {
+        PhysicalKey::Code(match kcav {
             "Backquote" => KeyCode::Backquote,
             "Backslash" => KeyCode::Backslash,
             "BracketLeft" => KeyCode::BracketLeft,

src/platform_impl/web/web_sys/event.rs

@@ -190,7 +190,7 @@ pub fn key_location(event: &KeyboardEvent) -> KeyLocation {
         KeyboardEvent::DOM_KEY_LOCATION_NUMPAD => KeyLocation::Numpad,
         KeyboardEvent::DOM_KEY_LOCATION_STANDARD => KeyLocation::Standard,
         location => {
-            tracing::warn!("Unexpected key location: {location}");
+            log::warn!("Unexpected key location: {location}");
             KeyLocation::Standard
         }
     }

src/platform_impl/web/web_sys/resize_scaling.rs

@@ -1,5 +1,5 @@
 use js_sys::{Array, Object};
-use tracing::warn;
+use log::warn;
 use wasm_bindgen::prelude::{wasm_bindgen, Closure};
 use wasm_bindgen::{JsCast, JsValue};
 use web_sys::{

src/platform_impl/web/web_sys/schedule.rs

@@ -117,7 +117,9 @@ impl Schedule {
         let channel = MessageChannel::new().unwrap();
         let closure = Closure::new(f);
         let port_1 = channel.port1();
-        port_1.set_onmessage(Some(closure.as_ref().unchecked_ref()));
+        port_1
+            .add_event_listener_with_callback("message", closure.as_ref().unchecked_ref())
+            .expect("Failed to set message handler");
         port_1.start();
 
         let port_2 = channel.port2();
@@ -176,7 +178,6 @@ impl Drop for Schedule {
             } => {
                 window.clear_timeout_with_handle(*handle);
                 port.close();
-                port.set_onmessage(None);
             }
         }
     }

src/platform_impl/windows/dark_mode.rs

@@ -117,13 +117,13 @@ fn set_dark_mode_for_window(hwnd: HWND, is_dark_mode: bool) -> bool {
 
     if let Some(set_window_composition_attribute) = *SET_WINDOW_COMPOSITION_ATTRIBUTE {
         unsafe {
-            // SetWindowCompositionAttribute needs a big_bool (i32), not bool.
+            // SetWindowCompositionAttribute needs a bigbool (i32), not bool.
-            let mut is_dark_mode_big_bool = BOOL::from(is_dark_mode);
+            let mut is_dark_mode_bigbool = BOOL::from(is_dark_mode);
 
             let mut data = WINDOWCOMPOSITIONATTRIBDATA {
                 Attrib: WCA_USEDARKMODECOLORS,
-                pvData: &mut is_dark_mode_big_bool as *mut _ as _,
+                pvData: &mut is_dark_mode_bigbool as *mut _ as _,
-                cbData: std::mem::size_of_val(&is_dark_mode_big_bool) as _,
+                cbData: std::mem::size_of_val(&is_dark_mode_bigbool) as _,
             };
 
             let status = set_window_composition_attribute(hwnd, &mut data);

src/platform_impl/windows/definitions.rs

@@ -17,7 +17,7 @@ use windows_sys::{
 pub struct IUnknownVtbl {
     pub QueryInterface: unsafe extern "system" fn(
         This: *mut IUnknown,
-        r_iid: *const GUID,
+        riid: *const GUID,
         ppvObject: *mut *mut c_void,
     ) -> HRESULT,
     pub AddRef: unsafe extern "system" fn(This: *mut IUnknown) -> u32,
@@ -29,45 +29,43 @@ pub struct IDataObjectVtbl {
     pub parent: IUnknownVtbl,
     pub GetData: unsafe extern "system" fn(
         This: *mut IDataObject,
-        p_format_etc_In: *const FORMATETC,
+        pformatetcIn: *const FORMATETC,
-        p_medium: *mut STGMEDIUM,
+        pmedium: *mut STGMEDIUM,
     ) -> HRESULT,
     pub GetDataHere: unsafe extern "system" fn(
         This: *mut IDataObject,
-        p_format_etc: *const FORMATETC,
+        pformatetc: *const FORMATETC,
-        p_medium: *mut STGMEDIUM,
+        pmedium: *mut STGMEDIUM,
-    ) -> HRESULT,
-    QueryGetData: unsafe extern "system" fn(
-        This: *mut IDataObject,
-        p_format_etc: *const FORMATETC,
     ) -> HRESULT,
+    QueryGetData:
+        unsafe extern "system" fn(This: *mut IDataObject, pformatetc: *const FORMATETC) -> HRESULT,
     pub GetCanonicalFormatEtc: unsafe extern "system" fn(
         This: *mut IDataObject,
-        p_format_etc_In: *const FORMATETC,
+        pformatetcIn: *const FORMATETC,
-        p_format_etc_Out: *mut FORMATETC,
+        pformatetcOut: *mut FORMATETC,
     ) -> HRESULT,
     pub SetData: unsafe extern "system" fn(
         This: *mut IDataObject,
-        p_format_etc: *const FORMATETC,
+        pformatetc: *const FORMATETC,
-        p_format_etcOut: *const FORMATETC,
+        pformatetcOut: *const FORMATETC,
         fRelease: BOOL,
     ) -> HRESULT,
     pub EnumFormatEtc: unsafe extern "system" fn(
         This: *mut IDataObject,
         dwDirection: u32,
-        pp_enumFormatEtc: *mut *mut IEnumFORMATETC,
+        ppenumFormatEtc: *mut *mut IEnumFORMATETC,
     ) -> HRESULT,
     pub DAdvise: unsafe extern "system" fn(
         This: *mut IDataObject,
-        p_format_etc: *const FORMATETC,
+        pformatetc: *const FORMATETC,
-        a_dvf: u32,
+        advf: u32,
         pAdvSInk: *const IAdviseSink,
         pdwConnection: *mut u32,
     ) -> HRESULT,
     pub DUnadvise: unsafe extern "system" fn(This: *mut IDataObject, dwConnection: u32) -> HRESULT,
     pub EnumDAdvise: unsafe extern "system" fn(
         This: *mut IDataObject,
-        pp_enumAdvise: *const *const IEnumSTATDATA,
+        ppenumAdvise: *const *const IEnumSTATDATA,
     ) -> HRESULT,
 }
 

src/platform_impl/windows/drop_handler.rs

@@ -18,7 +18,7 @@ use windows_sys::{
     },
 };
 
-use tracing::debug;
+use log::debug;
 
 use crate::platform_impl::platform::{
     definitions::{IDataObjectVtbl, IDropTarget, IDropTargetVtbl, IUnknownVtbl},

src/platform_impl/windows/event_loop.rs

@@ -536,7 +536,7 @@ impl ActiveEventLoop {
         let inner = match WinCursor::new(&source.inner.0) {
             Ok(cursor) => cursor,
             Err(err) => {
-                tracing::warn!("Failed to create custom cursor: {err}");
+                log::warn!("Failed to create custom cursor: {err}");
                 WinCursor::Failed
             }
         };
@@ -1021,10 +1021,10 @@ pub(super) unsafe extern "system" fn public_window_callback(
 
     let userdata_ptr = match (userdata, msg) {
         (0, WM_NCCREATE) => {
-            let create_struct = unsafe { &mut *(lparam as *mut CREATESTRUCTW) };
+            let createstruct = unsafe { &mut *(lparam as *mut CREATESTRUCTW) };
-            let init_data = unsafe { &mut *(create_struct.lpCreateParams as *mut InitData<'_>) };
+            let initdata = unsafe { &mut *(createstruct.lpCreateParams as *mut InitData<'_>) };
 
-            let result = match unsafe { init_data.on_nccreate(window) } {
+            let result = match unsafe { initdata.on_nccreate(window) } {
                 Some(userdata) => unsafe {
                     super::set_window_long(window, GWL_USERDATA, userdata as _);
                     DefWindowProcW(window, msg, wparam, lparam)
@@ -1038,11 +1038,11 @@ pub(super) unsafe extern "system" fn public_window_callback(
         // but we'll make window creation fail here just in case.
         (0, WM_CREATE) => return -1,
         (_, WM_CREATE) => unsafe {
-            let create_struct = &mut *(lparam as *mut CREATESTRUCTW);
+            let createstruct = &mut *(lparam as *mut CREATESTRUCTW);
-            let init_data = create_struct.lpCreateParams;
+            let initdata = createstruct.lpCreateParams;
-            let init_data = &mut *(init_data as *mut InitData<'_>);
+            let initdata = &mut *(initdata as *mut InitData<'_>);
 
-            init_data.on_create();
+            initdata.on_create();
             return DefWindowProcW(window, msg, wparam, lparam);
         },
         (0, _) => return unsafe { DefWindowProcW(window, msg, wparam, lparam) },
@@ -1147,7 +1147,7 @@ unsafe fn public_window_callback_inner(
                 // on all 4 borders would result in the caption getting drawn by the DWM.
                 //
                 // Another option would be to allow the DWM to paint inside the client area.
-                // Unfortunately this results in inconsistent resize behavior, where the compositor is
+                // Unfortunately this results in janky resize behavior, where the compositor is
                 // ahead of the window surface. Currently, there seems no option to achieve this
                 // with the Windows API.
                 params.rgrc[0].top += 1;
@@ -1312,10 +1312,10 @@ unsafe fn public_window_callback_inner(
         WM_WINDOWPOSCHANGED => {
             use crate::event::WindowEvent::Moved;
 
-            let window_pos = lparam as *const WINDOWPOS;
+            let windowpos = lparam as *const WINDOWPOS;
-            if unsafe { (*window_pos).flags & SWP_NOMOVE != SWP_NOMOVE } {
+            if unsafe { (*windowpos).flags & SWP_NOMOVE != SWP_NOMOVE } {
                 let physical_position =
-                    unsafe { PhysicalPosition::new((*window_pos).x, (*window_pos).y) };
+                    unsafe { PhysicalPosition::new((*windowpos).x, (*windowpos).y) };
                 userdata.send_event(Event::WindowEvent {
                     window_id: RootWindowId(WindowId(window)),
                     event: Moved(physical_position),
@@ -1817,18 +1817,18 @@ unsafe fn public_window_callback_inner(
         }
 
         WM_TOUCH => {
-            let p_count = super::loword(wparam as u32) as usize;
+            let pcount = super::loword(wparam as u32) as usize;
-            let mut inputs = Vec::with_capacity(p_count);
+            let mut inputs = Vec::with_capacity(pcount);
-            let h_touch = lparam;
+            let htouch = lparam;
             if unsafe {
                 GetTouchInputInfo(
-                    h_touch,
+                    htouch,
-                    p_count as u32,
+                    pcount as u32,
                     inputs.as_mut_ptr(),
                     mem::size_of::<TOUCHINPUT>() as i32,
                 ) > 0
             } {
-                unsafe { inputs.set_len(p_count) };
+                unsafe { inputs.set_len(pcount) };
                 for input in &inputs {
                     let mut location = POINT {
                         x: input.x / 100,
@@ -1862,7 +1862,7 @@ unsafe fn public_window_callback_inner(
                     });
                 }
             }
-            unsafe { CloseTouchInputHandle(h_touch) };
+            unsafe { CloseTouchInputHandle(htouch) };
             result = ProcResult::Value(0);
         }
 
@@ -2557,7 +2557,7 @@ unsafe fn handle_raw_input(userdata: &ThreadMsgTargetData, data: RAWINPUT) {
 }
 
 enum PointerMoveKind {
-    /// Pointer entered to the window.
+    /// Pointer enterd to the window.
     Enter,
     /// Pointer leaved the window client area.
     Leave,

src/platform_impl/windows/event_loop/runner.rs

@@ -399,19 +399,19 @@ impl<T> BufferedEvent<T> {
         match self {
             Self::Event(event) => dispatch(event),
             Self::ScaleFactorChanged(window_id, scale_factor, new_inner_size) => {
-                let user_new_inner_size = Arc::new(Mutex::new(new_inner_size));
+                let user_new_innner_size = Arc::new(Mutex::new(new_inner_size));
                 dispatch(Event::WindowEvent {
                     window_id,
                     event: WindowEvent::ScaleFactorChanged {
                         scale_factor,
                         inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                            &user_new_inner_size,
+                            &user_new_innner_size,
                         )),
                     },
                 });
-                let inner_size = *user_new_inner_size.lock().unwrap();
+                let inner_size = *user_new_innner_size.lock().unwrap();
 
-                drop(user_new_inner_size);
+                drop(user_new_innner_size);
 
                 if inner_size != new_inner_size {
                     let window_flags = unsafe {

src/platform_impl/windows/ime.rs

@@ -45,12 +45,12 @@ impl ImeContext {
         let mut boundary_before_char = 0;
 
         for (attr, chr) in attrs.into_iter().zip(text.chars()) {
-            let char_is_targeted =
+            let char_is_targetted =
                 attr as u32 == ATTR_TARGET_CONVERTED || attr as u32 == ATTR_TARGET_NOTCONVERTED;
 
-            if first.is_none() && char_is_targeted {
+            if first.is_none() && char_is_targetted {
                 first = Some(boundary_before_char);
-            } else if first.is_some() && last.is_none() && !char_is_targeted {
+            } else if first.is_some() && last.is_none() && !char_is_targetted {
                 last = Some(boundary_before_char);
             }
 

src/platform_impl/windows/keyboard.rs

@@ -32,8 +32,8 @@ use windows_sys::Win32::{
     },
 };
 
+use log::{trace, warn};
 use smol_str::SmolStr;
-use tracing::{trace, warn};
 use unicode_segmentation::UnicodeSegmentation;
 
 use crate::{
@@ -42,7 +42,7 @@ use crate::{
     platform_impl::platform::{
         event_loop::ProcResult,
         keyboard_layout::{Layout, LayoutCache, WindowsModifiers, LAYOUT_CACHE},
-        loword, primary_lang_id, KeyEventExtra,
+        loword, primarylangid, KeyEventExtra,
     },
 };
 
@@ -112,7 +112,7 @@ impl KeyEventBuilder {
                     MatchResult::MessagesToDispatch(self.pending.complete_multi(key_events))
                 }
                 WM_KILLFOCUS => {
-                    // synthesize keyup events
+                    // sythesize keyup events
                     let kbd_state = get_kbd_state();
                     let key_events = Self::synthesize_kbd_state(ElementState::Released, &kbd_state);
                     MatchResult::MessagesToDispatch(self.pending.complete_multi(key_events))
@@ -230,7 +230,7 @@ impl KeyEventBuilder {
                         .unwrap_or(false);
                     if more_char_coming {
                         // No need to produce an event just yet, because there are still more characters that
-                        // need to appended to this keyboard event
+                        // need to appended to this keyobard event
                         MatchResult::TokenToRemove(pending_token)
                     } else {
                         let mut event_info = self.event_info.lock().unwrap();
@@ -328,7 +328,7 @@ impl KeyEventBuilder {
         }
     }
 
-    // Allowing nonminimal_bool lint because the `is_key_pressed` macro triggers this warning
+    // Allowing nominimal_bool lint because the `is_key_pressed` macro triggers this warning
     // and I don't know of another way to resolve it and also keeping the macro
     #[allow(clippy::nonminimal_bool)]
     fn synthesize_kbd_state(
@@ -454,7 +454,7 @@ impl KeyEventBuilder {
             return None;
         }
         let scancode = scancode as ExScancode;
-        let physical_key = scancode_to_physical_key(scancode as u32);
+        let physical_key = scancode_to_physicalkey(scancode as u32);
         let mods = if caps_lock_on {
             WindowsModifiers::CAPS_LOCK
         } else {
@@ -499,7 +499,7 @@ enum PartialText {
 
 enum PartialLogicalKey {
     /// Use the text provided by the WM_CHAR messages and report that as a `Character` variant. If
-    /// the text consists of multiple grapheme clusters (user-perceived characters) that means that
+    /// the text consists of multiple grapheme clusters (user-precieved characters) that means that
     /// dead key could not be combined with the second input, and in that case we should fall back
     /// to using what would have without a dead-key input.
     TextOr(Key),
@@ -544,7 +544,7 @@ impl PartialKeyEventInfo {
         } else {
             new_ex_scancode(lparam_struct.scancode, lparam_struct.extended)
         };
-        let physical_key = scancode_to_physical_key(scancode as u32);
+        let physical_key = scancode_to_physicalkey(scancode as u32);
         let location = get_location(scancode, layout.hkl as HKL);
 
         let kbd_state = get_kbd_state();
@@ -589,7 +589,7 @@ impl PartialKeyEventInfo {
                 // We convert dead keys into their character.
                 // The reason for this is that `key_without_modifiers` is designed for key-bindings,
                 // but the US International layout treats `'` (apostrophe) as a dead key and the
-                // regular US layout treats it a character. In order for a single binding
+                // reguar US layout treats it a character. In order for a single binding
                 // configuration to work with both layouts, we forward each dead key as a character.
                 Key::Dead(k) => {
                     if let Some(ch) = k {
@@ -741,15 +741,15 @@ fn get_async_kbd_state() -> [u8; 256] {
 /// every AltGr key-press (and key-release). We check if the current event is a Ctrl event and if
 /// the next event is a right Alt (AltGr) event. If this is the case, the current event must be the
 /// fake Ctrl event.
-fn is_current_fake(current_info: &PartialKeyEventInfo, next_msg: MSG, layout: &Layout) -> bool {
+fn is_current_fake(curr_info: &PartialKeyEventInfo, next_msg: MSG, layout: &Layout) -> bool {
-    let current_is_ctrl = matches!(
+    let curr_is_ctrl = matches!(
-        current_info.logical_key,
+        curr_info.logical_key,
         PartialLogicalKey::This(Key::Named(NamedKey::Control))
     );
     if layout.has_alt_graph {
         let next_code = ex_scancode_from_lparam(next_msg.lParam);
         let next_is_altgr = next_code == 0xE038; // 0xE038 is right alt
-        if current_is_ctrl && next_is_altgr {
+        if curr_is_ctrl && next_is_altgr {
             return true;
         }
     }
@@ -942,12 +942,12 @@ fn get_location(scancode: ExScancode, hkl: HKL) -> KeyLocation {
     }
 }
 
-pub(crate) fn physical_key_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
+pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
-    // See `scancode_to_physical_key` for more info
+    // See `scancode_to_physicalkey` for more info
 
     let hkl = unsafe { GetKeyboardLayout(0) };
 
-    let primary_lang_id = primary_lang_id(loword(hkl as u32));
+    let primary_lang_id = primarylangid(loword(hkl as u32));
     let is_korean = primary_lang_id as u32 == LANG_KOREAN;
 
     let code = match physical_key {
@@ -1124,7 +1124,7 @@ pub(crate) fn physical_key_to_scancode(physical_key: PhysicalKey) -> Option<u32>
     }
 }
 
-pub(crate) fn scancode_to_physical_key(scancode: u32) -> PhysicalKey {
+pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
     // See: https://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
     // and: https://www.w3.org/TR/uievents-code/
     // and: The widget/NativeKeyToDOMCodeName.h file in the firefox source

src/platform_impl/windows/keyboard_layout.rs

@@ -53,7 +53,7 @@ use windows_sys::Win32::{
 
 use crate::{
     keyboard::{Key, KeyCode, ModifiersState, NamedKey, NativeKey, PhysicalKey},
-    platform_impl::{loword, primary_lang_id, scancode_to_physical_key},
+    platform_impl::{loword, primarylangid, scancode_to_physicalkey},
 };
 
 pub(crate) static LAYOUT_CACHE: Lazy<Mutex<LayoutCache>> =
@@ -121,12 +121,12 @@ impl WindowsModifiers {
         let rshift = key_state[VK_RSHIFT as usize] & 0x80 != 0;
 
         let control = key_state[VK_CONTROL as usize] & 0x80 != 0;
-        let l_control = key_state[VK_LCONTROL as usize] & 0x80 != 0;
+        let lcontrol = key_state[VK_LCONTROL as usize] & 0x80 != 0;
-        let r_control = key_state[VK_RCONTROL as usize] & 0x80 != 0;
+        let rcontrol = key_state[VK_RCONTROL as usize] & 0x80 != 0;
 
         let alt = key_state[VK_MENU as usize] & 0x80 != 0;
-        let l_alt = key_state[VK_LMENU as usize] & 0x80 != 0;
+        let lalt = key_state[VK_LMENU as usize] & 0x80 != 0;
-        let r_alt = key_state[VK_RMENU as usize] & 0x80 != 0;
+        let ralt = key_state[VK_RMENU as usize] & 0x80 != 0;
 
         let caps = key_state[VK_CAPITAL as usize] & 0x01 != 0;
 
@@ -134,10 +134,10 @@ impl WindowsModifiers {
         if shift || lshift || rshift {
             result.insert(WindowsModifiers::SHIFT);
         }
-        if control || l_control || r_control {
+        if control || lcontrol || rcontrol {
             result.insert(WindowsModifiers::CONTROL);
         }
-        if alt || l_alt || r_alt {
+        if alt || lalt || ralt {
             result.insert(WindowsModifiers::ALT);
         }
         if caps {
@@ -335,7 +335,7 @@ impl LayoutCache {
             if scancode == 0 {
                 continue;
             }
-            let keycode = match scancode_to_physical_key(scancode) {
+            let keycode = match scancode_to_physicalkey(scancode) {
                 PhysicalKey::Code(code) => code,
                 // TODO: validate that we can skip on unidentified keys (probably never occurs?)
                 _ => continue,
@@ -387,7 +387,7 @@ impl LayoutCache {
                 }
 
                 let native_code = NativeKey::Windows(vk as VIRTUAL_KEY);
-                let key_code = match scancode_to_physical_key(scancode) {
+                let key_code = match scancode_to_physicalkey(scancode) {
                     PhysicalKey::Code(code) => code,
                     // TODO: validate that we can skip on unidentified keys (probably never occurs?)
                     _ => continue,
@@ -542,7 +542,7 @@ fn is_numpad_specific(vk: VIRTUAL_KEY) -> bool {
 }
 
 fn keycode_to_vkey(keycode: KeyCode, hkl: u64) -> VIRTUAL_KEY {
-    let primary_lang_id = primary_lang_id(loword(hkl as u32));
+    let primary_lang_id = primarylangid(loword(hkl as u32));
     let is_korean = primary_lang_id as u32 == LANG_KOREAN;
     let is_japanese = primary_lang_id as u32 == LANG_JAPANESE;
 
@@ -763,7 +763,7 @@ fn vkey_to_non_char_key(
     // List of the Web key names and their corresponding platform-native key names:
     // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
 
-    let primary_lang_id = primary_lang_id(loword(hkl as u32));
+    let primary_lang_id = primarylangid(loword(hkl as u32));
     let is_korean = primary_lang_id as u32 == LANG_KOREAN;
     let is_japanese = primary_lang_id as u32 == LANG_JAPANESE;
 

src/platform_impl/windows/mod.rs

@@ -12,7 +12,7 @@ pub(crate) use self::{
         PlatformSpecificEventLoopAttributes,
     },
     icon::{SelectedCursor, WinIcon},
-    keyboard::{physical_key_to_scancode, scancode_to_physical_key},
+    keyboard::{physicalkey_to_scancode, scancode_to_physicalkey},
     monitor::{MonitorHandle, VideoModeHandle},
     window::Window,
 };
@@ -148,7 +148,7 @@ const fn get_y_lparam(x: u32) -> i16 {
 }
 
 #[inline(always)]
-pub(crate) const fn primary_lang_id(lgid: u16) -> u16 {
+pub(crate) const fn primarylangid(lgid: u16) -> u16 {
     lgid & 0x3FF
 }
 
@@ -163,26 +163,24 @@ const fn hiword(x: u32) -> u16 {
 }
 
 #[inline(always)]
-unsafe fn get_window_long(hwnd: HWND, n_index: WINDOW_LONG_PTR_INDEX) -> isize {
+unsafe fn get_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX) -> isize {
     #[cfg(target_pointer_width = "64")]
-    return unsafe {
+    return unsafe { windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, nindex) };
-        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, n_index)
-    };
     #[cfg(target_pointer_width = "32")]
     return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, n_index) as isize
+        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, nindex) as isize
     };
 }
 
 #[inline(always)]
-unsafe fn set_window_long(hwnd: HWND, n_index: WINDOW_LONG_PTR_INDEX, new_long: isize) -> isize {
+unsafe fn set_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX, dwnewlong: isize) -> isize {
     #[cfg(target_pointer_width = "64")]
     return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, n_index, new_long)
+        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, nindex, dwnewlong)
     };
     #[cfg(target_pointer_width = "32")]
     return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, n_index, new_long as i32)
+        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, nindex, dwnewlong as i32)
             as isize
     };
 }

src/platform_impl/windows/monitor.rs

@@ -236,7 +236,7 @@ impl MonitorHandle {
         let monitor_info = match get_monitor_info(self.0) {
             Ok(monitor_info) => monitor_info,
             Err(error) => {
-                tracing::warn!("Error from get_monitor_info: {error}");
+                log::warn!("Error from get_monitor_info: {error}");
                 return modes.into_iter().map(mod_map);
             }
         };

src/platform_impl/windows/raw_input.rs

@@ -27,7 +27,7 @@ use windows_sys::Win32::{
     },
 };
 
-use super::scancode_to_physical_key;
+use super::scancode_to_physicalkey;
 use crate::{
     event::ElementState,
     event_loop::DeviceEvents,
@@ -152,7 +152,7 @@ pub fn register_all_mice_and_keyboards_for_raw_input(
     mut window_handle: HWND,
     filter: DeviceEvents,
 ) -> bool {
-    // RIDEV_DEVNOTIFY: receive hot-plug events
+    // RIDEV_DEVNOTIFY: receive hotplug events
     // RIDEV_INPUTSINK: receive events even if we're not in the foreground
     // RIDEV_REMOVE: don't receive device events (requires NULL hwndTarget)
     let flags = match filter {
@@ -249,16 +249,16 @@ pub fn get_keyboard_physical_key(keyboard: RAWKEYBOARD) -> Option<PhysicalKey> {
     if scancode == 0xE11D || scancode == 0xE02A {
         // At the hardware (or driver?) level, pressing the Pause key is equivalent to pressing
         // Ctrl+NumLock.
-        // This equivalence means that if the user presses Pause, the keyboard will emit two
+        // This equvalence means that if the user presses Pause, the keyboard will emit two
         // subsequent keypresses:
         // 1, 0xE11D - Which is a left Ctrl (0x1D) with an extension flag (0xE100)
         // 2, 0x0045 - Which on its own can be interpreted as Pause
         //
         // There's another combination which isn't quite an equivalence:
-        // PrtSc used to be Shift+Asterisk. This means that on some keyboards, pressing
+        // PrtSc used to be Shift+Asterisk. This means that on some keyboards, presssing
         // PrtSc (print screen) produces the following sequence:
         // 1, 0xE02A - Which is a left shift (0x2A) with an extension flag (0xE000)
-        // 2, 0xE037 - Which is a numpad multiply (0x37) with an extension flag (0xE000). This on
+        // 2, 0xE037 - Which is a numpad multiply (0x37) with an exteion flag (0xE000). This on
         //             its own it can be interpreted as PrtSc
         //
         // For this reason, if we encounter the first keypress, we simply ignore it, trusting
@@ -284,7 +284,7 @@ pub fn get_keyboard_physical_key(keyboard: RAWKEYBOARD) -> Option<PhysicalKey> {
         // https://devblogs.microsoft.com/oldnewthing/20080211-00/?p=23503
         PhysicalKey::Code(KeyCode::NumLock)
     } else {
-        scancode_to_physical_key(scancode as u32)
+        scancode_to_physicalkey(scancode as u32)
     };
     if keyboard.VKey == VK_SHIFT {
         if let PhysicalKey::Code(code) = physical_key {

src/platform_impl/windows/window.rs

@@ -59,7 +59,7 @@ use windows_sys::Win32::{
     },
 };
 
-use tracing::warn;
+use log::warn;
 
 use crate::{
     cursor::Cursor,
@@ -1406,7 +1406,7 @@ unsafe fn init(
     let menu = attributes.platform_specific.menu;
     let fullscreen = attributes.fullscreen.clone();
     let maximized = attributes.maximized;
-    let mut init_data = InitData {
+    let mut initdata = InitData {
         event_loop,
         attributes,
         window_flags,
@@ -1427,7 +1427,7 @@ unsafe fn init(
             parent.unwrap_or(0),
             menu.unwrap_or(0),
             util::get_instance_handle(),
-            &mut init_data as *mut _ as *mut _,
+            &mut initdata as *mut _ as *mut _,
         )
     };
 
@@ -1442,7 +1442,7 @@ unsafe fn init(
 
     // If the handle is non-null, then window creation must have succeeded, which means
     // that we *must* have populated the `InitData.window` field.
-    let win = init_data.window.unwrap();
+    let win = initdata.window.unwrap();
 
     // Need to set FULLSCREEN or MAXIMIZED after CreateWindowEx
     // This is because if the size is changed in WM_CREATE, the restored size will be stored in that size.

src/platform_impl/windows/window_state.rs

@@ -416,7 +416,7 @@ impl WindowFlags {
                     0,
                 );
 
-                // This condition is necessary to avoid having an un-restorable window
+                // This condition is necessary to avoid having an unrestorable window
                 if !new.contains(WindowFlags::MINIMIZED) {
                     SetWindowLongW(window, GWL_STYLE, style as i32);
                     SetWindowLongW(window, GWL_EXSTYLE, style_ex as i32);
@@ -450,7 +450,7 @@ impl WindowFlags {
             let mut style = GetWindowLongW(hwnd, GWL_STYLE) as u32;
             let style_ex = GetWindowLongW(hwnd, GWL_EXSTYLE) as u32;
 
-            // Frame-less style implemented by manually overriding the non-client area in `WM_NCCALCSIZE`.
+            // Frameless style implemented by manually overriding the non-client area in `WM_NCCALCSIZE`.
             if !self.contains(WindowFlags::MARKER_DECORATIONS) {
                 style &= !(WS_CAPTION | WS_SIZEBOX);
             }

src/utils.rs

@@ -1,5 +1,5 @@
 // A poly-fill for `lazy_cell`
-// Replace with std::sync::LazyLock when https://github.com/rust-lang/rust/issues/109736 is stabilized.
+// Replace with std::sync::LazyLock when https://github.com/rust-lang/rust/issues/109736 is stablized.
 
 // This isn't used on every platform, which can come up as dead code warnings.
 #![allow(dead_code)]

src/window.rs

@@ -70,8 +70,8 @@ pub struct Window {
 }
 
 impl fmt::Debug for Window {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, fmtr: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter.pad("Window { .. }")
+        fmtr.pad("Window { .. }")
     }
 }
 
@@ -528,8 +528,6 @@ impl Window {
     /// Returns an identifier unique to the window.
     #[inline]
     pub fn id(&self) -> WindowId {
-        let _span = tracing::debug_span!("winit::Window::id",).entered();
-
         self.window.maybe_wait_on_main(|w| WindowId(w.id()))
     }
 
@@ -593,8 +591,6 @@ impl Window {
     /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
     #[inline]
     pub fn scale_factor(&self) -> f64 {
-        let _span = tracing::debug_span!("winit::Window::scale_factor",).entered();
-
         self.window.maybe_wait_on_main(|w| w.scale_factor())
     }
 
@@ -626,8 +622,6 @@ impl Window {
     /// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested
     #[inline]
     pub fn request_redraw(&self) {
-        let _span = tracing::debug_span!("winit::Window::request_redraw",).entered();
-
         self.window.maybe_queue_on_main(|w| w.request_redraw())
     }
 
@@ -664,8 +658,6 @@ impl Window {
     /// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested
     #[inline]
     pub fn pre_present_notify(&self) {
-        let _span = tracing::debug_span!("winit::Window::pre_present_notify",).entered();
-
         self.window.maybe_queue_on_main(|w| w.pre_present_notify());
     }
 
@@ -682,8 +674,6 @@ impl Window {
     // at least, then this function should be provided through a platform specific
     // extension trait
     pub fn reset_dead_keys(&self) {
-        let _span = tracing::debug_span!("winit::Window::reset_dead_keys",).entered();
-
         self.window.maybe_queue_on_main(|w| w.reset_dead_keys())
     }
 }
@@ -706,8 +696,6 @@ impl Window {
     /// [safe area]: https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc
     #[inline]
     pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        let _span = tracing::debug_span!("winit::Window::inner_position",).entered();
-
         self.window.maybe_wait_on_main(|w| w.inner_position())
     }
 
@@ -729,8 +717,6 @@ impl Window {
     /// - **Android / Wayland:** Always returns [`NotSupportedError`].
     #[inline]
     pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        let _span = tracing::debug_span!("winit::Window::outer_position",).entered();
-
         self.window.maybe_wait_on_main(|w| w.outer_position())
     }
 
@@ -763,12 +749,6 @@ impl Window {
     #[inline]
     pub fn set_outer_position<P: Into<Position>>(&self, position: P) {
         let position = position.into();
-        let _span = tracing::debug_span!(
-            "winit::Window::set_outer_position",
-            position = ?position
-        )
-        .entered();
-
         self.window
             .maybe_queue_on_main(move |w| w.set_outer_position(position))
     }
@@ -787,8 +767,6 @@ impl Window {
     /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
     #[inline]
     pub fn inner_size(&self) -> PhysicalSize<u32> {
-        let _span = tracing::debug_span!("winit::Window::inner_size",).entered();
-
         self.window.maybe_wait_on_main(|w| w.inner_size())
     }
 
@@ -830,11 +808,6 @@ impl Window {
     #[must_use]
     pub fn request_inner_size<S: Into<Size>>(&self, size: S) -> Option<PhysicalSize<u32>> {
         let size = size.into();
-        let _span = tracing::debug_span!(
-            "winit::Window::request_inner_size",
-            size = ?size
-        )
-        .entered();
         self.window
             .maybe_wait_on_main(|w| w.request_inner_size(size))
     }
@@ -852,7 +825,6 @@ impl Window {
     ///   [`Window::inner_size`]._
     #[inline]
     pub fn outer_size(&self) -> PhysicalSize<u32> {
-        let _span = tracing::debug_span!("winit::Window::outer_size",).entered();
         self.window.maybe_wait_on_main(|w| w.outer_size())
     }
 
@@ -876,11 +848,6 @@ impl Window {
     #[inline]
     pub fn set_min_inner_size<S: Into<Size>>(&self, min_size: Option<S>) {
         let min_size = min_size.map(|s| s.into());
-        let _span = tracing::debug_span!(
-            "winit::Window::set_min_inner_size",
-            min_size = ?min_size
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_min_inner_size(min_size))
     }
@@ -905,11 +872,6 @@ impl Window {
     #[inline]
     pub fn set_max_inner_size<S: Into<Size>>(&self, max_size: Option<S>) {
         let max_size = max_size.map(|s| s.into());
-        let _span = tracing::debug_span!(
-            "winit::Window::max_size",
-            max_size = ?max_size
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_max_inner_size(max_size))
     }
@@ -921,7 +883,6 @@ impl Window {
     /// - **iOS / Android / Web / Wayland / Windows / Orbital:** Always returns [`None`].
     #[inline]
     pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        let _span = tracing::debug_span!("winit::Window::resize_increments",).entered();
         self.window.maybe_wait_on_main(|w| w.resize_increments())
     }
 
@@ -938,11 +899,6 @@ impl Window {
     #[inline]
     pub fn set_resize_increments<S: Into<Size>>(&self, increments: Option<S>) {
         let increments = increments.map(Into::into);
-        let _span = tracing::debug_span!(
-            "winit::Window::set_resize_increments",
-            increments = ?increments
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_resize_increments(increments))
     }
@@ -957,7 +913,6 @@ impl Window {
     /// - **iOS / Android:** Unsupported.
     #[inline]
     pub fn set_title(&self, title: &str) {
-        let _span = tracing::debug_span!("winit::Window::set_title", title).entered();
         self.window.maybe_wait_on_main(|w| w.set_title(title))
     }
 
@@ -976,7 +931,6 @@ impl Window {
     /// - **X11:** Can only be set while building the window, with [`WindowAttributes::with_transparent`].
     #[inline]
     pub fn set_transparent(&self, transparent: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_transparent", transparent).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_transparent(transparent))
     }
@@ -991,7 +945,6 @@ impl Window {
     /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
     #[inline]
     pub fn set_blur(&self, blur: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_blur", blur).entered();
         self.window.maybe_queue_on_main(move |w| w.set_blur(blur))
     }
 
@@ -1005,7 +958,6 @@ impl Window {
     /// - **iOS:** Can only be called on the main thread.
     #[inline]
     pub fn set_visible(&self, visible: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_visible", visible).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_visible(visible))
     }
@@ -1020,13 +972,12 @@ impl Window {
     /// - **Wayland / iOS / Android / Web:** Unsupported.
     #[inline]
     pub fn is_visible(&self) -> Option<bool> {
-        let _span = tracing::debug_span!("winit::Window::is_visible",).entered();
         self.window.maybe_wait_on_main(|w| w.is_visible())
     }
 
     /// Sets whether the window is resizable or not.
     ///
-    /// Note that making the window un-resizable doesn't exempt you from handling [`WindowEvent::Resized`], as that
+    /// Note that making the window unresizable doesn't exempt you from handling [`WindowEvent::Resized`], as that
     /// event can still be triggered by DPI scaling, entering fullscreen mode, etc. Also, the
     /// window could still be resized by calling [`Window::request_inner_size`].
     ///
@@ -1040,7 +991,6 @@ impl Window {
     /// [`WindowEvent::Resized`]: crate::event::WindowEvent::Resized
     #[inline]
     pub fn set_resizable(&self, resizable: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_resizable", resizable).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_resizable(resizable))
     }
@@ -1053,7 +1003,6 @@ impl Window {
     /// - **iOS / Android / Web:** Unsupported.
     #[inline]
     pub fn is_resizable(&self) -> bool {
-        let _span = tracing::debug_span!("winit::Window::is_resizable",).entered();
         self.window.maybe_wait_on_main(|w| w.is_resizable())
     }
 
@@ -1064,11 +1013,6 @@ impl Window {
     /// - **Wayland / X11 / Orbital:** Not implemented.
     /// - **Web / iOS / Android:** Unsupported.
     pub fn set_enabled_buttons(&self, buttons: WindowButtons) {
-        let _span = tracing::debug_span!(
-            "winit::Window::set_enabled_buttons",
-            buttons = ?buttons
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_enabled_buttons(buttons))
     }
@@ -1080,7 +1024,6 @@ impl Window {
     /// - **Wayland / X11 / Orbital:** Not implemented. Always returns [`WindowButtons::all`].
     /// - **Web / iOS / Android:** Unsupported. Always returns [`WindowButtons::all`].
     pub fn enabled_buttons(&self) -> WindowButtons {
-        let _span = tracing::debug_span!("winit::Window::enabled_buttons",).entered();
         self.window.maybe_wait_on_main(|w| w.enabled_buttons())
     }
 
@@ -1092,7 +1035,6 @@ impl Window {
     /// - **Wayland:** Un-minimize is unsupported.
     #[inline]
     pub fn set_minimized(&self, minimized: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_minimized", minimized).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_minimized(minimized))
     }
@@ -1111,7 +1053,6 @@ impl Window {
     /// - **iOS / Android / Web / Orbital:** Unsupported.
     #[inline]
     pub fn is_minimized(&self) -> Option<bool> {
-        let _span = tracing::debug_span!("winit::Window::is_minimized",).entered();
         self.window.maybe_wait_on_main(|w| w.is_minimized())
     }
 
@@ -1122,7 +1063,6 @@ impl Window {
     /// - **iOS / Android / Web:** Unsupported.
     #[inline]
     pub fn set_maximized(&self, maximized: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_maximized", maximized).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_maximized(maximized))
     }
@@ -1134,7 +1074,6 @@ impl Window {
     /// - **iOS / Android / Web:** Unsupported.
     #[inline]
     pub fn is_maximized(&self) -> bool {
-        let _span = tracing::debug_span!("winit::Window::is_maximized",).entered();
         self.window.maybe_wait_on_main(|w| w.is_maximized())
     }
 
@@ -1163,11 +1102,6 @@ impl Window {
     /// [transient activation]: https://developer.mozilla.org/en-US/docs/Glossary/Transient_activation
     #[inline]
     pub fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
-        let _span = tracing::debug_span!(
-            "winit::Window::set_fullscreen",
-            fullscreen = ?fullscreen
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_fullscreen(fullscreen.map(|f| f.into())))
     }
@@ -1182,7 +1116,6 @@ impl Window {
     /// - **Web:** Can only return `None` or `Borderless(None)`.
     #[inline]
     pub fn fullscreen(&self) -> Option<Fullscreen> {
-        let _span = tracing::debug_span!("winit::Window::fullscreen",).entered();
         self.window
             .maybe_wait_on_main(|w| w.fullscreen().map(|f| f.into()))
     }
@@ -1198,7 +1131,6 @@ impl Window {
     /// - **iOS / Android / Web:** No effect.
     #[inline]
     pub fn set_decorations(&self, decorations: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_decorations", decorations).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_decorations(decorations))
     }
@@ -1213,7 +1145,6 @@ impl Window {
     /// - **iOS / Android / Web:** Always returns `true`.
     #[inline]
     pub fn is_decorated(&self) -> bool {
-        let _span = tracing::debug_span!("winit::Window::is_decorated",).entered();
         self.window.maybe_wait_on_main(|w| w.is_decorated())
     }
 
@@ -1223,11 +1154,6 @@ impl Window {
     ///
     /// See [`WindowLevel`] for details.
     pub fn set_window_level(&self, level: WindowLevel) {
-        let _span = tracing::debug_span!(
-            "winit::Window::set_window_level",
-            level = ?level
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_window_level(level))
     }
@@ -1248,7 +1174,6 @@ impl Window {
     ///   said, it's usually in the same ballpark as on Windows.
     #[inline]
     pub fn set_window_icon(&self, window_icon: Option<Icon>) {
-        let _span = tracing::debug_span!("winit::Window::set_window_icon",).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_window_icon(window_icon))
     }
@@ -1291,12 +1216,6 @@ impl Window {
     pub fn set_ime_cursor_area<P: Into<Position>, S: Into<Size>>(&self, position: P, size: S) {
         let position = position.into();
         let size = size.into();
-        let _span = tracing::debug_span!(
-            "winit::Window::set_ime_cursor_area",
-            position = ?position,
-            size = ?size,
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_ime_cursor_area(position, size))
     }
@@ -1323,7 +1242,6 @@ impl Window {
     /// [`KeyboardInput`]: crate::event::WindowEvent::KeyboardInput
     #[inline]
     pub fn set_ime_allowed(&self, allowed: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_ime_allowed", allowed).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_ime_allowed(allowed))
     }
@@ -1335,11 +1253,6 @@ impl Window {
     /// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported.
     #[inline]
     pub fn set_ime_purpose(&self, purpose: ImePurpose) {
-        let _span = tracing::debug_span!(
-            "winit::Window::set_ime_purpose",
-            purpose = ?purpose
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_ime_purpose(purpose))
     }
@@ -1356,7 +1269,6 @@ impl Window {
     /// - **iOS / Android / Wayland / Orbital:** Unsupported.
     #[inline]
     pub fn focus_window(&self) {
-        let _span = tracing::debug_span!("winit::Window::focus_window",).entered();
         self.window.maybe_queue_on_main(|w| w.focus_window())
     }
 
@@ -1367,7 +1279,6 @@ impl Window {
     /// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused
     #[inline]
     pub fn has_focus(&self) -> bool {
-        let _span = tracing::debug_span!("winit::Window::has_focus",).entered();
         self.window.maybe_wait_on_main(|w| w.has_focus())
     }
 
@@ -1375,7 +1286,7 @@ impl Window {
     /// is already focused. How requesting for user attention manifests is platform dependent,
     /// see [`UserAttentionType`] for details.
     ///
-    /// Providing `None` will unset the request for user attention. Un-setting the request for
+    /// Providing `None` will unset the request for user attention. Unsetting the request for
     /// user attention might not be done automatically by the WM when the window receives input.
     ///
     /// ## Platform-specific
@@ -1386,11 +1297,6 @@ impl Window {
     /// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect.
     #[inline]
     pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
-        let _span = tracing::debug_span!(
-            "winit::Window::request_user_attention",
-            request_type = ?request_type
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.request_user_attention(request_type))
     }
@@ -1406,11 +1312,6 @@ impl Window {
     /// - **iOS / Android / Web / Orbital:** Unsupported.
     #[inline]
     pub fn set_theme(&self, theme: Option<Theme>) {
-        let _span = tracing::debug_span!(
-            "winit::Window::set_theme",
-            theme = ?theme
-        )
-        .entered();
         self.window.maybe_queue_on_main(move |w| w.set_theme(theme))
     }
 
@@ -1422,7 +1323,6 @@ impl Window {
     /// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported.
     #[inline]
     pub fn theme(&self) -> Option<Theme> {
-        let _span = tracing::debug_span!("winit::Window::theme",).entered();
         self.window.maybe_wait_on_main(|w| w.theme())
     }
 
@@ -1436,8 +1336,6 @@ impl Window {
     ///
     /// [`NSWindowSharingNone`]: https://developer.apple.com/documentation/appkit/nswindowsharingtype/nswindowsharingnone
     pub fn set_content_protected(&self, protected: bool) {
-        let _span =
-            tracing::debug_span!("winit::Window::set_content_protected", protected).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_content_protected(protected))
     }
@@ -1449,7 +1347,6 @@ impl Window {
     /// - **iOS / Android / x11 / Wayland / Web:** Unsupported. Always returns an empty string.
     #[inline]
     pub fn title(&self) -> String {
-        let _span = tracing::debug_span!("winit::Window::title",).entered();
         self.window.maybe_wait_on_main(|w| w.title())
     }
 }
@@ -1466,7 +1363,6 @@ impl Window {
     #[inline]
     pub fn set_cursor(&self, cursor: impl Into<Cursor>) {
         let cursor = cursor.into();
-        let _span = tracing::debug_span!("winit::Window::set_cursor",).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_cursor(cursor))
     }
@@ -1499,11 +1395,6 @@ impl Window {
     #[inline]
     pub fn set_cursor_position<P: Into<Position>>(&self, position: P) -> Result<(), ExternalError> {
         let position = position.into();
-        let _span = tracing::debug_span!(
-            "winit::Window::set_cursor_position",
-            position = ?position
-        )
-        .entered();
         self.window
             .maybe_wait_on_main(|w| w.set_cursor_position(position))
     }
@@ -1524,11 +1415,6 @@ impl Window {
     /// ```
     #[inline]
     pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
-        let _span = tracing::debug_span!(
-            "winit::Window::set_cursor_grab",
-            mode = ?mode
-        )
-        .entered();
         self.window.maybe_wait_on_main(|w| w.set_cursor_grab(mode))
     }
 
@@ -1546,7 +1432,6 @@ impl Window {
     /// - **iOS / Android:** Unsupported.
     #[inline]
     pub fn set_cursor_visible(&self, visible: bool) {
-        let _span = tracing::debug_span!("winit::Window::set_cursor_visible", visible).entered();
         self.window
             .maybe_queue_on_main(move |w| w.set_cursor_visible(visible))
     }
@@ -1564,7 +1449,6 @@ impl Window {
     /// - **iOS / Android / Web:** Always returns an [`ExternalError::NotSupported`].
     #[inline]
     pub fn drag_window(&self) -> Result<(), ExternalError> {
-        let _span = tracing::debug_span!("winit::Window::drag_window",).entered();
         self.window.maybe_wait_on_main(|w| w.drag_window())
     }
 
@@ -1579,11 +1463,6 @@ impl Window {
     /// - **iOS / Android / Web:** Always returns an [`ExternalError::NotSupported`].
     #[inline]
     pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
-        let _span = tracing::debug_span!(
-            "winit::Window::drag_resize_window",
-            direction = ?direction
-        )
-        .entered();
         self.window
             .maybe_wait_on_main(|w| w.drag_resize_window(direction))
     }
@@ -1599,11 +1478,6 @@ impl Window {
     /// [window menu]: https://en.wikipedia.org/wiki/Common_menus_in_Microsoft_Windows#System_menu
     pub fn show_window_menu(&self, position: impl Into<Position>) {
         let position = position.into();
-        let _span = tracing::debug_span!(
-            "winit::Window::show_window_menu",
-            position = ?position
-        )
-        .entered();
         self.window
             .maybe_queue_on_main(move |w| w.show_window_menu(position))
     }
@@ -1618,7 +1492,6 @@ impl Window {
     /// - **iOS / Android / Web / Orbital:** Always returns an [`ExternalError::NotSupported`].
     #[inline]
     pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
-        let _span = tracing::debug_span!("winit::Window::set_cursor_hittest", hittest).entered();
         self.window
             .maybe_wait_on_main(|w| w.set_cursor_hittest(hittest))
     }
@@ -1631,7 +1504,6 @@ impl Window {
     /// Returns `None` if current monitor can't be detected.
     #[inline]
     pub fn current_monitor(&self) -> Option<MonitorHandle> {
-        let _span = tracing::debug_span!("winit::Window::current_monitor",).entered();
         self.window
             .maybe_wait_on_main(|w| w.current_monitor().map(|inner| MonitorHandle { inner }))
     }
@@ -1643,7 +1515,6 @@ impl Window {
     /// [`ActiveEventLoop::available_monitors`]: crate::event_loop::ActiveEventLoop::available_monitors
     #[inline]
     pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
-        let _span = tracing::debug_span!("winit::Window::available_monitors",).entered();
         self.window.maybe_wait_on_main(|w| {
             w.available_monitors()
                 .into_iter()
@@ -1664,7 +1535,6 @@ impl Window {
     /// [`ActiveEventLoop::primary_monitor`]: crate::event_loop::ActiveEventLoop::primary_monitor
     #[inline]
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        let _span = tracing::debug_span!("winit::Window::primary_monitor",).entered();
         self.window
             .maybe_wait_on_main(|w| w.primary_monitor().map(|inner| MonitorHandle { inner }))
     }