use super::{Window, WindowCommand};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct WindowModes {
pub(crate) minimized: bool,
pub(crate) maximized: bool,
pub(crate) full_screen: bool,
}
impl WindowModes {
#[cfg_attr(not(feature = "mcp"), allow(dead_code))]
pub(crate) fn any(self) -> bool {
self.minimized || self.maximized || self.full_screen
}
#[cfg_attr(not(feature = "mcp"), allow(dead_code))]
pub(crate) fn names(self) -> Vec<&'static str> {
[
(self.minimized, "minimized"),
(self.maximized, "maximized"),
(self.full_screen, "full_screen"),
]
.into_iter()
.filter_map(|(set, name)| set.then_some(name))
.collect()
}
}
pub(crate) trait NativeWindow {
fn modes(&self) -> WindowModes;
fn inner_size(&self) -> (u32, u32);
fn set_minimized(&self, minimized: bool);
fn set_maximized(&self, maximized: bool);
fn leave_full_screen(&self);
fn request_inner_size(&self, width: u32, height: u32);
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct ResizeOutcome {
pub(crate) requested: (u32, u32),
pub(crate) size: (u32, u32),
pub(crate) left: WindowModes,
pub(crate) remaining: WindowModes,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ResizeRestore {
Minimized,
Every,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct ResizeRequest {
pub(crate) width: u32,
pub(crate) height: u32,
pub(crate) restore: ResizeRestore,
pub(crate) report: Option<ResizeTicket>,
}
pub(crate) fn resize_native(
window: &impl NativeWindow,
width: u32,
height: u32,
restore: ResizeRestore,
) -> ResizeOutcome {
let every = restore == ResizeRestore::Every;
let mut left = WindowModes::default();
if every && window.modes().full_screen {
window.leave_full_screen();
left.full_screen = true;
}
if window.modes().minimized {
window.set_minimized(false);
left.minimized = true;
}
if every && window.modes().maximized {
window.set_maximized(false);
left.maximized = true;
}
window.request_inner_size(width, height);
ResizeOutcome {
requested: (width, height),
size: window.inner_size(),
left,
remaining: window.modes(),
}
}
#[cfg_attr(not(feature = "mcp"), allow(dead_code))]
pub(crate) struct ResizeReport {
deliver: Box<dyn FnOnce(Option<ResizeOutcome>) + Send + Sync>,
abandoned: Box<dyn Fn() -> bool + Send + Sync>,
}
impl ResizeReport {
#[cfg_attr(not(feature = "mcp"), allow(dead_code))]
pub(crate) fn new(
deliver: impl FnOnce(Option<ResizeOutcome>) + Send + Sync + 'static,
abandoned: impl Fn() -> bool + Send + Sync + 'static,
) -> Self {
Self {
deliver: Box::new(deliver),
abandoned: Box::new(abandoned),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct ResizeTicket(u64);
#[derive(Default)]
pub(super) struct ResizeReports {
next: u64,
pending: Vec<(ResizeTicket, ResizeReport)>,
}
impl Window {
#[cfg_attr(not(feature = "mcp"), allow(dead_code))]
pub(crate) fn resize_reported(&self, width: u32, height: u32, report: ResizeReport) {
let mut guard = self.inner.write().unwrap();
if !guard.shell_attached {
drop(guard);
(report.deliver)(None);
return;
}
let inner = &mut *guard;
let commands = &inner.commands;
inner.resize_reports.pending.retain(|(ticket, report)| {
let queued = commands
.iter()
.any(|command| matches!(command, WindowCommand::Resize(request) if request.report == Some(*ticket)));
queued && !(report.abandoned)()
});
let ticket = ResizeTicket(inner.resize_reports.next);
inner.resize_reports.next += 1;
inner.resize_reports.pending.push((ticket, report));
let waker = inner.queue_resize(ResizeRequest {
width,
height,
restore: ResizeRestore::Every,
report: Some(ticket),
});
drop(guard);
if let Some(waker) = waker {
waker();
}
}
#[cfg_attr(not(feature = "winit"), allow(dead_code))]
pub(crate) fn apply_resize(&self, native: Option<&impl NativeWindow>, request: ResizeRequest) {
let outcome = native.map(|native| resize_native(native, request.width, request.height, request.restore));
let Some(ticket) = request.report else {
return;
};
let report = {
let mut inner = self.inner.write().unwrap();
let pending = &mut inner.resize_reports.pending;
pending
.iter()
.position(|(waiting, _)| *waiting == ticket)
.map(|index| pending.remove(index).1)
};
if let Some(report) = report {
(report.deliver)(outcome);
}
}
#[cfg(test)]
pub(crate) fn pending_resize_reports(&self) -> usize {
self.inner.read().unwrap().resize_reports.pending.len()
}
}
#[derive(Default)]
#[cfg_attr(not(feature = "winit"), allow(dead_code))]
pub(crate) struct SizeReporter {
last: Option<(u32, u32)>,
}
impl SizeReporter {
#[cfg_attr(not(feature = "winit"), allow(dead_code))]
pub(crate) fn next(&mut self, minimized: bool, size: (u32, u32)) -> Option<(u32, u32)> {
if minimized || self.last == Some(size) {
return None;
}
self.last = Some(size);
Some(size)
}
}