use crate::prelude::*;
use winit::{dpi::PhysicalSize, event::ElementState, keyboard::KeyCode};
use zaxis::{
Color, CornerRadius, Padding, Rect, Root, ScrollArea, Shape, SplitHandle, SplitHandleStyle,
SplitOutput, SplitPane, SplitPanel, SplitSize, SplitStyle, SplitSurface, TextEdit, Transform,
};
fn draw(c: &mut Context, panels: Vec<SplitPanel>) -> SplitOutput<()> {
let mut output = None;
c.run(|c| {
Root::new().padding(Padding::all(0.0)).show(c, |ui| {
output = Some(
SplitPane::horizontal("test")
.panels(panels)
.show(ui, |_| {}),
);
})
});
output.unwrap()
}
fn specs() -> Vec<SplitPanel> {
(0..3).map(|i| SplitPanel::new(i).min_size(30.0)).collect()
}
#[test]
fn captured_drag_release_and_idle_cache() {
let mut c = Context::new();
c.set_viewport(PhysicalSize::new(600, 300), 1.0);
let before = draw(&mut c, specs());
let p = before.boundaries[0].bounds.center();
c.move_pointer(p);
assert!(c.primary_button(ElementState::Pressed));
c.move_pointer(p + Vec2::new(60.0, 900.0));
let after = draw(&mut c, specs());
assert!(after.resize_started && after.changed);
assert_eq!(after.panels[2].size, before.panels[2].size);
assert!((after.panels[0].size - before.panels[0].size - 60.0).abs() < 0.01);
assert_eq!(c.cursor_icon(), winit::window::CursorIcon::EwResize);
c.primary_button(ElementState::Released);
let released = draw(&mut c, specs());
assert!(released.resize_ended);
assert!((released.panels[0].size - after.panels[0].size).abs() < 0.01);
draw(&mut c, specs());
let stats = c.cache_stats();
let revision = c.draw_data().revision;
draw(&mut c, specs());
assert_eq!(
stats.tessellated_elements,
c.cache_stats().tessellated_elements
);
assert_eq!(revision, c.draw_data().revision);
assert!(!c.needs_repaint());
}
#[test]
fn batched_events_keyboard_focus_reset_and_nested_text() {
let mut c = Context::new();
c.set_viewport(PhysicalSize::new(600, 300), 1.0);
let out = draw(&mut c, specs());
let p = out.boundaries[0].bounds.center();
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
c.move_pointer(p + Vec2::new(50.0, 0.0));
c.primary_button(ElementState::Released);
let out = draw(&mut c, specs());
assert!(out.resize_started && out.resize_ended);
let before = out.panels[0].size;
assert!(c.key(KeyCode::ArrowRight, ElementState::Pressed, false));
assert_eq!(draw(&mut c, specs()).panels[0].size, before + 4.0);
c.set_modifiers(winit::keyboard::ModifiersState::SHIFT);
assert!(c.key(KeyCode::ArrowLeft, ElementState::Pressed, false));
assert_eq!(draw(&mut c, specs()).panels[0].size, before - 20.0);
c.key(KeyCode::Home, ElementState::Pressed, false);
let reset = draw(&mut c, specs());
assert!((reset.panels[0].size - reset.panels[1].size).abs() < 0.01);
c.set_modifiers(Default::default());
c.set_focus(None);
c.key(KeyCode::Tab, ElementState::Pressed, false);
let focused = draw(&mut c, specs());
assert!(focused.boundaries[0].focused);
assert!(c.focus_visible(focused.boundaries[0].id));
let mut text = String::from("abc");
let mut edit = None;
c.run(|c| {
Root::new().show(c, |ui| {
ui.split_horizontal("nested", specs(), |split| {
split.panel(0, |ui| {
edit = Some(ui.add(TextEdit::new(&mut text)));
});
});
})
});
c.request_focus(edit.unwrap().id);
assert!(c.key(KeyCode::ArrowRight, ElementState::Pressed, false));
assert!(c.probe().counts.split_input == 0);
}
#[test]
fn topology_ids_focus_viewport_and_fixed_sizes() {
let mut c = Context::new();
c.set_viewport(PhysicalSize::new(600, 300), 1.0);
let specs = || {
vec![
SplitPanel::new(0).default_size(SplitSize::Pixels(100.0)),
SplitPanel::new(1),
SplitPanel::new(2),
SplitPanel::new(3),
]
};
let before = draw(&mut c, specs());
let p = before.boundaries[1].bounds.center();
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
c.move_pointer(p + Vec2::new(50.0, 0.0));
c.primary_button(ElementState::Released);
let resized = draw(&mut c, specs());
let ratio = resized.panels[1].size / resized.panels[2].size;
let focus = resized.boundaries[1].id;
c.set_viewport(PhysicalSize::new(900, 400), 1.0);
let grown = draw(&mut c, specs());
assert_eq!(grown.panels[0].size, 100.0);
assert!((grown.panels[1].size / grown.panels[2].size - ratio).abs() < 0.0001);
let mut reordered = specs();
reordered.rotate_left(1);
let reordered = draw(&mut c, reordered);
assert_eq!(reordered.boundaries[0].id, focus);
assert!(reordered.boundaries[0].focused);
assert!((reordered.panels[0].size - grown.panels[1].size).abs() < 0.01);
let mut added = specs();
added.push(SplitPanel::new(4));
let added = draw(&mut c, added);
assert_eq!(added.panels.len(), 5);
assert_eq!(added.panels[0].size, 100.0);
let p = added.boundaries[1].bounds.center();
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
draw(&mut c, specs());
let removed = draw(
&mut c,
vec![SplitPanel::new(0), SplitPanel::new(1), SplitPanel::new(3)],
);
assert!(removed.resize_ended && c.probe().capture.is_none());
assert!(!removed.boundaries.iter().any(|b| b.id == focus));
}
#[test]
fn controlled_values_rebase_drag_and_propose_without_feedback() {
let mut c = Context::new();
c.set_viewport(PhysicalSize::new(600, 300), 1.0);
let specs = |size| {
vec![
SplitPanel::new(0).size(SplitSize::Pixels(size)),
SplitPanel::new(1),
SplitPanel::new(2),
]
};
let out = draw(&mut c, specs(100.0));
let p = out.boundaries[0].bounds.center();
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
c.move_pointer(p + Vec2::new(30.0, 0.0));
assert_eq!(draw(&mut c, specs(100.0)).panels[0].size, 130.0);
c.move_pointer(p + Vec2::new(40.0, 0.0));
assert_eq!(draw(&mut c, specs(130.0)).panels[0].size, 140.0);
assert_eq!(draw(&mut c, specs(200.0)).panels[0].size, 200.0);
c.move_pointer(p + Vec2::new(50.0, 0.0));
assert_eq!(draw(&mut c, specs(200.0)).panels[0].size, 210.0);
c.primary_button(ElementState::Released);
draw(&mut c, specs(210.0));
assert_eq!(draw(&mut c, specs(180.0)).panels[0].size, 180.0);
}
#[test]
fn disabled_cancellation_focus_loss_and_component_removal() {
let mut c = Context::new();
c.set_viewport(PhysicalSize::new(600, 300), 1.0);
let out = draw(&mut c, specs());
let p = out.boundaries[0].bounds.center();
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
draw(&mut c, specs());
c.key(KeyCode::Escape, ElementState::Pressed, false);
let out = draw(&mut c, specs());
assert!(out.resize_ended && out.boundaries[0].cancelled);
c.primary_button(ElementState::Released);
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
draw(&mut c, specs());
c.on_window_event(&winit::event::WindowEvent::Focused(false));
assert!(draw(&mut c, specs()).resize_ended);
assert!(c.probe().capture.is_none());
c.on_window_event(&winit::event::WindowEvent::Focused(true));
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
draw(&mut c, specs());
let mut disabled = specs();
disabled[0].resizable_after = false;
let out = draw(&mut c, disabled);
assert!(out.resize_ended);
assert!(!out.boundaries[0].enabled);
assert!(c.probe().capture.is_none());
c.primary_button(ElementState::Released);
c.move_pointer(p);
c.primary_button(ElementState::Pressed);
draw(&mut c, specs());
c.run(|c| Root::new().show(c, |_| {}));
assert!(c.probe().capture.is_none());
assert!(c.probe().counts.splits == 0);
}
#[test]
fn tiny_empty_and_single_panels_and_edge_hit_priority() {
let mut c = Context::new();
c.set_viewport(PhysicalSize::new(4, 2), 1.0);
let out = draw(&mut c, specs());
assert!(out.panels.iter().all(|p| p.size == 0.0));
assert!(out
.boundaries
.iter()
.all(|b| b.bounds.min.x >= 0.0 && b.bounds.max.x <= 4.0));
assert!(draw(&mut c, vec![]).panels.is_empty());
assert_eq!(draw(&mut c, vec![SplitPanel::new(0)]).panels[0].size, 4.0);
c.set_viewport(PhysicalSize::new(0, 0), 1.0);
assert!(draw(&mut c, specs())
.panels
.iter()
.all(|p| p.bounds.is_empty()));
c.set_viewport(PhysicalSize::new(600, 300), 1.0);
let mut out = None;
let mut button = None;
c.run(|c| {
Root::new().padding(Padding::all(0.0)).show(c, |ui| {
out = Some(
SplitPane::horizontal("edge")
.gap(0.0)
.handle(
SplitHandleStyle::default()
.kind(SplitHandle::PanelEdge)
.hit_width(10.0),
)
.panels(specs())
.show(ui, |s| {
s.panel(0, |ui| {
button = Some(ui.button("Button outside edge zone"));
let bounds = ui.allocate_space(Vec2::new(1000.0, 1000.0));
let clip = ui.clip_rect();
ui.context().register_hit(HitRegion {
id: Id::new("overflow"),
window: Id::new("zaxis-root"),
rect: bounds,
clip,
action: HitAction::Activate,
});
})
}),
);
})
});
let out = out.unwrap();
let handle = out.boundaries[0].bounds;
assert_eq!(handle.max.x, out.panels[0].bounds.max.x);
assert_eq!(
c.hit_test(handle.center()).unwrap().id,
out.boundaries[0].id
);
assert_eq!(
c.hit_test(button.unwrap().rect.center()).unwrap().action,
HitAction::Activate
);
assert!(c
.probe()
.previous_hits
.iter()
.filter(|h| h.id == Id::new("overflow"))
.all(|h| h.clip.max.x <= out.panels[0].content_bounds.max.x));
}
#[test]
fn dpi_transforms_scroll_clipping_and_nested_axes() {
let mut c = Context::new();
c.set_viewport(PhysicalSize::new(1200, 800), 2.0);
let surface = SplitSurface::default()
.corner_radius(CornerRadius {
top_left: 30.0,
top_right: 10.0,
bottom_left: 18.0,
bottom_right: 2.0,
})
.padding(Padding::all(0.0));
let transform = Transform::around(Vec2::ZERO, 0.8, Vec2::new(10.0, 20.0));
let mut out = None;
let mut nested = None;
let draw = |c: &mut Context,
out: &mut Option<SplitOutput<()>>,
nested: &mut Option<SplitOutput<()>>| {
c.run(|c| {
Root::new().padding(Padding::all(0.0)).show(c, |ui| {
ui.visual("scaled", transform, 1.0, |ui| {
*out = Some(
SplitPane::horizontal("visual")
.size(Vec2::new(500.0, 350.0))
.style(SplitStyle::default().panel(surface))
.panels(specs())
.show(ui, |s| {
s.panel(0, |ui| {
ui.paint(Shape::rect(
Rect::from_min_size(Vec2::ZERO, Vec2::splat(5000.0)),
Color::WHITE,
));
ScrollArea::vertical().show(ui, |ui| {
for i in 0..20 {
ui.button(format!("Button {i}"));
}
});
});
s.panel(1, |ui| {
*nested = Some(
SplitPane::vertical("nested")
.panels(specs())
.show(ui, |_| {}),
);
});
}),
);
});
})
});
};
draw(&mut c, &mut out, &mut nested);
let bounds = transform.rect(out.as_ref().unwrap().panels[0].content_bounds);
let white: Vec<_> = c
.probe()
.elements
.iter()
.filter(|e| {
c.probe()
.cache
.get(&e.id)
.is_some_and(|p| format!("{:?}", p.paint).contains("255, 255, 255"))
})
.collect();
assert!(!white.is_empty());
assert!(white.iter().all(|e| e.clip.intersect(bounds) == e.clip));
let bid = nested.as_ref().unwrap().boundaries[0].id;
let hit = *c
.probe()
.previous_hits
.iter()
.find(|h| h.id == bid)
.unwrap();
c.move_pointer(hit.rect.center());
c.primary_button(ElementState::Pressed);
c.move_pointer(hit.rect.center() + Vec2::new(0.0, 24.0));
let old = nested.as_ref().unwrap().panels[0].size;
draw(&mut c, &mut out, &mut nested);
assert!((nested.as_ref().unwrap().panels[0].size - old - 30.0).abs() < 0.02);
assert_eq!(c.cursor_icon(), winit::window::CursorIcon::NsResize);
}