jiao 0.2.1

Cross platform 2D rendering engine
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

// Copyright (c) 2022 Xu Shaohua <shaohua@biofan.org>. All rights reserved.
// Use of this source is governed by Apache-2.0 License that can be found
// in the LICENSE file.

use crate::base::{PointF, RectF, SizeF};
use crate::kernel::{PainterTrait, PathTrait};
use crate::platforms::Path;
use crate::shapes::ShapeTrait;
use crate::util::fuzzy_compare;

#[allow(clippy::module_name_repetitions)]
#[derive(Debug)]
pub struct BracketShape {
    size: SizeF,
    handle_base: Option<PointF>,
    handle_width: f64,
    corner_radius: f64,

    path_is_dirty: bool,
    path: Path,
}

impl BracketShape {
    /// Create a new bracket.
    ///
    /// # Panics
    ///
    /// Both `handle_width` and `corner_radius` shall be non-negative.
    #[must_use]
    pub fn new(
        size: SizeF,
        handle_base: Option<PointF>,
        handle_width: f64,
        corner_radius: f64,
    ) -> Self {
        assert!(handle_width >= 0.0);
        assert!(corner_radius >= 0.0);
        let path = Path::new();
        Self {
            size,
            handle_base,
            handle_width,
            corner_radius,
            path_is_dirty: true,
            path,
        }
    }

    /// Create a new square bracket.
    #[must_use]
    pub fn new_square_bracket() -> Self {
        let size = SizeF::from(18.0, 124.0);
        Self::new(size, None, 0.0, 0.0)
    }

    /// Create a new rounded square bracket.
    #[must_use]
    pub fn new_rounded_square_bracket() -> Self {
        let size = SizeF::from(18.0, 124.0);
        Self::new(size, None, 0.0, 17.28)
    }

    /// Create a new indented square bracket.
    #[must_use]
    pub fn new_indented_square_bracket() -> Self {
        let size = SizeF::from(30.0, 124.0);
        let handle_base = PointF::from(-30.0, 124.0 / 2.0);
        Self::new(size, Some(handle_base), 0.0, 0.0)
    }

    /// Create a new straight curly bracket.
    #[must_use]
    pub fn new_straight_curly_bracket() -> Self {
        let size = SizeF::from(30.0, 124.0);
        let handle_base = PointF::from(-30.0, 124.0 / 2.0);
        Self::new(size, Some(handle_base), 16.0, 0.0)
    }

    /// Create a new curly bracket.
    #[must_use]
    pub fn new_curly_bracket() -> Self {
        let size = SizeF::from(30.0, 124.0);
        let handle_base = PointF::from(-30.0, 124.0 / 2.0);
        Self::new(size, Some(handle_base), 16.0, 17.28)
    }

    /// Get bracket size.
    #[must_use]
    pub const fn size(&self) -> SizeF {
        self.size
    }

    /// Update bracket size.
    pub fn set_size(&mut self, size: SizeF) {
        self.size = size;
        self.path_is_dirty = true;
    }

    /// Get bracket handle base point.
    #[must_use]
    pub const fn handle_base(&self) -> Option<PointF> {
        self.handle_base
    }

    /// Update bracket handle base point.
    pub fn set_handle_base(&mut self, point: Option<PointF>) {
        self.handle_base = point;
        self.path_is_dirty = true;
    }

    /// Get handle width.
    #[must_use]
    pub const fn handle_width(&self) -> f64 {
        self.handle_width
    }

    /// Update handle width.
    pub fn set_handle_width(&mut self, width: f64) {
        if !fuzzy_compare(self.handle_width, width) {
            self.handle_width = width;
            self.path_is_dirty = true;
        }
    }

    /// Get corner radius.
    #[must_use]
    pub const fn corner_radius(&self) -> f64 {
        self.corner_radius
    }

    /// Set corner radius.
    pub fn set_corner_radius(&mut self, corner_radius: f64) {
        if !fuzzy_compare(self.corner_radius, corner_radius) {
            self.corner_radius = corner_radius;
            self.path_is_dirty = true;
        }
    }

    fn update_path(&mut self) {
        if !self.path_is_dirty {
            return;
        }
        self.path.clear();
        // TODO(Shaohua): Draw bracket.
        self.path_is_dirty = false;
    }
}

impl ShapeTrait for BracketShape {
    fn bounding_rect(&self) -> RectF {
        todo!()
    }

    fn repaint(&mut self, painter: &mut dyn PainterTrait) {
        self.update_path();
        painter.stroke(&self.path);
    }
}