use crate::component::ComponentId;
use crate::geometry::{PointF, RectF};
use crate::ui::Ui;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ScreenRect {
pub x: i32,
pub y: i32,
pub width: u32,
pub height: u32,
}
impl ScreenRect {
pub const fn new(x: i32, y: i32, width: u32, height: u32) -> Self {
Self { x, y, width, height }
}
pub fn right(&self) -> i64 {
self.x as i64 + self.width as i64
}
pub fn bottom(&self) -> i64 {
self.y as i64 + self.height as i64
}
pub fn is_empty(&self) -> bool {
self.width == 0 || self.height == 0
}
pub fn intersect(&self, other: ScreenRect) -> Option<ScreenRect> {
let (x, y) = (self.x.max(other.x), self.y.max(other.y));
let (r, b) = (self.right().min(other.right()), self.bottom().min(other.bottom()));
(r > x as i64 && b > y as i64).then(|| ScreenRect::new(x, y, (r - x as i64) as u32, (b - y as i64) as u32))
}
pub fn contains_rect(&self, other: ScreenRect) -> bool {
other.x >= self.x && other.y >= self.y && other.right() <= self.right() && other.bottom() <= self.bottom()
}
pub fn bounding(rects: &[ScreenRect]) -> Option<ScreenRect> {
let rects: Vec<&ScreenRect> = rects.iter().filter(|r| !r.is_empty()).collect();
let x = rects.iter().map(|r| r.x).min()?;
let y = rects.iter().map(|r| r.y).min()?;
let r = rects.iter().map(|r| r.right()).max()?;
let b = rects.iter().map(|r| r.bottom()).max()?;
Some(ScreenRect::new(x, y, (r - x as i64) as u32, (b - y as i64) as u32))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Piece {
pub monitor: usize,
pub screen: ScreenRect,
pub origin_x: i32,
pub origin_y: i32,
}
impl Piece {
pub fn rect_in_form(&self, scale: f64) -> RectF {
let s = scale.max(0.01);
RectF::new((self.origin_x as f64 / s) as f32, (self.origin_y as f64 / s) as f32, (self.screen.width as f64 / s) as f32, (self.screen.height as f64 / s) as f32)
}
pub fn to_form(&self, x: f64, y: f64, scale: f64) -> PointF {
let s = scale.max(0.01);
PointF::new(((x + self.origin_x as f64) / s) as f32, ((y + self.origin_y as f64) / s) as f32)
}
}
pub fn split(form: ScreenRect, monitors: &[ScreenRect]) -> Vec<Piece> {
let mut pieces: Vec<Piece> = Vec::new();
for (monitor, m) in monitors.iter().enumerate() {
let Some(screen) = form.intersect(*m) else { continue };
if pieces.iter().any(|p| p.screen.contains_rect(screen)) {
continue;
}
pieces.push(Piece { monitor, screen, origin_x: screen.x - form.x, origin_y: screen.y - form.y });
}
pieces.sort_by_key(|p| (p.screen.y, p.screen.x));
pieces
}
pub fn largest(pieces: &[Piece]) -> Option<usize> {
let area = |p: &Piece| p.screen.width as u64 * p.screen.height as u64;
pieces.iter().enumerate().fold(None, |best: Option<(usize, u64)>, (i, p)| match best {
Some((_, a)) if a >= area(p) => best,
_ => Some((i, area(p))),
}).map(|(i, _)| i)
}
impl Ui {
pub fn form_pieces(&self, form: ComponentId) -> &[RectF] {
self.form_pieces.get(&self.root_of(form)).map_or(&[], Vec::as_slice)
}
pub fn set_form_pieces(&mut self, form: ComponentId, pieces: Vec<RectF>) {
if pieces.len() <= 1 {
self.form_pieces.remove(&form);
} else {
self.form_pieces.insert(form, pieces);
}
}
pub fn popup_area(&self, form: ComponentId, at: PointF) -> RectF {
let root = self.root_of(form);
let whole = self.control(root).map_or(RectF::new(0.0, 0.0, f32::MAX, f32::MAX), |cb| RectF::new(0.0, 0.0, cb.width(), cb.height()));
let pieces = self.form_pieces(root);
if let Some(p) = pieces.iter().find(|p| p.contains(at)) {
return *p;
}
let distance = |r: &RectF| {
let dx = (r.x - at.x).max(at.x - r.right()).max(0.0);
let dy = (r.y - at.y).max(at.y - r.bottom()).max(0.0);
dx * dx + dy * dy
};
pieces.iter().copied().min_by(|a, b| distance(a).total_cmp(&distance(b))).unwrap_or(whole)
}
pub fn paint_piece(&mut self, root: ComponentId, canvas: &mut dyn crate::Canvas, piece: RectF, areas: Option<&[RectF]>, start: bool) {
let in_form: Vec<RectF> = match areas {
Some(a) => a.iter().filter_map(|r| r.offset(piece.x, piece.y).intersect(piece)).collect(),
None => vec![piece],
};
if in_form.is_empty() {
return;
}
canvas.save();
canvas.translate(-piece.x, -piece.y);
self.paint_regions_in(root, canvas, &in_form, start && areas.is_none());
canvas.restore();
let mine = self.frame_requests.borrow().get(&root).copied().unwrap_or((false, None));
let merged = match self.piece_requests.get().filter(|_| !start) {
Some((animating, wake)) => {
let wake = [wake, mine.1].into_iter().flatten().reduce(f64::min);
(animating || mine.0, wake)
}
None => mine,
};
self.piece_requests.set(Some(merged));
self.frame_requests.borrow_mut().insert(root, merged);
}
}
#[cfg(test)]
mod tests {
use super::*;
const LEFT: ScreenRect = ScreenRect::new(0, 0, 1920, 1080);
const RIGHT: ScreenRect = ScreenRect::new(1920, 0, 2560, 1440);
#[test]
fn a_form_inside_one_monitor_is_one_piece() {
let pieces = split(ScreenRect::new(100, 100, 800, 600), &[LEFT, RIGHT]);
assert_eq!(pieces, vec![Piece { monitor: 0, screen: ScreenRect::new(100, 100, 800, 600), origin_x: 0, origin_y: 0 }]);
}
#[test]
fn a_form_across_two_monitors_is_split_at_the_border() {
let pieces = split(ScreenRect::new(1500, 200, 1000, 500), &[LEFT, RIGHT]);
assert_eq!(pieces.len(), 2);
assert_eq!(pieces[0], Piece { monitor: 0, screen: ScreenRect::new(1500, 200, 420, 500), origin_x: 0, origin_y: 0 });
assert_eq!(pieces[1], Piece { monitor: 1, screen: ScreenRect::new(1920, 200, 580, 500), origin_x: 420, origin_y: 0 });
assert_eq!(largest(&pieces), Some(1));
}
#[test]
fn the_monitor_on_the_left_has_negative_coordinates() {
let left = ScreenRect::new(-1280, 100, 1280, 1024);
let pieces = split(ScreenRect::new(-300, 300, 900, 400), &[LEFT, left]);
assert_eq!(pieces.len(), 2);
assert_eq!(pieces[0].monitor, 1);
assert_eq!((pieces[0].origin_x, pieces[0].screen.x, pieces[0].screen.width), (0, -300, 300));
assert_eq!(pieces[1].monitor, 0);
assert_eq!((pieces[1].origin_x, pieces[1].screen.width), (300, 600));
}
#[test]
fn a_video_wall_covers_every_monitor_and_skips_the_gaps() {
let mut monitors: Vec<ScreenRect> = (0..6).map(|i| ScreenRect::new((i % 3) * 1920, (i / 3) * 1080, 1920, 1080)).collect();
monitors.push(ScreenRect::new(0, 2160, 1280, 720));
let all = ScreenRect::bounding(&monitors).unwrap();
assert_eq!(all, ScreenRect::new(0, 0, 5760, 2880));
let pieces = split(all, &monitors);
assert_eq!(pieces.len(), 7);
let covered: u64 = pieces.iter().map(|p| p.screen.width as u64 * p.screen.height as u64).sum();
assert_eq!(covered, 6 * 1920 * 1080 + 1280 * 720);
assert_eq!(pieces.iter().map(|p| p.monitor).collect::<Vec<_>>(), vec![0, 1, 2, 3, 4, 5, 6]);
assert_eq!((pieces[4].origin_x, pieces[4].origin_y), (1920, 1080));
}
#[test]
fn a_mirrored_monitor_does_not_get_another_window() {
let pieces = split(ScreenRect::new(1000, 0, 2000, 800), &[LEFT, LEFT, RIGHT]);
assert_eq!(pieces.iter().map(|p| p.monitor).collect::<Vec<_>>(), vec![0, 2]);
}
#[test]
fn the_input_of_a_window_becomes_a_point_in_the_form() {
let pieces = split(ScreenRect::new(1500, 200, 1000, 500), &[LEFT, RIGHT]);
assert_eq!(pieces[1].to_form(0.0, 0.0, 1.5), PointF::new(280.0, 0.0));
assert_eq!(pieces[1].to_form(30.0, 15.0, 1.5), PointF::new(300.0, 10.0));
assert_eq!(pieces[0].to_form(450.0, 0.0, 1.5), pieces[1].to_form(30.0, 0.0, 1.5));
assert_eq!(pieces[1].rect_in_form(1.5), RectF::new(280.0, 0.0, 580.0 / 1.5, 500.0 / 1.5));
}
}