uzor 1.0.7

Core UI engine — geometry, interaction, input state
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

//! Panel input adapter - Contract/Connector for panel event handling

use crate::types::Rect;

/// Input handler adapter for panel events
pub trait PanelInputHandler {
    fn hit_test(&self, rect: Rect, mouse_pos: (f64, f64)) -> bool {
        let (mx, my) = mouse_pos;
        mx >= rect.x
            && mx <= rect.x + rect.width
            && my >= rect.y
            && my <= rect.y + rect.height
    }

    fn hit_test_resize_handle(
        &self,
        handle_rect: Rect,
        mouse_pos: (f64, f64),
    ) -> bool {
        self.hit_test(handle_rect, mouse_pos)
    }

    fn hit_test_chevron(
        &self,
        chevron_rect: Rect,
        mouse_pos: (f64, f64),
    ) -> bool {
        self.hit_test(chevron_rect, mouse_pos)
    }

    fn mouse_to_size(
        &self,
        mouse_pos: f64,
        min_size: f64,
        max_size: f64,
    ) -> f64 {
        mouse_pos.clamp(min_size, max_size)
    }

    fn calculate_resize_handle(
        &self,
        panel_rect: Rect,
        handle_width: f64,
        is_left: bool,
    ) -> Rect {
        if is_left {
            Rect {
                x: panel_rect.x + panel_rect.width - handle_width / 2.0,
                y: panel_rect.y,
                width: handle_width,
                height: panel_rect.height,
            }
        } else {
            Rect {
                x: panel_rect.x - handle_width / 2.0,
                y: panel_rect.y,
                width: handle_width,
                height: panel_rect.height,
            }
        }
    }

    fn is_outside_click(
        &self,
        mouse_pos: (f64, f64),
        modal_rect: Rect,
    ) -> bool {
        !self.hit_test(modal_rect, mouse_pos)
    }

    fn calculate_floating_position(
        &self,
        anchor_rect: Rect,
        offset: (f64, f64),
    ) -> (f64, f64) {
        (anchor_rect.x + offset.0, anchor_rect.y + offset.1)
    }

    fn calculate_chevron_rect(
        &self,
        panel_x: f64,
        panel_y: f64,
        button_height: f64,
        panel_width: f64,
    ) -> Rect {
        Rect {
            x: panel_x,
            y: panel_y,
            width: panel_width,
            height: button_height,
        }
    }
}

/// Default implementation of PanelInputHandler
#[derive(Clone, Copy, Debug, Default)]
pub struct DefaultPanelInputHandler;

impl PanelInputHandler for DefaultPanelInputHandler {}