euv-ui 0.18.7

Reusable UI component library for the euv framework, providing buttons, cards, modals, inputs, and more.
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

use super::*;

/// Inherent implementation of [`Counter`].
impl Counter {
    /// Adds `step` to the value, clamping into `[min, max]`
    /// afterwards. If the counter is already at `max`, the
    /// value is left at `max`.
    pub fn increment(&self) {
        let current: i32 = self.get_value().get();
        let mut next: i32 = current.saturating_add(self.step);
        if let Some(max) = self.max {
            next = next.min(max);
        }
        if let Some(min) = self.min {
            next = next.max(min);
        }
        self.get_value().set(next);
    }

    /// Subtracts `step` from the value, clamping into
    /// `[min, max]` afterwards. If the counter is already
    /// at `min`, the value is left at `min`.
    pub fn decrement(&self) {
        let current: i32 = self.get_value().get();
        let mut next: i32 = current.saturating_sub(self.step);
        if let Some(min) = self.min {
            next = next.max(min);
        }
        if let Some(max) = self.max {
            next = next.min(max);
        }
        self.get_value().set(next);
    }

    /// Replaces the value with `next`, clamping into
    /// `[min, max]` if bounds are set.
    ///
    /// # Arguments
    ///
    /// - `i32` - A 32-bit signed integer (`i32`).
    pub fn set(&self, next: i32) {
        let clamped: i32 = match (self.min, self.max) {
            (Some(min), Some(max)) => next.clamp(min, max),
            (Some(min), None) => next.max(min),
            (None, Some(max)) => next.min(max),
            (None, None) => next,
        };
        self.get_value().set(clamped);
    }

    /// Replaces the value with `next` without clamping.
    /// Bypasses both the `min` and `max` bounds. Use
    /// when you genuinely want to push the counter outside
    /// its configured range (e.g., to "reset to a
    /// deliberately out-of-range sentinel" or to recover
    /// from an invalid configuration).
    ///
    /// # Arguments
    ///
    /// - `i32` - A 32-bit signed integer (`i32`).
    pub fn set_unchecked(&self, next: i32) {
        self.get_value().set(next);
    }

    /// Returns `true` when the value is at the configured
    /// `max` (or always `false` if unbounded above).
    ///
    /// # Returns
    ///
    /// - `bool` - `true` when the value is at the configured maximum.
    pub fn is_at_max(&self) -> bool {
        match self.max {
            Some(max) => self.get_value().get() >= max,
            None => false,
        }
    }

    /// Returns `true` when the value is at the configured
    /// `min` (or always `false` if unbounded below).
    ///
    /// # Returns
    ///
    /// - `bool` - `true` when the value is at the configured minimum.
    pub fn is_at_min(&self) -> bool {
        match self.min {
            Some(min) => self.get_value().get() <= min,
            None => false,
        }
    }

    /// Returns the current value as a snapshot.
    ///
    /// # Returns
    ///
    /// - `i32` - The current value (or a snapshot thereof).
    pub fn get(&self) -> i32 {
        self.get_value().get()
    }
}

/// Formatting / debug-printing for [`Counter`].
impl Display for Counter {
    /// Formats the [`Counter`] via the supplied formatter.
    ///
    /// # Arguments
    ///
    /// - `&mut Formatter<'_>` - The formatter receiving the formatted output.
    ///
    /// # Returns
    ///
    /// - `FmtResult` - Result of the formatting operation.
    fn fmt(&self, formatter: &mut Formatter<'_>) -> FmtResult {
        write!(formatter, "Counter({})", self.get_value().get())
    }
}