winit | macOS Ecosystem Directory

winit - Winit version 0.30.4 Latest Release

Published by kchibisov 3 months ago

Changed

DeviceId::dummy() and WindowId::dummy() are no longer marked unsafe.

Fixed

On Wayland, avoid crashing when compositor is misbehaving.
On Web, fix WindowEvent::Resized not using requestAnimationFrame when sending
WindowEvent::RedrawRequested and also potentially causing WindowEvent::RedrawRequested
to not be de-duplicated.
Account for different browser engine implementations of pointer movement coordinate space.

winit - Winit version 0.30.3

Published by kchibisov 4 months ago

Added

On Web, add EventLoopExtWebSys::(set_)poll_strategy() to allow setting
control flow strategies before starting the event loop.
On Web, add WaitUntilStrategy, which allows to set different strategies for
ControlFlow::WaitUntil. By default the Prioritized Task Scheduling API is
used, with a fallback to setTimeout() with a trick to circumvent throttling
to 4ms. But an option to use a Web worker to schedule the timer is available
as well, which commonly prevents any throttling when the window is not focused.

Changed

On macOS, set the window theme on the NSWindow instead of application-wide.

Fixed

On X11, build on arm platforms.
On macOS, fixed WindowBuilder::with_theme not having any effect on the window.

winit - Winit version 0.30.2

Published by kchibisov 4 months ago

Fixed

On Web, fix EventLoopProxy::send_event() triggering event loop immediately
when not called from inside the event loop. Now queues a microtask instead.
On Web, stop overwriting default cursor with CursorIcon::Default.
On Web, prevent crash when using InnerSizeWriter::request_inner_size().
On macOS, fix not working opacity for entire window.

winit - Winit version 0.30.1

Published by kchibisov 4 months ago

Added

Reexport raw-window-handle versions 0.4 and 0.5 as raw_window_handle_04 and raw_window_handle_05.
Implement ApplicationHandler for &mut references and heap allocations to something that implements ApplicationHandler.
Add traits EventLoopExtWayland and EventLoopExtX11, providing methods is_wayland and is_x11 on EventLoop.

Fixed

On macOS, fix panic on exit when dropping windows outside the event loop.
On macOS, fix window dragging glitches when dragging across a monitor boundary with different scale factor.
On macOS, fix the range in Ime::Preedit.
On macOS, use the system's internal mechanisms for queuing events.
On macOS, handle events directly instead of queuing when possible.

winit - Winit version 0.30.0

Published by kchibisov 6 months ago

Added

Add OwnedDisplayHandle type for allowing safe display handle usage outside of
trivial cases.
Add ApplicationHandler<T> trait which mimics Event<T>.
Add WindowBuilder::with_cursor and Window::set_cursor which takes a
CursorIcon or CustomCursor.
Add Sync implementation for EventLoopProxy<T: Send>.
Add Window::default_attributes to get default WindowAttributes.
Add EventLoop::builder to get EventLoopBuilder without export.
Add CustomCursor::from_rgba to allow creating cursor images from RGBA data.
Add CustomCursorExtWebSys::from_url to allow loading cursor images from URLs.
Add CustomCursorExtWebSys::from_animation to allow creating animated
cursors from other CustomCursors.
Add {Active,}EventLoop::create_custom_cursor to load custom cursor image sources.
Add ActiveEventLoop::create_window and EventLoop::create_window.
Add CustomCursor which could be set via Window::set_cursor, implemented on
Windows, macOS, X11, Wayland, and Web.
On Web, add to toggle calling Event.preventDefault() on Window.
On iOS, add PinchGesture, DoubleTapGesture, PanGesture and RotationGesture.
on iOS, use UIGestureRecognizerDelegate for fine grained control of gesture recognizers.
On macOS, add services menu.
On Windows, add with_title_text_color, and with_corner_preference on
WindowAttributesExtWindows.
On Windows, implement resize increments.
On Windows, add AnyThread API to access window handle off the main thread.

Changed

Bump MSRV from 1.65 to 1.70.
On Wayland, bump sctk-adwaita to 0.9.0, which changed system library
crates. This change is a cascading breaking change, you must do breaking
change as well, even if you don't expose winit.
Rename TouchpadMagnify to PinchGesture.
Rename SmartMagnify to DoubleTapGesture.
Rename TouchpadRotate to RotationGesture.
Rename EventLoopWindowTarget to ActiveEventLoop.
Rename platform::x11::XWindowType to platform::x11::WindowType.
Rename VideoMode to VideoModeHandle to represent that it doesn't hold
static data.
Make Debug formatting of WindowId more concise.
Move dpi types to its own crate, and re-export it from the root crate.
Replace log with tracing, use log feature on tracing to restore old
behavior.
EventLoop::with_user_event now returns EventLoopBuilder.
On Web, return HandleError::Unavailable when a window handle is not available.
On Web, return RawWindowHandle::WebCanvas instead of RawWindowHandle::Web.
On Web, remove queuing fullscreen request in absence of transient activation.
On iOS, return HandleError::Unavailable when a window handle is not available.
On macOS, return HandleError::Unavailable when a window handle is not available.
On Windows, remove WS_CAPTION, WS_BORDER, and WS_EX_WINDOWEDGE styles
for child windows without decorations.
On Android, bump ndk to 0.9.0 and android-activity to 0.6.0,
and remove unused direct dependency on ndk-sys.

Deprecated

Deprecate EventLoop::run, use EventLoop::run_app.
Deprecate EventLoopExtRunOnDemand::run_on_demand, use EventLoop::run_app_on_demand.

Deprecate EventLoopExtPumpEvents::pump_events, use EventLoopExtPumpEvents::pump_app_events.

The new app APIs accept a newly added ApplicationHandler<T> instead of
Fn. The semantics are mostly the same, given that the capture list of the
closure is your new State. Consider the following code:

use winit::event::Event;
use winit::event_loop::EventLoop;
use winit::window::Window;

struct MyUserEvent;

let event_loop = EventLoop::<MyUserEvent>::with_user_event().build().unwrap();
let window = event_loop.create_window(Window::default_attributes()).unwrap();
let mut counter = 0;

let _ = event_loop.run(move |event, event_loop| {
    match event {
        Event::AboutToWait => {
            window.request_redraw();
            counter += 1;
        }
        Event::WindowEvent { window_id, event } => {
            // Handle window event.
        }
        Event::UserEvent(event) => {
            // Handle user event.
        }
        Event::DeviceEvent { device_id, event } => {
            // Handle device event.
        }
        _ => (),
    }
});

To migrate this code, you should move all the captured values into some
newtype State and implement ApplicationHandler for this type. Finally,
we move particular match event arms into methods on ApplicationHandler,
for example:

use winit::application::ApplicationHandler;
use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
use winit::event_loop::{EventLoop, ActiveEventLoop};
use winit::window::{Window, WindowId};

struct MyUserEvent;

struct State {
    window: Window,
    counter: i32,
}

impl ApplicationHandler<MyUserEvent> for State {
    fn user_event(&mut self, event_loop: &ActiveEventLoop, user_event: MyUserEvent) {
        // Handle user event.
    }

    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        // Your application got resumed.
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
        // Handle window event.
    }

    fn device_event(&mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent) {
        // Handle device event.
    }

    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
        self.window.request_redraw();
        self.counter += 1;
    }
}

let event_loop = EventLoop::<MyUserEvent>::with_user_event().build().unwrap();
#[allow(deprecated)]
let window = event_loop.create_window(Window::default_attributes()).unwrap();
let mut state = State { window, counter: 0 };

let _ = event_loop.run_app(&mut state);

Please submit your feedback after migrating in this issue.

Deprecate Window::set_cursor_icon, use Window::set_cursor.

Removed

Remove Window::new, use ActiveEventLoop::create_window instead.

You now have to create your windows inside the actively running event loop
(usually the new_events(cause: StartCause::Init) or resumed() events),
and can no longer do it before the application has properly launched.
This change is done to fix many long-standing issues on iOS and macOS, and
will improve things on Wayland once fully implemented.

To ease migration, we provide the deprecated EventLoop::create_window that
will allow you to bypass this restriction in this release.

Using the migration example from above, you can change your code as follows:

use winit::application::ApplicationHandler;
use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
use winit::event_loop::{EventLoop, ActiveEventLoop};
use winit::window::{Window, WindowId};

#[derive(Default)]
struct State {
    // Use an `Option` to allow the window to not be available until the
    // application is properly running.
    window: Option<Window>,
    counter: i32,
}

impl ApplicationHandler for State {
    // This is a common indicator that you can create a window.
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
    }
    fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
        // `unwrap` is fine, the window will always be available when
        // receiving a window event.
        let window = self.window.as_ref().unwrap();
        // Handle window event.
    }
    fn device_event(&mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent) {
        // Handle window event.
    }
    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
        if let Some(window) = self.window.as_ref() {
            window.request_redraw();
            self.counter += 1;
        }
    }
}

let event_loop = EventLoop::new().unwrap();
let mut state = State::default();
let _ = event_loop.run_app(&mut state);

Remove Deref implementation for EventLoop that gave EventLoopWindowTarget.
Remove WindowBuilder in favor of WindowAttributes.
Remove Generic parameter T from ActiveEventLoop.
Remove EventLoopBuilder::with_user_event, use EventLoop::with_user_event.
Remove Redundant EventLoopError::AlreadyRunning.
Remove WindowAttributes::fullscreen and expose as field directly.
On X11, remove platform::x11::XNotSupported export.

Fixed

On Web, fix setting cursor icon overriding cursor visibility.
On Windows, fix cursor not confined to center of window when grabbed and hidden.
On macOS, fix sequence of mouse events being out of order when dragging on the trackpad.
On Wayland, fix decoration glitch on close with some compositors.
On Android, fix a regression introduced in #2748 to allow volume key events to be received again.
On Windows, don't return a valid window handle outside of the GUI thread.
On macOS, don't set the background color when initializing a window with transparency.

winit - Winit version 0.29.15

Published by kchibisov 7 months ago

On X11, fix crash due to xsettings query on systems with incomplete xsettings.

winit - Winit version 0.29.14

Published by kchibisov 8 months ago

On X11/Wayland, fix text and text_with_all_modifiers not being None during compose.
On Wayland, don't reapply cursor grab when unchanged.
On X11, fix a bug where some mouse events would be unexpectedly filtered out.

winit - Winit version 0.29.13

Published by daxpedda 8 months ago

On Web, fix possible crash with ControlFlow::Wait and ControlFlow::WaitUntil.

winit - Winit version 0.29.12

Published by kchibisov 8 months ago

On X11, fix use after free during xinput2 handling.
On X11, filter close to zero values in mouse device events

winit - Winit version 0.29.11 [yanked]

Published by kchibisov 8 months ago

On Wayland, fix DeviceEvent::Motion not being sent
On X11, don't require XIM to run.
On X11, fix xkb state not being updated correctly sometimes leading to wrong input.
Fix compatibility with 32-bit platforms without 64-bit atomics.
On macOS, fix incorrect IME cursor rect origin.
On X11, fix swapped instance and general class names.
On Windows, fixed a race condition when sending an event through the loop proxy.
On Wayland, disable Occluded event handling.
On X11, reload dpi on _XSETTINGS_SETTINGS update.
On X11, fix deadlock when adjusting DPI and resizing at the same time.
On Wayland, fix Focused(false) being send when other seats still have window focused.
On Wayland, fix Window::set_{min,max}_inner_size not always applied.
On Windows, fix inconsistent resizing behavior with multi-monitor setups when repositioning outside the event loop.
On Wayland, fix WAYLAND_SOCKET not used when detecting platform.
On Orbital, fix logical_key and text not reported in KeyEvent.
On Orbital, implement KeyEventExtModifierSupplement.
On Orbital, map keys to NamedKey when possible.
On Orbital, implement set_cursor_grab.
On Orbital, implement set_cursor_visible.
On Orbital, implement drag_window.
On Orbital, implement drag_resize_window.
On Orbital, implement set_transparent.
On Orbital, implement set_visible.
On Orbital, implement is_visible.
On Orbital, implement set_resizable.
On Orbital, implement is_resizable.
On Orbital, implement set_maximized.
On Orbital, implement is_maximized.
On Orbital, implement set_decorations.
On Orbital, implement is_decorated.
On Orbital, implement set_window_level.
On Orbital, emit DeviceEvent::MouseMotion.
On Wayland, fix title in CSD not updated from AboutToWait.

winit - Winit version 0.29.10

Published by kchibisov 9 months ago

On Web, account for canvas being focused already before event loop starts.
On Web, increase cursor position accuracy.

winit - Winit version 0.29.9