migrations/winit
1
0
Fork 0
mirror of https://github.com/rust-windowing/winit.git synced 2026-08-29 21:00:04 -04:00
Code Issues Packages Projects Releases Wiki Activity

Change instances of "events_loop" to "event_loop"

Browse Source
This commit is contained in:
Osspial
2018-08-23 20:16:52 -04:00
parent 0f34408763
commit 8d8d9b7cd1
34 changed files with 137 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
examples/cursor.rs
View File

@@ -5,14 +5,14 @@ use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&events_loop).unwrap();
let window = WindowBuilder::new().build(&event_loop).unwrap();
window.set_title("A fantastic window!");
let mut cursor_idx = 0;
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
match event {
Event::WindowEvent { event: WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, .. }, .. }, .. } => {
println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);

6
examples/cursor_grab.rs
View File

@@ -5,14 +5,14 @@ use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("Super Cursor Grab'n'Hide Simulator 9000")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Wait;
if let Event::WindowEvent { event, .. } = event {
match event {

10
examples/fullscreen.rs
View File

@@ -6,11 +6,11 @@ use winit::event::{Event, WindowEvent, VirtualKeyCode, ElementState, KeyboardInp
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
// enumerating monitors
let monitor = {
for (num, monitor) in events_loop.get_available_monitors().enumerate() {
for (num, monitor) in event_loop.get_available_monitors().enumerate() {
println!("Monitor #{}: {:?}", num, monitor.get_name());
}
@@ -20,7 +20,7 @@ fn main() {
let mut num = String::new();
io::stdin().read_line(&mut num).unwrap();
let num = num.trim().parse().ok().expect("Please enter a number");
let monitor = events_loop.get_available_monitors().nth(num).expect("Please enter a valid ID");
let monitor = event_loop.get_available_monitors().nth(num).expect("Please enter a valid ID");
println!("Using {:?}", monitor.get_name());
@@ -30,14 +30,14 @@ fn main() {
let window = WindowBuilder::new()
.with_title("Hello world!")
.with_fullscreen(Some(monitor))
.build(&events_loop)
.build(&event_loop)
.unwrap();
let mut is_fullscreen = true;
let mut is_maximized = false;
let mut decorations = true;
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
*control_flow = ControlFlow::Wait;

6
examples/handling_close.rs
View File

@@ -5,16 +5,16 @@ use winit::event::{Event, WindowEvent, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let _window = WindowBuilder::new()
.with_title("Your faithful window")
.build(&events_loop)
.build(&event_loop)
.unwrap();
let mut close_requested = false;
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
use winit::event::ElementState::Released;
use winit::event::VirtualKeyCode::{N, Y};

6
examples/min_max_size.rs
View File

@@ -6,16 +6,16 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.build(&events_loop)
.build(&event_loop)
.unwrap();
window.set_min_dimensions(Some(LogicalSize::new(400.0, 200.0)));
window.set_max_dimensions(Some(LogicalSize::new(800.0, 400.0)));
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

8
examples/multiwindow.rs
View File

@@ -6,15 +6,15 @@ use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let mut windows = HashMap::new();
for _ in 0..3 {
let window = Window::new(&events_loop).unwrap();
let window = Window::new(&event_loop).unwrap();
windows.insert(window.id(), window);
}
events_loop.run(move |event, events_loop, control_flow| {
event_loop.run(move |event, event_loop, control_flow| {
*control_flow = ControlFlow::Wait;
match event {
Event::WindowEvent { event, window_id } => {
@@ -30,7 +30,7 @@ fn main() {
}
},
WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, .. }, .. } => {
let window = Window::new(&events_loop).unwrap();
let window = Window::new(&event_loop).unwrap();
windows.insert(window.id(), window);
},
_ => ()

10
examples/proxy.rs
View File

@@ -4,18 +4,18 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop: EventLoop<i32> = EventLoop::new_user_event();
let event_loop: EventLoop<i32> = EventLoop::new_user_event();
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
let proxy = events_loop.create_proxy();
let proxy = event_loop.create_proxy();
std::thread::spawn(move || {
let mut counter = 0;
// Wake up the `events_loop` once every second.
// Wake up the `event_loop` once every second.
loop {
std::thread::sleep(std::time::Duration::from_secs(1));
proxy.send_event(counter).unwrap();
@@ -23,7 +23,7 @@ fn main() {
}
});
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>

6
examples/request_redraw.rs
View File

@@ -6,14 +6,14 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/resizable.rs
View File

@@ -4,7 +4,7 @@ use winit::event::{Event, WindowEvent, VirtualKeyCode, ElementState, KeyboardInp
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let mut resizable = false;
@@ -12,10 +12,10 @@ fn main() {
.with_title("Hit space to toggle resizability.")
.with_dimensions((400, 200).into())
.with_resizable(resizable)
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Wait;
match event {
Event::WindowEvent { event, .. } => match event {

6
examples/timer.rs
View File

@@ -5,14 +5,14 @@ use winit::event::{Event, WindowEvent, StartCause};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/transparent.rs
View File

@@ -4,15 +4,15 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new().with_decorations(false)
.with_transparency(true)
.build(&events_loop).unwrap();
.build(&event_loop).unwrap();
window.set_title("A fantastic window!");
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/window.rs
View File

@@ -4,14 +4,14 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(|event, _, control_flow| {
event_loop.run(|event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/window_icon.rs
View File

@@ -23,17 +23,17 @@ fn main() {
// feature enabled).
let icon = Icon::from_path(path).expect("Failed to open icon");
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("An iconic window!")
// At present, this only does anything on Windows and X11, so if you want to save load
// time, you can put icon loading behind a function that returns `None` on other platforms.
.with_window_icon(Some(icon))
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Wait;
if let Event::WindowEvent { event, .. } = event {
use winit::event::WindowEvent::*;

10
examples/window_run_return.rs
View File

@@ -6,15 +6,15 @@ use winit::event_loop::{EventLoop, ControlFlow};
use winit::platform::desktop::EventLoopExtDesktop;
fn main() {
let mut events_loop = EventLoop::new();
let mut event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
println!("Close the window to continue.");
events_loop.run_return(|event, _, control_flow| {
event_loop.run_return(|event, _, control_flow| {
match event {
Event::WindowEvent {
event: WindowEvent::CloseRequested,
@@ -27,11 +27,11 @@ fn main() {
let _window_2 = WindowBuilder::new()
.with_title("A second, fantasticer window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
println!("Wa ha ha! You thought that closing the window would finish this?!");
events_loop.run_return(|event, _, control_flow| {
event_loop.run_return(|event, _, control_flow| {
match event {
Event::WindowEvent {
event: WindowEvent::CloseRequested,