migrations/egui
1
0
Fork 0
mirror of https://github.com/emilk/egui.git synced 2026-09-01 06:10:06 -04:00
Code Activity

WIP: Update to winit 0.29

Browse Source
This commit is contained in:
Fredrik Fornwall
2023-11-21 23:26:40 +01:00
parent e037489ac2
commit c93defdcf8
13 changed files with 776 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files

685
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

6
crates/eframe/Cargo.toml
View File

@@ -127,7 +127,7 @@ image = { version = "0.24", default-features = false, features = [
"png", "png",
] } # Needed for app icon ] } # Needed for app icon
raw-window-handle.workspace = true raw-window-handle.workspace = true
winit = { version = "0.28.1", default-features = false } winit = { version = "0.29", default-features = false, features = ["rwh_05"] }
# optional native: # optional native:
directories-next = { version = "2", optional = true } directories-next = { version = "2", optional = true }
@@ -138,8 +138,8 @@ pollster = { version = "0.3", optional = true } # needed for wgpu
# we can expose these to user so that they can select which backends they want to enable to avoid compiling useless deps. # we can expose these to user so that they can select which backends they want to enable to avoid compiling useless deps.
# this can be done at the same time we expose x11/wayland features of winit crate. # this can be done at the same time we expose x11/wayland features of winit crate.
glutin = { version = "0.30", optional = true } glutin = { version = "0.31", optional = true }
glutin-winit = { version = "0.3.0", optional = true } glutin-winit = { version = "0.4", optional = true }
puffin = { workspace = true, optional = true } puffin = { workspace = true, optional = true }
wgpu = { workspace = true, optional = true } wgpu = { workspace = true, optional = true }

2
crates/eframe/src/native/epi_integration.rs
View File

@@ -221,7 +221,7 @@ impl EpiIntegration {
pub fn on_window_event( pub fn on_window_event(
&mut self, &mut self,
app: &mut dyn epi::App, app: &mut dyn epi::App,
event: &winit::event::WindowEvent<'_>, event: &winit::event::WindowEvent,
egui_winit: &mut egui_winit::State, egui_winit: &mut egui_winit::State,
viewport_id: ViewportId, viewport_id: ViewportId,
) -> EventResponse { ) -> EventResponse {

23
crates/eframe/src/native/glow_integration.rs
View File

@@ -1,8 +1,9 @@
use std::{cell::RefCell, rc::Rc, sync::Arc, time::Instant}; use std::{cell::RefCell, rc::Rc, sync::Arc, time::Instant};
use glutin::{ use glutin::{
context::NotCurrentGlContext,
display::GetGlDisplay, display::GetGlDisplay,
prelude::{GlDisplay, NotCurrentGlContextSurfaceAccessor, PossiblyCurrentGlContext}, prelude::{GlDisplay, PossiblyCurrentGlContext},
surface::GlSurface, surface::GlSurface,
}; };
use raw_window_handle::{HasRawDisplayHandle as _, HasRawWindowHandle as _}; use raw_window_handle::{HasRawDisplayHandle as _, HasRawWindowHandle as _};
@@ -391,7 +392,7 @@ impl WinitApp for GlowWinitApp {
fn on_event( fn on_event(
&mut self, &mut self,
event_loop: &EventLoopWindowTarget<UserEvent>, event_loop: &EventLoopWindowTarget<UserEvent>,
event: &winit::event::Event<'_, UserEvent>, event: &winit::event::Event<UserEvent>,
) -> Result<EventResult> { ) -> Result<EventResult> {
crate::profile_function!(winit_integration::short_event_description(event)); crate::profile_function!(winit_integration::short_event_description(event));
@@ -423,15 +424,6 @@ impl WinitApp for GlowWinitApp {
EventResult::Wait EventResult::Wait
} }
winit::event::Event::MainEventsCleared => {
if let Some(running) = &self.running {
if let Err(err) = running.glutin.borrow_mut().on_resume(event_loop) {
log::warn!("on_resume failed {err}");
}
}
EventResult::Wait
}
winit::event::Event::WindowEvent { event, window_id } => { winit::event::Event::WindowEvent { event, window_id } => {
if let Some(running) = &mut self.running { if let Some(running) = &mut self.running {
running.on_window_event(*window_id, event) running.on_window_event(*window_id, event)
@@ -652,7 +644,7 @@ impl GlowWinitRunning {
fn on_window_event( fn on_window_event(
&mut self, &mut self,
window_id: WindowId, window_id: WindowId,
event: &winit::event::WindowEvent<'_>, event: &winit::event::WindowEvent,
) -> EventResult { ) -> EventResult {
crate::profile_function!(egui_winit::short_window_event_description(event)); crate::profile_function!(egui_winit::short_window_event_description(event));
@@ -691,10 +683,9 @@ impl GlowWinitRunning {
} }
} }
winit::event::WindowEvent::ScaleFactorChanged { new_inner_size, .. } => { winit::event::WindowEvent::ScaleFactorChanged { .. } => {
if let Some(viewport_id) = viewport_id { if viewport_id.is_some() {
repaint_asap = true; repaint_asap = true;
glutin.resize(viewport_id, **new_inner_size);
} }
} }
@@ -811,7 +802,7 @@ impl GlutinWindowContext {
// Create GL display. This may probably create a window too on most platforms. Definitely on `MS windows`. Never on Android. // Create GL display. This may probably create a window too on most platforms. Definitely on `MS windows`. Never on Android.
let display_builder = glutin_winit::DisplayBuilder::new() let display_builder = glutin_winit::DisplayBuilder::new()
// we might want to expose this option to users in the future. maybe using an env var or using native_options. // we might want to expose this option to users in the future. maybe using an env var or using native_options.
.with_preference(glutin_winit::ApiPrefence::FallbackEgl) // https://github.com/emilk/egui/issues/2520#issuecomment-1367841150 .with_preference(glutin_winit::ApiPreference::FallbackEgl) // https://github.com/emilk/egui/issues/2520#issuecomment-1367841150
.with_window_builder(Some(create_winit_window_builder(viewport_builder.clone()))); .with_window_builder(Some(create_winit_window_builder(viewport_builder.clone())));
let (window, gl_config) = { let (window, gl_config) = {

67
crates/eframe/src/native/run.rs
View File

@@ -39,7 +39,7 @@ fn create_event_loop(native_options: &mut epi::NativeOptions) -> EventLoop<UserE
let mut builder = create_event_loop_builder(native_options); let mut builder = create_event_loop_builder(native_options);
crate::profile_scope!("EventLoopBuilder::build"); crate::profile_scope!("EventLoopBuilder::build");
builder.build() builder.build().unwrap()
} }
/// Access a thread-local event loop. /// Access a thread-local event loop.
@@ -67,7 +67,7 @@ fn run_and_return(
event_loop: &mut EventLoop<UserEvent>, event_loop: &mut EventLoop<UserEvent>,
mut winit_app: impl WinitApp, mut winit_app: impl WinitApp,
) -> Result<()> { ) -> Result<()> {
use winit::{event_loop::ControlFlow, platform::run_return::EventLoopExtRunReturn as _}; use winit::{event_loop::ControlFlow, platform::run_on_demand::EventLoopExtRunOnDemand};
log::debug!("Entering the winit event loop (run_return)…"); log::debug!("Entering the winit event loop (run_return)…");
@@ -76,20 +76,22 @@ fn run_and_return(
let mut returned_result = Ok(()); let mut returned_result = Ok(());
event_loop.run_return(|event, event_loop, control_flow| { let _ = event_loop.run_on_demand(|event, event_loop_window_target| {
crate::profile_scope!("winit_event", short_event_description(&event)); crate::profile_scope!("winit_event", short_event_description(&event));
let event_result = match &event { let event_result = match &event {
winit::event::Event::LoopDestroyed => { winit::event::Event::LoopExiting => {
// On Mac, Cmd-Q we get here and then `run_return` doesn't return (despite its name), // On Mac, Cmd-Q we get here and then `run_on_demand` doesn't return (despite its name),
// so we need to save state now: // so we need to save state now:
log::debug!("Received Event::LoopDestroyed - saving app state…"); log::debug!("Received Event::LoopExiting - saving app state…");
winit_app.save_and_destroy(); winit_app.save_and_destroy();
*control_flow = ControlFlow::Exit;
return; return;
} }
winit::event::Event::RedrawRequested(window_id) => { winit::event::Event::WindowEvent {
event: winit::event::WindowEvent::RedrawRequested,
window_id,
} => {
windows_next_repaint_times.remove(window_id); windows_next_repaint_times.remove(window_id);
winit_app.run_ui_and_paint(*window_id) winit_app.run_ui_and_paint(*window_id)
} }
@@ -120,7 +122,7 @@ fn run_and_return(
EventResult::Wait EventResult::Wait
} }
event => match winit_app.on_event(event_loop, event) { event => match winit_app.on_event(event_loop_window_target, event) {
Ok(event_result) => event_result, Ok(event_result) => event_result,
Err(err) => { Err(err) => {
log::error!("Exiting because of error: {err} during event {event:?}"); log::error!("Exiting because of error: {err} during event {event:?}");
@@ -132,7 +134,7 @@ fn run_and_return(
match event_result { match event_result {
EventResult::Wait => { EventResult::Wait => {
control_flow.set_wait(); event_loop_window_target.set_control_flow(ControlFlow::Wait);
} }
EventResult::RepaintNow(window_id) => { EventResult::RepaintNow(window_id) => {
log::trace!("Repaint caused by {}", short_event_description(&event)); log::trace!("Repaint caused by {}", short_event_description(&event));
@@ -160,7 +162,7 @@ fn run_and_return(
EventResult::Exit => { EventResult::Exit => {
log::debug!("Asking to exit event loop…"); log::debug!("Asking to exit event loop…");
winit_app.save_and_destroy(); winit_app.save_and_destroy();
*control_flow = ControlFlow::Exit; event_loop_window_target.exit();
return; return;
} }
} }
@@ -171,7 +173,10 @@ fn run_and_return(
use winit::event::Event; use winit::event::Event;
if matches!( if matches!(
event, event,
Event::RedrawEventsCleared | Event::RedrawRequested(_) | Event::Resumed Event::WindowEvent {
event: winit::event::WindowEvent::RedrawRequested,
..
} | Event::Resumed
) { ) {
windows_next_repaint_times.retain(|window_id, repaint_time| { windows_next_repaint_times.retain(|window_id, repaint_time| {
if Instant::now() < *repaint_time { if Instant::now() < *repaint_time {
@@ -179,7 +184,7 @@ fn run_and_return(
}; };
next_repaint_time = None; next_repaint_time = None;
control_flow.set_poll(); event_loop_window_target.set_control_flow(ControlFlow::Poll);
if let Some(window) = winit_app.window(*window_id) { if let Some(window) = winit_app.window(*window_id) {
log::trace!("request_redraw for {window_id:?}"); log::trace!("request_redraw for {window_id:?}");
@@ -196,7 +201,7 @@ fn run_and_return(
if time_until_next < std::time::Duration::from_secs(10_000) { if time_until_next < std::time::Duration::from_secs(10_000) {
log::trace!("WaitUntil {time_until_next:?}"); log::trace!("WaitUntil {time_until_next:?}");
} }
control_flow.set_wait_until(next_repaint_time); event_loop_window_target.set_control_flow(ControlFlow::WaitUntil(next_repaint_time));
}; };
}); });
@@ -220,21 +225,25 @@ fn run_and_return(
} }
fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp + 'static) -> ! { fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp + 'static) -> ! {
use winit::event_loop::ControlFlow;
log::debug!("Entering the winit event loop (run)…"); log::debug!("Entering the winit event loop (run)…");
// When to repaint what window // When to repaint what window
let mut windows_next_repaint_times = HashMap::default(); let mut windows_next_repaint_times = HashMap::default();
event_loop.run(move |event, event_loop, control_flow| { let result = event_loop.run(move |event, event_loop_window_target| {
crate::profile_scope!("winit_event", short_event_description(&event)); crate::profile_scope!("winit_event", short_event_description(&event));
let event_result = match &event { let event_result = match &event {
winit::event::Event::LoopDestroyed => { winit::event::Event::LoopExiting => {
log::debug!("Received Event::LoopDestroyed"); log::debug!("Received Event::LoopExiting");
EventResult::Exit EventResult::Exit
} }
winit::event::Event::RedrawRequested(window_id) => { winit::event::Event::WindowEvent {
event: winit::event::WindowEvent::RedrawRequested,
window_id,
} => {
windows_next_repaint_times.remove(window_id); windows_next_repaint_times.remove(window_id);
winit_app.run_ui_and_paint(*window_id) winit_app.run_ui_and_paint(*window_id)
} }
@@ -264,7 +273,7 @@ fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp +
EventResult::Wait EventResult::Wait
} }
event => match winit_app.on_event(event_loop, event) { event => match winit_app.on_event(event_loop_window_target, event) {
Ok(event_result) => event_result, Ok(event_result) => event_result,
Err(err) => { Err(err) => {
panic!("eframe encountered a fatal error: {err} during event {event:?}"); panic!("eframe encountered a fatal error: {err} during event {event:?}");
@@ -274,7 +283,7 @@ fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp +
match event_result { match event_result {
EventResult::Wait => { EventResult::Wait => {
control_flow.set_wait(); event_loop_window_target.set_control_flow(ControlFlow::Wait);
} }
EventResult::RepaintNow(window_id) => { EventResult::RepaintNow(window_id) => {
log::trace!("Repaint caused by {}", short_event_description(&event)); log::trace!("Repaint caused by {}", short_event_description(&event));
@@ -314,7 +323,10 @@ fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp +
use winit::event::Event; use winit::event::Event;
if matches!( if matches!(
event, event,
Event::RedrawEventsCleared | Event::RedrawRequested(_) | Event::Resumed Event::WindowEvent {
event: winit::event::WindowEvent::RedrawRequested,
..
} | Event::Resumed
) { ) {
windows_next_repaint_times.retain(|window_id, repaint_time| { windows_next_repaint_times.retain(|window_id, repaint_time| {
if Instant::now() < *repaint_time { if Instant::now() < *repaint_time {
@@ -322,7 +334,7 @@ fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp +
} }
next_repaint_time = None; next_repaint_time = None;
control_flow.set_poll(); event_loop_window_target.set_control_flow(ControlFlow::Poll);
if let Some(window) = winit_app.window(*window_id) { if let Some(window) = winit_app.window(*window_id) {
log::trace!("request_redraw for {window_id:?}"); log::trace!("request_redraw for {window_id:?}");
@@ -350,9 +362,16 @@ fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp +
.map(|window| window.request_redraw()) .map(|window| window.request_redraw())
}); });
control_flow.set_wait_until(next_repaint_time); event_loop_window_target.set_control_flow(ControlFlow::WaitUntil(next_repaint_time));
}; };
}) });
std::process::exit(if let Err(e) = result {
log::warn!("Error from event loop: {e}");
1
} else {
0
});
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

17
crates/eframe/src/native/wgpu_integration.rs
View File

@@ -355,7 +355,7 @@ impl WinitApp for WgpuWinitApp {
fn on_event( fn on_event(
&mut self, &mut self,
event_loop: &EventLoopWindowTarget<UserEvent>, event_loop: &EventLoopWindowTarget<UserEvent>,
event: &winit::event::Event<'_, UserEvent>, event: &winit::event::Event<UserEvent>,
) -> Result<EventResult> { ) -> Result<EventResult> {
crate::profile_function!(winit_integration::short_event_description(event)); crate::profile_function!(winit_integration::short_event_description(event));
@@ -643,7 +643,7 @@ impl WgpuWinitRunning {
fn on_window_event( fn on_window_event(
&mut self, &mut self,
window_id: WindowId, window_id: WindowId,
event: &winit::event::WindowEvent<'_>, event: &winit::event::WindowEvent,
) -> EventResult { ) -> EventResult {
crate::profile_function!(egui_winit::short_window_event_description(event)); crate::profile_function!(egui_winit::short_window_event_description(event));
@@ -692,18 +692,9 @@ impl WgpuWinitRunning {
} }
} }
winit::event::WindowEvent::ScaleFactorChanged { new_inner_size, .. } => { winit::event::WindowEvent::ScaleFactorChanged { .. } => {
use std::num::NonZeroU32; repaint_asap = true;
if let (Some(width), Some(height), Some(viewport_id)) = (
NonZeroU32::new(new_inner_size.width),
NonZeroU32::new(new_inner_size.height),
viewport_id,
) {
repaint_asap = true;
shared.painter.on_window_resized(viewport_id, width, height);
}
} }
winit::event::WindowEvent::CloseRequested => { winit::event::WindowEvent::CloseRequested => {
if viewport_id == Some(ViewportId::ROOT) && integration.should_close() { if viewport_id == Some(ViewportId::ROOT) && integration.should_close() {
log::debug!( log::debug!(

4
crates/eframe/src/native/winit_integration.rs
View File

@@ -65,7 +65,7 @@ pub trait WinitApp {
fn on_event( fn on_event(
&mut self, &mut self,
event_loop: &EventLoopWindowTarget<UserEvent>, event_loop: &EventLoopWindowTarget<UserEvent>,
event: &winit::event::Event<'_, UserEvent>, event: &winit::event::Event<UserEvent>,
) -> crate::Result<EventResult>; ) -> crate::Result<EventResult>;
} }
@@ -103,7 +103,7 @@ pub fn system_theme(window: &Window, options: &crate::NativeOptions) -> Option<c
/// Short and fast description of an event. /// Short and fast description of an event.
/// Useful for logging and profiling. /// Useful for logging and profiling.
pub fn short_event_description(event: &winit::event::Event<'_, UserEvent>) -> &'static str { pub fn short_event_description(event: &winit::event::Event<UserEvent>) -> &'static str {
use winit::event::Event; use winit::event::Event;
match event { match event {

2
crates/egui-wgpu/Cargo.toml
View File

@@ -51,7 +51,7 @@ wgpu.workspace = true
## Enable this when generating docs. ## Enable this when generating docs.
document-features = { version = "0.2", optional = true } document-features = { version = "0.2", optional = true }
winit = { version = "0.28", default-features = false, optional = true } winit = { version = "0.29", default-features = false, optional = true, features = ["rwh_05"] }
# Native: # Native:
[target.'cfg(not(target_arch = "wasm32"))'.dependencies] [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

4
crates/egui-winit/Cargo.toml
View File

@@ -61,12 +61,12 @@ egui = { version = "0.23.0", path = "../egui", default-features = false, feature
log = { version = "0.4", features = ["std"] } log = { version = "0.4", features = ["std"] }
raw-window-handle.workspace = true raw-window-handle.workspace = true
web-time = { version = "0.2" } # We use web-time so we can (maybe) compile for web web-time = { version = "0.2" } # We use web-time so we can (maybe) compile for web
winit = { version = "0.28", default-features = false } winit = { version = "0.29", default-features = false, features = ["rwh_05"] }
#! ### Optional dependencies #! ### Optional dependencies
# feature accesskit # feature accesskit
accesskit_winit = { version = "0.15.0", optional = true } accesskit_winit = { version = "0.16.0", optional = true }
## Enable this when generating docs. ## Enable this when generating docs.
document-features = { version = "0.2", optional = true } document-features = { version = "0.2", optional = true }

307
crates/egui-winit/src/lib.rs
View File

@@ -209,12 +209,6 @@ impl State {
self.egui_input.time = Some(self.start_time.elapsed().as_secs_f64()); self.egui_input.time = Some(self.start_time.elapsed().as_secs_f64());
// TODO remove this in winit 0.29
// This hack make the window outer_position and size to be valid, X11 Only
// That was happending because winit get the window state before the compositor adds decorations!
#[cfg(all(feature = "x11", target_os = "linux"))]
window.set_maximized(window.is_maximized());
// On Windows, a minimized window will have 0 width and height. // On Windows, a minimized window will have 0 width and height.
// See: https://github.com/rust-windowing/winit/issues/208 // See: https://github.com/rust-windowing/winit/issues/208
// This solves an issue where egui window positions would be changed when minimizing on Windows. // This solves an issue where egui window positions would be changed when minimizing on Windows.
@@ -237,7 +231,7 @@ impl State {
pub fn on_window_event( pub fn on_window_event(
&mut self, &mut self,
egui_ctx: &egui::Context, egui_ctx: &egui::Context,
event: &winit::event::WindowEvent<'_>, event: &winit::event::WindowEvent,
) -> EventResponse { ) -> EventResponse {
crate::profile_function!(short_window_event_description(event)); crate::profile_function!(short_window_event_description(event));
@@ -295,25 +289,6 @@ impl State {
consumed, consumed,
} }
} }
WindowEvent::ReceivedCharacter(ch) => {
// On Mac we get here when the user presses Cmd-C (copy), ctrl-W, etc.
// We need to ignore these characters that are side-effects of commands.
let is_mac_cmd = cfg!(target_os = "macos")
&& (self.egui_input.modifiers.ctrl || self.egui_input.modifiers.mac_cmd);
let consumed = if is_printable_char(*ch) && !is_mac_cmd {
self.egui_input
.events
.push(egui::Event::Text(ch.to_string()));
egui_ctx.wants_keyboard_input()
} else {
false
};
EventResponse {
repaint: true,
consumed,
}
}
WindowEvent::Ime(ime) => { WindowEvent::Ime(ime) => {
// on Mac even Cmd-C is pressed during ime, a `c` is pushed to Preedit. // on Mac even Cmd-C is pressed during ime, a `c` is pushed to Preedit.
// So no need to check is_mac_cmd. // So no need to check is_mac_cmd.
@@ -353,11 +328,12 @@ impl State {
consumed: egui_ctx.wants_keyboard_input(), consumed: egui_ctx.wants_keyboard_input(),
} }
} }
WindowEvent::KeyboardInput { input, .. } => { WindowEvent::KeyboardInput { event, .. } => {
self.on_keyboard_input(input);
// When pressing the Tab key, egui focuses the first focusable element, hence Tab always consumes. // When pressing the Tab key, egui focuses the first focusable element, hence Tab always consumes.
let consumed = egui_ctx.wants_keyboard_input() let consumed = self.on_keyboard_input(event)
|| input.virtual_keycode == Some(winit::event::VirtualKeyCode::Tab); || egui_ctx.wants_keyboard_input()
|| event.logical_key
== winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab);
EventResponse { EventResponse {
repaint: true, repaint: true,
consumed, consumed,
@@ -405,14 +381,20 @@ impl State {
} }
} }
WindowEvent::ModifiersChanged(state) => { WindowEvent::ModifiersChanged(state) => {
self.egui_input.modifiers.alt = state.alt(); use winit::keyboard::ModifiersKeyState::Pressed;
self.egui_input.modifiers.ctrl = state.ctrl(); self.egui_input.modifiers.alt =
self.egui_input.modifiers.shift = state.shift(); state.lalt_state() == Pressed || state.ralt_state() == Pressed;
self.egui_input.modifiers.mac_cmd = cfg!(target_os = "macos") && state.logo(); self.egui_input.modifiers.ctrl =
state.lcontrol_state() == Pressed || state.rcontrol_state() == Pressed;
self.egui_input.modifiers.shift =
state.lshift_state() == Pressed || state.rshift_state() == Pressed;
self.egui_input.modifiers.mac_cmd = cfg!(target_os = "macos")
&& (state.lsuper_state() == Pressed || state.rsuper_state() == Pressed);
self.egui_input.modifiers.command = if cfg!(target_os = "macos") { self.egui_input.modifiers.command = if cfg!(target_os = "macos") {
state.logo() state.lsuper_state() == Pressed || state.rsuper_state() == Pressed
} else { } else {
state.ctrl() state.lcontrol_state() == Pressed || state.rcontrol_state() == Pressed
}; };
EventResponse { EventResponse {
repaint: true, repaint: true,
@@ -420,6 +402,16 @@ impl State {
} }
} }
winit::event::WindowEvent::RedrawRequested => EventResponse {
repaint: true,
consumed: false,
},
winit::event::WindowEvent::ActivationTokenDone { .. } => EventResponse {
repaint: false,
consumed: false,
},
// Things that may require repaint: // Things that may require repaint:
WindowEvent::CloseRequested => EventResponse { WindowEvent::CloseRequested => EventResponse {
consumed: true, consumed: true,
@@ -649,17 +641,19 @@ impl State {
} }
} }
fn on_keyboard_input(&mut self, input: &winit::event::KeyboardInput) { fn on_keyboard_input(&mut self, input: &winit::event::KeyEvent) -> bool {
if let Some(keycode) = input.virtual_keycode { if let winit::keyboard::PhysicalKey::Code(keycode) = input.physical_key {
let pressed = input.state == winit::event::ElementState::Pressed; let pressed = input.state == winit::event::ElementState::Pressed;
if pressed { if pressed {
// VirtualKeyCode::Paste etc in winit are broken/untrustworthy, // KeyCode::Paste etc in winit are broken/untrustworthy,
// so we detect these things manually: // so we detect these things manually:
if is_cut_command(self.egui_input.modifiers, keycode) { if is_cut_command(self.egui_input.modifiers, keycode) {
self.egui_input.events.push(egui::Event::Cut); self.egui_input.events.push(egui::Event::Cut);
return true;
} else if is_copy_command(self.egui_input.modifiers, keycode) { } else if is_copy_command(self.egui_input.modifiers, keycode) {
self.egui_input.events.push(egui::Event::Copy); self.egui_input.events.push(egui::Event::Copy);
return true;
} else if is_paste_command(self.egui_input.modifiers, keycode) { } else if is_paste_command(self.egui_input.modifiers, keycode) {
if let Some(contents) = self.clipboard.get() { if let Some(contents) = self.clipboard.get() {
let contents = contents.replace("\r\n", "\n"); let contents = contents.replace("\r\n", "\n");
@@ -667,10 +661,11 @@ impl State {
self.egui_input.events.push(egui::Event::Paste(contents)); self.egui_input.events.push(egui::Event::Paste(contents));
} }
} }
return true;
} }
} }
if let Some(key) = translate_virtual_key_code(keycode) { if let Some(key) = translate_key_code(keycode) {
self.egui_input.events.push(egui::Event::Key { self.egui_input.events.push(egui::Event::Key {
key, key,
pressed, pressed,
@@ -679,6 +674,14 @@ impl State {
}); });
} }
} }
if let Some(text) = &input.text {
self.egui_input
.events
.push(egui::Event::Text(text.to_string()));
}
false
} }
/// Call with the output given by `egui`. /// Call with the output given by `egui`.
@@ -728,7 +731,14 @@ impl State {
} }
if let Some(egui::Pos2 { x, y }) = text_cursor_pos { if let Some(egui::Pos2 { x, y }) = text_cursor_pos {
window.set_ime_position(winit::dpi::LogicalPosition { x, y }); window.set_ime_cursor_area(
winit::dpi::LogicalPosition { x, y },
winit::dpi::LogicalSize {
// TODO: What size to use? New size arg in winit 0.29
width: 10,
height: 10,
},
);
} }
#[cfg(feature = "accesskit")] #[cfg(feature = "accesskit")]
@@ -851,37 +861,25 @@ fn open_url_in_browser(_url: &str) {
} }
} }
/// Winit sends special keys (backspace, delete, F1, …) as characters. fn is_cut_command(modifiers: egui::Modifiers, keycode: winit::keyboard::KeyCode) -> bool {
/// Ignore those. (modifiers.command && keycode == winit::keyboard::KeyCode::KeyX)
/// We also ignore '\r', '\n', '\t'.
/// Newlines are handled by the `Key::Enter` event.
fn is_printable_char(chr: char) -> bool {
let is_in_private_use_area = '\u{e000}' <= chr && chr <= '\u{f8ff}'
|| '\u{f0000}' <= chr && chr <= '\u{ffffd}'
|| '\u{100000}' <= chr && chr <= '\u{10fffd}';
!is_in_private_use_area && !chr.is_ascii_control()
}
fn is_cut_command(modifiers: egui::Modifiers, keycode: winit::event::VirtualKeyCode) -> bool {
(modifiers.command && keycode == winit::event::VirtualKeyCode::X)
|| (cfg!(target_os = "windows") || (cfg!(target_os = "windows")
&& modifiers.shift && modifiers.shift
&& keycode == winit::event::VirtualKeyCode::Delete) && keycode == winit::keyboard::KeyCode::Delete)
} }
fn is_copy_command(modifiers: egui::Modifiers, keycode: winit::event::VirtualKeyCode) -> bool { fn is_copy_command(modifiers: egui::Modifiers, keycode: winit::keyboard::KeyCode) -> bool {
(modifiers.command && keycode == winit::event::VirtualKeyCode::C) (modifiers.command && keycode == winit::keyboard::KeyCode::KeyC)
|| (cfg!(target_os = "windows") || (cfg!(target_os = "windows")
&& modifiers.ctrl && modifiers.ctrl
&& keycode == winit::event::VirtualKeyCode::Insert) && keycode == winit::keyboard::KeyCode::Insert)
} }
fn is_paste_command(modifiers: egui::Modifiers, keycode: winit::event::VirtualKeyCode) -> bool { fn is_paste_command(modifiers: egui::Modifiers, keycode: winit::keyboard::KeyCode) -> bool {
(modifiers.command && keycode == winit::event::VirtualKeyCode::V) (modifiers.command && keycode == winit::keyboard::KeyCode::KeyV)
|| (cfg!(target_os = "windows") || (cfg!(target_os = "windows")
&& modifiers.shift && modifiers.shift
&& keycode == winit::event::VirtualKeyCode::Insert) && keycode == winit::keyboard::KeyCode::Insert)
} }
fn translate_mouse_button(button: winit::event::MouseButton) -> Option<egui::PointerButton> { fn translate_mouse_button(button: winit::event::MouseButton) -> Option<egui::PointerButton> {
@@ -889,100 +887,99 @@ fn translate_mouse_button(button: winit::event::MouseButton) -> Option<egui::Poi
winit::event::MouseButton::Left => Some(egui::PointerButton::Primary), winit::event::MouseButton::Left => Some(egui::PointerButton::Primary),
winit::event::MouseButton::Right => Some(egui::PointerButton::Secondary), winit::event::MouseButton::Right => Some(egui::PointerButton::Secondary),
winit::event::MouseButton::Middle => Some(egui::PointerButton::Middle), winit::event::MouseButton::Middle => Some(egui::PointerButton::Middle),
winit::event::MouseButton::Other(1) => Some(egui::PointerButton::Extra1), winit::event::MouseButton::Back => Some(egui::PointerButton::Extra1),
winit::event::MouseButton::Other(2) => Some(egui::PointerButton::Extra2), winit::event::MouseButton::Forward => Some(egui::PointerButton::Extra2),
winit::event::MouseButton::Other(_) => None, winit::event::MouseButton::Other(_) => None,
} }
} }
fn translate_virtual_key_code(key: winit::event::VirtualKeyCode) -> Option<egui::Key> { fn translate_key_code(key: winit::keyboard::KeyCode) -> Option<egui::Key> {
use egui::Key; use egui::Key;
use winit::event::VirtualKeyCode; use winit::keyboard::KeyCode;
Some(match key { Some(match key {
VirtualKeyCode::Down => Key::ArrowDown, KeyCode::ArrowDown => Key::ArrowDown,
VirtualKeyCode::Left => Key::ArrowLeft, KeyCode::ArrowLeft => Key::ArrowLeft,
VirtualKeyCode::Right => Key::ArrowRight, KeyCode::ArrowRight => Key::ArrowRight,
VirtualKeyCode::Up => Key::ArrowUp, KeyCode::ArrowUp => Key::ArrowUp,
VirtualKeyCode::Escape => Key::Escape, KeyCode::Escape => Key::Escape,
VirtualKeyCode::Tab => Key::Tab, KeyCode::Tab => Key::Tab,
VirtualKeyCode::Back => Key::Backspace, KeyCode::Backspace => Key::Backspace,
VirtualKeyCode::Return | VirtualKeyCode::NumpadEnter => Key::Enter, KeyCode::Enter | KeyCode::NumpadEnter => Key::Enter,
VirtualKeyCode::Space => Key::Space, KeyCode::Space => Key::Space,
VirtualKeyCode::Insert => Key::Insert, KeyCode::Insert => Key::Insert,
VirtualKeyCode::Delete => Key::Delete, KeyCode::Delete => Key::Delete,
VirtualKeyCode::Home => Key::Home, KeyCode::Home => Key::Home,
VirtualKeyCode::End => Key::End, KeyCode::End => Key::End,
VirtualKeyCode::PageUp => Key::PageUp, KeyCode::PageUp => Key::PageUp,
VirtualKeyCode::PageDown => Key::PageDown, KeyCode::PageDown => Key::PageDown,
KeyCode::Minus | KeyCode::NumpadSubtract => Key::Minus,
VirtualKeyCode::Minus | VirtualKeyCode::NumpadSubtract => Key::Minus,
// Using Mac the key with the Plus sign on it is reported as the Equals key // Using Mac the key with the Plus sign on it is reported as the Equals key
// (with both English and Swedish keyboard). // (with both English and Swedish keyboard).
VirtualKeyCode::Equals | VirtualKeyCode::Plus | VirtualKeyCode::NumpadAdd => { KeyCode::Equal | KeyCode::NumpadAdd => Key::PlusEquals,
Key::PlusEquals
}
VirtualKeyCode::Key0 | VirtualKeyCode::Numpad0 => Key::Num0, KeyCode::Digit0 | KeyCode::Numpad0 => Key::Num0,
VirtualKeyCode::Key1 | VirtualKeyCode::Numpad1 => Key::Num1, KeyCode::Digit1 | KeyCode::Numpad1 => Key::Num1,
VirtualKeyCode::Key2 | VirtualKeyCode::Numpad2 => Key::Num2, KeyCode::Digit2 | KeyCode::Numpad2 => Key::Num2,
VirtualKeyCode::Key3 | VirtualKeyCode::Numpad3 => Key::Num3, KeyCode::Digit3 | KeyCode::Numpad3 => Key::Num3,
VirtualKeyCode::Key4 | VirtualKeyCode::Numpad4 => Key::Num4, KeyCode::Digit4 | KeyCode::Numpad4 => Key::Num4,
VirtualKeyCode::Key5 | VirtualKeyCode::Numpad5 => Key::Num5, KeyCode::Digit5 | KeyCode::Numpad5 => Key::Num5,
VirtualKeyCode::Key6 | VirtualKeyCode::Numpad6 => Key::Num6, KeyCode::Digit6 | KeyCode::Numpad6 => Key::Num6,
VirtualKeyCode::Key7 | VirtualKeyCode::Numpad7 => Key::Num7, KeyCode::Digit7 | KeyCode::Numpad7 => Key::Num7,
VirtualKeyCode::Key8 | VirtualKeyCode::Numpad8 => Key::Num8, KeyCode::Digit8 | KeyCode::Numpad8 => Key::Num8,
VirtualKeyCode::Key9 | VirtualKeyCode::Numpad9 => Key::Num9, KeyCode::Digit9 | KeyCode::Numpad9 => Key::Num9,
VirtualKeyCode::A => Key::A, KeyCode::KeyA => Key::A,
VirtualKeyCode::B => Key::B, KeyCode::KeyB => Key::B,
VirtualKeyCode::C => Key::C, KeyCode::KeyC => Key::C,
VirtualKeyCode::D => Key::D, KeyCode::KeyD => Key::D,
VirtualKeyCode::E => Key::E, KeyCode::KeyE => Key::E,
VirtualKeyCode::F => Key::F, KeyCode::KeyF => Key::F,
VirtualKeyCode::G => Key::G, KeyCode::KeyG => Key::G,
VirtualKeyCode::H => Key::H, KeyCode::KeyH => Key::H,
VirtualKeyCode::I => Key::I, KeyCode::KeyI => Key::I,
VirtualKeyCode::J => Key::J, KeyCode::KeyJ => Key::J,
VirtualKeyCode::K => Key::K, KeyCode::KeyK => Key::K,
VirtualKeyCode::L => Key::L, KeyCode::KeyL => Key::L,
VirtualKeyCode::M => Key::M, KeyCode::KeyM => Key::M,
VirtualKeyCode::N => Key::N, KeyCode::KeyN => Key::N,
VirtualKeyCode::O => Key::O, KeyCode::KeyO => Key::O,
VirtualKeyCode::P => Key::P, KeyCode::KeyP => Key::P,
VirtualKeyCode::Q => Key::Q, KeyCode::KeyQ => Key::Q,
VirtualKeyCode::R => Key::R, KeyCode::KeyR => Key::R,
VirtualKeyCode::S => Key::S, KeyCode::KeyS => Key::S,
VirtualKeyCode::T => Key::T, KeyCode::KeyT => Key::T,
VirtualKeyCode::U => Key::U, KeyCode::KeyU => Key::U,
VirtualKeyCode::V => Key::V, KeyCode::KeyV => Key::V,
VirtualKeyCode::W => Key::W, KeyCode::KeyW => Key::W,
VirtualKeyCode::X => Key::X, KeyCode::KeyX => Key::X,
VirtualKeyCode::Y => Key::Y, KeyCode::KeyY => Key::Y,
VirtualKeyCode::Z => Key::Z, KeyCode::KeyZ => Key::Z,
VirtualKeyCode::F1 => Key::F1, KeyCode::F1 => Key::F1,
VirtualKeyCode::F2 => Key::F2, KeyCode::F2 => Key::F2,
VirtualKeyCode::F3 => Key::F3, KeyCode::F3 => Key::F3,
VirtualKeyCode::F4 => Key::F4, KeyCode::F4 => Key::F4,
VirtualKeyCode::F5 => Key::F5, KeyCode::F5 => Key::F5,
VirtualKeyCode::F6 => Key::F6, KeyCode::F6 => Key::F6,
VirtualKeyCode::F7 => Key::F7, KeyCode::F7 => Key::F7,
VirtualKeyCode::F8 => Key::F8, KeyCode::F8 => Key::F8,
VirtualKeyCode::F9 => Key::F9, KeyCode::F9 => Key::F9,
VirtualKeyCode::F10 => Key::F10, KeyCode::F10 => Key::F10,
VirtualKeyCode::F11 => Key::F11, KeyCode::F11 => Key::F11,
VirtualKeyCode::F12 => Key::F12, KeyCode::F12 => Key::F12,
VirtualKeyCode::F13 => Key::F13, KeyCode::F13 => Key::F13,
VirtualKeyCode::F14 => Key::F14, KeyCode::F14 => Key::F14,
VirtualKeyCode::F15 => Key::F15, KeyCode::F15 => Key::F15,
VirtualKeyCode::F16 => Key::F16, KeyCode::F16 => Key::F16,
VirtualKeyCode::F17 => Key::F17, KeyCode::F17 => Key::F17,
VirtualKeyCode::F18 => Key::F18, KeyCode::F18 => Key::F18,
VirtualKeyCode::F19 => Key::F19, KeyCode::F19 => Key::F19,
VirtualKeyCode::F20 => Key::F20, KeyCode::F20 => Key::F20,
_ => { _ => {
return None; return None;
@@ -1007,7 +1004,7 @@ fn translate_cursor(cursor_icon: egui::CursorIcon) -> Option<winit::window::Curs
egui::CursorIcon::Move => Some(winit::window::CursorIcon::Move), egui::CursorIcon::Move => Some(winit::window::CursorIcon::Move),
egui::CursorIcon::NoDrop => Some(winit::window::CursorIcon::NoDrop), egui::CursorIcon::NoDrop => Some(winit::window::CursorIcon::NoDrop),
egui::CursorIcon::NotAllowed => Some(winit::window::CursorIcon::NotAllowed), egui::CursorIcon::NotAllowed => Some(winit::window::CursorIcon::NotAllowed),
egui::CursorIcon::PointingHand => Some(winit::window::CursorIcon::Hand), egui::CursorIcon::PointingHand => Some(winit::window::CursorIcon::Pointer),
egui::CursorIcon::Progress => Some(winit::window::CursorIcon::Progress), egui::CursorIcon::Progress => Some(winit::window::CursorIcon::Progress),
egui::CursorIcon::ResizeHorizontal => Some(winit::window::CursorIcon::EwResize), egui::CursorIcon::ResizeHorizontal => Some(winit::window::CursorIcon::EwResize),
@@ -1068,7 +1065,7 @@ pub fn process_viewport_commands(
ViewportCommand::InnerSize(size) => { ViewportCommand::InnerSize(size) => {
let width = size.x.max(1.0); let width = size.x.max(1.0);
let height = size.y.max(1.0); let height = size.y.max(1.0);
window.set_inner_size(LogicalSize::new(width, height)); let _ = window.request_inner_size(LogicalSize::new(width, height));
} }
ViewportCommand::BeginResize(direction) => { ViewportCommand::BeginResize(direction) => {
if let Err(err) = window.drag_resize_window(match direction { if let Err(err) = window.drag_resize_window(match direction {
@@ -1148,7 +1145,14 @@ pub fn process_viewport_commands(
})); }));
} }
ViewportCommand::IMEPosition(pos) => { ViewportCommand::IMEPosition(pos) => {
window.set_ime_position(LogicalPosition::new(pos.x, pos.y)); window.set_ime_cursor_area(
LogicalPosition::new(pos.x, pos.y),
winit::dpi::LogicalSize {
// TODO: What size to use? New size arg in winit 0.29
width: 10,
height: 10,
},
);
} }
ViewportCommand::IMEAllowed(v) => window.set_ime_allowed(v), ViewportCommand::IMEAllowed(v) => window.set_ime_allowed(v),
ViewportCommand::IMEPurpose(p) => window.set_ime_purpose(match p { ViewportCommand::IMEPurpose(p) => window.set_ime_purpose(match p {
@@ -1337,16 +1341,15 @@ pub fn apply_viewport_builder_to_new_window(window: &Window, builder: &ViewportB
/// Short and fast description of an event. /// Short and fast description of an event.
/// Useful for logging and profiling. /// Useful for logging and profiling.
pub fn short_generic_event_description<T>(event: &winit::event::Event<'_, T>) -> &'static str { pub fn short_generic_event_description<T>(event: &winit::event::Event<T>) -> &'static str {
use winit::event::{DeviceEvent, Event, StartCause}; use winit::event::{DeviceEvent, Event, StartCause};
match event { match event {
Event::AboutToWait => "Event::AboutToWait",
Event::LoopExiting => "Event::LoopExiting",
Event::Suspended => "Event::Suspended", Event::Suspended => "Event::Suspended",
Event::Resumed => "Event::Resumed", Event::Resumed => "Event::Resumed",
Event::MainEventsCleared => "Event::MainEventsCleared", Event::MemoryWarning => "Event::MemoryWarning",
Event::RedrawRequested(_) => "Event::RedrawRequested",
Event::RedrawEventsCleared => "Event::RedrawEventsCleared",
Event::LoopDestroyed => "Event::LoopDestroyed",
Event::UserEvent(_) => "UserEvent", Event::UserEvent(_) => "UserEvent",
Event::DeviceEvent { event, .. } => match event { Event::DeviceEvent { event, .. } => match event {
DeviceEvent::Added { .. } => "DeviceEvent::Added", DeviceEvent::Added { .. } => "DeviceEvent::Added",
@@ -1356,7 +1359,6 @@ pub fn short_generic_event_description<T>(event: &winit::event::Event<'_, T>) ->
DeviceEvent::Motion { .. } => "DeviceEvent::Motion", DeviceEvent::Motion { .. } => "DeviceEvent::Motion",
DeviceEvent::Button { .. } => "DeviceEvent::Button", DeviceEvent::Button { .. } => "DeviceEvent::Button",
DeviceEvent::Key { .. } => "DeviceEvent::Key", DeviceEvent::Key { .. } => "DeviceEvent::Key",
DeviceEvent::Text { .. } => "DeviceEvent::Text",
}, },
Event::NewEvents(start_cause) => match start_cause { Event::NewEvents(start_cause) => match start_cause {
StartCause::ResumeTimeReached { .. } => "NewEvents::ResumeTimeReached", StartCause::ResumeTimeReached { .. } => "NewEvents::ResumeTimeReached",
@@ -1370,10 +1372,11 @@ pub fn short_generic_event_description<T>(event: &winit::event::Event<'_, T>) ->
/// Short and fast description of an event. /// Short and fast description of an event.
/// Useful for logging and profiling. /// Useful for logging and profiling.
pub fn short_window_event_description(event: &winit::event::WindowEvent<'_>) -> &'static str { pub fn short_window_event_description(event: &winit::event::WindowEvent) -> &'static str {
use winit::event::WindowEvent; use winit::event::WindowEvent;
match event { match event {
WindowEvent::ActivationTokenDone { .. } => "WindowEvent::ActivationTokenDone",
WindowEvent::Resized { .. } => "WindowEvent::Resized", WindowEvent::Resized { .. } => "WindowEvent::Resized",
WindowEvent::Moved { .. } => "WindowEvent::Moved", WindowEvent::Moved { .. } => "WindowEvent::Moved",
WindowEvent::CloseRequested { .. } => "WindowEvent::CloseRequested", WindowEvent::CloseRequested { .. } => "WindowEvent::CloseRequested",
@@ -1381,7 +1384,6 @@ pub fn short_window_event_description(event: &winit::event::WindowEvent<'_>) ->
WindowEvent::DroppedFile { .. } => "WindowEvent::DroppedFile", WindowEvent::DroppedFile { .. } => "WindowEvent::DroppedFile",
WindowEvent::HoveredFile { .. } => "WindowEvent::HoveredFile", WindowEvent::HoveredFile { .. } => "WindowEvent::HoveredFile",
WindowEvent::HoveredFileCancelled { .. } => "WindowEvent::HoveredFileCancelled", WindowEvent::HoveredFileCancelled { .. } => "WindowEvent::HoveredFileCancelled",
WindowEvent::ReceivedCharacter { .. } => "WindowEvent::ReceivedCharacter",
WindowEvent::Focused { .. } => "WindowEvent::Focused", WindowEvent::Focused { .. } => "WindowEvent::Focused",
WindowEvent::KeyboardInput { .. } => "WindowEvent::KeyboardInput", WindowEvent::KeyboardInput { .. } => "WindowEvent::KeyboardInput",
WindowEvent::ModifiersChanged { .. } => "WindowEvent::ModifiersChanged", WindowEvent::ModifiersChanged { .. } => "WindowEvent::ModifiersChanged",
@@ -1392,6 +1394,7 @@ pub fn short_window_event_description(event: &winit::event::WindowEvent<'_>) ->
WindowEvent::MouseWheel { .. } => "WindowEvent::MouseWheel", WindowEvent::MouseWheel { .. } => "WindowEvent::MouseWheel",
WindowEvent::MouseInput { .. } => "WindowEvent::MouseInput", WindowEvent::MouseInput { .. } => "WindowEvent::MouseInput",
WindowEvent::TouchpadMagnify { .. } => "WindowEvent::TouchpadMagnify", WindowEvent::TouchpadMagnify { .. } => "WindowEvent::TouchpadMagnify",
WindowEvent::RedrawRequested { .. } => "WindowEvent::RedrawRequested",
WindowEvent::SmartMagnify { .. } => "WindowEvent::SmartMagnify", WindowEvent::SmartMagnify { .. } => "WindowEvent::SmartMagnify",
WindowEvent::TouchpadRotate { .. } => "WindowEvent::TouchpadRotate", WindowEvent::TouchpadRotate { .. } => "WindowEvent::TouchpadRotate",
WindowEvent::TouchpadPressure { .. } => "WindowEvent::TouchpadPressure", WindowEvent::TouchpadPressure { .. } => "WindowEvent::TouchpadPressure",

4
crates/egui_glow/Cargo.toml
View File

@@ -69,9 +69,9 @@ wasm-bindgen = "0.2"
[dev-dependencies] [dev-dependencies]
glutin = "0.30" # examples/pure_glow glutin = "0.31" # examples/pure_glow
raw-window-handle.workspace = true raw-window-handle.workspace = true
glutin-winit = "0.3.0" glutin-winit = "0.4.0"
[[example]] [[example]]

55
crates/egui_glow/examples/pure_glow.rs
View File

@@ -19,7 +19,7 @@ impl GlutinWindowContext {
#[allow(unsafe_code)] #[allow(unsafe_code)]
unsafe fn new(event_loop: &winit::event_loop::EventLoopWindowTarget<UserEvent>) -> Self { unsafe fn new(event_loop: &winit::event_loop::EventLoopWindowTarget<UserEvent>) -> Self {
use egui::NumExt; use egui::NumExt;
use glutin::context::NotCurrentGlContextSurfaceAccessor; use glutin::context::NotCurrentGlContext;
use glutin::display::GetGlDisplay; use glutin::display::GetGlDisplay;
use glutin::display::GlDisplay; use glutin::display::GlDisplay;
use glutin::prelude::GlSurface; use glutin::prelude::GlSurface;
@@ -42,7 +42,7 @@ impl GlutinWindowContext {
log::debug!("trying to get gl_config"); log::debug!("trying to get gl_config");
let (mut window, gl_config) = let (mut window, gl_config) =
glutin_winit::DisplayBuilder::new() // let glutin-winit helper crate handle the complex parts of opengl context creation glutin_winit::DisplayBuilder::new() // let glutin-winit helper crate handle the complex parts of opengl context creation
.with_preference(glutin_winit::ApiPrefence::FallbackEgl) // https://github.com/emilk/egui/issues/2520#issuecomment-1367841150 .with_preference(glutin_winit::ApiPreference::FallbackEgl) // https://github.com/emilk/egui/issues/2520#issuecomment-1367841150
.with_window_builder(Some(winit_window_builder.clone())) .with_window_builder(Some(winit_window_builder.clone()))
.build( .build(
event_loop, event_loop,
@@ -150,7 +150,9 @@ pub enum UserEvent {
fn main() { fn main() {
let mut clear_color = [0.1, 0.1, 0.1]; let mut clear_color = [0.1, 0.1, 0.1];
let event_loop = winit::event_loop::EventLoopBuilder::<UserEvent>::with_user_event().build(); let event_loop = winit::event_loop::EventLoopBuilder::<UserEvent>::with_user_event()
.build()
.unwrap();
let (gl_window, gl) = create_display(&event_loop); let (gl_window, gl) = create_display(&event_loop);
let gl = std::rc::Rc::new(gl); let gl = std::rc::Rc::new(gl);
@@ -168,7 +170,7 @@ fn main() {
let mut repaint_delay = std::time::Duration::MAX; let mut repaint_delay = std::time::Duration::MAX;
event_loop.run(move |event, _, control_flow| { let _ = event_loop.run(move |event, event_loop_window_target| {
let mut redraw = || { let mut redraw = || {
let mut quit = false; let mut quit = false;
@@ -182,18 +184,20 @@ fn main() {
}); });
}); });
*control_flow = if quit { if quit {
winit::event_loop::ControlFlow::Exit event_loop_window_target.exit();
} else if repaint_delay.is_zero() {
gl_window.window().request_redraw();
winit::event_loop::ControlFlow::Poll
} else if let Some(repaint_delay_instant) =
std::time::Instant::now().checked_add(repaint_delay)
{
winit::event_loop::ControlFlow::WaitUntil(repaint_delay_instant)
} else { } else {
winit::event_loop::ControlFlow::Wait event_loop_window_target.set_control_flow(if repaint_delay.is_zero() {
}; gl_window.window().request_redraw();
winit::event_loop::ControlFlow::Poll
} else if let Some(repaint_after_instant) =
std::time::Instant::now().checked_add(repaint_delay)
{
winit::event_loop::ControlFlow::WaitUntil(repaint_after_instant)
} else {
winit::event_loop::ControlFlow::Wait
});
}
{ {
unsafe { unsafe {
@@ -217,22 +221,23 @@ fn main() {
// Platform-dependent event handlers to workaround a winit bug // Platform-dependent event handlers to workaround a winit bug
// See: https://github.com/rust-windowing/winit/issues/987 // See: https://github.com/rust-windowing/winit/issues/987
// See: https://github.com/rust-windowing/winit/issues/1619 // See: https://github.com/rust-windowing/winit/issues/1619
winit::event::Event::RedrawEventsCleared if cfg!(target_os = "windows") => redraw(), // winit::event::Event::RedrawEventsCleared if cfg!(target_os = "windows") => redraw(),
winit::event::Event::RedrawRequested(_) if !cfg!(target_os = "windows") => redraw(), // winit::event::Event::RedrawRequested(_) if !cfg!(target_os = "windows") => redraw(),
// TODO: Adopt to above comment (if still relevant)
winit::event::Event::WindowEvent { event, .. } => { winit::event::Event::WindowEvent { event, .. } => {
use winit::event::WindowEvent; use winit::event::WindowEvent;
if matches!(event, WindowEvent::CloseRequested | WindowEvent::Destroyed) { if matches!(event, WindowEvent::CloseRequested | WindowEvent::Destroyed) {
*control_flow = winit::event_loop::ControlFlow::Exit; event_loop_window_target.exit();
return;
}
if matches!(event, WindowEvent::RedrawRequested) {
redraw();
return;
} }
if let winit::event::WindowEvent::Resized(physical_size) = &event { if let winit::event::WindowEvent::Resized(physical_size) = &event {
gl_window.resize(*physical_size); gl_window.resize(*physical_size);
} else if let winit::event::WindowEvent::ScaleFactorChanged {
new_inner_size, ..
} = &event
{
gl_window.resize(**new_inner_size);
} }
let event_response = egui_glow.on_window_event(&event); let event_response = egui_glow.on_window_event(&event);
@@ -245,7 +250,7 @@ fn main() {
winit::event::Event::UserEvent(UserEvent::Redraw(delay)) => { winit::event::Event::UserEvent(UserEvent::Redraw(delay)) => {
repaint_delay = delay; repaint_delay = delay;
} }
winit::event::Event::LoopDestroyed => { winit::event::Event::LoopExiting => {
egui_glow.destroy(); egui_glow.destroy();
} }
winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached { winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {

2
crates/egui_glow/src/winit.rs
View File

@@ -52,7 +52,7 @@ impl EguiGlow {
} }
} }
pub fn on_window_event(&mut self, event: &winit::event::WindowEvent<'_>) -> EventResponse { pub fn on_window_event(&mut self, event: &winit::event::WindowEvent) -> EventResponse {
self.egui_winit.on_window_event(&self.egui_ctx, event) self.egui_winit.on_window_event(&self.egui_ctx, event)
} }