use super::{native, Native, Runner, Slot};
use crate::{
app::{
callbacks::CloseSource,
commands::Command,
registry::{Closed, OpenRequest},
App, RunError, WindowError, WindowKey, WindowOptions,
},
Context, PresentationMode, RenderError, Renderer,
};
use std::sync::Arc;
use winit::{dpi::LogicalSize, event_loop::ActiveEventLoop, keyboard::ModifiersState, window::Window};
const MAX_ROUNDS: usize = 16;
impl From<WindowError> for RunError {
fn from(error: WindowError) -> Self {
match error {
WindowError::Create(error) => Self::Window(error),
WindowError::Render(error) => Self::Render(error),
WindowError::UnknownParent(_) => {
Self::Render(RenderError::Validation(error.to_string()))
}
}
}
}
impl<A: App> Runner<A> {
pub(super) fn open_main(&mut self, event_loop: &ActiveEventLoop) -> Result<(), RunError> {
let key = self.options.main_window.clone();
let mut options = WindowOptions::from_attributes(self.options.window_attributes.clone());
options.presentation_mode = Some(self.options.presentation_mode);
self.hub.begin_open(&key, None, false);
let native = self.create_native(event_loop, &options)?;
self.attach(key, options, native);
Ok(())
}
fn create_native(
&self,
event_loop: &ActiveEventLoop,
options: &WindowOptions,
) -> Result<Native, WindowError> {
let owner = options
.parent
.as_ref()
.and_then(|parent| self.slots.get(parent))
.and_then(|slot| slot.native.as_ref())
.map(|native| native.window.as_ref());
let sibling = self
.slots
.values()
.find_map(|slot| slot.native.as_ref())
.map(|native| &native.renderer);
native::create(
event_loop,
options,
owner,
sibling,
self.options.presentation_mode,
&self.hub.control.resources,
)
}
fn attach(&mut self, key: WindowKey, options: WindowOptions, native: Native) {
let mut context = Context::with_shared(&self.hub.control.resources);
context.set_viewport(native.window.inner_size(), native.window.scale_factor());
self.hub.opened(&key, native.window.id());
self.slots.insert(
key,
Slot {
context,
options,
native: Some(native),
modifiers: ModifiersState::default(),
frames: 0,
},
);
}
pub(super) fn open_window(
&mut self,
event_loop: &ActiveEventLoop,
key: WindowKey,
options: WindowOptions,
declared: bool,
) {
match self.hub.begin_open(&key, options.parent.as_ref(), declared) {
OpenRequest::Exists => return,
OpenRequest::UnknownParent => {
let parent = options.parent.clone().unwrap_or_default();
return self.report_failure(event_loop, key, WindowError::UnknownParent(parent));
}
OpenRequest::Queued => {}
}
match self.create_native(event_loop, &options) {
Ok(native) => self.attach(key, options, native),
Err(error) => self.report_failure(event_loop, key, error),
}
}
fn report_failure(&mut self, event_loop: &ActiveEventLoop, key: WindowKey, error: WindowError) {
self.app.window_failed(&key, &error);
let closed = self.hub.open_failed(&key, error.to_string());
self.finish_close(event_loop, closed);
}
pub(super) fn recreate_natives(&mut self, event_loop: &ActiveEventLoop) -> Result<(), RunError> {
let mut keys: Vec<_> = self.slots.keys().cloned().collect();
keys.sort_by_key(|key| !self.hub.registry.is_main(key));
for key in keys {
let options = self.slots[&key].options.clone();
match self.create_native(event_loop, &options) {
Ok(native) => {
self.hub.registry.attach(&key, native.window.id());
let slot = self.slots.get_mut(&key).expect("slot exists");
slot.context.set_viewport(native.window.inner_size(), native.window.scale_factor());
slot.context.request_repaint();
slot.native = Some(native);
}
Err(error) if self.hub.registry.is_main(&key) => return Err(error.into()),
Err(error) => {
self.app.window_failed(&key, &error);
let closed = self.hub.close(&key);
self.finish_close(event_loop, closed);
}
}
}
Ok(())
}
pub(super) fn request_close(
&mut self,
event_loop: &ActiveEventLoop,
key: &WindowKey,
source: CloseSource,
) {
let outcome = self.hub.close_requested(&mut self.app, key, source);
if outcome.rejected {
if let Some(slot) = self.slots.get_mut(key) {
slot.context.request_repaint();
if let Some(native) = &slot.native {
native.window.request_redraw();
}
}
}
self.finish_close(event_loop, outcome.closed);
}
pub(super) fn finish_close(&mut self, event_loop: &ActiveEventLoop, closed: Closed) {
for key in &closed.keys {
if let Some(Slot {
native: Some(native),
..
}) = self.slots.remove(key)
{
native.window.set_visible(false);
}
}
if closed.exit {
event_loop.exit();
}
}
pub(super) fn settle(&mut self, event_loop: &ActiveEventLoop, declare: bool) {
if declare {
self.hub.declare(&mut self.app);
}
for _ in 0..MAX_ROUNDS {
let commands = self.hub.take_commands();
if commands.is_empty() {
break;
}
for command in commands {
self.execute(event_loop, command);
}
}
}
fn execute(&mut self, event_loop: &ActiveEventLoop, command: Command) {
match command {
Command::Open {
key,
options,
declared,
} => self.open_window(event_loop, key, *options, declared),
Command::Close(key) => {
let closed = self.hub.close(&key);
self.finish_close(event_loop, closed);
}
Command::RequestClose(key) => self.request_close(event_loop, &key, CloseSource::Application),
Command::Exit => event_loop.exit(),
Command::Repaint(key) => {
for (name, slot) in &mut self.slots {
if key.as_ref().is_none_or(|key| key == name) {
slot.context.request_repaint();
if let Some(native) = slot.native.as_ref().filter(|n| n.visible()) {
native.window.request_redraw();
}
}
}
}
Command::Focus(key) => {
if let Some(native) = self.native(&key) {
if native.window.is_minimized() == Some(true) {
native.window.set_minimized(false);
}
native.window.focus_window();
}
}
Command::Title(key, title) => {
if let Some(native) = self.native(&key) {
native.window.set_title(&title);
}
}
Command::Size(key, width, height) => {
if let Some(native) = self.native(&key) {
let _ = native
.window
.request_inner_size(LogicalSize::new(width, height));
}
}
Command::Visible(key, visible) => {
if let Some(slot) = self.slots.get_mut(&key) {
if let Some(native) = &slot.native {
native.window.set_visible(visible);
if visible {
slot.context.request_repaint();
native.window.request_redraw();
}
}
}
}
}
}
fn native(&self, key: &WindowKey) -> Option<&Native> {
self.slots.get(key).and_then(|slot| slot.native.as_ref())
}
pub(super) fn recover_device(
&mut self,
event_loop: &ActiveEventLoop,
reason: String,
) -> Result<(), RenderError> {
self.device_resets += 1;
self.device_loss = Some(reason);
let mut windows: Vec<(WindowKey, Arc<Window>, PresentationMode)> = self
.slots
.iter()
.filter_map(|(key, slot)| {
let native = slot.native.as_ref()?;
Some((
key.clone(),
Arc::clone(&native.window),
native.renderer.presentation_mode(),
))
})
.collect();
windows.sort_by_key(|(key, ..)| !self.hub.registry.is_main(key));
let mut renderers: Vec<(WindowKey, Renderer)> = Vec::new();
let mut lost = Vec::new();
for (key, window, mode) in windows {
let renderer = match renderers.first() {
Some((_, first)) => first.create_sibling(window, mode),
None => pollster::block_on(Renderer::new_with_presentation_mode(window, mode)),
};
match renderer {
Ok(renderer) => renderers.push((key, renderer)),
Err(error) if renderers.is_empty() => return Err(error),
Err(error) => lost.push((key, error)),
}
}
for (key, mut renderer) in renderers {
let Some(slot) = self.slots.get_mut(&key) else {
continue;
};
let Some(native) = slot.native.as_mut() else {
continue;
};
renderer.set_transparent(native.transparent);
native::clamp_image_limits(&self.hub.control.resources, &renderer);
native.renderer = renderer;
native.retry_at = None;
slot.context.request_repaint();
native.window.request_redraw();
}
for (key, error) in lost {
self.report_failure(event_loop, key, WindowError::Render(error));
}
Ok(())
}
}