zaxis 0.0.2

An event-driven immediate mode GUI for desktop tools
Documentation
use super::*;
use crate::{
    Align, Column, ColumnWidth, Grid, GridOutput, GridStyle, Padding, Rect, ScrollArea, Shape,
    Window,
};
use winit::{dpi::PhysicalSize, event::ElementState};

pub(super) fn setup() -> Context {
    let mut c = Context::new();
    c.set_viewport(PhysicalSize::new(800, 600), 1.0);
    c
}
pub(super) fn click(c: &mut Context, rect: Rect) {
    c.move_pointer(rect.center());
    c.primary_button(ElementState::Pressed);
    c.primary_button(ElementState::Released);
}
fn style() -> GridStyle {
    GridStyle {
        padding: Padding::all(0.0),
        cell_padding: Padding::all(0.0),
        spacing: Vec2::new(4.0, 3.0),
        ..Default::default()
    }
}

#[test]
fn columns_resolve_fixed_content_weighted_remainder_and_overflow() {
    let columns = [
        Column::fixed("fixed", 80.0),
        Column::content("auto").min_width(20.0),
        Column::remainder("one").min_width(10.0),
        Column::new("two", ColumnWidth::Remainder(2.0)).min_width(10.0),
    ];
    assert_eq!(
        crate::components::columns::resolve(&columns, &[0.0, 50.0], 400.0, 10.0),
        [80.0, 50.0, 10.0 + 220.0 / 3.0, 10.0 + 440.0 / 3.0]
    );
    assert_eq!(
        crate::components::columns::resolve(&columns, &[0.0, 50.0], 5.0, 10.0),
        [80.0, 50.0, 10.0, 10.0]
    );
}

fn measured(c: &mut Context, calls: &mut usize) -> GridOutput<()> {
    let mut out = None;
    c.run(|c| {
        Window::new("Grid")
            .default_size(Vec2::new(500.0, 400.0))
            .show(c, |ui| {
                out = Some(
                    Grid::new("form")
                        .style(style())
                        .width(350.0)
                        .columns([
                            Column::content("label"),
                            Column::fixed("fixed", 80.0).align(Align::Center, Align::End),
                            Column::remainder("rest"),
                        ])
                        .show(ui, |grid| {
                            for (key, size) in
                                [("a", Vec2::new(45.0, 20.0)), ("b", Vec2::new(100.0, 50.0))]
                            {
                                grid.row(key, |row| {
                                    row.cell(|ui| {
                                        *calls += 1;
                                        let rect = ui.allocate_space(size);
                                        ui.paint(Shape::rect(rect, crate::Color::WHITE));
                                    });
                                    row.cell(|ui| {
                                        *calls += 1;
                                        let rect = ui.allocate_space(Vec2::new(20.0, 10.0));
                                        ui.paint(Shape::rect(rect, crate::Color::gray(123)));
                                    });
                                    row.cell(|ui| {
                                        *calls += 1;
                                        ui.horizontal(|ui| {
                                            ui.label("Label");
                                            ui.button("Action");
                                        });
                                    });
                                });
                            }
                        }),
                );
            });
    });
    out.unwrap()
}
#[test]
fn callbacks_once_shared_widths_max_height_alignment_and_idle() {
    let mut c = setup();
    let mut calls = 0;
    let first = measured(&mut c, &mut calls);
    assert_eq!(calls, 6);
    assert_eq!(first.widths, [100.0, 80.0, 162.0]);
    assert!(first.rows[1].size().y >= 50.0);
    assert_eq!(first.cells[0][1].size().x, first.cells[1][1].size().x);
    let second = measured(&mut c, &mut calls);
    assert_eq!(calls, 12);
    assert_eq!(second.widths, first.widths);
    assert!(
        !c.needs_repaint(),
        "settled layout must not redraw continuously"
    );
    // A centered 20 px allocation in an 80 px column has a 30 px offset.
    assert!(c.cache.values().flat_map(|cached| &cached.paint).any(|p| matches!(p, Paint::Shape(Shape::Rect { rect, fill, .. }) if *fill == crate::Color::gray(123) && (rect.min.x - second.cells[0][1].min.x - 30.0).abs() < 0.01)));
}

#[test]
fn cell_paint_hits_clipping_nested_scroll_and_single_bound_mutation() {
    let mut c = setup();
    let mut value = 5.0;
    let mut calls = 0;
    let mut button = None;
    let mut output = None;
    for _ in 0..2 {
        c.run(|c| {
            Window::new("Grid").show(c, |ui| {
                output = Some(
                    Grid::new("outer")
                        .style(style())
                        .columns([
                            Column::fixed("first", 100.0),
                            Column::fixed("second", 100.0),
                        ])
                        .show(ui, |grid| {
                            grid.row("stable", |row| {
                                row.cell(|ui| {
                                    calls += 1;
                                    ui.add(crate::Slider::new(&mut value, 0.0..=1.0));
                                    ScrollArea::vertical()
                                        .id_source("inside")
                                        .max_height(50.0)
                                        .show(ui, |ui| {
                                            for n in 0..5 {
                                                ui.push_id(n, |ui| {
                                                    ui.button("Nested");
                                                });
                                            }
                                        });
                                });
                                row.cell(|ui| {
                                    button = Some(
                                        ui.add(
                                            crate::Button::new("Overflow")
                                                .min_size(Vec2::new(250.0, 30.0)),
                                        ),
                                    );
                                });
                            })
                        }),
                );
            });
        });
    }
    assert_eq!(calls, 2);
    assert_eq!(value, 1.0);
    let output = output.unwrap();
    let button = button.unwrap();
    let hit = *c
        .previous_hits
        .iter()
        .find(|hit| hit.id == button.id)
        .unwrap();
    assert_eq!(hit.clip, output.cells[0][1]);
    assert!(
        hit.rect.size().x <= hit.clip.size().x,
        "built-in buttons constrain their own width"
    );
    for state in c.scrolling.states.values() {
        assert!(state.viewport.min.x >= output.cells[0][0].min.x);
        assert!(state.viewport.max.x <= output.cells[0][0].max.x);
    }
    assert_eq!(c.placements.outstanding, 0);
    assert!(c.placements.stack.is_empty());
    assert!(c.scrolling.pending.is_empty());
    click(
        &mut c,
        Rect::from_min_size(hit.clip.max + Vec2::new(1.0, -15.0), Vec2::splat(1.0)),
    );
    assert!(!c.clicked(button.id));
}

#[test]
fn nested_grid_scroll_corrections_and_zero_space_have_nonnegative_rects() {
    let mut c = setup();
    c.run(|c| {
        Window::new("Tiny").show(c, |ui| {
            ScrollArea::both()
                .max_height(90.0)
                .scroll_offset(Vec2::splat(1000.0))
                .show(ui, |ui| {
                    Grid::new("outer")
                        .width(0.0)
                        .style(GridStyle {
                            padding: Padding::all(30.0),
                            cell_padding: Padding::all(20.0),
                            ..style()
                        })
                        .columns([
                            Column::remainder("a"),
                            Column::remainder("b").min_width(5.0),
                        ])
                        .show(ui, |grid| {
                            grid.row(1, |row| {
                                row.cell(|ui| {
                                    Grid::new("inner")
                                        .column(Column::remainder("c"))
                                        .show(ui, |grid| {
                                            grid.row(2, |row| row.cell(|ui| ui.label("Nested")))
                                        });
                                });
                                row.cell(|ui| {
                                    ui.label("Long content that must be clipped");
                                });
                            })
                        });
                });
        });
    });
    assert!(c
        .previous_hits
        .iter()
        .all(|h| h.rect.size().min_element() >= 0.0 && h.clip.size().min_element() >= 0.0));
    assert!(c
        .draw_data()
        .vertices
        .iter()
        .all(|v| v.position.iter().all(|n| n.is_finite())));
}

struct CountWidget<'a>(&'a mut usize);
impl crate::Widget for CountWidget<'_> {
    fn ui(self, ui: &mut crate::Ui<'_>) -> crate::Response {
        *self.0 += 1;
        let rect = ui.allocate_space(Vec2::new(400.0, 20.0));
        ui.paint(Shape::rect(rect, crate::Color::gray(124)));
        ui.button("Custom widget")
    }
}
#[test]
fn arbitrary_widget_overflow_is_clipped_and_evaluated_once() {
    let mut c = setup();
    let mut calls = 0;
    let mut output = None;
    c.run(|c| {
        Window::new("Custom").show(c, |ui| {
            output = Some(
                Grid::new("custom")
                    .style(style())
                    .column(Column::fixed("cell", 60.0))
                    .show(ui, |grid| {
                        grid.row(1, |row| row.cell(|ui| ui.add(CountWidget(&mut calls))))
                    }),
            );
        });
    });
    let out = output.unwrap();
    assert_eq!(calls, 1);
    assert_eq!(out.widths, [60.0]);
    assert_eq!(out.measured_widths, [400.0]);
    let hit = c
        .previous_hits
        .iter()
        .find(|hit| hit.id == out.inner.id)
        .unwrap();
    assert_eq!(hit.clip, out.cells[0][0]);
    assert!(c
        .draw_data()
        .commands
        .iter()
        .any(|command| command.clip_rect == out.cells[0][0]));
}

#[test]
fn aligned_text_edit_ime_moves_with_cell_and_nested_scroll() {
    let mut c = setup();
    let mut text = "Editable".to_owned();
    let mut field = None;
    let mut output = None;
    for pass in 0..2 {
        if pass == 1 {
            c.request_focus(field.unwrap());
        }
        c.run(|c| {
            Window::new("Editing").show(c, |ui| {
                ScrollArea::vertical().max_height(160.0).show(ui, |ui| {
                    output = Some(
                        Grid::new("form")
                            .style(style())
                            .columns([
                                Column::fixed("label", 80.0),
                                Column::fixed("value", 150.0).align(Align::Start, Align::End),
                            ])
                            .show(ui, |grid| {
                                grid.row("name", |row| {
                                    row.cell(|ui| {
                                        ui.allocate_space(Vec2::new(80.0, 100.0));
                                    });
                                    row.cell(|ui| {
                                        field = Some(ui.text_edit(&mut text).id);
                                    });
                                })
                            }),
                    );
                });
            });
        });
    }
    let out = output.unwrap();
    let ime = c.ime_area.expect("focused field emits IME geometry");
    assert!(ime.min.y >= out.cells[0][1].min.y + 60.0);
    assert!(ime.max.y <= out.cells[0][1].max.y);
}