summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--winit/src/multi_window.rs620
-rw-r--r--winit/src/multi_window/state.rs4
-rw-r--r--winit/src/multi_window/window_manager.rs156
-rw-r--r--winit/src/multi_window/windows.rs201
4 files changed, 470 insertions, 511 deletions
diff --git a/winit/src/multi_window.rs b/winit/src/multi_window.rs
index 31c27a6d..84651d40 100644
--- a/winit/src/multi_window.rs
+++ b/winit/src/multi_window.rs
@@ -1,21 +1,20 @@
//! Create interactive, native cross-platform applications for WGPU.
mod state;
-mod windows;
+mod window_manager;
pub use state::State;
use crate::conversion;
use crate::core;
-use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::operation;
use crate::core::window;
-use crate::core::{Point, Size};
+use crate::core::Size;
use crate::futures::futures::channel::mpsc;
use crate::futures::futures::{task, Future, StreamExt};
use crate::futures::{Executor, Runtime, Subscription};
use crate::graphics::{compositor, Compositor};
-use crate::multi_window::windows::Windows;
+use crate::multi_window::window_manager::WindowManager;
use crate::runtime::command::{self, Command};
use crate::runtime::multi_window::Program;
use crate::runtime::user_interface::{self, UserInterface};
@@ -23,6 +22,7 @@ use crate::runtime::Debug;
use crate::style::application::StyleSheet;
use crate::{Clipboard, Error, Proxy, Settings};
+use std::collections::HashMap;
use std::mem::ManuallyDrop;
use std::time::Instant;
@@ -182,13 +182,13 @@ where
}
let mut compositor = C::new(compositor_settings, Some(&main_window))?;
- let renderer = compositor.create_renderer();
- let windows = Windows::new(
+ let mut window_manager = WindowManager::new();
+ let _ = window_manager.insert(
+ window::Id::MAIN,
+ main_window,
&application,
&mut compositor,
- renderer,
- main_window,
exit_on_close_request,
);
@@ -204,7 +204,7 @@ where
event_receiver,
control_sender,
init_command,
- windows,
+ window_manager,
should_main_be_visible,
));
@@ -312,7 +312,7 @@ async fn run_instance<A, E, C>(
mut event_receiver: mpsc::UnboundedReceiver<Event<A::Message>>,
mut control_sender: mpsc::UnboundedSender<Control>,
init_command: Command<A::Message>,
- mut windows: Windows<A, C>,
+ mut window_manager: WindowManager<A, C>,
should_main_window_be_visible: bool,
) where
A: Application + 'static,
@@ -323,20 +323,39 @@ async fn run_instance<A, E, C>(
use winit::event;
use winit::event_loop::ControlFlow;
- let mut clipboard = Clipboard::connect(windows.main());
+ let main_window = window_manager
+ .get_mut(window::Id::MAIN)
+ .expect("Get main window");
+
+ if should_main_window_be_visible {
+ main_window.raw.set_visible(true);
+ }
+
+ let mut clipboard = Clipboard::connect(&main_window.raw);
+ let mut events = {
+ vec![(
+ Some(window::Id::MAIN),
+ core::Event::Window(
+ window::Id::MAIN,
+ window::Event::Opened {
+ position: main_window.position(),
+ size: main_window.size(),
+ },
+ ),
+ )]
+ };
- let mut ui_caches = vec![user_interface::Cache::default()];
+ let mut ui_caches = HashMap::new();
let mut user_interfaces = ManuallyDrop::new(build_user_interfaces(
&application,
&mut debug,
- &mut windows,
- vec![user_interface::Cache::default()],
+ &mut window_manager,
+ HashMap::from_iter([(
+ window::Id::MAIN,
+ user_interface::Cache::default(),
+ )]),
));
- if should_main_window_be_visible {
- windows.main().set_visible(true);
- }
-
run_command(
&application,
&mut compositor,
@@ -346,26 +365,12 @@ async fn run_instance<A, E, C>(
&mut control_sender,
&mut proxy,
&mut debug,
- &mut windows,
+ &mut window_manager,
&mut ui_caches,
);
runtime.track(application.subscription().into_recipes());
- let mut mouse_interaction = mouse::Interaction::default();
-
- let mut events = {
- let (position, size) = logical_bounds_of(windows.main());
-
- vec![(
- Some(window::Id::MAIN),
- core::Event::Window(
- window::Id::MAIN,
- window::Event::Opened { position, size },
- ),
- )]
- };
-
let mut messages = Vec::new();
let mut redraw_pending = false;
@@ -378,31 +383,37 @@ async fn run_instance<A, E, C>(
window,
exit_on_close_request,
} => {
- let (position, size) = logical_bounds_of(&window);
-
- let (inner_size, i) = windows.add(
- &application,
- &mut compositor,
+ let window = window_manager.insert(
id,
window,
+ &application,
+ &mut compositor,
exit_on_close_request,
);
- user_interfaces.push(build_user_interface(
- &application,
- user_interface::Cache::default(),
- &mut windows.renderers[i],
- inner_size,
- &mut debug,
+ let logical_size = window.state.logical_size();
+
+ let _ = user_interfaces.insert(
id,
- ));
- ui_caches.push(user_interface::Cache::default());
+ build_user_interface(
+ &application,
+ user_interface::Cache::default(),
+ &mut window.renderer,
+ logical_size,
+ &mut debug,
+ id,
+ ),
+ );
+ let _ = ui_caches.insert(id, user_interface::Cache::default());
events.push((
Some(id),
core::Event::Window(
id,
- window::Event::Opened { position, size },
+ window::Event::Opened {
+ position: window.position(),
+ size: window.size(),
+ },
),
));
}
@@ -420,12 +431,11 @@ async fn run_instance<A, E, C>(
debug.event_processing_started();
let mut uis_stale = false;
- for (i, id) in windows.ids.iter().enumerate() {
+ for (id, window) in window_manager.iter_mut() {
let mut window_events = vec![];
events.retain(|(window_id, event)| {
- if *window_id == Some(*id)
- || window_id.is_none()
+ if *window_id == Some(id) || window_id.is_none()
{
window_events.push(event.clone());
false
@@ -441,11 +451,13 @@ async fn run_instance<A, E, C>(
continue;
}
- let (ui_state, statuses) = user_interfaces[i]
+ let (ui_state, statuses) = user_interfaces
+ .get_mut(&id)
+ .expect("Get user interface")
.update(
&window_events,
- windows.states[i].cursor(),
- &mut windows.renderers[i],
+ window.state.cursor(),
+ &mut window.renderer,
&mut clipboard,
&mut messages,
);
@@ -469,11 +481,12 @@ async fn run_instance<A, E, C>(
// TODO mw application update returns which window IDs to update
if !messages.is_empty() || uis_stale {
- let mut cached_interfaces: Vec<
+ let mut cached_interfaces: HashMap<
+ window::Id,
user_interface::Cache,
> = ManuallyDrop::into_inner(user_interfaces)
- .drain(..)
- .map(UserInterface::into_cache)
+ .drain()
+ .map(|(id, ui)| (id, ui.into_cache()))
.collect();
// Update application
@@ -486,18 +499,18 @@ async fn run_instance<A, E, C>(
&mut proxy,
&mut debug,
&mut messages,
- &mut windows,
+ &mut window_manager,
&mut cached_interfaces,
);
// we must synchronize all window states with application state after an
// application update since we don't know what changed
- for (state, (id, window)) in windows
- .states
- .iter_mut()
- .zip(windows.ids.iter().zip(windows.raw.iter()))
- {
- state.synchronize(&application, *id, window);
+ for (id, window) in window_manager.iter_mut() {
+ window.state.synchronize(
+ &application,
+ id,
+ &window.raw,
+ );
}
// rebuild UIs with the synchronized states
@@ -505,39 +518,43 @@ async fn run_instance<A, E, C>(
ManuallyDrop::new(build_user_interfaces(
&application,
&mut debug,
- &mut windows,
+ &mut window_manager,
cached_interfaces,
));
}
debug.draw_started();
- for (i, id) in windows.ids.iter().enumerate() {
+ for (id, window) in window_manager.iter_mut() {
// TODO: Avoid redrawing all the time by forcing widgets to
// request redraws on state changes
//
// Then, we can use the `interface_state` here to decide if a redraw
// is needed right away, or simply wait until a specific time.
let redraw_event = core::Event::Window(
- *id,
+ id,
window::Event::RedrawRequested(Instant::now()),
);
- let cursor = windows.states[i].cursor();
+ let cursor = window.state.cursor();
+
+ let ui = user_interfaces
+ .get_mut(&id)
+ .expect("Get user interface");
- let (ui_state, _) = user_interfaces[i].update(
+ let (ui_state, _) = ui.update(
&[redraw_event.clone()],
cursor,
- &mut windows.renderers[i],
+ &mut window.renderer,
&mut clipboard,
&mut messages,
);
let new_mouse_interaction = {
- let state = &windows.states[i];
+ let state = &window.state;
- user_interfaces[i].draw(
- &mut windows.renderers[i],
+ ui.draw(
+ &mut window.renderer,
state.theme(),
&renderer::Style {
text_color: state.text_color(),
@@ -546,19 +563,21 @@ async fn run_instance<A, E, C>(
)
};
- if new_mouse_interaction != mouse_interaction {
- windows.raw[i].set_cursor_icon(
+ if new_mouse_interaction != window.mouse_interaction
+ {
+ window.raw.set_cursor_icon(
conversion::mouse_interaction(
new_mouse_interaction,
),
);
- mouse_interaction = new_mouse_interaction;
+ window.mouse_interaction =
+ new_mouse_interaction;
}
// TODO once widgets can request to be redrawn, we can avoid always requesting a
// redraw
- windows.raw[i].request_redraw();
+ window.raw.request_redraw();
runtime.broadcast(
redraw_event.clone(),
@@ -606,9 +625,13 @@ async fn run_instance<A, E, C>(
messages.push(message);
}
event::Event::RedrawRequested(id) => {
- let i = windows.index_from_raw(id);
- let state = &windows.states[i];
- let physical_size = state.physical_size();
+ let Some((id, window)) =
+ window_manager.get_mut_alias(id)
+ else {
+ continue;
+ };
+
+ let physical_size = window.state.physical_size();
if physical_size.width == 0 || physical_size.height == 0
{
@@ -616,60 +639,65 @@ async fn run_instance<A, E, C>(
}
debug.render_started();
- let current_viewport_version = state.viewport_version();
- let window_viewport_version =
- windows.viewport_versions[i];
-
- if window_viewport_version != current_viewport_version {
- let logical_size = state.logical_size();
+ if window.viewport_version
+ != window.state.viewport_version()
+ {
+ let logical_size = window.state.logical_size();
debug.layout_started();
- let renderer = &mut windows.renderers[i];
- let ui = user_interfaces.remove(i);
+ let ui = user_interfaces
+ .remove(&id)
+ .expect("Remove user interface");
- user_interfaces
- .insert(i, ui.relayout(logical_size, renderer));
+ let _ = user_interfaces.insert(
+ id,
+ ui.relayout(logical_size, &mut window.renderer),
+ );
debug.layout_finished();
debug.draw_started();
- let new_mouse_interaction = user_interfaces[i]
+ let new_mouse_interaction = user_interfaces
+ .get_mut(&id)
+ .expect("Get user interface")
.draw(
- renderer,
- state.theme(),
+ &mut window.renderer,
+ window.state.theme(),
&renderer::Style {
- text_color: state.text_color(),
+ text_color: window.state.text_color(),
},
- state.cursor(),
+ window.state.cursor(),
);
- if new_mouse_interaction != mouse_interaction {
- windows.raw[i].set_cursor_icon(
+ if new_mouse_interaction != window.mouse_interaction
+ {
+ window.raw.set_cursor_icon(
conversion::mouse_interaction(
new_mouse_interaction,
),
);
- mouse_interaction = new_mouse_interaction;
+ window.mouse_interaction =
+ new_mouse_interaction;
}
debug.draw_finished();
compositor.configure_surface(
- &mut windows.surfaces[i],
+ &mut window.surface,
physical_size.width,
physical_size.height,
);
- windows.viewport_versions[i] =
- current_viewport_version;
+ window.viewport_version =
+ window.state.viewport_version();
}
match compositor.present(
- &mut windows.renderers[i],
- &mut windows.surfaces[i],
- state.viewport(),
- state.background_color(),
+ &mut window.renderer,
+ &mut window.surface,
+ window.state.viewport(),
+ window.state.background_color(),
&debug.overlay(),
) {
Ok(()) => {
@@ -690,8 +718,10 @@ async fn run_instance<A, E, C>(
);
// Try rendering all windows again next frame.
- for window in &windows.raw {
- window.request_redraw();
+ for (_id, window) in
+ window_manager.iter_mut()
+ {
+ window.raw.request_redraw();
}
}
},
@@ -701,70 +731,43 @@ async fn run_instance<A, E, C>(
event: window_event,
window_id,
} => {
- let window_index = windows
- .raw
- .iter()
- .position(|w| w.id() == window_id);
+ let Some((id, window)) =
+ window_manager.get_mut_alias(window_id)
+ else {
+ continue;
+ };
- match window_index {
- Some(i) => {
- let id = windows.ids[i];
- let raw = &windows.raw[i];
- let exit_on_close_request =
- windows.exit_on_close_requested[i];
+ if matches!(
+ window_event,
+ winit::event::WindowEvent::CloseRequested
+ ) && window.exit_on_close_request
+ {
+ let _ = window_manager.remove(id);
+ let _ = user_interfaces.remove(&id);
+ let _ = ui_caches.remove(&id);
- if matches!(
- window_event,
- winit::event::WindowEvent::CloseRequested
- ) && exit_on_close_request
- {
- let i = windows.delete(id);
- let _ = user_interfaces.remove(i);
- let _ = ui_caches.remove(i);
+ events.push((
+ None,
+ core::Event::Window(id, window::Event::Closed),
+ ));
- if windows.is_empty() {
- break 'main;
- }
- } else {
- let state = &mut windows.states[i];
- state.update(
- raw,
- &window_event,
- &mut debug,
- );
-
- if let Some(event) =
- conversion::window_event(
- id,
- &window_event,
- state.scale_factor(),
- state.modifiers(),
- )
- {
- events.push((Some(id), event));
- }
- }
+ if window_manager.is_empty() {
+ break 'main;
}
- None => {
- // This is the only special case, since in order to trigger the Destroyed event the
- // window reference from winit must be dropped, but we still want to inform the
- // user that the window was destroyed so they can clean up any specific window
- // code for this window
- if matches!(
- window_event,
- winit::event::WindowEvent::Destroyed
- ) {
- let id =
- windows.get_pending_destroy(window_id);
-
- events.push((
- None,
- core::Event::Window(
- id,
- window::Event::Closed,
- ),
- ));
- }
+ } else {
+ window.state.update(
+ &window.raw,
+ &window_event,
+ &mut debug,
+ );
+
+ if let Some(event) = conversion::window_event(
+ id,
+ &window_event,
+ window.state.scale_factor(),
+ window.state.modifiers(),
+ ) {
+ events.push((Some(id), event));
}
}
}
@@ -811,8 +814,8 @@ fn update<A: Application, C, E: Executor>(
proxy: &mut winit::event_loop::EventLoopProxy<A::Message>,
debug: &mut Debug,
messages: &mut Vec<A::Message>,
- windows: &mut Windows<A, C>,
- ui_caches: &mut Vec<user_interface::Cache>,
+ window_manager: &mut WindowManager<A, C>,
+ ui_caches: &mut HashMap<window::Id, user_interface::Cache>,
) where
C: Compositor<Renderer = A::Renderer> + 'static,
<A::Renderer as core::Renderer>::Theme: StyleSheet,
@@ -833,7 +836,7 @@ fn update<A: Application, C, E: Executor>(
control_sender,
proxy,
debug,
- windows,
+ window_manager,
ui_caches,
);
}
@@ -852,8 +855,8 @@ fn run_command<A, C, E>(
control_sender: &mut mpsc::UnboundedSender<Control>,
proxy: &mut winit::event_loop::EventLoopProxy<A::Message>,
debug: &mut Debug,
- windows: &mut Windows<A, C>,
- ui_caches: &mut Vec<user_interface::Cache>,
+ window_manager: &mut WindowManager<A, C>,
+ ui_caches: &mut HashMap<window::Id, user_interface::Cache>,
) where
A: Application,
E: Executor,
@@ -886,7 +889,7 @@ fn run_command<A, C, E>(
},
command::Action::Window(action) => match action {
window::Action::Spawn(id, settings) => {
- let monitor = windows.last_monitor();
+ let monitor = window_manager.last_monitor();
control_sender
.start_send(Control::CreateWindow {
@@ -900,10 +903,10 @@ fn run_command<A, C, E>(
window::Action::Close(id) => {
use winit::event_loop::ControlFlow;
- let i = windows.delete(id);
- let _ = ui_caches.remove(i);
+ let _ = window_manager.remove(id);
+ let _ = ui_caches.remove(&id);
- if windows.is_empty() {
+ if window_manager.is_empty() {
control_sender
.start_send(Control::ChangeFlow(
ControlFlow::ExitWithCode(0),
@@ -912,113 +915,133 @@ fn run_command<A, C, E>(
}
}
window::Action::Drag(id) => {
- let _ = windows.with_raw(id).drag_window();
+ if let Some(window) = window_manager.get_mut(id) {
+ let _ = window.raw.drag_window();
+ }
}
window::Action::Resize(id, size) => {
- windows.with_raw(id).set_inner_size(
- winit::dpi::LogicalSize {
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_inner_size(winit::dpi::LogicalSize {
width: size.width,
height: size.height,
- },
- );
+ });
+ }
}
window::Action::FetchSize(id, callback) => {
- let window = windows.with_raw(id);
- let size =
- window.inner_size().to_logical(window.scale_factor());
-
- proxy
- .send_event(callback(Size::new(
- size.width,
- size.height,
- )))
- .expect("Send message to event loop");
+ if let Some(window) = window_manager.get_mut(id) {
+ let size = window
+ .raw
+ .inner_size()
+ .to_logical(window.raw.scale_factor());
+
+ proxy
+ .send_event(callback(Size::new(
+ size.width,
+ size.height,
+ )))
+ .expect("Send message to event loop");
+ }
}
window::Action::Maximize(id, maximized) => {
- windows.with_raw(id).set_maximized(maximized);
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_maximized(maximized);
+ }
}
window::Action::Minimize(id, minimized) => {
- windows.with_raw(id).set_minimized(minimized);
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_minimized(minimized);
+ }
}
window::Action::Move(id, position) => {
- windows.with_raw(id).set_outer_position(
- winit::dpi::LogicalPosition {
- x: position.x,
- y: position.y,
- },
- );
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_outer_position(
+ winit::dpi::LogicalPosition {
+ x: position.x,
+ y: position.y,
+ },
+ );
+ }
}
window::Action::ChangeMode(id, mode) => {
- let window = windows.with_raw(id);
- window.set_visible(conversion::visible(mode));
- window.set_fullscreen(conversion::fullscreen(
- window.current_monitor(),
- mode,
- ));
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_visible(conversion::visible(mode));
+ window.raw.set_fullscreen(conversion::fullscreen(
+ window.raw.current_monitor(),
+ mode,
+ ));
+ }
}
window::Action::ChangeIcon(id, icon) => {
- windows
- .with_raw(id)
- .set_window_icon(conversion::icon(icon));
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_window_icon(conversion::icon(icon));
+ }
}
window::Action::FetchMode(id, tag) => {
- let window = windows.with_raw(id);
- let mode = if window.is_visible().unwrap_or(true) {
- conversion::mode(window.fullscreen())
- } else {
- core::window::Mode::Hidden
- };
-
- proxy
- .send_event(tag(mode))
- .expect("Event loop doesn't exist.");
+ if let Some(window) = window_manager.get_mut(id) {
+ let mode = if window.raw.is_visible().unwrap_or(true) {
+ conversion::mode(window.raw.fullscreen())
+ } else {
+ core::window::Mode::Hidden
+ };
+
+ proxy
+ .send_event(tag(mode))
+ .expect("Event loop doesn't exist.");
+ }
}
window::Action::ToggleMaximize(id) => {
- let window = windows.with_raw(id);
- window.set_maximized(!window.is_maximized());
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_maximized(!window.raw.is_maximized());
+ }
}
window::Action::ToggleDecorations(id) => {
- let window = windows.with_raw(id);
- window.set_decorations(!window.is_decorated());
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.set_decorations(!window.raw.is_decorated());
+ }
}
window::Action::RequestUserAttention(id, attention_type) => {
- windows.with_raw(id).request_user_attention(
- attention_type.map(conversion::user_attention),
- );
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.request_user_attention(
+ attention_type.map(conversion::user_attention),
+ );
+ }
}
window::Action::GainFocus(id) => {
- windows.with_raw(id).focus_window();
+ if let Some(window) = window_manager.get_mut(id) {
+ window.raw.focus_window();
+ }
}
window::Action::ChangeLevel(id, level) => {
- windows
- .with_raw(id)
- .set_window_level(conversion::window_level(level));
+ if let Some(window) = window_manager.get_mut(id) {
+ window
+ .raw
+ .set_window_level(conversion::window_level(level));
+ }
}
window::Action::FetchId(id, tag) => {
- proxy
- .send_event(tag(windows.with_raw(id).id().into()))
- .expect("Event loop doesn't exist.");
+ if let Some(window) = window_manager.get_mut(id) {
+ proxy
+ .send_event(tag(window.raw.id().into()))
+ .expect("Event loop doesn't exist.");
+ }
}
window::Action::Screenshot(id, tag) => {
- let i = windows.index_from_id(id);
- let state = &windows.states[i];
- let surface = &mut windows.surfaces[i];
- let renderer = &mut windows.renderers[i];
-
- let bytes = compositor.screenshot(
- renderer,
- surface,
- state.viewport(),
- state.background_color(),
- &debug.overlay(),
- );
+ if let Some(window) = window_manager.get_mut(id) {
+ let bytes = compositor.screenshot(
+ &mut window.renderer,
+ &mut window.surface,
+ window.state.viewport(),
+ window.state.background_color(),
+ &debug.overlay(),
+ );
- proxy
- .send_event(tag(window::Screenshot::new(
- bytes,
- state.physical_size(),
- )))
- .expect("Event loop doesn't exist.");
+ proxy
+ .send_event(tag(window::Screenshot::new(
+ bytes,
+ window.state.physical_size(),
+ )))
+ .expect("Event loop doesn't exist.");
+ }
}
},
command::Action::System(action) => match action {
@@ -1047,43 +1070,45 @@ fn run_command<A, C, E>(
let mut uis = build_user_interfaces(
application,
debug,
- windows,
+ window_manager,
std::mem::take(ui_caches),
);
'operate: while let Some(mut operation) =
current_operation.take()
{
- for (i, ui) in uis.iter_mut().enumerate() {
- ui.operate(&windows.renderers[i], operation.as_mut());
-
- match operation.finish() {
- operation::Outcome::None => {}
- operation::Outcome::Some(message) => {
- proxy
- .send_event(message)
- .expect("Event loop doesn't exist.");
-
- // operation completed, don't need to try to operate on rest of UIs
- break 'operate;
- }
- operation::Outcome::Chain(next) => {
- current_operation = Some(next);
+ for (id, ui) in uis.iter_mut() {
+ if let Some(window) = window_manager.get_mut(*id) {
+ ui.operate(&window.renderer, operation.as_mut());
+
+ match operation.finish() {
+ operation::Outcome::None => {}
+ operation::Outcome::Some(message) => {
+ proxy
+ .send_event(message)
+ .expect("Event loop doesn't exist.");
+
+ // operation completed, don't need to try to operate on rest of UIs
+ break 'operate;
+ }
+ operation::Outcome::Chain(next) => {
+ current_operation = Some(next);
+ }
}
}
}
}
*ui_caches =
- uis.drain(..).map(UserInterface::into_cache).collect();
+ uis.drain().map(|(id, ui)| (id, ui.into_cache())).collect();
}
command::Action::LoadFont { bytes, tagger } => {
use crate::core::text::Renderer;
// TODO change this once we change each renderer to having a single backend reference.. :pain:
// TODO: Error handling (?)
- for renderer in &mut windows.renderers {
- renderer.load_font(bytes.clone());
+ for (_, window) in window_manager.iter_mut() {
+ window.renderer.load_font(bytes.clone());
}
proxy
@@ -1098,33 +1123,31 @@ fn run_command<A, C, E>(
pub fn build_user_interfaces<'a, A: Application, C: Compositor>(
application: &'a A,
debug: &mut Debug,
- windows: &mut Windows<A, C>,
- mut cached_user_interfaces: Vec<user_interface::Cache>,
-) -> Vec<UserInterface<'a, A::Message, A::Renderer>>
+ window_manager: &mut WindowManager<A, C>,
+ mut cached_user_interfaces: HashMap<window::Id, user_interface::Cache>,
+) -> HashMap<window::Id, UserInterface<'a, A::Message, A::Renderer>>
where
<A::Renderer as core::Renderer>::Theme: StyleSheet,
C: Compositor<Renderer = A::Renderer>,
{
cached_user_interfaces
- .drain(..)
- .zip(
- windows
- .ids
- .iter()
- .zip(windows.states.iter().zip(windows.renderers.iter_mut())),
- )
- .fold(vec![], |mut uis, (cache, (id, (state, renderer)))| {
- uis.push(build_user_interface(
- application,
- cache,
- renderer,
- state.logical_size(),
- debug,
- *id,
- ));
-
- uis
+ .drain()
+ .filter_map(|(id, cache)| {
+ let window = window_manager.get_mut(id)?;
+
+ Some((
+ id,
+ build_user_interface(
+ application,
+ cache,
+ &mut window.renderer,
+ window.state.logical_size(),
+ debug,
+ id,
+ ),
+ ))
})
+ .collect()
}
/// Returns true if the provided event should cause an [`Application`] to
@@ -1148,25 +1171,6 @@ pub fn user_force_quit(
}
}
-fn logical_bounds_of(window: &winit::window::Window) -> (Option<Point>, Size) {
- let position = window
- .inner_position()
- .ok()
- .map(|position| position.to_logical(window.scale_factor()))
- .map(|position| Point {
- x: position.x,
- y: position.y,
- });
-
- let size = {
- let size = window.inner_size().to_logical(window.scale_factor());
-
- Size::new(size.width, size.height)
- };
-
- (position, size)
-}
-
#[cfg(not(target_arch = "wasm32"))]
mod platform {
pub fn run<T, F>(
diff --git a/winit/src/multi_window/state.rs b/winit/src/multi_window/state.rs
index e9a9f91a..03da5ad7 100644
--- a/winit/src/multi_window/state.rs
+++ b/winit/src/multi_window/state.rs
@@ -19,7 +19,7 @@ where
title: String,
scale_factor: f64,
viewport: Viewport,
- viewport_version: usize,
+ viewport_version: u64,
cursor_position: Option<winit::dpi::PhysicalPosition<f64>>,
modifiers: winit::event::ModifiersState,
theme: <A::Renderer as core::Renderer>::Theme,
@@ -86,7 +86,7 @@ where
/// Returns the version of the [`Viewport`] of the [`State`].
///
/// The version is incremented every time the [`Viewport`] changes.
- pub fn viewport_version(&self) -> usize {
+ pub fn viewport_version(&self) -> u64 {
self.viewport_version
}
diff --git a/winit/src/multi_window/window_manager.rs b/winit/src/multi_window/window_manager.rs
new file mode 100644
index 00000000..d54156e7
--- /dev/null
+++ b/winit/src/multi_window/window_manager.rs
@@ -0,0 +1,156 @@
+use crate::core::mouse;
+use crate::core::window::Id;
+use crate::core::{Point, Size};
+use crate::graphics::Compositor;
+use crate::multi_window::{Application, State};
+use crate::style::application::StyleSheet;
+
+use std::collections::BTreeMap;
+use winit::monitor::MonitorHandle;
+
+#[allow(missing_debug_implementations)]
+pub struct WindowManager<A: Application, C: Compositor>
+where
+ <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
+ C: Compositor<Renderer = A::Renderer>,
+{
+ aliases: BTreeMap<winit::window::WindowId, Id>,
+ entries: BTreeMap<Id, Window<A, C>>,
+}
+
+impl<A, C> WindowManager<A, C>
+where
+ A: Application,
+ C: Compositor<Renderer = A::Renderer>,
+ <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
+{
+ pub fn new() -> Self {
+ Self {
+ aliases: BTreeMap::new(),
+ entries: BTreeMap::new(),
+ }
+ }
+
+ pub fn insert(
+ &mut self,
+ id: Id,
+ window: winit::window::Window,
+ application: &A,
+ compositor: &mut C,
+ exit_on_close_request: bool,
+ ) -> &mut Window<A, C> {
+ let state = State::new(application, id, &window);
+ let viewport_version = state.viewport_version();
+ let physical_size = state.physical_size();
+ let surface = compositor.create_surface(
+ &window,
+ physical_size.width,
+ physical_size.height,
+ );
+ let renderer = compositor.create_renderer();
+
+ let _ = self.aliases.insert(window.id(), id);
+
+ let _ = self.entries.insert(
+ id,
+ Window {
+ raw: window,
+ state,
+ viewport_version,
+ exit_on_close_request,
+ surface,
+ renderer,
+ mouse_interaction: mouse::Interaction::Idle,
+ },
+ );
+
+ self.entries
+ .get_mut(&id)
+ .expect("Get window that was just inserted")
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.entries.is_empty()
+ }
+
+ pub fn iter_mut(
+ &mut self,
+ ) -> impl Iterator<Item = (Id, &mut Window<A, C>)> {
+ self.entries.iter_mut().map(|(k, v)| (*k, v))
+ }
+
+ pub fn get_mut(&mut self, id: Id) -> Option<&mut Window<A, C>> {
+ self.entries.get_mut(&id)
+ }
+
+ pub fn get_mut_alias(
+ &mut self,
+ id: winit::window::WindowId,
+ ) -> Option<(Id, &mut Window<A, C>)> {
+ let id = self.aliases.get(&id).copied()?;
+
+ Some((id, self.get_mut(id)?))
+ }
+
+ pub fn last_monitor(&self) -> Option<MonitorHandle> {
+ self.entries.values().last()?.raw.current_monitor()
+ }
+
+ pub fn remove(&mut self, id: Id) -> Option<Window<A, C>> {
+ let window = self.entries.remove(&id)?;
+ let _ = self.aliases.remove(&window.raw.id());
+
+ Some(window)
+ }
+}
+
+impl<A, C> Default for WindowManager<A, C>
+where
+ A: Application,
+ C: Compositor<Renderer = A::Renderer>,
+ <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
+{
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+#[allow(missing_debug_implementations)]
+pub struct Window<A, C>
+where
+ A: Application,
+ C: Compositor<Renderer = A::Renderer>,
+ <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
+{
+ pub raw: winit::window::Window,
+ pub state: State<A>,
+ pub viewport_version: u64,
+ pub exit_on_close_request: bool,
+ pub mouse_interaction: mouse::Interaction,
+ pub surface: C::Surface,
+ pub renderer: A::Renderer,
+}
+
+impl<A, C> Window<A, C>
+where
+ A: Application,
+ C: Compositor<Renderer = A::Renderer>,
+ <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
+{
+ pub fn position(&self) -> Option<Point> {
+ self.raw
+ .inner_position()
+ .ok()
+ .map(|position| position.to_logical(self.raw.scale_factor()))
+ .map(|position| Point {
+ x: position.x,
+ y: position.y,
+ })
+ }
+
+ pub fn size(&self) -> Size {
+ let size = self.raw.inner_size().to_logical(self.raw.scale_factor());
+
+ Size::new(size.width, size.height)
+ }
+}
diff --git a/winit/src/multi_window/windows.rs b/winit/src/multi_window/windows.rs
deleted file mode 100644
index 5a33b7b4..00000000
--- a/winit/src/multi_window/windows.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-use crate::core::{window, Size};
-use crate::graphics::Compositor;
-use crate::multi_window::{Application, State};
-use crate::style::application::StyleSheet;
-
-use winit::monitor::MonitorHandle;
-
-use std::fmt::{Debug, Formatter};
-
-pub struct Windows<A: Application, C: Compositor>
-where
- <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
- C: Compositor<Renderer = A::Renderer>,
-{
- pub ids: Vec<window::Id>,
- pub raw: Vec<winit::window::Window>,
- pub states: Vec<State<A>>,
- pub viewport_versions: Vec<usize>,
- pub exit_on_close_requested: Vec<bool>,
- pub surfaces: Vec<C::Surface>,
- pub renderers: Vec<A::Renderer>,
- pub pending_destroy: Vec<(window::Id, winit::window::WindowId)>,
-}
-
-impl<A: Application, C: Compositor> Debug for Windows<A, C>
-where
- <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
- C: Compositor<Renderer = A::Renderer>,
-{
- fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
- f.debug_struct("Windows")
- .field("ids", &self.ids)
- .field(
- "raw",
- &self
- .raw
- .iter()
- .map(winit::window::Window::id)
- .collect::<Vec<winit::window::WindowId>>(),
- )
- .field("states", &self.states)
- .field("viewport_versions", &self.viewport_versions)
- .finish()
- }
-}
-
-impl<A: Application, C: Compositor> Windows<A, C>
-where
- <A::Renderer as crate::core::Renderer>::Theme: StyleSheet,
- C: Compositor<Renderer = A::Renderer>,
-{
- /// Creates a new [`Windows`] with a single `window::Id::MAIN` window.
- pub fn new(
- application: &A,
- compositor: &mut C,
- renderer: A::Renderer,
- main: winit::window::Window,
- exit_on_close_requested: bool,
- ) -> Self {
- let state = State::new(application, window::Id::MAIN, &main);
- let viewport_version = state.viewport_version();
- let physical_size = state.physical_size();
- let surface = compositor.create_surface(
- &main,
- physical_size.width,
- physical_size.height,
- );
-
- Self {
- ids: vec![window::Id::MAIN],
- raw: vec![main],
- states: vec![state],
- viewport_versions: vec![viewport_version],
- exit_on_close_requested: vec![exit_on_close_requested],
- surfaces: vec![surface],
- renderers: vec![renderer],
- pending_destroy: vec![],
- }
- }
-
- /// Adds a new window to [`Windows`]. Returns the size of the newly created window in logical
- /// pixels & the index of the window within [`Windows`].
- pub fn add(
- &mut self,
- application: &A,
- compositor: &mut C,
- id: window::Id,
- window: winit::window::Window,
- exit_on_close_requested: bool,
- ) -> (Size, usize) {
- let state = State::new(application, id, &window);
- let window_size = state.logical_size();
- let viewport_version = state.viewport_version();
- let physical_size = state.physical_size();
- let surface = compositor.create_surface(
- &window,
- physical_size.width,
- physical_size.height,
- );
- let renderer = compositor.create_renderer();
-
- self.ids.push(id);
- self.raw.push(window);
- self.states.push(state);
- self.exit_on_close_requested.push(exit_on_close_requested);
- self.viewport_versions.push(viewport_version);
- self.surfaces.push(surface);
- self.renderers.push(renderer);
-
- (window_size, self.ids.len() - 1)
- }
-
- pub fn is_empty(&self) -> bool {
- self.ids.is_empty()
- }
-
- pub fn main(&self) -> &winit::window::Window {
- &self.raw[0]
- }
-
- pub fn index_from_raw(&self, id: winit::window::WindowId) -> usize {
- self.raw
- .iter()
- .position(|window| window.id() == id)
- .expect("No raw window in multi_window::Windows")
- }
-
- pub fn index_from_id(&self, id: window::Id) -> usize {
- self.ids
- .iter()
- .position(|window_id| *window_id == id)
- .expect("No window in multi_window::Windows")
- }
-
- pub fn last_monitor(&self) -> Option<MonitorHandle> {
- self.raw
- .last()
- .and_then(winit::window::Window::current_monitor)
- }
-
- pub fn last(&self) -> usize {
- self.ids.len() - 1
- }
-
- pub fn with_raw(&self, id: window::Id) -> &winit::window::Window {
- let i = self.index_from_id(id);
- &self.raw[i]
- }
-
- /// Deletes the window with `id` from [`Windows`]. Returns the index that the window had.
- pub fn delete(&mut self, id: window::Id) -> usize {
- let i = self.index_from_id(id);
-
- let id = self.ids.remove(i);
- let window = self.raw.remove(i);
- let _ = self.states.remove(i);
- let _ = self.exit_on_close_requested.remove(i);
- let _ = self.viewport_versions.remove(i);
- let _ = self.surfaces.remove(i);
-
- self.pending_destroy.push((id, window.id()));
-
- i
- }
-
- /// Gets the winit `window` that is pending to be destroyed if it exists.
- pub fn get_pending_destroy(
- &mut self,
- window: winit::window::WindowId,
- ) -> window::Id {
- let i = self
- .pending_destroy
- .iter()
- .position(|(_, window_id)| window == *window_id)
- .unwrap();
-
- let (id, _) = self.pending_destroy.remove(i);
- id
- }
-
- /// Returns the windows that need to be requested to closed, and also the windows that can be
- /// closed immediately.
- pub fn partition_close_requests(
- &self,
- ) -> (Vec<window::Id>, Vec<window::Id>) {
- self.exit_on_close_requested.iter().enumerate().fold(
- (vec![], vec![]),
- |(mut close_immediately, mut needs_request_closed), (i, close)| {
- let id = self.ids[i];
-
- if *close {
- close_immediately.push(id);
- } else {
- needs_request_closed.push(id);
- }
-
- (close_immediately, needs_request_closed)
- },
- )
- }
-}
generated by cgit (git 2.34.1) at 2025-04-16 05:39:42 +0000