agg-gui 0.2.1

Immediate-mode Rust GUI library with AGG rendering, Y-up layout, widgets, text, SVG, and native/WASM adapters
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Regression: `Stack::layout` must not panic when a child that requests a
//! raise sits at an index beyond the parallel `aligned` vec.
//!
//! `aligned` can be shorter than `children` because callers mutate the tree
//! through `children_mut()` (e.g. the demo pushes a full-canvas overlay
//! directly, bypassing `add()`). The layout read path already tolerates this
//! (`aligned.get(idx).unwrap_or(false)`); the bring-to-front pass used to
//! assume a strict 1:1 length and panicked in `Vec::remove`. Adding a new demo
//! window shifted indices enough to land a raise on the overhang slot and crash
//! the whole app on startup.

use agg_gui::{DrawCtx, Event, EventResult, Rect, Size, Stack, Widget};

/// Minimal widget that asks to be raised exactly once.
struct RaiseOnce {
    bounds: Rect,
    children: Vec<Box<dyn Widget>>,
    pending: bool,
}

impl RaiseOnce {
    fn new() -> Self {
        Self {
            bounds: Rect::default(),
            children: Vec::new(),
            pending: true,
        }
    }
}

impl Widget for RaiseOnce {
    fn type_name(&self) -> &'static str {
        "RaiseOnce"
    }
    fn bounds(&self) -> Rect {
        self.bounds
    }
    fn set_bounds(&mut self, b: Rect) {
        self.bounds = b;
    }
    fn children(&self) -> &[Box<dyn Widget>] {
        &self.children
    }
    fn children_mut(&mut self) -> &mut Vec<Box<dyn Widget>> {
        &mut self.children
    }
    fn layout(&mut self, available: Size) -> Size {
        self.bounds = Rect::new(0.0, 0.0, available.width, available.height);
        available
    }
    fn paint(&mut self, _ctx: &mut dyn DrawCtx) {}
    fn on_event(&mut self, _e: &Event) -> EventResult {
        EventResult::Ignored
    }
    fn take_raise_request(&mut self) -> bool {
        std::mem::replace(&mut self.pending, false)
    }
}

/// Inert filler widget so the stack has stretched children before the overhang.
struct Filler {
    bounds: Rect,
    children: Vec<Box<dyn Widget>>,
}

impl Filler {
    fn new() -> Self {
        Self {
            bounds: Rect::default(),
            children: Vec::new(),
        }
    }
}

impl Widget for Filler {
    fn type_name(&self) -> &'static str {
        "Filler"
    }
    fn bounds(&self) -> Rect {
        self.bounds
    }
    fn set_bounds(&mut self, b: Rect) {
        self.bounds = b;
    }
    fn children(&self) -> &[Box<dyn Widget>] {
        &self.children
    }
    fn children_mut(&mut self) -> &mut Vec<Box<dyn Widget>> {
        &mut self.children
    }
    fn layout(&mut self, available: Size) -> Size {
        self.bounds = Rect::new(0.0, 0.0, available.width, available.height);
        available
    }
    fn paint(&mut self, _ctx: &mut dyn DrawCtx) {}
    fn on_event(&mut self, _e: &Event) -> EventResult {
        EventResult::Ignored
    }
}

#[test]
fn raise_on_overhang_index_does_not_panic() {
    // Two children via add() → aligned.len() == 2.
    let mut stack = Stack::new().add(Box::new(Filler::new())).add(Box::new(Filler::new()));
    // A third child pushed directly bypasses `aligned` → children.len() == 3,
    // aligned.len() == 2. This raise-requesting child sits on the overhang.
    stack.children_mut().push(Box::new(RaiseOnce::new()));

    // Must not panic.
    stack.layout(Size::new(200.0, 100.0));

    // The raised child is moved to the end (front-most) and all three survive.
    assert_eq!(stack.children().len(), 3);
    assert_eq!(stack.children()[2].type_name(), "RaiseOnce");
}