term39 0.6.0

A modern, retro-styled terminal multiplexer inspired by Norton Disk Doctor (MS-DOS)
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

use crate::theme::Theme;
use crate::video_buffer::{Cell, VideoBuffer};

#[derive(Debug, Clone, PartialEq)]
pub enum ButtonState {
    Normal,
    Hovered,
    Pressed,
}

#[derive(Debug, Clone)]
pub struct Button {
    pub x: u16,
    pub y: u16,
    pub label: String,
    pub state: ButtonState,
    pub enabled: bool,
}

impl Button {
    /// Create a new button at the specified position with the given label
    pub fn new(x: u16, y: u16, label: String) -> Self {
        Self {
            x,
            y,
            label,
            state: ButtonState::Normal,
            enabled: true,
        }
    }

    /// Get the width of the button (includes brackets and spaces)
    /// Format: "[ Label ]"
    pub fn width(&self) -> u16 {
        (self.label.len() as u16) + 4 // "[ " + label + " ]"
    }

    /// Check if a point (x, y) is inside the button
    pub fn contains(&self, x: u16, y: u16) -> bool {
        if !self.enabled {
            return false;
        }
        x >= self.x && x < self.x + self.width() && y == self.y
    }

    /// Set the button state
    pub fn set_state(&mut self, state: ButtonState) {
        self.state = state;
    }

    /// Render the button to the video buffer
    pub fn render(&self, buffer: &mut VideoBuffer, theme: &Theme) {
        if !self.enabled {
            return;
        }

        let (fg_color, bg_color) = match self.state {
            ButtonState::Normal => (theme.button_normal_fg, theme.button_normal_bg),
            ButtonState::Hovered => (theme.button_hovered_fg, theme.button_hovered_bg),
            ButtonState::Pressed => (theme.button_pressed_fg, theme.button_pressed_bg),
        };

        let mut current_x = self.x;

        // Render "[ "
        buffer.set(current_x, self.y, Cell::new('[', fg_color, bg_color));
        current_x += 1;
        buffer.set(current_x, self.y, Cell::new(' ', fg_color, bg_color));
        current_x += 1;

        // Render label
        for ch in self.label.chars() {
            buffer.set(current_x, self.y, Cell::new(ch, fg_color, bg_color));
            current_x += 1;
        }

        // Render " ]"
        buffer.set(current_x, self.y, Cell::new(' ', fg_color, bg_color));
        current_x += 1;
        buffer.set(current_x, self.y, Cell::new(']', fg_color, bg_color));
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_button_width() {
        let button = Button::new(0, 0, "Test".to_string());
        assert_eq!(button.width(), 8); // "[ Test ]"
    }

    #[test]
    fn test_button_contains() {
        let button = Button::new(5, 10, "Click".to_string());
        // Button renders as "[ Click ]" from x=5 to x=13 (width=9)
        assert!(button.contains(5, 10)); // Left edge '['
        assert!(button.contains(8, 10)); // Middle 'i'
        assert!(button.contains(13, 10)); // Right edge ']'
        assert!(!button.contains(14, 10)); // Past right edge
        assert!(!button.contains(4, 10)); // Before left edge
        assert!(!button.contains(5, 11)); // Wrong row
    }
}