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

Re-organize into module structure

Browse Source
This commit is contained in:
Osspial
2018-08-22 23:01:36 -04:00
parent f20fac99f6
commit 4377680a44
31 changed files with 740 additions and 701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
examples/cursor.rs
View File

@@ -1,11 +1,13 @@
extern crate winit;
use winit::{Event, EventLoop, ElementState, MouseCursor, WindowEvent, KeyboardInput, ControlFlow};
use winit::window::{WindowBuilder, MouseCursor};
use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let window = winit::WindowBuilder::new().build(&events_loop).unwrap();
let window = WindowBuilder::new().build(&events_loop).unwrap();
window.set_title("A fantastic window!");
let mut cursor_idx = 0;

27
examples/cursor_grab.rs
View File

@@ -1,31 +1,34 @@
extern crate winit;
fn main() {
let events_loop = winit::EventLoop::new();
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
let window = winit::WindowBuilder::new()
fn main() {
let events_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("Super Cursor Grab'n'Hide Simulator 9000")
.build(&events_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
*control_flow = winit::ControlFlow::Wait;
if let winit::Event::WindowEvent { event, .. } = event {
use winit::WindowEvent::*;
*control_flow = ControlFlow::Wait;
if let Event::WindowEvent { event, .. } = event {
match event {
CloseRequested => *control_flow = winit::ControlFlow::Exit,
KeyboardInput {
input: winit::KeyboardInput {
state: winit::ElementState::Released,
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::KeyboardInput {
input: KeyboardInput {
state: ElementState::Released,
virtual_keycode: Some(key),
modifiers,
..
},
..
} => {
use winit::VirtualKeyCode::*;
use winit::event::VirtualKeyCode::*;
match key {
Escape => *control_flow = winit::ControlFlow::Exit,
Escape => *control_flow = ControlFlow::Exit,
G => window.grab_cursor(!modifiers.shift).unwrap(),
H => window.hide_cursor(!modifiers.shift),
_ => (),

18
examples/fullscreen.rs
View File

@@ -1,10 +1,12 @@
extern crate winit;
use std::io::{self, Write};
use winit::{ControlFlow, Event, WindowEvent};
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent, VirtualKeyCode, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
// enumerating monitors
let monitor = {
@@ -25,7 +27,7 @@ fn main() {
monitor
};
let window = winit::WindowBuilder::new()
let window = WindowBuilder::new()
.with_title("Hello world!")
.with_fullscreen(Some(monitor))
.build(&events_loop)
@@ -44,15 +46,15 @@ fn main() {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::KeyboardInput {
input:
winit::KeyboardInput {
KeyboardInput {
virtual_keycode: Some(virtual_code),
state,
..
},
..
} => match (virtual_code, state) {
(winit::VirtualKeyCode::Escape, _) => *control_flow = ControlFlow::Exit,
(winit::VirtualKeyCode::F, winit::ElementState::Pressed) => {
(VirtualKeyCode::Escape, _) => *control_flow = ControlFlow::Exit,
(VirtualKeyCode::F, ElementState::Pressed) => {
is_fullscreen = !is_fullscreen;
if !is_fullscreen {
window.set_fullscreen(None);
@@ -60,11 +62,11 @@ fn main() {
window.set_fullscreen(Some(window.get_current_monitor()));
}
}
(winit::VirtualKeyCode::M, winit::ElementState::Pressed) => {
(VirtualKeyCode::M, ElementState::Pressed) => {
is_maximized = !is_maximized;
window.set_maximized(is_maximized);
}
(winit::VirtualKeyCode::D, winit::ElementState::Pressed) => {
(VirtualKeyCode::D, ElementState::Pressed) => {
decorations = !decorations;
window.set_decorations(decorations);
}

27
examples/handling_close.rs
View File

@@ -1,9 +1,13 @@
extern crate winit;
fn main() {
let events_loop = winit::EventLoop::new();
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
let _window = winit::WindowBuilder::new()
fn main() {
let events_loop = EventLoop::new();
let _window = WindowBuilder::new()
.with_title("Your faithful window")
.build(&events_loop)
.unwrap();
@@ -11,13 +15,12 @@ fn main() {
let mut close_requested = false;
events_loop.run(move |event, _, control_flow| {
use winit::WindowEvent::*;
use winit::ElementState::Released;
use winit::VirtualKeyCode::{N, Y};
use winit::event::ElementState::Released;
use winit::event::VirtualKeyCode::{N, Y};
match event {
winit::Event::WindowEvent { event, .. } => match event {
CloseRequested => {
Event::WindowEvent { event, .. } => match event {
WindowEvent::CloseRequested => {
// `CloseRequested` is sent when the close button on the window is pressed (or
// through whatever other mechanisms the window manager provides for closing a
// window). If you don't handle this event, the close button won't actually do
@@ -34,9 +37,9 @@ fn main() {
// closing the window. How to close the window is detailed in the handler for
// the Y key.
}
KeyboardInput {
WindowEvent::KeyboardInput {
input:
winit::KeyboardInput {
KeyboardInput {
virtual_keycode: Some(virtual_code),
state: Released,
..
@@ -53,7 +56,7 @@ fn main() {
// event loop (i.e. if it's a multi-window application), you need to
// drop the window. That closes it, and results in `Destroyed` being
// sent.
*control_flow = winit::ControlFlow::Exit;
*control_flow = ControlFlow::Exit;
}
}
N => {
@@ -69,6 +72,6 @@ fn main() {
_ => (),
}
*control_flow = winit::ControlFlow::Wait;
*control_flow = ControlFlow::Wait;
});
}

13
examples/min_max_size.rs
View File

@@ -1,11 +1,14 @@
extern crate winit;
use winit::dpi::LogicalSize;
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
let window = winit::WindowBuilder::new()
let window = WindowBuilder::new()
.build(&events_loop)
.unwrap();
@@ -16,9 +19,9 @@ fn main() {
println!("{:?}", event);
match event {
winit::Event::WindowEvent { event: winit::WindowEvent::CloseRequested, .. } =>
*control_flow = winit::ControlFlow::Exit,
_ => *control_flow = winit::ControlFlow::Wait,
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
*control_flow = ControlFlow::Exit,
_ => *control_flow = ControlFlow::Wait,
}
});
}

6
examples/monitor_list.rs
View File

@@ -1,7 +1,9 @@
extern crate winit;
use winit::event_loop::EventLoop;
use winit::window::WindowBuilder;
fn main() {
let event_loop = winit::EventLoop::new();
let window = winit::WindowBuilder::new().build(&event_loop).unwrap();
let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&event_loop).unwrap();
println!("{:#?}\nPrimary: {:#?}", window.get_available_monitors(), window.get_primary_monitor());
}

19
examples/multiwindow.rs
View File

@@ -1,33 +1,36 @@
extern crate winit;
use std::collections::HashMap;
use winit::window::Window;
use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
let mut windows = HashMap::new();
for _ in 0..3 {
let window = winit::Window::new(&events_loop).unwrap();
let window = Window::new(&events_loop).unwrap();
windows.insert(window.id(), window);
}
events_loop.run(move |event, events_loop, control_flow| {
*control_flow = winit::ControlFlow::Wait;
*control_flow = ControlFlow::Wait;
match event {
winit::Event::WindowEvent { event, window_id } => {
Event::WindowEvent { event, window_id } => {
match event {
winit::WindowEvent::CloseRequested => {
WindowEvent::CloseRequested => {
println!("Window {:?} has received the signal to close", window_id);
// This drops the window, causing it to close.
windows.remove(&window_id);
if windows.is_empty() {
*control_flow = winit::ControlFlow::Exit;
*control_flow = ControlFlow::Exit;
}
},
winit::WindowEvent::KeyboardInput{..} => {
let window = winit::Window::new(&events_loop).unwrap();
WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, .. }, .. } => {
let window = Window::new(&events_loop).unwrap();
windows.insert(window.id(), window);
},
_ => ()

10
examples/proxy.rs
View File

@@ -1,5 +1,7 @@
extern crate winit;
use winit::{EventLoop, WindowBuilder};
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop: EventLoop<i32> = EventLoop::new_user_event();
@@ -24,9 +26,9 @@ fn main() {
events_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {
winit::Event::WindowEvent { event: winit::WindowEvent::CloseRequested, .. } =>
*control_flow = winit::ControlFlow::Exit,
_ => *control_flow = winit::ControlFlow::Wait,
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
*control_flow = ControlFlow::Exit,
_ => *control_flow = ControlFlow::Wait,
}
});
}

15
examples/request_redraw.rs
View File

@@ -1,11 +1,14 @@
extern crate winit;
use winit::{Event, WindowEvent};
use std::time::{Instant, Duration};
fn main() {
let events_loop = winit::EventLoop::new();
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
let window = winit::WindowBuilder::new()
fn main() {
let events_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.unwrap();
@@ -17,10 +20,10 @@ fn main() {
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => *control_flow = winit::ControlFlow::Exit,
} => *control_flow = ControlFlow::Exit,
Event::EventsCleared => {
window.request_redraw();
*control_flow = winit::ControlFlow::WaitUntil(Instant::now() + Duration::new(1, 0))
*control_flow = ControlFlow::WaitUntil(Instant::now() + Duration::new(1, 0))
},
_ => ()
}

21
examples/resizable.rs
View File

@@ -1,11 +1,14 @@
extern crate winit;
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent, VirtualKeyCode, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
let mut resizable = false;
let window = winit::WindowBuilder::new()
let window = WindowBuilder::new()
.with_title("Hit space to toggle resizability.")
.with_dimensions((400, 200).into())
.with_resizable(resizable)
@@ -13,15 +16,15 @@ fn main() {
.unwrap();
events_loop.run(move |event, _, control_flow| {
*control_flow = winit::ControlFlow::Wait;
*control_flow = ControlFlow::Wait;
match event {
winit::Event::WindowEvent { event, .. } => match event {
winit::WindowEvent::CloseRequested => *control_flow = winit::ControlFlow::Exit,
winit::WindowEvent::KeyboardInput {
Event::WindowEvent { event, .. } => match event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::KeyboardInput {
input:
winit::KeyboardInput {
virtual_keycode: Some(winit::VirtualKeyCode::Space),
state: winit::ElementState::Released,
KeyboardInput {
virtual_keycode: Some(VirtualKeyCode::Space),
state: ElementState::Released,
..
},
..

26
examples/run_return.rs
View File

@@ -1,10 +1,14 @@
extern crate winit;
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
use winit::platform::desktop::EventLoopExtDesktop;
fn main() {
let mut events_loop = winit::EventLoop::new();
let mut events_loop = EventLoop::new();
let window = winit::WindowBuilder::new()
let window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.unwrap();
@@ -12,16 +16,16 @@ fn main() {
println!("Close the window to continue.");
events_loop.run_return(|event, _, control_flow| {
match event {
winit::Event::WindowEvent {
event: winit::WindowEvent::CloseRequested,
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => *control_flow = winit::ControlFlow::Exit,
_ => *control_flow = winit::ControlFlow::Wait,
} => *control_flow = ControlFlow::Exit,
_ => *control_flow = ControlFlow::Wait,
}
});
drop(window);
let _window_2 = winit::WindowBuilder::new()
let _window_2 = WindowBuilder::new()
.with_title("A second, fantasticer window!")
.build(&events_loop)
.unwrap();
@@ -29,11 +33,11 @@ fn main() {
println!("Wa ha ha! You thought that closing the window would finish this?!");
events_loop.run_return(|event, _, control_flow| {
match event {
winit::Event::WindowEvent {
event: winit::WindowEvent::CloseRequested,
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => *control_flow = winit::ControlFlow::Exit,
_ => *control_flow = winit::ControlFlow::Wait,
} => *control_flow = ControlFlow::Exit,
_ => *control_flow = ControlFlow::Wait,
}
});

8
examples/timer.rs
View File

@@ -1,11 +1,13 @@
extern crate winit;
use std::time::{Duration, Instant};
use winit::{Event, WindowEvent, StartCause, ControlFlow};
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent, StartCause};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
let _window = winit::WindowBuilder::new()
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.unwrap();

13
examples/transparent.rs
View File

@@ -1,9 +1,12 @@
extern crate winit;
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
let window = winit::WindowBuilder::new().with_decorations(false)
let window = WindowBuilder::new().with_decorations(false)
.with_transparency(true)
.build(&events_loop).unwrap();
@@ -13,9 +16,9 @@ fn main() {
println!("{:?}", event);
match event {
winit::Event::WindowEvent { event: winit::WindowEvent::CloseRequested, .. } =>
*control_flow = winit::ControlFlow::Exit,
_ => *control_flow = winit::ControlFlow::Wait,
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
*control_flow = ControlFlow::Exit,
_ => *control_flow = ControlFlow::Wait,
}
});
}

15
examples/window.rs
View File

@@ -1,9 +1,12 @@
extern crate winit;
use winit::window::WindowBuilder;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
let _window = winit::WindowBuilder::new()
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.unwrap();
@@ -12,11 +15,11 @@ fn main() {
println!("{:?}", event);
match event {
winit::Event::WindowEvent {
event: winit::WindowEvent::CloseRequested,
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => *control_flow = winit::ControlFlow::Exit,
_ => *control_flow = winit::ControlFlow::Wait,
} => *control_flow = ControlFlow::Exit,
_ => *control_flow = ControlFlow::Wait,
}
});
}

19
examples/window_icon.rs
View File

@@ -8,7 +8,14 @@ extern crate image;
#[cfg(feature = "icon_loading")]
fn main() {
<<<<<<< HEAD
use winit::Icon;
=======
use winit::window::{WindowBuilder, Icon};
use winit::event::Event;
use winit::event_loop::{EventLoop, ControlFlow};
>>>>>>> Re-organize into module structure
// You'll have to choose an icon size at your own discretion. On X11, the desired size varies
// by WM, and on Windows, you still have to account for screen scaling. Here we use 32px,
// since it seems to work well enough in most cases. Be careful about going too high, or
@@ -20,9 +27,9 @@ fn main() {
// feature enabled).
let icon = Icon::from_path(path).expect("Failed to open icon");
let events_loop = winit::EventLoop::new();
let events_loop = EventLoop::new();
let window = winit::WindowBuilder::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.
@@ -31,11 +38,11 @@ fn main() {
.unwrap();
events_loop.run(move |event, _, control_flow| {
*control_flow = winit::ControlFlow::Wait;
if let winit::Event::WindowEvent { event, .. } = event {
use winit::WindowEvent::*;
*control_flow = ControlFlow::Wait;
if let Event::WindowEvent { event, .. } = event {
use winit::event::WindowEvent::*;
match event {
CloseRequested => *control_flow = winit::ControlFlow::Exit,
CloseRequested => *control_flow = ControlFlow::Exit,
DroppedFile(path) => {
use image::GenericImageView;