1
0
Fork 0
baseview/examples/open_window.rs

108 lines
3 KiB
Rust
Raw Normal View History

use std::num::NonZeroU32;
use std::time::Duration;
use rtrb::{Consumer, RingBuffer};
2023-02-22 11:29:38 +11:00
#[cfg(target_os = "macos")]
2024-03-27 14:46:47 +11:00
use baseview::{copy_to_clipboard, MouseEvent};
use baseview::{
2024-03-27 14:46:47 +11:00
Event, EventStatus, PhySize, Window, WindowEvent, WindowHandler, WindowScalePolicy,
};
#[derive(Debug, Clone)]
enum Message {
Hello,
}
2020-12-09 11:37:17 +11:00
struct OpenWindowExample {
rx: Consumer<Message>,
2024-03-27 14:46:47 +11:00
_ctx: softbuffer::Context,
surface: softbuffer::Surface,
current_size: PhySize,
damaged: bool,
2020-12-09 11:37:17 +11:00
}
impl WindowHandler for OpenWindowExample {
fn on_frame(&mut self, _window: &mut Window) {
let mut buf = self.surface.buffer_mut().unwrap();
if self.damaged {
buf.fill(0xFFAAAAAA);
self.damaged = false;
}
buf.present().unwrap();
2020-12-09 11:37:17 +11:00
while let Ok(message) = self.rx.pop() {
println!("Message: {:?}", message);
}
}
fn on_event(&mut self, _window: &mut Window, event: Event) -> EventStatus {
match &event {
#[cfg(target_os = "macos")]
2024-03-30 10:55:44 +11:00
Event::Mouse(MouseEvent::ButtonPressed { .. }) => copy_to_clipboard("This is a test!"),
Event::Window(WindowEvent::Resized(info)) => {
println!("Resized: {:?}", info);
let new_size = info.physical_size();
self.current_size = new_size;
if let (Some(width), Some(height)) =
(NonZeroU32::new(new_size.width), NonZeroU32::new(new_size.height))
{
self.surface.resize(width, height).unwrap();
self.damaged = true;
2023-02-22 10:45:11 +11:00
}
}
_ => {}
}
log_event(&event);
EventStatus::Captured
}
2020-09-03 07:23:03 +10:00
}
2020-09-12 02:25:50 +10:00
fn main() {
let window_open_options = baseview::WindowOpenOptions {
title: "baseview".into(),
2020-10-21 11:02:45 +11:00
size: baseview::Size::new(512.0, 512.0),
scale: WindowScalePolicy::SystemScaleFactor,
// TODO: Add an example that uses the OpenGL context
#[cfg(feature = "opengl")]
gl_config: None,
2020-09-12 02:25:50 +10:00
};
let (mut tx, rx) = RingBuffer::new(128);
2020-12-09 11:37:17 +11:00
std::thread::spawn(move || loop {
std::thread::sleep(Duration::from_secs(5));
2024-03-30 10:55:44 +11:00
if tx.push(Message::Hello).is_err() {
println!("Failed sending message");
}
});
Window::open_blocking(window_open_options, |window| {
let ctx = unsafe { softbuffer::Context::new(window) }.unwrap();
let mut surface = unsafe { softbuffer::Surface::new(&ctx, window) }.unwrap();
surface.resize(NonZeroU32::new(512).unwrap(), NonZeroU32::new(512).unwrap()).unwrap();
2024-03-27 14:46:47 +11:00
OpenWindowExample {
_ctx: ctx,
surface,
rx,
current_size: PhySize::new(512, 512),
damaged: true,
}
});
}
fn log_event(event: &Event) {
match event {
Event::Mouse(e) => println!("Mouse event: {:?}", e),
Event::Keyboard(e) => println!("Keyboard event: {:?}", e),
Event::Window(e) => println!("Window event: {:?}", e),
}
2020-09-12 02:25:50 +10:00
}