use crate::printer::Printer;
use crate::view::{SizeConstraint, View, ViewWrapper};
use crate::Vec2;
use crate::XY;
pub struct ResizedView<T> {
size: XY<SizeConstraint>,
invalidated: bool,
view: T,
}
impl<T> ResizedView<T> {
pub fn new(
width: SizeConstraint,
height: SizeConstraint,
view: T,
) -> Self {
ResizedView {
size: (width, height).into(),
invalidated: true,
view,
}
}
pub fn set_constraints(
&mut self,
width: SizeConstraint,
height: SizeConstraint,
) {
self.set_width(width);
self.set_height(height);
}
pub fn set_width(&mut self, width: SizeConstraint) {
self.size.x = width;
self.invalidate();
}
pub fn set_height(&mut self, height: SizeConstraint) {
self.size.y = height;
self.invalidate();
}
pub fn with_fixed_size<S: Into<Vec2>>(size: S, view: T) -> Self {
let size = size.into();
ResizedView::new(
SizeConstraint::Fixed(size.x),
SizeConstraint::Fixed(size.y),
view,
)
}
pub fn with_fixed_width(width: usize, view: T) -> Self {
ResizedView::new(
SizeConstraint::Fixed(width),
SizeConstraint::Free,
view,
)
}
pub fn with_fixed_height(height: usize, view: T) -> Self {
ResizedView::new(
SizeConstraint::Free,
SizeConstraint::Fixed(height),
view,
)
}
pub fn with_full_screen(view: T) -> Self {
ResizedView::new(SizeConstraint::Full, SizeConstraint::Full, view)
}
pub fn with_full_width(view: T) -> Self {
ResizedView::new(SizeConstraint::Full, SizeConstraint::Free, view)
}
pub fn with_full_height(view: T) -> Self {
ResizedView::new(SizeConstraint::Free, SizeConstraint::Full, view)
}
pub fn with_max_size<S: Into<Vec2>>(size: S, view: T) -> Self {
let size = size.into();
ResizedView::new(
SizeConstraint::AtMost(size.x),
SizeConstraint::AtMost(size.y),
view,
)
}
pub fn with_max_width(max_width: usize, view: T) -> Self {
ResizedView::new(
SizeConstraint::AtMost(max_width),
SizeConstraint::Free,
view,
)
}
pub fn with_max_height(max_height: usize, view: T) -> Self {
ResizedView::new(
SizeConstraint::Free,
SizeConstraint::AtMost(max_height),
view,
)
}
pub fn with_min_size<S: Into<Vec2>>(size: S, view: T) -> Self {
let size = size.into();
ResizedView::new(
SizeConstraint::AtLeast(size.x),
SizeConstraint::AtLeast(size.y),
view,
)
}
pub fn with_min_width(min_width: usize, view: T) -> Self {
ResizedView::new(
SizeConstraint::AtLeast(min_width),
SizeConstraint::Free,
view,
)
}
pub fn with_min_height(min_height: usize, view: T) -> Self {
ResizedView::new(
SizeConstraint::Free,
SizeConstraint::AtLeast(min_height),
view,
)
}
fn invalidate(&mut self) {
self.invalidated = true;
}
inner_getters!(self.view: T);
}
impl<T: View> ViewWrapper for ResizedView<T> {
wrap_impl!(self.view: T);
fn wrap_draw(&self, printer: &Printer) {
self.view.draw(&printer.inner_size(
self.size.zip_map(printer.size, |c, s| c.result((s, s))),
));
}
fn wrap_required_size(&mut self, req: Vec2) -> Vec2 {
let req = self.size.zip_map(req, SizeConstraint::available);
let child_size = self.view.required_size(req);
self.size
.zip_map(child_size.zip(req), SizeConstraint::result)
}
fn wrap_layout(&mut self, size: Vec2) {
self.invalidated = false;
self.view
.layout(self.size.zip_map(size, |c, s| c.result((s, s))));
}
fn wrap_needs_relayout(&self) -> bool {
self.invalidated || self.view.needs_relayout()
}
}
#[cfg(test)]
mod tests {
use crate::view::{Boxable, View};
use crate::views::DummyView;
use crate::Vec2;
#[test]
fn min_size() {
let mut min_w = DummyView.full_screen().min_width(5);
assert_eq!(Vec2::new(5, 1), min_w.required_size(Vec2::new(1, 1)));
assert_eq!(Vec2::new(5, 10), min_w.required_size(Vec2::new(1, 10)));
assert_eq!(Vec2::new(10, 1), min_w.required_size(Vec2::new(10, 1)));
assert_eq!(Vec2::new(10, 10), min_w.required_size(Vec2::new(10, 10)));
let mut min_h = DummyView.full_screen().min_height(5);
assert_eq!(Vec2::new(1, 5), min_h.required_size(Vec2::new(1, 1)));
assert_eq!(Vec2::new(1, 10), min_h.required_size(Vec2::new(1, 10)));
assert_eq!(Vec2::new(10, 5), min_h.required_size(Vec2::new(10, 1)));
assert_eq!(Vec2::new(10, 10), min_h.required_size(Vec2::new(10, 10)));
let mut min_s = DummyView.full_screen().min_size((5, 5));
assert_eq!(Vec2::new(5, 5), min_s.required_size(Vec2::new(1, 1)));
assert_eq!(Vec2::new(5, 10), min_s.required_size(Vec2::new(1, 10)));
assert_eq!(Vec2::new(10, 5), min_s.required_size(Vec2::new(10, 1)));
assert_eq!(Vec2::new(10, 10), min_s.required_size(Vec2::new(10, 10)));
}
#[test]
fn max_size() {
let mut max_w = DummyView.full_screen().max_width(5);
assert_eq!(Vec2::new(1, 1), max_w.required_size(Vec2::new(1, 1)));
assert_eq!(Vec2::new(1, 10), max_w.required_size(Vec2::new(1, 10)));
assert_eq!(Vec2::new(5, 1), max_w.required_size(Vec2::new(10, 1)));
assert_eq!(Vec2::new(5, 10), max_w.required_size(Vec2::new(10, 10)));
let mut max_h = DummyView.full_screen().max_height(5);
assert_eq!(Vec2::new(1, 1), max_h.required_size(Vec2::new(1, 1)));
assert_eq!(Vec2::new(1, 5), max_h.required_size(Vec2::new(1, 10)));
assert_eq!(Vec2::new(10, 1), max_h.required_size(Vec2::new(10, 1)));
assert_eq!(Vec2::new(10, 5), max_h.required_size(Vec2::new(10, 10)));
let mut max_s = DummyView.full_screen().max_size((5, 5));
assert_eq!(Vec2::new(1, 1), max_s.required_size(Vec2::new(1, 1)));
assert_eq!(Vec2::new(1, 5), max_s.required_size(Vec2::new(1, 10)));
assert_eq!(Vec2::new(5, 1), max_s.required_size(Vec2::new(10, 1)));
assert_eq!(Vec2::new(5, 5), max_s.required_size(Vec2::new(10, 10)));
}
#[test]
fn full_screen() {
let mut full = DummyView.full_screen();
assert_eq!(Vec2::new(1, 1), full.required_size(Vec2::new(1, 1)));
assert_eq!(Vec2::new(1, 10), full.required_size(Vec2::new(1, 10)));
assert_eq!(Vec2::new(10, 1), full.required_size(Vec2::new(10, 1)));
assert_eq!(Vec2::new(10, 10), full.required_size(Vec2::new(10, 10)));
}
#[test]
fn test_get_inner() {
use crate::views::TextView;
let parent = TextView::new("abc").full_screen();
let child = parent.get_inner();
assert_eq!(child.get_content().source(), "abc");
}
#[test]
fn test_get_inner_mut() {
use crate::views::TextView;
let mut parent = TextView::new("").full_screen();
let new_value = "new";
let child = parent.get_inner_mut();
child.set_content(new_value);
assert_eq!(child.get_content().source(), new_value);
}
}