migrations/winit
1
0
Fork 0
mirror of https://github.com/rust-windowing/winit.git synced 2026-08-30 05:10:03 -04:00
Code Issues Packages Projects Releases Wiki Activity

chore: Fix remaining typos in Rust file

Browse Source 
Signed-off-by: John Nunley <dev@notgull.net>
This commit is contained in:
John Nunley
2024-03-02 22:27:45 -08:00
parent 4dc8878511
commit 204dd734dd
46 changed files with 802 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/event.rs
View File

@@ -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.
///
/// ```

2
src/event_loop.rs
View File

@@ -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
///

2
src/keyboard.rs
View File

@@ -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,

6
src/platform/android.rs
View File

@@ -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).

2
src/platform/run_on_demand.rs
View File

@@ -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(|_, _| {});
/// });
/// ```

4
src/platform/scancode.rs
View File

@@ -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)
}
}

2
src/platform/startup_notify.rs
View File

@@ -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`].

2
src/platform/wayland.rs
View File

@@ -7,7 +7,7 @@
//!
//! ## Client-side decorations
//!
//! Winit provides client-side decorations by default, but the behavior can
//! Winit provides client-side decorations by default, but the behaviour can
//! be controlled with the following feature flags:
//!
//! * `wayland-csd-adwaita` (default).

10
src/platform/web.rs
View File

@@ -82,7 +82,7 @@ pub trait WindowExtWebSys {
/// would prevent that.
///
/// Some events are impossible to prevent. E.g. Firefox allows to access the native browser
/// context menu with Shift+Right-click.
/// context menu with Shift+Rightclick.
fn set_prevent_default(&self, prevent_default: bool);
}
@@ -274,7 +274,7 @@ pub trait CustomCursorExtWebSys {
/// but browser support for image formats is inconsistent. Using [PNG] is recommended.
///
/// [PNG]: https://en.wikipedia.org/wiki/PNG
fn from_url(url: String, hot_spot_x: u16, hot_spot_y: u16) -> CustomCursorSource;
fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource;
/// Crates a new animated cursor from multiple [`CustomCursor`]s.
/// Supplied `cursors` can't be empty or other animations.
@@ -289,12 +289,12 @@ impl CustomCursorExtWebSys for CustomCursor {
self.inner.animation
}
fn from_url(url: String, hot_spot_x: u16, hot_spot_y: u16) -> CustomCursorSource {
fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource {
CustomCursorSource {
inner: PlatformCustomCursorSource::Url {
url,
hot_spot_x,
hot_spot_y,
hotspot_x,
hotspot_y,
},
}
}

2
src/platform_impl/android/mod.rs
View File

@@ -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;

6
src/platform_impl/linux/common/xkb/keymap.rs
View File

@@ -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) => {

2
src/platform_impl/linux/common/xkb/mod.rs
View File

@@ -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`.

2
src/platform_impl/linux/mod.rs
View File

@@ -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;

2
src/platform_impl/linux/wayland/seat/keyboard/mod.rs
View File

@@ -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;

2
src/platform_impl/linux/wayland/seat/pointer/mod.rs
View File

@@ -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(

8
src/platform_impl/linux/x11/event_processor.rs
View File

@@ -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,

4
src/platform_impl/linux/x11/ime/callbacks.rs
View File

@@ -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 _;

2
src/platform_impl/linux/x11/ime/context.rs
View File

@@ -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

2
src/platform_impl/linux/x11/ime/input_method.rs
View File

@@ -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

2
src/platform_impl/linux/x11/util/geometry.rs
View File

@@ -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

2
src/platform_impl/linux/x11/util/mod.rs
View File

@@ -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"

2
src/platform_impl/linux/x11/util/wm.rs
View File

@@ -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

8
src/platform_impl/linux/x11/util/xmodmap.rs
View File

@@ -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);
}
}
}

11
src/platform_impl/linux/x11/window.rs
View File

@@ -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]

2
src/platform_impl/linux/x11/xdisplay.rs
View File

@@ -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()?

9
src/platform_impl/macos/event.rs
View File

@@ -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,

2
src/platform_impl/macos/event_loop.rs
View File

@@ -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));

2
src/platform_impl/macos/mod.rs
View File

@@ -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,

4
src/platform_impl/macos/view.rs
View File

@@ -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));

4
src/platform_impl/macos/window_delegate.rs
View File

@@ -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));

8
src/platform_impl/web/cursor.rs
View File

@@ -31,8 +31,8 @@ pub(crate) enum CustomCursorSource {
Image(CursorImage),
Url {
url: String,
hot_spot_x: u16,
hot_spot_y: u16,
hotspot_x: u16,
hotspot_y: u16,
},
Animation {
duration: Duration,
@@ -88,8 +88,8 @@ impl CustomCursor {
),
CustomCursorSource::Url {
url,
hot_spot_x: hotspot_x,
hot_spot_y: hotspot_y,
hotspot_x,
hotspot_y,
} => Self::build_spawn(
event_loop,
from_url(UrlType::Plain(url), hotspot_x, hotspot_y),

4
src/platform_impl/web/keyboard.rs
View File

@@ -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,

8
src/platform_impl/windows/dark_mode.rs
View File

@@ -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);

32
src/platform_impl/windows/definitions.rs
View File

@@ -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,
}

38
src/platform_impl/windows/event_loop.rs
View File

@@ -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,

8
src/platform_impl/windows/event_loop/runner.rs
View File

@@ -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 {

6
src/platform_impl/windows/ime.rs
View File

@@ -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);
}

34
src/platform_impl/windows/keyboard.rs
View File

@@ -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

22
src/platform_impl/windows/keyboard_layout.rs
View File

@@ -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;

18
src/platform_impl/windows/mod.rs
View File

@@ -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
};
}

14
src/platform_impl/windows/raw_input.rs
View File

@@ -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 {

6
src/platform_impl/windows/window.rs
View File

@@ -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.

6
src/platform_impl/windows/window_state.rs
View File

@@ -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)?;
}