Which version of egui should I use with winit

[oawad79]

I am trying to run egui with winit but need to know what version of egui need to use?

here are my current dependencies

[dependencies]
glow = "0.16.0"
bytemuck = "1.14.0"
nalgebra-glm = "0.20.0"
glutin = "0.31.2"
glutin-winit = "0.4.2"
winit = "0.29.10"

what version of egui, egui-winit I need to use?

[aspcartman]

As of right now egui 0.33.0 asks for winit - 0.30.12.

You can lookup the history of

egui/Cargo.toml

Line 145 in bf5604b

winit = { version = "0.30.12", default-features = false }

and find the latest egui version that is ok with winit you need.

UPD: Updated the link

[oawad79]

thanks, I guess I will upgrade to latest

trying to run the example from the docs site show the window minimized and clicking it does not bring it up on debian 13, any idea why?

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

#[derive(Default)]
struct App {
    window: Option<Window>,
}

impl ApplicationHandler for App {
    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, id: WindowId, event: WindowEvent) {
        match event {
            WindowEvent::CloseRequested => {
                println!("The close button was pressed; stopping");
                event_loop.exit();
            },
            WindowEvent::RedrawRequested => {
                // Redraw the application.
                //
                // It's preferable for applications that do not render continuously to render in
                // this event rather than in AboutToWait, since rendering in here allows
                // the program to gracefully handle redraws requested by the OS.

                // Draw.

                // Queue a RedrawRequested event.
                //
                // You only need to call this if you've determined that you need to redraw in
                // applications which do not always need to. Applications that redraw continuously
                // can render here instead.
                self.window.as_ref().unwrap().request_redraw();
            }
            _ => (),
        }
    }
}

fn main() {
    let event_loop = EventLoop::new().unwrap();

    // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
    // dispatched any events. This is ideal for games and similar applications.
    event_loop.set_control_flow(ControlFlow::Poll);

    // ControlFlow::Wait pauses the event loop if no events are available to process.
    // This is ideal for non-game applications that only update in response to user
    // input, and uses significantly less power/CPU time than ControlFlow::Poll.
    event_loop.set_control_flow(ControlFlow::Wait);

    let mut app = App::default();
    event_loop.run_app(&mut app);
}