chore: Add words from markdown files

Signed-off-by: John Nunley <dev@notgull.net>
chore: Fix remaining typos in Rust file
2026-06-26 22:53:15 -04:00 · 2024-03-02 22:30:34 -08:00 · 2024-03-02 22:27:45 -08:00 · 2024-03-02 09:40:20 -08:00 · 2024-03-02 09:38:54 -08:00 · 2024-03-02 13:22:36 +01:00
54 changed files with 934 additions and 316 deletions
--- a/.cspell.json
+++ b/.cspell.json
@@ -0,0 +1,13 @@
+{
+    "$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"]
+  }
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,7 +7,7 @@ on:

 jobs:
  fmt:
-    name: Check formatting
+    name: Tidy Code
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
@@ -16,10 +16,13 @@ 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
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -48,6 +48,10 @@ Unreleased` header.
 - 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.
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,169 +1,57 @@
-# Contribution Guidelines
+# Winit Contributing Guidelines

-This document contains guidelines for contributing code to winit. It has to be
-followed in order for your patch to be approved and applied.
+## Scope
+[See `FEATURES.md`](./FEATURES.md). When requesting or implementing a new Winit feature, you should
+consider whether or not it's directly related to window creation or input handling. If it isn't, it
+may be worth creating a separate crate that extends Winit's API to add that functionality.

-## Contributing

-Anyone can contribute to winit, however given that it's a cross platform
-windowing toolkit getting certain changes incorporated upstream could be
-challenging.
+## Reporting an issue

-To save your time it's wise to check already opened [pull requests][prs] and
-[issues][issues]. In general, bug fixes and missing implementations are always
-accepted, however new API proposals should go into the issue first. When in
-doubt contact us on [matrix][matrix] or via opening an issue.
+When reporting an issue, in order to help the maintainers understand what the problem is, please make
+your description of the issue as detailed as possible:

-### Submitting your work and handling review
+- if it is a bug, please provide a clear explanation of what happens, what should happen, and how to
+  reproduce the issue, ideally by providing a minimal program exhibiting the problem
+- if it is a feature request, please provide a clear argumentation about why you believe this feature
+  should be supported by winit

-All patches have to be sent on Github as [pull requests][prs]. To simplify your
-life during review it's recommended to check the "give contributors write access
-to the branch" checkbox.
+## Making a pull request

-#### Creating commits
+When making a code contribution to winit, before opening your pull request, please make sure that:

-When creating a commit, follow these general rules:
-  - Try to limit the first line (title) of the commit message to 50 characters,
-    but not more than 60 characters.
-  - The commit starts with an uppercase latter and everything else must be
-    lowercase, unless you quote a symbol, like `Window`.
-  - Use the body of the commit message to actually explain what your patch does
-    and why it is useful. Even if your patch is a one line fix, the description
-    is not limited in length and may span over multiple paragraphs. Use proper
-    English syntax, grammar and punctuation. The body is generally wrapped
-    at 72 characters.
-  - If you're a downstream user and your fixing your issue, consider to link it
-    like `Links: URL` in the end of the commit message.
-  - Try to address only one issue/topic per commit.
-  - Prefer describing your changes in imperative mood, e.g. *"make xyzzy do
-    frotz"* instead of *"[This patch] makes xyzzy do frotz"* or *"[I] changed
-    xyzzy to do frotz"*, as if you are giving orders to the codebase to change
-    its behaviour.
-  - When fixing an issue from https://github.com/rust-windowing/winit/issues,
-    ensure to have it include in the end of the commit. See other commits
-    on how it's done.
-  - When in doubt, follow the format and layout of the recent existing commits.
+- your patch builds with Winit's minimal supported rust version - Rust 1.70.
+- you tested your modifications on all the platforms impacted, or if not possible, detail which platforms
+  were not tested, and what should be tested, so that a maintainer or another contributor can test them
+- you updated any relevant documentation in winit
+- you left comments in your code explaining any part that is not straightforward, so that the
+  maintainers and future contributors don't have to try to guess what your code is supposed to do
+- your PR adds an entry to the changelog file if the introduced change is relevant to winit users.

-The maintainers will fixup your commit message when applying the patch, but it's
-still recommended to follow the rules above to make the life of maintainers
-easier.
+  You needn't worry about the added entry causing conflicts, the maintainer that merges the PR will
+  handle those for you when merging (see below).
+- if your PR affects the platform compatibility of one or more features or adds another feature, the
+  relevant sections in [`FEATURES.md`](https://github.com/rust-windowing/winit/blob/master/FEATURES.md#features)
+  should be updated.

-If you want to communicate something to reviewers, but it doesn't belong to
-the commit message, write that under `--` on PR body. Your PR could look like:
+Once your PR is open, you can ask for a review by a maintainer of your platform. Winit's merging policy
+is that a PR must be approved by at least two maintainers of winit before being merged, including
+at least a maintainer of the platform (a maintainer making a PR themselves counts as approving it).

-  ```
-  TITLE (matches commit title)
-
-  Body (matches commit body)
-
-  --
-
-  Your arbitrary message goes here.
-
-  Various checkboxes PR template required you to fill.
-  ```
-
-#### Handling review
-
-During the review process certain events could require an action from your side,
-to communication more efficient the common patterns and reactions are described
-below.
-
-_Event:_ The CI fails to build, but it looks like not your fault. Not
-communicating so, could result into maintainers not looking into your patch,
-unless they CI that CI pass.\
-_Desired behavior:_ Write a message saying roughly the following "The CI failure
-is unrelated", so maintainers will fix it for you.
-
-_Event:_ Collaborator requested review on your PR.\
-_Desired behavior:_ Once you address the request, you _should_ re-request review
-with the github's UI. If you don't agree with what maintainer suggested, you
-should object that and re-request the review. That will indicate that the
-_ball_ is on maintainer's side.
-
-_Event:_ You've opened a PR, but maintainer shortly after commented that they
-want to work on that _themselves_.\
-_Desired behavior:_ Discusses with maintainer their plans if they were not
-outlined in the initial response, because such response means that they
-are not interested in reviewing your code. Such thing could happen when
-underestimating complexity of the task you're solving or when your patch
-mandate certain downstream designs.
-
-[prs]: https://github.com/rust-windowing/winit/pulls
-[issues]: https://github.com/rust-windowing/winit/issues
-[matrix]: https://matrix.to/#/#rust-windowing:matrix.org
+Once your PR is deemed ready, the merging maintainer will take care of resolving conflicts in
+`CHANGELOG.md` (but you must resolve other conflicts yourself). Doing this requires that you check the
+"give contributors write access to the branch" checkbox when creating the PR.

 ## Maintainers

-Winit has plenty of maintainers with different backgrounds, experience level,
-and reasons to be winit maintainer in the first place. To ensure that winit's
-code quality is not decreasing over time and to make it easier to teach new
-maintainers the _winit way of doing things_ the common policies and routines
-are defined in this section.
+The current maintainers for each platform are listed in the [CODEOWNERS](.github/CODEOWNERS) file.

-The current maintainers for each platform are listed in [this file][CODEOWNERS].
-
-### Contributions handling
-
-The maintainer must ensure that the external contributions meet the winit's
-quality standards. If it's not, it **is maintainer's responsibility** to bring
-it on par, which includes:
-
-  - Decline the patch if it tries to achieve short term goals instead of solving
-    the problem in general. In such case maintainer must communicate that **as
-    early as possible**, so contributors don't spend their time on something
-    that won't be accepted in the end.
-  - Ensure that formatting is consistent and `CHANGELOG` messages are clear
-    for the end users.
-  - Improve the commit message, so it'll be easier for other maintainers to
-    understand the motivation without going through all the discussions on the
-    particular patch/PR.
-  - Ensure that the proposed patch doesn't break platform parity. If the
-    breakage is desired by contributor, an issue should be opened to discuss
-    with other maintainers before merging.
-  - Always fix CI issues before merging if they don't originate from the
-    submitted work.
-
-However, maintainer must always give a leeway for external contributors, so they
-don't feel discouraged contributing, for example:
-
-  - Suggest a patch to resolve style issues, if it's the only issue with the
-    submitted work. Keep in mind that pushing the resolution yourself is not
-    desired, because contributor might not agree with what you did.
-  - Be more explicit on how things should be done if you doesn't like the
-    approach.
-  - Suggest to finish PR for them if they're absent for a while and you need the
-    proposed changes to move forward with something. In such case maintainer
-    must preserve attribution with `Co-authored-by`, `Suggested-by`, or keep
-    the original commiter.
-  - Rebase their work for them when massive changes to winit codebase were
-    introduced.
-
-When reviewing code of other maintainers all of the above is on the maintainer
-who submitted the patch. Interested maintainers could help push the work over
-the finish line, but teaching other maintainers should be preferred.
-
-When contributor is _regular_ in winit, the maintainer should slowly start
-requiring contributor to match *maintainer* quality standards when writing
-patches and commit messages.
-
-### Contributing
-
-When submitting a patch maintainer should follow the general contributing
-guidelines, however all soft rules (e.g `Try to`), become strict.
-
-To make life simpler for other maintainers it's suggested to create your branch
-under the project repository instead of your own fork. The naming scheme is
-`github_user_name/branch_name`. Doing so will make your work easier to rebase
-for other maintainers when you're absent.
-
-### Release process
+## Release process

 Given that winit is a widely used library, we should be able to make a patch
 releases at any time we want without blocking the development of new features.

-To achieve these goals, a new branch is created for every new release. Releases
-and later patch releases are committed and tagged in this branch.
+To achieve these goals, a new branch is created for every new release. Releases and later patch releases are committed and tagged in this branch.

 The exact steps for an exemplary `0.2.0` release might look like this:
  1. Initially, the version on the latest master is `0.1.0`
@@ -179,5 +67,3 @@ When doing a patch release, the process is similar:
  2. Checkout the `v0.2.x` branch
  3. Cherry-pick the required non-breaking changes into the `v0.2.x`
  4. Follow steps 3-7 of the regular release example
-
-[CODEOWNERS]: .github/CODEOWNERS
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.12"
+version = "0.29.13"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 keywords = ["windowing"]
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@

 ```toml
 [dependencies]
-winit = "0.29.12"
+winit = "0.29.13"
 ```

 ## [Documentation](https://docs.rs/winit)
--- a/examples/window.rs
+++ b/examples/window.rs
@@ -244,9 +244,9 @@ impl Application {
            }
            WindowEvent::Focused(focused) => {
                if focused {
-                    println!("Window={window_id:?} fosused");
+                    println!("Window={window_id:?} focused");
                } else {
-                    println!("Window={window_id:?} unfosused");
+                    println!("Window={window_id:?} unfocused");
                }
            }
            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
@@ -333,7 +333,7 @@ impl Application {
                    println!("Preedit: {}, with caret at {:?}", text, caret_pos);
                }
                Ime::Commit(text) => {
-                    println!("Commited: {}", text);
+                    println!("Committed: {}", text);
                }
                Ime::Disabled => println!("IME disabled for Window={window_id:?}"),
            },
--- a/project-words.txt
+++ b/project-words.txt
@@ -0,0 +1,707 @@
+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
--- a/src/event.rs
+++ b/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,
-    /// minimised, set invisible, or fully occluded by another window.
+    /// minimized, set invisible, or fully occluded by another window.
    ///
    /// ## Platform-specific
    ///
@@ -784,7 +784,7 @@ pub struct KeyEvent {
    ///
    /// # Example
    ///
-    /// In games, you often want to ignore repated key events - this can be
+    /// In games, you often want to ignore repeated key events - this can be
    /// done by ignoring events where this property is set.
    ///
    /// ```
--- a/src/event_loop.rs
+++ b/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 initialisation.
+    /// Calling this function will result in display backend initialization.
    ///
    /// ## Panics
    ///
--- a/src/keyboard.rs
+++ b/src/keyboard.rs
@@ -1229,7 +1229,7 @@ pub enum NamedKey {
    Dimmer,
    /// Swap video sources. (`VK_DISPLAY_SWAP`)
    DisplaySwap,
-    /// Select Digital Video Rrecorder. (`KEYCODE_DVR`)
+    /// Select Digital Video Recorder. (`KEYCODE_DVR`)
    DVR,
    /// Exit the current application. (`VK_EXIT`)
    Exit,
--- a/src/platform/android.rs
+++ b/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][agdk_jetpack] (or link with an embedded [release][agdk_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][android_jet] (or link with an embedded [release][android_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
-//! [agdk_jetpack]: https://developer.android.com/jetpack/androidx/releases/games
-//! [agdk_releases]: https://developer.android.com/games/agdk/download#agdk-libraries
+//! [android_jet]: https://developer.android.com/jetpack/androidx/releases/games
+//! [android_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.12", features = [ "android-native-activity" ] }`
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.13", 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).

--- a/src/platform/run_on_demand.rs
+++ b/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 re-entrantly; this must fail.
+///     // Attempt to run the event loop in a re-entrant manner; this must fail.
 ///     event_loop.run_on_demand(|_, _| {});
 /// });
 /// ```
--- a/src/platform/scancode.rs
+++ b/src/platform/scancode.rs
@@ -29,11 +29,11 @@ pub trait PhysicalKeyExtScancode {

 impl PhysicalKeyExtScancode for PhysicalKey {
    fn to_scancode(self) -> Option<u32> {
-        crate::platform_impl::physicalkey_to_scancode(self)
+        crate::platform_impl::physical_key_to_scancode(self)
    }

    fn from_scancode(scancode: u32) -> PhysicalKey {
-        crate::platform_impl::scancode_to_physicalkey(scancode)
+        crate::platform_impl::scancode_to_physical_key(scancode)
    }
 }

--- a/src/platform/startup_notify.rs
+++ b/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 requered to click on the window.
+//! be required 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`].
--- a/src/platform/web.rs
+++ b/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 animtion"),
+            Self::Animation => write!(f, "A supplied cursor is an animation"),
        }
    }
 }
--- a/src/platform/windows.rs
+++ b/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 accels: Vec<ACCEL> = Vec::new();
+    /// #   let accelerators: Vec<ACCEL> = Vec::new();
    ///     let translated = unsafe {
    ///         TranslateAcceleratorW(
    ///             (*msg).hwnd,
-    ///             CreateAcceleratorTableW(accels.as_ptr() as _, 1),
+    ///             CreateAcceleratorTableW(accelerators.as_ptr() as _, 1),
    ///             msg,
    ///         ) == 1
    ///     };
--- a/src/platform/x11.rs
+++ b/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 proxying
+    /// screen, allowing the desktop environment to have full control of the desktop, without the need for proxy-ing
    /// 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,
-    /// Pinnable menu windows. "Torn off" from the main application.
+    /// Pin-able menu windows. "Torn off" from the main application.
    Menu,
    /// A small persistent utility window, such as a palette or toolbox.
    Utility,
--- a/src/platform_impl/android/mod.rs
+++ b/src/platform_impl/android/mod.rs
@@ -211,7 +211,7 @@ impl<T: 'static> EventLoop<T> {
    where
        F: FnMut(event::Event<T>, &RootAEL),
    {
-        trace!("Mainloop iteration");
+        trace!("Main loop iteration");

        let cause = self.cause;
        let mut pending_redraw = self.pending_redraw;
--- a/src/platform_impl/linux/common/xkb/keymap.rs
+++ b/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_physicalkey(keycode.saturating_sub(8))
+    scancode_to_physical_key(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_physicalkey(scancode: u32) -> PhysicalKey {
+pub fn scancode_to_physical_key(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_physicalkey(scancode: u32) -> PhysicalKey {
    })
 }

-pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
+pub fn physical_key_to_scancode(key: PhysicalKey) -> Option<u32> {
    let code = match key {
        PhysicalKey::Code(code) => code,
        PhysicalKey::Unidentified(code) => {
--- a/src/platform_impl/linux/common/xkb/mod.rs
+++ b/src/platform_impl/linux/common/xkb/mod.rs
@@ -29,7 +29,7 @@ use keymap::XkbKeymap;

 #[cfg(x11_platform)]
 pub use keymap::raw_keycode_to_physicalkey;
-pub use keymap::{physicalkey_to_scancode, scancode_to_physicalkey};
+pub use keymap::{physical_key_to_scancode, scancode_to_physical_key};
 pub use state::XkbState;

 // TODO: Wire this up without using a static `AtomicBool`.
--- a/src/platform_impl/linux/mod.rs
+++ b/src/platform_impl/linux/mod.rs
@@ -34,7 +34,7 @@ use crate::{
    },
 };

-pub(crate) use self::common::xkb::{physicalkey_to_scancode, scancode_to_physicalkey};
+pub(crate) use self::common::xkb::{physical_key_to_scancode, scancode_to_physical_key};
 pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
--- a/src/platform_impl/linux/wayland/seat/keyboard/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/keyboard/mod.rs
@@ -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 whethere it was for the present
+                // NOTE: we should drop the repeat regardless whether 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;
--- a/src/platform_impl/linux/wayland/seat/pointer/mod.rs
+++ b/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 descrite values if they are present.
+                    // the discrete values if they are present.
                    let delta = if has_discrete_scroll {
                        // XXX Wayland sign convention is the inverse of winit.
                        MouseScrollDelta::LineDelta(
--- a/src/platform_impl/linux/x11/event_processor.rs
+++ b/src/platform_impl/linux/x11/event_processor.rs
@@ -981,13 +981,13 @@ impl EventProcessor {

        // Always update the modifiers when we're not replaying.
        if !replay {
-            self.udpate_mods_from_core_event(window_id, xev.state as u16, &mut callback);
+            self.update_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_synthic_modifier_from_core(window_id, xev.state as u16, &mut callback);
+                self.send_synthetic_modifier_from_core(window_id, xev.state as u16, &mut callback);
            }

            if let Some(mut key_processor) = self.xkb_context.key_context() {
@@ -1037,7 +1037,7 @@ impl EventProcessor {
        }
    }

-    fn send_synthic_modifier_from_core<T: 'static, F>(
+    fn send_synthetic_modifier_from_core<T: 'static, F>(
        &mut self,
        window_id: crate::window::WindowId,
        state: u16,
@@ -1778,7 +1778,7 @@ impl EventProcessor {
        self.send_modifiers(window_id, mods.into(), true, &mut callback)
    }

-    pub fn udpate_mods_from_core_event<T: 'static, F>(
+    pub fn update_mods_from_core_event<T: 'static, F>(
        &mut self,
        window_id: crate::window::WindowId,
        state: u16,
--- a/src/platform_impl/linux/x11/ime/callbacks.rs
+++ b/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 unsupplied.
+    // This field is un-supplied.
    _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 unsupplied.
+    // This field is un-supplied.
    _call_data: ffi::XPointer,
 ) {
    let inner: *mut ImeInner = client_data as _;
--- a/src/platform_impl/linux/x11/ime/context.rs
+++ b/src/platform_impl/linux/x11/ime/context.rs
@@ -87,7 +87,7 @@ extern "C" fn preedit_draw_callback(
        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!(
-            "invalid chg range: buffer length={}, but chg_first={} chg_lengthg={}",
+            "invalid chg range: buffer length={}, but chg_first={} chg_length={}",
            client_data.text.len(),
            call_data.chg_first,
            call_data.chg_length
--- a/src/platform_impl/linux/x11/ime/input_method.rs
+++ b/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 availabile XIM servers. For instance, if you're using ibus, it would contain an atom named
+// the available 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
--- a/src/platform_impl/linux/x11/util/geometry.rs
+++ b/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 reparenting WMs, thus the window
+    // Note that the overwhelming majority of window managers are re-parenting 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
--- a/src/platform_impl/linux/x11/util/mod.rs
+++ b/src/platform_impl/linux/x11/util/mod.rs
@@ -48,7 +48,7 @@ where
 }

 impl XConnection {
-    // This is impoartant, so pay attention!
+    // This is important, 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"
--- a/src/platform_impl/linux/x11/util/wm.rs
+++ b/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
-        // inavailability of time machines, we'll just try to get _NET_SUPPORTING_WM_CHECK
+        // unavailability 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
--- a/src/platform_impl/linux/x11/util/xmodmap.rs
+++ b/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
-    modifers: HashSet<XKeyCode>,
+    modifiers: HashSet<XKeyCode>,
 }

 impl ModifierKeymap {
@@ -25,7 +25,7 @@ impl ModifierKeymap {
    }

    pub fn is_modifier(&self, keycode: XKeyCode) -> bool {
-        self.modifers.contains(&keycode)
+        self.modifiers.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.modifers.clear();
+        self.modifiers.clear();
        for key in keys {
-            self.modifers.insert(*key);
+            self.modifiers.insert(*key);
        }
    }
 }
--- a/src/platform_impl/linux/x11/window.rs
+++ b/src/platform_impl/linux/x11/window.rs
@@ -391,7 +391,7 @@ impl UnownedWindow {
        }

        {
-            // Enable drag and drop (TODO: extend API to make this toggleable)
+            // Enable drag and drop (TODO: extend API to make this toggle-able)
            {
                let dnd_aware_atom = atoms[XdndAware];
                let version = &[5u32]; // Latest version; hasn't changed since 2002
@@ -1038,9 +1038,10 @@ impl UnownedWindow {
        let vert_atom = atoms[_NET_WM_STATE_MAXIMIZED_VERT];
        match state {
            Ok(atoms) => {
-                let horz_maximized = atoms.iter().any(|atom: &xproto::Atom| *atom == horz_atom);
+                let horizontal_maximized =
+                    atoms.iter().any(|atom: &xproto::Atom| *atom == horz_atom);
                let vert_maximized = atoms.iter().any(|atom: &xproto::Atom| *atom == vert_atom);
-                horz_maximized && vert_maximized
+                horizontal_maximized && vert_maximized
            }
            _ => false,
        }
@@ -1048,10 +1049,10 @@ impl UnownedWindow {

    fn set_maximized_inner(&self, maximized: bool) -> Result<VoidCookie<'_>, X11Error> {
        let atoms = self.xconn.atoms();
-        let horz_atom = atoms[_NET_WM_STATE_MAXIMIZED_HORZ];
+        let horizontal_atom = atoms[_NET_WM_STATE_MAXIMIZED_HORZ];
        let vert_atom = atoms[_NET_WM_STATE_MAXIMIZED_VERT];

-        self.set_netwm(maximized.into(), (horz_atom, vert_atom, 0, 0))
+        self.set_netwm(maximized.into(), (horizontal_atom, vert_atom, 0, 0))
    }

    #[inline]
--- a/src/platform_impl/linux/x11/xdisplay.rs
+++ b/src/platform_impl/linux/x11/xdisplay.rs
@@ -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 accomodate for a changed window here.
+        // in order to accommodate for a changed window here.
        let selector_window = xcb
            .get_selection_owner(xsettings_screen)
            .ok()?
--- a/src/platform_impl/macos/event.rs
+++ b/src/platform_impl/macos/event.rs
@@ -113,7 +113,8 @@ pub(crate) fn create_key_event(
    let state = if is_press { Pressed } else { Released };

    let scancode = unsafe { ns_event.keyCode() };
-    let mut physical_key = key_override.unwrap_or_else(|| scancode_to_physicalkey(scancode as u32));
+    let mut physical_key =
+        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:
@@ -150,7 +151,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 Germay layout- one
+            // include its effect in the key. For example if -on the Germany 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.
@@ -415,7 +416,7 @@ pub(super) fn dummy_event() -> Option<Id<NSEvent>> {
    }
 }

-pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
+pub(crate) fn physical_key_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
    let code = match physical_key {
        PhysicalKey::Code(code) => code,
        PhysicalKey::Unidentified(_) => return None,
@@ -537,7 +538,7 @@ pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32>
    }
 }

-pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
+pub(crate) fn scancode_to_physical_key(scancode: u32) -> PhysicalKey {
    PhysicalKey::Code(match scancode {
        0x00 => KeyCode::KeyA,
        0x01 => KeyCode::KeyS,
--- a/src/platform_impl/macos/event_loop.rs
+++ b/src/platform_impl/macos/event_loop.rs
@@ -60,7 +60,7 @@ impl PanicInfo {
        self.inner.set(inner);
        result
    }
-    /// Overwrites the curret state if the current state is not panicking
+    /// Overwrites the current 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));
--- a/src/platform_impl/macos/mod.rs
+++ b/src/platform_impl/macos/mod.rs
@@ -18,7 +18,7 @@ mod window_delegate;
 use std::fmt;

 pub(crate) use self::{
-    event::{physicalkey_to_scancode, scancode_to_physicalkey, KeyEventExtra},
+    event::{physical_key_to_scancode, scancode_to_physical_key, KeyEventExtra},
    event_loop::{
        ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
        PlatformSpecificEventLoopAttributes,
--- a/src/platform_impl/macos/view.rs
+++ b/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_physicalkey,
+    scancode_to_physical_key,
 };
 use super::window::WinitWindow;
 use super::{util, DEVICE_ID};
@@ -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_physicalkey(scancode as u32);
+                let physical_key = scancode_to_physical_key(scancode as u32);

                // We'll correct the `is_press` later.
                let mut event = create_key_event(ns_event, false, false, Some(physical_key));
--- a/src/platform_impl/macos/window_delegate.rs
+++ b/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-backedness of a view breaks the association between
+        // a window. Changing the layer-backed-ness 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 resizability of the window (which is
+        // since that mask also affect the resize ability 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));
--- a/src/platform_impl/web/keyboard.rs
+++ b/src/platform_impl/web/keyboard.rs
@@ -321,8 +321,8 @@ impl Key {
 }

 impl PhysicalKey {
-    pub fn from_key_code_attribute_value(kcav: &str) -> Self {
-        PhysicalKey::Code(match kcav {
+    pub fn from_key_code_attribute_value(k_code: &str) -> Self {
+        PhysicalKey::Code(match k_code {
            "Backquote" => KeyCode::Backquote,
            "Backslash" => KeyCode::Backslash,
            "BracketLeft" => KeyCode::BracketLeft,
--- a/src/platform_impl/web/web_sys/schedule.rs
+++ b/src/platform_impl/web/web_sys/schedule.rs
@@ -117,9 +117,7 @@ impl Schedule {
        let channel = MessageChannel::new().unwrap();
        let closure = Closure::new(f);
        let port_1 = channel.port1();
-        port_1
-            .add_event_listener_with_callback("message", closure.as_ref().unchecked_ref())
-            .expect("Failed to set message handler");
+        port_1.set_onmessage(Some(closure.as_ref().unchecked_ref()));
        port_1.start();

        let port_2 = channel.port2();
@@ -178,6 +176,7 @@ impl Drop for Schedule {
            } => {
                window.clear_timeout_with_handle(*handle);
                port.close();
+                port.set_onmessage(None);
            }
        }
    }
--- a/src/platform_impl/windows/dark_mode.rs
+++ b/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 bigbool (i32), not bool.
-            let mut is_dark_mode_bigbool = BOOL::from(is_dark_mode);
+            // SetWindowCompositionAttribute needs a big_bool (i32), not bool.
+            let mut is_dark_mode_big_bool = BOOL::from(is_dark_mode);

            let mut data = WINDOWCOMPOSITIONATTRIBDATA {
                Attrib: WCA_USEDARKMODECOLORS,
-                pvData: &mut is_dark_mode_bigbool as *mut _ as _,
-                cbData: std::mem::size_of_val(&is_dark_mode_bigbool) as _,
+                pvData: &mut is_dark_mode_big_bool as *mut _ as _,
+                cbData: std::mem::size_of_val(&is_dark_mode_big_bool) as _,
            };

            let status = set_window_composition_attribute(hwnd, &mut data);
--- a/src/platform_impl/windows/definitions.rs
+++ b/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,
-        riid: *const GUID,
+        r_iid: *const GUID,
        ppvObject: *mut *mut c_void,
    ) -> HRESULT,
    pub AddRef: unsafe extern "system" fn(This: *mut IUnknown) -> u32,
@@ -29,43 +29,45 @@ pub struct IDataObjectVtbl {
    pub parent: IUnknownVtbl,
    pub GetData: unsafe extern "system" fn(
        This: *mut IDataObject,
-        pformatetcIn: *const FORMATETC,
-        pmedium: *mut STGMEDIUM,
+        p_format_etc_In: *const FORMATETC,
+        p_medium: *mut STGMEDIUM,
    ) -> HRESULT,
    pub GetDataHere: unsafe extern "system" fn(
        This: *mut IDataObject,
-        pformatetc: *const FORMATETC,
-        pmedium: *mut STGMEDIUM,
+        p_format_etc: *const FORMATETC,
+        p_medium: *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,
-        pformatetcIn: *const FORMATETC,
-        pformatetcOut: *mut FORMATETC,
+        p_format_etc_In: *const FORMATETC,
+        p_format_etc_Out: *mut FORMATETC,
    ) -> HRESULT,
    pub SetData: unsafe extern "system" fn(
        This: *mut IDataObject,
-        pformatetc: *const FORMATETC,
-        pformatetcOut: *const FORMATETC,
+        p_format_etc: *const FORMATETC,
+        p_format_etcOut: *const FORMATETC,
        fRelease: BOOL,
    ) -> HRESULT,
    pub EnumFormatEtc: unsafe extern "system" fn(
        This: *mut IDataObject,
        dwDirection: u32,
-        ppenumFormatEtc: *mut *mut IEnumFORMATETC,
+        pp_enumFormatEtc: *mut *mut IEnumFORMATETC,
    ) -> HRESULT,
    pub DAdvise: unsafe extern "system" fn(
        This: *mut IDataObject,
-        pformatetc: *const FORMATETC,
-        advf: u32,
+        p_format_etc: *const FORMATETC,
+        a_dvf: 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,
-        ppenumAdvise: *const *const IEnumSTATDATA,
+        pp_enumAdvise: *const *const IEnumSTATDATA,
    ) -> HRESULT,
 }

--- a/src/platform_impl/windows/event_loop.rs
+++ b/src/platform_impl/windows/event_loop.rs
@@ -1021,10 +1021,10 @@ pub(super) unsafe extern "system" fn public_window_callback(

    let userdata_ptr = match (userdata, msg) {
        (0, WM_NCCREATE) => {
-            let createstruct = unsafe { &mut *(lparam as *mut CREATESTRUCTW) };
-            let initdata = unsafe { &mut *(createstruct.lpCreateParams as *mut InitData<'_>) };
+            let create_struct = unsafe { &mut *(lparam as *mut CREATESTRUCTW) };
+            let init_data = unsafe { &mut *(create_struct.lpCreateParams as *mut InitData<'_>) };

-            let result = match unsafe { initdata.on_nccreate(window) } {
+            let result = match unsafe { init_data.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 createstruct = &mut *(lparam as *mut CREATESTRUCTW);
-            let initdata = createstruct.lpCreateParams;
-            let initdata = &mut *(initdata as *mut InitData<'_>);
+            let create_struct = &mut *(lparam as *mut CREATESTRUCTW);
+            let init_data = create_struct.lpCreateParams;
+            let init_data = &mut *(init_data as *mut InitData<'_>);

-            initdata.on_create();
+            init_data.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 janky resize behavior, where the compositor is
+                // Unfortunately this results in inconsistent 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 windowpos = lparam as *const WINDOWPOS;
-            if unsafe { (*windowpos).flags & SWP_NOMOVE != SWP_NOMOVE } {
+            let window_pos = lparam as *const WINDOWPOS;
+            if unsafe { (*window_pos).flags & SWP_NOMOVE != SWP_NOMOVE } {
                let physical_position =
-                    unsafe { PhysicalPosition::new((*windowpos).x, (*windowpos).y) };
+                    unsafe { PhysicalPosition::new((*window_pos).x, (*window_pos).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 pcount = super::loword(wparam as u32) as usize;
-            let mut inputs = Vec::with_capacity(pcount);
-            let htouch = lparam;
+            let p_count = super::loword(wparam as u32) as usize;
+            let mut inputs = Vec::with_capacity(p_count);
+            let h_touch = lparam;
            if unsafe {
                GetTouchInputInfo(
-                    htouch,
-                    pcount as u32,
+                    h_touch,
+                    p_count as u32,
                    inputs.as_mut_ptr(),
                    mem::size_of::<TOUCHINPUT>() as i32,
                ) > 0
            } {
-                unsafe { inputs.set_len(pcount) };
+                unsafe { inputs.set_len(p_count) };
                for input in &inputs {
                    let mut location = POINT {
                        x: input.x / 100,
@@ -1862,7 +1862,7 @@ unsafe fn public_window_callback_inner(
                    });
                }
            }
-            unsafe { CloseTouchInputHandle(htouch) };
+            unsafe { CloseTouchInputHandle(h_touch) };
            result = ProcResult::Value(0);
        }

@@ -2557,7 +2557,7 @@ unsafe fn handle_raw_input(userdata: &ThreadMsgTargetData, data: RAWINPUT) {
 }

 enum PointerMoveKind {
-    /// Pointer enterd to the window.
+    /// Pointer entered to the window.
    Enter,
    /// Pointer leaved the window client area.
    Leave,
--- a/src/platform_impl/windows/event_loop/runner.rs
+++ b/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_innner_size = Arc::new(Mutex::new(new_inner_size));
+                let user_new_inner_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_innner_size,
+                            &user_new_inner_size,
                        )),
                    },
                });
-                let inner_size = *user_new_innner_size.lock().unwrap();
+                let inner_size = *user_new_inner_size.lock().unwrap();

-                drop(user_new_innner_size);
+                drop(user_new_inner_size);

                if inner_size != new_inner_size {
                    let window_flags = unsafe {
--- a/src/platform_impl/windows/ime.rs
+++ b/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_targetted =
+            let char_is_targeted =
                attr as u32 == ATTR_TARGET_CONVERTED || attr as u32 == ATTR_TARGET_NOTCONVERTED;

-            if first.is_none() && char_is_targetted {
+            if first.is_none() && char_is_targeted {
                first = Some(boundary_before_char);
-            } else if first.is_some() && last.is_none() && !char_is_targetted {
+            } else if first.is_some() && last.is_none() && !char_is_targeted {
                last = Some(boundary_before_char);
            }

--- a/src/platform_impl/windows/keyboard.rs
+++ b/src/platform_impl/windows/keyboard.rs
@@ -42,7 +42,7 @@ use crate::{
    platform_impl::platform::{
        event_loop::ProcResult,
        keyboard_layout::{Layout, LayoutCache, WindowsModifiers, LAYOUT_CACHE},
-        loword, primarylangid, KeyEventExtra,
+        loword, primary_lang_id, KeyEventExtra,
    },
 };

@@ -106,13 +106,13 @@ impl KeyEventBuilder {
        let mut matcher = || -> MatchResult {
            match msg_kind {
                WM_SETFOCUS => {
-                    // synthesize keydown events
+                    // synthesize key down events
                    let kbd_state = get_async_kbd_state();
                    let key_events = Self::synthesize_kbd_state(ElementState::Pressed, &kbd_state);
                    MatchResult::MessagesToDispatch(self.pending.complete_multi(key_events))
                }
                WM_KILLFOCUS => {
-                    // sythesize keyup events
+                    // synthesize 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 keyobard event
+                        // need to appended to this keyboard event
                        MatchResult::TokenToRemove(pending_token)
                    } else {
                        let mut event_info = self.event_info.lock().unwrap();
@@ -328,7 +328,7 @@ impl KeyEventBuilder {
        }
    }

-    // Allowing nominimal_bool lint because the `is_key_pressed` macro triggers this warning
+    // Allowing nonminimal_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_physicalkey(scancode as u32);
+        let physical_key = scancode_to_physical_key(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-precieved characters) that means that
+    /// the text consists of multiple grapheme clusters (user-perceived 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_physicalkey(scancode as u32);
+        let physical_key = scancode_to_physical_key(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
-                // reguar US layout treats it a character. In order for a single binding
+                // regular 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(curr_info: &PartialKeyEventInfo, next_msg: MSG, layout: &Layout) -> bool {
-    let curr_is_ctrl = matches!(
-        curr_info.logical_key,
+fn is_current_fake(current_info: &PartialKeyEventInfo, next_msg: MSG, layout: &Layout) -> bool {
+    let current_is_ctrl = matches!(
+        current_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 curr_is_ctrl && next_is_altgr {
+        if current_is_ctrl && next_is_altgr {
            return true;
        }
    }
@@ -942,12 +942,12 @@ fn get_location(scancode: ExScancode, hkl: HKL) -> KeyLocation {
    }
 }

-pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
-    // See `scancode_to_physicalkey` for more info
+pub(crate) fn physical_key_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
+    // See `scancode_to_physical_key` for more info

    let hkl = unsafe { GetKeyboardLayout(0) };

-    let primary_lang_id = primarylangid(loword(hkl as u32));
+    let primary_lang_id = primary_lang_id(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 physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32>
    }
 }

-pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
+pub(crate) fn scancode_to_physical_key(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
--- a/src/platform_impl/windows/keyboard_layout.rs
+++ b/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, primarylangid, scancode_to_physicalkey},
+    platform_impl::{loword, primary_lang_id, scancode_to_physical_key},
 };

 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 lcontrol = key_state[VK_LCONTROL as usize] & 0x80 != 0;
-        let rcontrol = key_state[VK_RCONTROL as usize] & 0x80 != 0;
+        let l_control = key_state[VK_LCONTROL as usize] & 0x80 != 0;
+        let r_control = key_state[VK_RCONTROL as usize] & 0x80 != 0;

        let alt = key_state[VK_MENU as usize] & 0x80 != 0;
-        let lalt = key_state[VK_LMENU as usize] & 0x80 != 0;
-        let ralt = key_state[VK_RMENU as usize] & 0x80 != 0;
+        let l_alt = key_state[VK_LMENU as usize] & 0x80 != 0;
+        let r_alt = 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 || lcontrol || rcontrol {
+        if control || l_control || r_control {
            result.insert(WindowsModifiers::CONTROL);
        }
-        if alt || lalt || ralt {
+        if alt || l_alt || r_alt {
            result.insert(WindowsModifiers::ALT);
        }
        if caps {
@@ -335,7 +335,7 @@ impl LayoutCache {
            if scancode == 0 {
                continue;
            }
-            let keycode = match scancode_to_physicalkey(scancode) {
+            let keycode = match scancode_to_physical_key(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_physicalkey(scancode) {
+                let key_code = match scancode_to_physical_key(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 = primarylangid(loword(hkl as u32));
+    let primary_lang_id = primary_lang_id(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 = primarylangid(loword(hkl as u32));
+    let primary_lang_id = primary_lang_id(loword(hkl as u32));
    let is_korean = primary_lang_id as u32 == LANG_KOREAN;
    let is_japanese = primary_lang_id as u32 == LANG_JAPANESE;

--- a/src/platform_impl/windows/mod.rs
+++ b/src/platform_impl/windows/mod.rs
@@ -12,7 +12,7 @@ pub(crate) use self::{
        PlatformSpecificEventLoopAttributes,
    },
    icon::{SelectedCursor, WinIcon},
-    keyboard::{physicalkey_to_scancode, scancode_to_physicalkey},
+    keyboard::{physical_key_to_scancode, scancode_to_physical_key},
    monitor::{MonitorHandle, VideoModeHandle},
    window::Window,
 };
@@ -148,7 +148,7 @@ const fn get_y_lparam(x: u32) -> i16 {
 }

 #[inline(always)]
-pub(crate) const fn primarylangid(lgid: u16) -> u16 {
+pub(crate) const fn primary_lang_id(lgid: u16) -> u16 {
    lgid & 0x3FF
 }

@@ -163,24 +163,26 @@ const fn hiword(x: u32) -> u16 {
 }

 #[inline(always)]
-unsafe fn get_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX) -> isize {
+unsafe fn get_window_long(hwnd: HWND, n_index: WINDOW_LONG_PTR_INDEX) -> isize {
    #[cfg(target_pointer_width = "64")]
-    return unsafe { windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, nindex) };
+    return unsafe {
+        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, n_index)
+    };
    #[cfg(target_pointer_width = "32")]
    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, nindex) as isize
+        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, n_index) as isize
    };
 }

 #[inline(always)]
-unsafe fn set_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX, dwnewlong: isize) -> isize {
+unsafe fn set_window_long(hwnd: HWND, n_index: WINDOW_LONG_PTR_INDEX, new_long: isize) -> isize {
    #[cfg(target_pointer_width = "64")]
    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, nindex, dwnewlong)
+        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, n_index, new_long)
    };
    #[cfg(target_pointer_width = "32")]
    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, nindex, dwnewlong as i32)
+        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, n_index, new_long as i32)
            as isize
    };
 }
--- a/src/platform_impl/windows/raw_input.rs
+++ b/src/platform_impl/windows/raw_input.rs
@@ -27,7 +27,7 @@ use windows_sys::Win32::{
    },
 };

-use super::scancode_to_physicalkey;
+use super::scancode_to_physical_key;
 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 hotplug events
+    // RIDEV_DEVNOTIFY: receive hot-plug 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 equvalence means that if the user presses Pause, the keyboard will emit two
-        // subsequent keypresses:
+        // This equivalence means that if the user presses Pause, the keyboard will emit two
+        // subsequent key presses:
        // 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, presssing
+        // PrtSc used to be Shift+Asterisk. This means that on some keyboards, pressing
        // 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 exteion flag (0xE000). This on
+        // 2, 0xE037 - Which is a numpad multiply (0x37) with an extension 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_physicalkey(scancode as u32)
+        scancode_to_physical_key(scancode as u32)
    };
    if keyboard.VKey == VK_SHIFT {
        if let PhysicalKey::Code(code) = physical_key {
--- a/src/platform_impl/windows/window.rs
+++ b/src/platform_impl/windows/window.rs
@@ -1406,7 +1406,7 @@ unsafe fn init(
    let menu = attributes.platform_specific.menu;
    let fullscreen = attributes.fullscreen.clone();
    let maximized = attributes.maximized;
-    let mut initdata = InitData {
+    let mut init_data = 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 initdata as *mut _ as *mut _,
+            &mut init_data 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 = initdata.window.unwrap();
+    let win = init_data.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.
--- a/src/platform_impl/windows/window_state.rs
+++ b/src/platform_impl/windows/window_state.rs
@@ -416,7 +416,7 @@ impl WindowFlags {
                    0,
                );

-                // This condition is necessary to avoid having an unrestorable window
+                // This condition is necessary to avoid having an un-restorable 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;

-            // Frameless style implemented by manually overriding the non-client area in `WM_NCCALCSIZE`.
+            // Frame-less style implemented by manually overriding the non-client area in `WM_NCCALCSIZE`.
            if !self.contains(WindowFlags::MARKER_DECORATIONS) {
                style &= !(WS_CAPTION | WS_SIZEBOX);
            }
@@ -525,7 +525,7 @@ impl CursorFlags {

            // We do this check because calling `set_cursor_clip` incessantly will flood the event
            // loop with `WM_MOUSEMOVE` events, and `refresh_os_cursor` is called by `set_cursor_flags`
-            // which at times gets called once every iteration of the eventloop.
+            // which at times gets called once every iteration of the event loop.
            if active_cursor_clip != cursor_clip.map(rect_to_tuple) {
                util::set_cursor_clip(cursor_clip)?;
            }
--- a/src/utils.rs
+++ b/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 stablized.
+// Replace with std::sync::LazyLock when https://github.com/rust-lang/rust/issues/109736 is stabilized.

 // This isn't used on every platform, which can come up as dead code warnings.
 #![allow(dead_code)]
--- a/src/window.rs
+++ b/src/window.rs
@@ -70,8 +70,8 @@ pub struct Window {
 }

 impl fmt::Debug for Window {
-    fn fmt(&self, fmtr: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmtr.pad("Window { .. }")
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.pad("Window { .. }")
    }
 }

@@ -1026,7 +1026,7 @@ impl Window {

    /// Sets whether the window is resizable or not.
    ///
-    /// Note that making the window unresizable doesn't exempt you from handling [`WindowEvent::Resized`], as that
+    /// Note that making the window un-resizable 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`].
    ///
@@ -1235,7 +1235,7 @@ impl Window {
    /// Sets the window icon.
    ///
    /// On Windows and X11, this is typically the small icon in the top-left
-    /// corner of the titlebar.
+    /// corner of the title bar.
    ///
    /// ## Platform-specific
    ///
@@ -1375,7 +1375,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. Unsetting the request for
+    /// Providing `None` will unset the request for user attention. Un-setting the request for
    /// user attention might not be done automatically by the WM when the window receives input.
    ///
    /// ## Platform-specific
Author	SHA1	Message	Date
John Nunley	0871c849ef	chore: Add words from markdown files Signed-off-by: John Nunley <dev@notgull.net>	2024-03-02 22:30:34 -08:00
John Nunley	204dd734dd	chore: Fix remaining typos in Rust file Signed-off-by: John Nunley <dev@notgull.net>	2024-03-02 22:27:45 -08:00
John Nunley	4dc8878511	ci: Add spellcheck to CI winit is a large codebase and manually checking for typos is infeasible. This commit adds a spellcheck hook using cspell to the CI. That way we can be sure that there are no typos in our code before we commit. Signed-off-by: John Nunley <dev@notgull.net>	2024-03-02 09:40:20 -08:00
John Nunley	47e7d8b7fa	chore: Use cspell to fix some typos Signed-off-by: John Nunley <dev@notgull.net>	2024-03-02 09:38:54 -08:00
daxpedda	388c40b1e0	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2024-03-02 13:22:36 +01:00
daxpedda	7a40aa43dc	Web: fix crash with `ControlFlow::Wait\|WaitUntil`	2024-03-02 12:26:26 +01:00