Go to file
Philippe Renon 2f27f64cdb
On Windows, fix request_redraw() related panics (#1461)
* On Windows, fix request_redraw() related panics

These panics were introduced by 6a330a2894

Fixes https://github.com/rust-windowing/winit/issues/1391
Fixes https://github.com/rust-windowing/winit/issues/1400
Fixes https://github.com/rust-windowing/winit/issues/1466
Probably fixes other related issues

See https://github.com/rust-windowing/winit/issues/1429

* On Windows, replace all calls to UpdateWindow by calls to InvalidateRgn

This avoids directly sending a WM_PAINT message,
which might cause buffering of RedrawRequested events.

We don't want to buffer RedrawRequested events because:
- we wan't to handle RedrawRequested during processing of WM_PAINT messages
- state transitionning is broken when handling buffered RedrawRequested events

Fixes https://github.com/rust-windowing/winit/issues/1469

* On Windows, panic if we are trying to buffer a RedrawRequested event

* On Windows, move modal loop jumpstart to set_modal_loop() method

This fixes a panic.
Note that the WM_PAINT event is now sent to the modal_redraw_method
which is more correct and avoids an unecessary redraw of the window.

Relates to but does does not fix https://github.com/rust-windowing/winit/issues/1484

* On Window, filter by paint messages when draining paint messages

This seems to prevent PeekMessage from dispatching unrelated sent messages

* Change recently added panic/assert calls with warn calls

This makes the code less panicky...

And actually, winit's Windoww callbacks should not panic
because the panic will unwind into Windows code.

It is currently undefined behavior to unwind from Rust code into foreign code.
See https://doc.rust-lang.org/std/panic/fn.catch_unwind.html

* add comments to clarify WM_PAINT handling in non modal loop

* made redraw_events_cleared more explicit and more comments
2020-03-07 14:04:24 -05:00
.github Fix GitHub Actions (#1479) 2020-02-25 09:10:31 -07:00
examples Move ModifiersChanged variant to WindowEvent (#1381) 2020-03-06 15:43:55 -07:00
src On Windows, fix request_redraw() related panics (#1461) 2020-03-07 14:04:24 -05:00
tests Make size/position types generic over pixel type (#1277) 2020-01-05 14:15:11 -05:00
.gitattributes Set CHANGELOG.md merge style to union (#919) 2019-06-13 16:11:44 -04:00
.gitignore Remove util from gitignore 2020-01-09 12:24:57 -05:00
.gitmodules Forward porting (#966) 2019-06-23 02:39:26 -04:00
Cargo.toml Update image to 0.23 (#1485) 2020-03-03 16:13:53 -07:00
CHANGELOG.md On Windows, fix request_redraw() related panics (#1461) 2020-03-07 14:04:24 -05:00
CONTRIBUTING.md Move contributors table to wiki (#934) 2019-06-19 15:12:27 -04:00
FEATURES.md Implement ThemeChanged for web target. (#1462) 2020-02-17 14:25:27 -05:00
HALL_OF_CHAMPIONS.md Linkify HALL_OF_CHAMPIONS.md (#935) 2019-06-18 16:30:37 -06:00
LICENSE Initial commit 2014-07-27 11:41:26 +02:00
README.md Release 0.21.0 (#1440) 2020-02-04 19:07:31 -07:00
rustfmt.toml Re-format on stable rustfmt (#974) 2019-06-24 12:14:55 -04:00

winit - Cross-platform window creation and management in Rust

Crates.io Docs.rs Build Status Build status

[dependencies]
winit = "0.21.0"

Documentation

For features within the scope of winit, see FEATURES.md.

For features outside the scope of winit, see Missing features provided by other crates in the wiki.

Contact Us

Join us in any of these:

Freenode Matrix Gitter

Usage

Winit is a window creation and management library. It can create windows and lets you handle events (for example: the window being resized, a key being pressed, a mouse movement, etc.) produced by window.

Winit is designed to be a low-level brick in a hierarchy of libraries. Consequently, in order to show something on the window you need to use the platform-specific getters provided by winit, or another library.

use winit::{
    event::{Event, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
    window::WindowBuilder,
};

fn main() {
    let event_loop = EventLoop::new();
    let window = WindowBuilder::new().build(&event_loop).unwrap();

    event_loop.run(move |event, _, control_flow| {
        *control_flow = ControlFlow::Wait;

        match event {
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                window_id,
            } if window_id == window.id() => *control_flow = ControlFlow::Exit,
            _ => (),
        }
    });
}

Winit is only officially supported on the latest stable version of the Rust compiler.

Cargo Features

Winit provides the following features, which can be enabled in your Cargo.toml file:

  • serde: Enables serialization/deserialization of certain types with Serde.

Platform-specific usage

WebAssembly

Building a binary will yield a .js file. In order to use it in an HTML file, you need to:

  • Put a <canvas id="my_id"></canvas> element somewhere. A canvas corresponds to a winit "window".
  • Write a Javascript code that creates a global variable named Module. Set Module.canvas to the element of the <canvas> element (in the example you would retrieve it via document.getElementById("my_id")). More information here.
  • Make sure that you insert the .js file generated by Rust after the Module variable is created.