Struct EventLoop

pub struct EventLoop<T>
where
    T: 'static,
{ /* private fields */ }

Provides a way to retrieve events from the system and from the windows that were registered to the events loop.

An EventLoop can be seen more or less as a “context”. Calling EventLoop::new initializes everything that will be required to create windows. For example on Linux creating an event loop opens a connection to the X or Wayland server.

To wake up an EventLoop from a another thread, see the EventLoopProxy docs.

Note that this cannot be shared across threads (due to platform-dependant logic forbidding it), as such it is neither Send nor Sync. If you need cross-thread access, the Window created from this can be sent to an other thread, and the EventLoopProxy allows you to wake up an EventLoop from another thread.

Implementations

impl EventLoop<()>

pub fn new() -> Result<EventLoop<()>, EventLoopError>

Create the event loop.

This is an alias of EventLoop::builder().build().

Examples found in repository

examples/minimum.rs (line 3)

fn main() {
    let event_loop = EventLoop::new().unwrap();
    thin_engine::builder(input_map!()).with_update(|_, display, _, _, _| {
        let mut frame = display.draw();
        frame.clear_color(0.1, 0.7, 0.4, 1.0);
        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

examples/simple.rs (line 11)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);
    
    let input = { use base_input_codes::*; input_map!(
        (Jump,    Space,  GamepadInput::South),
        (Exit,    Escape, GamepadInput::Start),
        (Left,    ArrowLeft,  KeyA,  LeftStickLeft ),
        (Right,   ArrowRight, KeyD,  LeftStickRight),
        (Forward, ArrowUp,    KeyW,  LeftStickUp   ),
        (Back,    ArrowDown,  KeyS,  LeftStickDown ),
        (LookRight, MouseMoveRight, RightStickRight),
        (LookLeft,  MouseMoveLeft,  RightStickLeft ),
        (LookUp,    MouseMoveUp,    RightStickUp   ),
        (LookDown,  MouseMoveDown,  RightStickDown )
    )};

    struct Graphics {
        program: Program,
        indices: IndexBuffer<u16>,
        vertices: VertexBuffer<Vertex>,
        normals: VertexBuffer<Normal>
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::new(RefCell::new(None));
    let graphics_setup = graphics.clone();
    
    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };

    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    let mut gravity = 0.0;

    let mut frame_start = Instant::now();

    thin_engine::builder(input).with_setup(|display, window, _| {
        let _ = window.set_cursor_grab(CursorGrabMode::Confined);
        let _ = window.set_cursor_grab(CursorGrabMode::Locked);
        window.set_cursor_visible(false);
        window.set_title("Walk Test");

        let (indices, vertices, normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &teapot::NORMALS
        );
        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            const vec3 albedo = vec3(0.1, 1.0, 0.3);
            void main(){
                float light_level = dot(light, v_normal);
                colour = vec4(albedo * light_level, 1.0);
            }", None,
        ).unwrap();
        graphics_setup.replace(Some(Graphics { program, indices, vertices, normals }));
    }).with_update(|input, display, _, target, _| {
        let graphics = graphics.borrow();
        let Graphics { vertices, indices, normals, program } = graphics.as_ref().unwrap();
        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        let mut frame = display.draw();
        let view = Mat4::view_matrix_3d(frame.get_dimensions(), 1.0, 1024.0, 0.1);

        //handle gravity and jump
        gravity += delta_time * 9.5;
        if input.pressed(Jump) { gravity = -10.0 }

        //set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.0);
        rot.y = rot.y.clamp(-PI / 2.0, PI / 2.0);
        let rx = Quat::from_y_rot(rot.x);
        let ry = Quat::from_x_rot(rot.y);
        let rot = rx * ry;

        //move player based on view and gravity
        let dir = input.dir_max_len_1(Right, Left, Forward, Back);
        let move_dir = vec3(dir.x, 0.0, dir.y).scale(5.0*delta_time);
        pos += move_dir.transform(&Mat3::from_rot(rx));
        pos.y = (pos.y - gravity * delta_time).max(0.0);

        if input.pressed(Exit) { target.exit() }

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        //draw teapot
        frame.draw(
            (vertices, normals), indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light: vec3(1.0, -0.9, -1.0).normalise()
            },
            &draw_parameters,
        ).unwrap();

        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

examples/simple-fxaa.rs (line 15)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);

    let mut colour = ResizableTexture2d::default();
    let mut depth = ResizableDepthTexture2d::default();

    let input = { use base_input_codes::*; input_map!(
        (Left,    ArrowLeft,  KeyA, LeftStickLeft ),
        (Right,   ArrowRight, KeyD, LeftStickRight),
        (Forward, ArrowUp,    KeyW, LeftStickUp   ),
        (Back,    ArrowDown,  KeyS, LeftStickDown ),
        (LookRight, MouseMoveRight, RightStickRight),
        (LookLeft,  MouseMoveLeft,  RightStickLeft ),
        (LookUp,    MouseMoveUp,    RightStickUp   ),
        (LookDown,  MouseMoveDown,  RightStickDown ),
        (FXAA,      KeyF,       GamepadInput::North)
    ) };
    struct Graphics {
        screen_indices: IndexBuffer<u32>,
        screen_vertices: VertexBuffer<Vertex>,
        screen_uvs: VertexBuffer<TextureCoords>,

        teapot_indices: IndexBuffer<u16>,
        teapot_vertices: VertexBuffer<Vertex>,
        teapot_uvs: VertexBuffer<TextureCoords>,
        teapot_normals: VertexBuffer<Normal>,

        fxaa: Program, normal: Program, program: Program
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::default();
    let graphics_setup = graphics.clone();

    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };
    let mut fxaa_on = true;
    
    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    
    let mut frame_start = Instant::now();

    thin_engine::builder(input).with_setup(|display, window, _| {
        window.set_title("FXAA Test");
        let _ = window.set_cursor_grab(CursorGrabMode::Confined);
        let _ = window.set_cursor_grab(CursorGrabMode::Locked);
        window.set_cursor_visible(false);

        let (screen_indices, screen_vertices, screen_uvs) = mesh!(
            display, &screen::INDICES, &screen::VERTICES, &screen::UVS
        );
        let (teapot_indices, teapot_vertices, teapot_uvs, teapot_normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &[] as &[TextureCoords; 0], &teapot::NORMALS
        );

        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            uniform mat4 camera;
            uniform vec3 ambient;
            uniform vec3 albedo;
            uniform float shine;
            void main() {
                vec3 camera_dir = inverse(mat3(camera)) * vec3(0, 0, -1);
                vec3 half_dir = normalize(camera_dir + light);
                float specular = pow(max(dot(half_dir, v_normal), 0.0), shine);
                float light_level = max(dot(light, v_normal), 0.0);
                colour = vec4(albedo * light_level + ambient + vec3(specular), 1.0);
            }", None
        ).unwrap();
        let fxaa = shaders::fxaa_shader(display).unwrap();
        let normal = Program::from_source(
            display, shaders::SCREEN_VERTEX, 
            "#version 140
            in vec2 uv;
            uniform sampler2D tex;
            out vec4 colour;
            void main() {
                colour = texture(tex, uv);
            }", None
        ).unwrap();
        graphics_setup.replace(Some(Graphics {
            screen_indices, screen_vertices, screen_uvs,
            teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
            program, normal, fxaa
        }));
    }).with_update(|input, display, _, _, _| {
        let graphics = graphics.borrow();
        let Graphics {
            screen_indices, screen_vertices, screen_uvs,
            teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
            program, normal, fxaa
        } = graphics.as_ref().unwrap();
        let teapot_mesh = (teapot_vertices, teapot_normals, teapot_uvs);
        let screen_mesh = (screen_vertices, screen_uvs);

        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        // using a small resolution to better show the effect of fxaa.
        let size = (380, 216);
        display.resize(size);
        depth.resize_to_display(&display);
        colour.resize_to_display(&display);

        // press f to toggle FXAA
        if input.pressed(FXAA) { fxaa_on = !fxaa_on }

        let colour = colour.texture();
        let depth = depth.texture();
        let mut frame = SimpleFrameBuffer::with_depth_buffer(
            display, colour, depth
        ).unwrap();

        let view = Mat4::view_matrix_3d(size, 1.0, 1024.0, 0.1);

        // set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.0);
        rot.y = rot.y.clamp(-PI / 2.0, PI / 2.0);
        let rx = Quat::from_y_rot(rot.x);
        let ry = Quat::from_x_rot(rot.y);
        let rot = rx * ry;

        // move player based on view
        let dir = input.dir_max_len_1(Right, Left, Forward, Back);
        let move_dir = vec3(dir.x, 0.0, dir.y).scale(5.0*delta_time);
        pos += move_dir.transform(&Mat3::from_rot(rx));

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        // draw teapot
        frame.draw(
            teapot_mesh, teapot_indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light:   vec3(0.1, 0.25, -1.0).normalise(),
                albedo:  vec3(0.5, 0.1,   0.4),
                ambient: vec3(0.0, 0.05,  0.1),
                shine: 50.0f32,
            },
            &draw_parameters,
        ).unwrap();

        let mut frame = display.draw();
        frame.draw(
            screen_mesh, screen_indices, if fxaa_on { fxaa } else { normal },
            &shaders::fxaa_uniforms(colour), &DrawParameters::default()
        ).unwrap();
        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

pub fn builder() -> EventLoopBuilder<()>

Start building a new event loop.

This returns an EventLoopBuilder, to allow configuring the event loop before creation.

To get the actual event loop, call build on that.

impl<T> EventLoop<T>

pub fn with_user_event() -> EventLoopBuilder<T>

Start building a new event loop, with the given type as the user event type.

pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>

where F: FnMut(Event<T>, &ActiveEventLoop),

👎Deprecated: use EventLoop::run_app instead

See run_app.

pub fn run_app<A>(self, app: &mut A) -> Result<(), EventLoopError>

where A: ApplicationHandler<T>,

Run the application with the event loop on the calling thread.

See the set_control_flow() docs on how to change the event loop’s behavior.

Platform-specific

• iOS: Will never return to the caller and so values not passed to this function will not be dropped before the process exits.

• Web: Will act as if it never returns to the caller by throwing a Javascript exception (that Rust doesn’t see) that will also mean that the rest of the function is never executed and any values not passed to this function will not be dropped.

  Web applications are recommended to use EventLoopExtWebSys::spawn() ¹ instead of run_app() to avoid the need for the Javascript exception trick, and to make it clearer that the event loop runs asynchronously (via the browser’s own, internal, event loop) and doesn’t block the current thread of execution like it does on other platforms.

  This function won’t be available with target_feature = "exception-handling".

---

1. EventLoopExtWebSys::spawn_app() is only available on Web. ↩

pub fn create_proxy(&self) -> EventLoopProxy<T>

Creates an EventLoopProxy that can be used to dispatch user events to the main event loop, possibly from another thread.

pub fn owned_display_handle(&self) -> OwnedDisplayHandle

Gets a persistent reference to the underlying platform display.

See the OwnedDisplayHandle type for more information.

pub fn listen_device_events(&self, allowed: DeviceEvents)

Change if or when DeviceEvents are captured.

See ActiveEventLoop::listen_device_events for details.

pub fn set_control_flow(&self, control_flow: ControlFlow)

Sets the ControlFlow.

Examples found in repository

examples/simple.rs (line 12)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);
    
    let input = { use base_input_codes::*; input_map!(
        (Jump,    Space,  GamepadInput::South),
        (Exit,    Escape, GamepadInput::Start),
        (Left,    ArrowLeft,  KeyA,  LeftStickLeft ),
        (Right,   ArrowRight, KeyD,  LeftStickRight),
        (Forward, ArrowUp,    KeyW,  LeftStickUp   ),
        (Back,    ArrowDown,  KeyS,  LeftStickDown ),
        (LookRight, MouseMoveRight, RightStickRight),
        (LookLeft,  MouseMoveLeft,  RightStickLeft ),
        (LookUp,    MouseMoveUp,    RightStickUp   ),
        (LookDown,  MouseMoveDown,  RightStickDown )
    )};

    struct Graphics {
        program: Program,
        indices: IndexBuffer<u16>,
        vertices: VertexBuffer<Vertex>,
        normals: VertexBuffer<Normal>
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::new(RefCell::new(None));
    let graphics_setup = graphics.clone();
    
    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };

    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    let mut gravity = 0.0;

    let mut frame_start = Instant::now();

    thin_engine::builder(input).with_setup(|display, window, _| {
        let _ = window.set_cursor_grab(CursorGrabMode::Confined);
        let _ = window.set_cursor_grab(CursorGrabMode::Locked);
        window.set_cursor_visible(false);
        window.set_title("Walk Test");

        let (indices, vertices, normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &teapot::NORMALS
        );
        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            const vec3 albedo = vec3(0.1, 1.0, 0.3);
            void main(){
                float light_level = dot(light, v_normal);
                colour = vec4(albedo * light_level, 1.0);
            }", None,
        ).unwrap();
        graphics_setup.replace(Some(Graphics { program, indices, vertices, normals }));
    }).with_update(|input, display, _, target, _| {
        let graphics = graphics.borrow();
        let Graphics { vertices, indices, normals, program } = graphics.as_ref().unwrap();
        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        let mut frame = display.draw();
        let view = Mat4::view_matrix_3d(frame.get_dimensions(), 1.0, 1024.0, 0.1);

        //handle gravity and jump
        gravity += delta_time * 9.5;
        if input.pressed(Jump) { gravity = -10.0 }

        //set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.0);
        rot.y = rot.y.clamp(-PI / 2.0, PI / 2.0);
        let rx = Quat::from_y_rot(rot.x);
        let ry = Quat::from_x_rot(rot.y);
        let rot = rx * ry;

        //move player based on view and gravity
        let dir = input.dir_max_len_1(Right, Left, Forward, Back);
        let move_dir = vec3(dir.x, 0.0, dir.y).scale(5.0*delta_time);
        pos += move_dir.transform(&Mat3::from_rot(rx));
        pos.y = (pos.y - gravity * delta_time).max(0.0);

        if input.pressed(Exit) { target.exit() }

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        //draw teapot
        frame.draw(
            (vertices, normals), indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light: vec3(1.0, -0.9, -1.0).normalise()
            },
            &draw_parameters,
        ).unwrap();

        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

examples/simple-fxaa.rs (line 16)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);

    let mut colour = ResizableTexture2d::default();
    let mut depth = ResizableDepthTexture2d::default();

    let input = { use base_input_codes::*; input_map!(
        (Left,    ArrowLeft,  KeyA, LeftStickLeft ),
        (Right,   ArrowRight, KeyD, LeftStickRight),
        (Forward, ArrowUp,    KeyW, LeftStickUp   ),
        (Back,    ArrowDown,  KeyS, LeftStickDown ),
        (LookRight, MouseMoveRight, RightStickRight),
        (LookLeft,  MouseMoveLeft,  RightStickLeft ),
        (LookUp,    MouseMoveUp,    RightStickUp   ),
        (LookDown,  MouseMoveDown,  RightStickDown ),
        (FXAA,      KeyF,       GamepadInput::North)
    ) };
    struct Graphics {
        screen_indices: IndexBuffer<u32>,
        screen_vertices: VertexBuffer<Vertex>,
        screen_uvs: VertexBuffer<TextureCoords>,

        teapot_indices: IndexBuffer<u16>,
        teapot_vertices: VertexBuffer<Vertex>,
        teapot_uvs: VertexBuffer<TextureCoords>,
        teapot_normals: VertexBuffer<Normal>,

        fxaa: Program, normal: Program, program: Program
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::default();
    let graphics_setup = graphics.clone();

    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };
    let mut fxaa_on = true;
    
    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    
    let mut frame_start = Instant::now();

    thin_engine::builder(input).with_setup(|display, window, _| {
        window.set_title("FXAA Test");
        let _ = window.set_cursor_grab(CursorGrabMode::Confined);
        let _ = window.set_cursor_grab(CursorGrabMode::Locked);
        window.set_cursor_visible(false);

        let (screen_indices, screen_vertices, screen_uvs) = mesh!(
            display, &screen::INDICES, &screen::VERTICES, &screen::UVS
        );
        let (teapot_indices, teapot_vertices, teapot_uvs, teapot_normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &[] as &[TextureCoords; 0], &teapot::NORMALS
        );

        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            uniform mat4 camera;
            uniform vec3 ambient;
            uniform vec3 albedo;
            uniform float shine;
            void main() {
                vec3 camera_dir = inverse(mat3(camera)) * vec3(0, 0, -1);
                vec3 half_dir = normalize(camera_dir + light);
                float specular = pow(max(dot(half_dir, v_normal), 0.0), shine);
                float light_level = max(dot(light, v_normal), 0.0);
                colour = vec4(albedo * light_level + ambient + vec3(specular), 1.0);
            }", None
        ).unwrap();
        let fxaa = shaders::fxaa_shader(display).unwrap();
        let normal = Program::from_source(
            display, shaders::SCREEN_VERTEX, 
            "#version 140
            in vec2 uv;
            uniform sampler2D tex;
            out vec4 colour;
            void main() {
                colour = texture(tex, uv);
            }", None
        ).unwrap();
        graphics_setup.replace(Some(Graphics {
            screen_indices, screen_vertices, screen_uvs,
            teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
            program, normal, fxaa
        }));
    }).with_update(|input, display, _, _, _| {
        let graphics = graphics.borrow();
        let Graphics {
            screen_indices, screen_vertices, screen_uvs,
            teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
            program, normal, fxaa
        } = graphics.as_ref().unwrap();
        let teapot_mesh = (teapot_vertices, teapot_normals, teapot_uvs);
        let screen_mesh = (screen_vertices, screen_uvs);

        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        // using a small resolution to better show the effect of fxaa.
        let size = (380, 216);
        display.resize(size);
        depth.resize_to_display(&display);
        colour.resize_to_display(&display);

        // press f to toggle FXAA
        if input.pressed(FXAA) { fxaa_on = !fxaa_on }

        let colour = colour.texture();
        let depth = depth.texture();
        let mut frame = SimpleFrameBuffer::with_depth_buffer(
            display, colour, depth
        ).unwrap();

        let view = Mat4::view_matrix_3d(size, 1.0, 1024.0, 0.1);

        // set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.0);
        rot.y = rot.y.clamp(-PI / 2.0, PI / 2.0);
        let rx = Quat::from_y_rot(rot.x);
        let ry = Quat::from_x_rot(rot.y);
        let rot = rx * ry;

        // move player based on view
        let dir = input.dir_max_len_1(Right, Left, Forward, Back);
        let move_dir = vec3(dir.x, 0.0, dir.y).scale(5.0*delta_time);
        pos += move_dir.transform(&Mat3::from_rot(rx));

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        // draw teapot
        frame.draw(
            teapot_mesh, teapot_indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light:   vec3(0.1, 0.25, -1.0).normalise(),
                albedo:  vec3(0.5, 0.1,   0.4),
                ambient: vec3(0.0, 0.05,  0.1),
                shine: 50.0f32,
            },
            &draw_parameters,
        ).unwrap();

        let mut frame = display.draw();
        frame.draw(
            screen_mesh, screen_indices, if fxaa_on { fxaa } else { normal },
            &shaders::fxaa_uniforms(colour), &DrawParameters::default()
        ).unwrap();
        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

pub fn create_window( &self, window_attributes: WindowAttributes, ) -> Result<Window, OsError>

👎Deprecated: use ActiveEventLoop::create_window instead

Create a window.

Creating window without event loop running often leads to improper window creation; use ActiveEventLoop::create_window instead.

pub fn create_custom_cursor( &self, custom_cursor: CustomCursorSource, ) -> CustomCursor

Create custom cursor.

Trait Implementations

impl<T> AsFd for EventLoop<T>

fn as_fd(&self) -> BorrowedFd<'_>

Get the underlying EventLoop’s fd which you can register into other event loop, like calloop or mio. When doing so, the loop must be polled with the pump_app_events API.

impl<T> AsRawFd for EventLoop<T>

fn as_raw_fd(&self) -> i32

Get the underlying EventLoop’s raw fd which you can register into other event loop, like calloop or mio. When doing so, the loop must be polled with the pump_app_events API.

impl<T> Debug for EventLoop<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> EventLoopExtPumpEvents for EventLoop<T>

type UserEvent = T

A type provided by the user that can be passed through Event::UserEvent.

fn pump_events<F>( &mut self, timeout: Option<Duration>, event_handler: F, ) -> PumpStatus

where F: FnMut(Event<<EventLoop<T> as EventLoopExtPumpEvents>::UserEvent>, &ActiveEventLoop),

👎Deprecated: use EventLoopExtPumpEvents::pump_app_events

See pump_app_events.

fn pump_app_events<A>( &mut self, timeout: Option<Duration>, app: &mut A, ) -> PumpStatus

where A: ApplicationHandler<Self::UserEvent>,

Pump the EventLoop to check for and dispatch pending events.

impl<T> EventLoopExtRunOnDemand for EventLoop<T>

type UserEvent = T

A type provided by the user that can be passed through Event::UserEvent.

fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>

where F: FnMut(Event<<EventLoop<T> as EventLoopExtRunOnDemand>::UserEvent>, &ActiveEventLoop),

👎Deprecated: use EventLoopExtRunOnDemand::run_app_on_demand

See run_app_on_demand.

fn run_app_on_demand<A>(&mut self, app: &mut A) -> Result<(), EventLoopError>

where A: ApplicationHandler<Self::UserEvent>,

Run the application with the event loop on the calling thread.

impl<T> EventLoopExtWayland for EventLoop<T>

where T: 'static,

fn is_wayland(&self) -> bool

True if the EventLoop uses Wayland.

impl<T> EventLoopExtX11 for EventLoop<T>

where T: 'static,

fn is_x11(&self) -> bool

True if the EventLoop uses X11.

impl<T> GliumEventLoop for EventLoop<T>

fn build<Picker>( &self, display_builder: DisplayBuilder, template_builder: ConfigTemplateBuilder, config_picker: Picker, ) -> Result<(Option<Window>, Config), Box<dyn Error>>

where Picker: FnOnce(Box<dyn Iterator<Item = Config> + '_>) -> Config,

Calls display_builder.build(self, template_builder, config_picker).

impl<T> HasDisplayHandle for EventLoop<T>

fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>

Get a handle to the display controller of the windowing system.