minifb-ui 0.2.1

Light wrapper around minifb to make creation of windows and UI elements simple
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

pub struct ScrollArea {
    pub pos_x: usize,
    pub pos_y: usize,
    pub width: usize,
    pub height: usize,

    pub content_height: usize,
    scroll_offset: f32,
    pub scroll_speed: f32,

    pub scrollbar_width: usize,
    pub scrollbar_color: crate::color::Color,
    pub scrollbar_track_color: crate::color::Color,
    pub scrollbar_radius: usize,

    dragging: bool,
    drag_start_y: f32,
    drag_start_offset: f32,
    lmb_was_down: bool,
}

impl Default for ScrollArea {
    fn default() -> Self {
        Self {
            pos_x: 0,
            pos_y: 0,
            width: 200,
            height: 300,
            content_height: 300,
            scroll_offset: 0.0,
            scroll_speed: 3.0,
            scrollbar_width: 6,
            scrollbar_color: crate::color::Color::rgba(200, 200, 210, 120),
            scrollbar_track_color: crate::color::Color::rgba(60, 60, 80, 40),
            scrollbar_radius: 3,
            dragging: false,
            drag_start_y: 0.0,
            drag_start_offset: 0.0,
            lmb_was_down: false,
        }
    }
}

impl ScrollArea {
    pub fn position(mut self, x: usize, y: usize) -> Self {
        self.pos_x = x;
        self.pos_y = y;
        self
    }

    pub fn size(mut self, width: usize, height: usize) -> Self {
        self.width = width;
        self.height = height;
        self
    }

    pub fn content_height(mut self, h: usize) -> Self {
        self.content_height = h;
        self
    }

    pub fn scroll_speed(mut self, speed: f32) -> Self {
        self.scroll_speed = speed;
        self
    }

    pub fn scrollbar_width(mut self, w: usize) -> Self {
        self.scrollbar_width = w;
        self
    }

    pub fn scrollbar_color(mut self, color: crate::color::Color) -> Self {
        self.scrollbar_color = color;
        self
    }

    pub fn scrollbar_track_color(mut self, color: crate::color::Color) -> Self {
        self.scrollbar_track_color = color;
        self
    }

    pub fn scrollbar_radius(mut self, r: usize) -> Self {
        self.scrollbar_radius = r;
        self
    }

    /// Sets the content height dynamically (call before draw each frame if content changes)
    pub fn set_content_height(&mut self, h: usize) {
        self.content_height = h;
    }

    /// Returns current scroll offset in pixels
    pub fn offset(&self) -> f32 {
        self.scroll_offset
    }

    /// Sets scroll offset directly
    pub fn set_offset(&mut self, offset: f32) {
        self.scroll_offset = offset.max(0.0);
        self.clamp_offset();
    }

    /// Returns true if content overflows the visible area
    pub fn can_scroll(&self) -> bool {
        self.content_height > self.height
    }

    fn max_offset(&self) -> f32 {
        (self.content_height as f32 - self.height as f32).max(0.0)
    }

    fn clamp_offset(&mut self) {
        self.scroll_offset = self.scroll_offset.clamp(0.0, self.max_offset());
    }

    /// Updates scroll state (call once per frame, before drawing content)
    /// Pushes a clip region. Call `end_draw` after drawing content.
    pub fn begin_draw(&mut self, window: &mut crate::window::Window) {
        let mouse = window.get_mouse_state();
        let mx = mouse.pos_x;
        let my = mouse.pos_y;
        let lmb = mouse.lmb_clicked;

        let in_bounds = mx >= self.pos_x as f32
            && mx < (self.pos_x + self.width) as f32
            && my >= self.pos_y as f32
            && my < (self.pos_y + self.height) as f32;

        // Mouse wheel scrolling
        if in_bounds {
            if let Some(scroll) = window.window.get_scroll_wheel() {
                self.scroll_offset += scroll.1 * self.scroll_speed;
                self.clamp_offset();
            }
        }

        // Scrollbar dragging
        if self.can_scroll() {
            let sb_x = self.pos_x + self.width - self.scrollbar_width - 2;
            let thumb_frac = self.height as f32 / self.content_height as f32;
            let thumb_h = (thumb_frac * self.height as f32).max(20.0);
            let track_range = self.height as f32 - thumb_h;
            let thumb_y = self.pos_y as f32 + (self.scroll_offset / self.max_offset()) * track_range;

            let lmb_just = lmb && !self.lmb_was_down;

            if lmb_just {
                let on_thumb = mx >= sb_x as f32
                    && mx < (sb_x + self.scrollbar_width) as f32
                    && my >= thumb_y
                    && my < thumb_y + thumb_h;
                if on_thumb {
                    self.dragging = true;
                    self.drag_start_y = my;
                    self.drag_start_offset = self.scroll_offset;
                }
            }

            if self.dragging {
                if lmb {
                    let delta = my - self.drag_start_y;
                    let ratio = delta / track_range;
                    self.scroll_offset = self.drag_start_offset + ratio * self.max_offset();
                    self.clamp_offset();
                } else {
                    self.dragging = false;
                }
            }
        }

        self.lmb_was_down = lmb;

        // Push clip
        window.push_clip(self.pos_x, self.pos_y, self.width, self.height);
    }

    /// Ends the scroll area draw (pops clip) and draws scrollbar
    pub fn end_draw(&self, window: &mut crate::window::Window) {
        window.pop_clip();

        // Draw scrollbar if content overflows
        if self.can_scroll() {
            let sb_x = self.pos_x + self.width - self.scrollbar_width - 2;
            let thumb_frac = self.height as f32 / self.content_height as f32;
            let thumb_h = (thumb_frac * self.height as f32).max(20.0) as usize;
            let track_range = self.height as f32 - thumb_h as f32;
            let thumb_y = self.pos_y + ((self.scroll_offset / self.max_offset()) * track_range) as usize;

            // Track
            window.draw_rect_f(
                sb_x, self.pos_y, self.scrollbar_width, self.height,
                self.scrollbar_radius, &self.scrollbar_track_color, 0,
            );

            // Thumb
            window.draw_rect_f(
                sb_x, thumb_y, self.scrollbar_width, thumb_h,
                self.scrollbar_radius, &self.scrollbar_color, 0,
            );
        }
    }
}