From 69382fda9aaa09ce674637afd31ad7da0f9d87e8 Mon Sep 17 00:00:00 2001 From: Sl-L <49354224+Sl-L@users.noreply.github.com> Date: Fri, 10 Jan 2025 12:07:17 -0300 Subject: [PATCH] examples/child_window: use distinct color/position for children This should help with understanding how they work. --- examples/child_window.rs | 43 ++++++++++++++++++++++++++++++++-------- examples/util/fill.rs | 20 +++++++++++++++---- 2 files changed, 51 insertions(+), 12 deletions(-) diff --git a/examples/child_window.rs b/examples/child_window.rs index 43ed75c9..52bbbaaa 100644 --- a/examples/child_window.rs +++ b/examples/child_window.rs @@ -13,10 +13,21 @@ fn main() -> Result<(), impl std::error::Error> { #[path = "util/fill.rs"] mod fill; + struct WindowData { + window: Box, + color: u32, + } + + impl WindowData { + fn new(window: Box, color: u32) -> Self { + Self { window, color } + } + } + #[derive(Default)] struct Application { parent_window_id: Option, - windows: HashMap>, + windows: HashMap, } impl ApplicationHandler for Application { @@ -26,11 +37,10 @@ fn main() -> Result<(), impl std::error::Error> { .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0))) .with_surface_size(LogicalSize::new(640.0f32, 480.0f32)); let window = event_loop.create_window(attributes).unwrap(); - println!("Parent window id: {:?})", window.id()); self.parent_window_id = Some(window.id()); - self.windows.insert(window.id(), window); + self.windows.insert(window.id(), WindowData::new(window, 0xffbbbbbb)); } fn window_event( @@ -56,15 +66,24 @@ fn main() -> Result<(), impl std::error::Error> { event: KeyEvent { state: ElementState::Pressed, .. }, .. } => { + let child_index = self.windows.len() - 1; + let child_color = + 0xff000000 + 3_u32.pow((child_index + 2).rem_euclid(16) as u32); + let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap(); - let child_window = spawn_child_window(parent_window.as_ref(), event_loop); + let child_window = + spawn_child_window(parent_window.window.as_ref(), event_loop, child_index); let child_id = child_window.id(); println!("Child window created with id: {child_id:?}"); - self.windows.insert(child_id, child_window); + self.windows.insert(child_id, WindowData::new(child_window, child_color)); }, WindowEvent::RedrawRequested => { if let Some(window) = self.windows.get(&window_id) { - fill::fill_window(window.as_ref()); + if window_id == self.parent_window_id.unwrap() { + fill::fill_window(window.window.as_ref()); + } else { + fill::fill_window_with_color(window.window.as_ref(), window.color); + } } }, _ => (), @@ -75,12 +94,20 @@ fn main() -> Result<(), impl std::error::Error> { fn spawn_child_window( parent: &dyn Window, event_loop: &dyn ActiveEventLoop, + child_count: usize, ) -> Box { let parent = parent.raw_window_handle().unwrap(); + + // As child count increases, x goes from 0*128 to 5*128 and then repeats + let x: f64 = child_count.rem_euclid(5) as f64 * 128.0; + + // After 5 windows have been put side by side horizontally, a new row starts + let y: f64 = (child_count / 5) as f64 * 96.0; + let mut window_attributes = WindowAttributes::default() .with_title("child window") - .with_surface_size(LogicalSize::new(200.0f32, 200.0f32)) - .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0))) + .with_surface_size(LogicalSize::new(128.0f32, 96.0)) + .with_position(Position::Logical(LogicalPosition::new(x, y))) .with_visible(true); // `with_parent_window` is unsafe. Parent window must be a valid window. window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) }; diff --git a/examples/util/fill.rs b/examples/util/fill.rs index c93dfc58..dab4a1d7 100644 --- a/examples/util/fill.rs +++ b/examples/util/fill.rs @@ -9,7 +9,10 @@ #[allow(unused_imports)] pub use platform::cleanup_window; +#[allow(unused_imports)] pub use platform::fill_window; +#[allow(unused_imports)] +pub use platform::fill_window_with_color; #[cfg(not(any(target_os = "android", target_os = "ios")))] mod platform { @@ -70,7 +73,7 @@ mod platform { } } - pub fn fill_window(window: &dyn Window) { + pub fn fill_window_with_color(window: &dyn Window, color: u32) { GC.with(|gc| { let size = window.surface_size(); let (Some(width), Some(height)) = @@ -84,17 +87,21 @@ mod platform { let surface = gc.get_or_insert_with(|| GraphicsContext::new(window)).create_surface(window); - // Fill a buffer with a solid color. - const DARK_GRAY: u32 = 0xff181818; + // Fill a buffer with a solid color surface.resize(width, height).expect("Failed to resize the softbuffer surface"); let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer"); - buffer.fill(DARK_GRAY); + buffer.fill(color); buffer.present().expect("Failed to present the softbuffer buffer"); }) } + #[allow(dead_code)] + pub fn fill_window(window: &dyn Window) { + fill_window_with_color(window, 0xff181818); + } + #[allow(dead_code)] pub fn cleanup_window(window: &dyn Window) { GC.with(|gc| { @@ -112,6 +119,11 @@ mod platform { // No-op on mobile platforms. } + #[allow(dead_code)] + pub fn fill_window_with_color(_window: &dyn winit::window::Window, _color: u32) { + // No-op on mobile platforms. + } + #[allow(dead_code)] pub fn cleanup_window(_window: &dyn winit::window::Window) { // No-op on mobile platforms.