hadrone-core 0.1.1

Core layout engine: compaction, collisions, and layout validation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Property-based checks for layout invariants.

use hadrone_core::{
    CollisionStrategy, FreePlacementCompactor, LayoutEngine, LayoutItem, RisingTideCompactor,
    collides, repair_layout, validate_layout,
};
use proptest::prelude::*;

fn layout_item_strategy() -> impl Strategy<Value = LayoutItem> {
    (
        any::<u16>(),
        0i32..8i32,
        0i32..20i32,
        1i32..5i32,
        1i32..6i32,
    )
        .prop_map(|(id, x, y, w, h)| LayoutItem {
            id: format!("i-{id}"),
            x,
            y,
            w,
            h,
            ..Default::default()
        })
}

proptest! {
    #[test]
    fn repair_then_validate(cols in 4i32..16i32, mut items in prop::collection::vec(layout_item_strategy(), 1..12)) {
        repair_layout(&mut items, cols);
        let _ = validate_layout(&items, cols);
    }
}

#[test]
fn pushdown_then_no_overlaps_gravity() {
    let mut layout = vec![
        LayoutItem {
            id: "a".into(),
            x: 0,
            y: 5,
            w: 3,
            h: 2,
            ..Default::default()
        },
        LayoutItem {
            id: "b".into(),
            x: 0,
            y: 0,
            w: 3,
            h: 2,
            ..Default::default()
        },
    ];
    let engine = LayoutEngine::with_default_collision(Box::new(RisingTideCompactor), 12);
    engine.compact(&mut layout);
    for i in 0..layout.len() {
        for j in (i + 1)..layout.len() {
            assert!(!collides(&layout[i], &layout[j]));
        }
    }
}

#[test]
fn noop_collision_freeplacement_compact_clears_overlap() {
    let mut layout = vec![
        LayoutItem {
            id: "a".into(),
            x: 0,
            y: 0,
            w: 4,
            h: 2,
            ..Default::default()
        },
        LayoutItem {
            id: "b".into(),
            x: 1,
            y: 0,
            w: 2,
            h: 2,
            ..Default::default()
        },
    ];
    let engine = LayoutEngine::new(
        Box::new(FreePlacementCompactor),
        CollisionStrategy::None.build(),
        12,
    );
    engine.move_element(&mut layout, "b", 1, 0);
    let engine2 = LayoutEngine::with_default_collision(Box::new(FreePlacementCompactor), 12);
    engine2.compact(&mut layout);
    for i in 0..layout.len() {
        for j in (i + 1)..layout.len() {
            assert!(!collides(&layout[i], &layout[j]));
        }
    }
}