term39 1.5.1

A modern, retro-styled terminal multiplexer with a classic MS-DOS aesthetic
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

//! Text mode definitions for DOS-like screen modes
//!
//! This module defines the classic DOS/VGA text modes with their
//! corresponding character cell dimensions.

use std::fmt;

/// Text mode kinds available in the application
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TextModeKind {
    /// 40 columns x 25 rows (16x16 character cells)
    Mode40x25,
    /// 80 columns x 25 rows (8x16 character cells) - Standard DOS mode
    Mode80x25,
    /// 80 columns x 43 rows (8x11 character cells)
    Mode80x43,
    /// 80 columns x 50 rows (8x8 character cells) - High density mode
    Mode80x50,
    /// 160 columns x 50 rows (8x16 character cells) - Double-wide standard
    Mode160x50,
    /// 160 columns x 100 rows (8x16 character cells) - High resolution
    Mode160x100,
    /// 320 columns x 100 rows (8x16 character cells) - Ultra-wide
    Mode320x100,
    /// 320 columns x 200 rows (8x8 character cells) - Maximum resolution
    Mode320x200,
}

impl TextModeKind {
    /// Parse text mode from string (e.g., "80x25", "80x50")
    pub fn from_str(s: &str) -> Option<Self> {
        match s.to_lowercase().as_str() {
            "40x25" => Some(TextModeKind::Mode40x25),
            "80x25" => Some(TextModeKind::Mode80x25),
            "80x43" => Some(TextModeKind::Mode80x43),
            "80x50" => Some(TextModeKind::Mode80x50),
            "160x50" => Some(TextModeKind::Mode160x50),
            "160x100" => Some(TextModeKind::Mode160x100),
            "320x100" => Some(TextModeKind::Mode320x100),
            "320x200" => Some(TextModeKind::Mode320x200),
            _ => None,
        }
    }

    /// Get all available modes
    #[allow(dead_code)]
    pub fn all_modes() -> &'static [TextModeKind] {
        &[
            TextModeKind::Mode40x25,
            TextModeKind::Mode80x25,
            TextModeKind::Mode80x43,
            TextModeKind::Mode80x50,
            TextModeKind::Mode160x50,
            TextModeKind::Mode160x100,
            TextModeKind::Mode320x100,
            TextModeKind::Mode320x200,
        ]
    }
}

impl fmt::Display for TextModeKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TextModeKind::Mode40x25 => write!(f, "40x25"),
            TextModeKind::Mode80x25 => write!(f, "80x25"),
            TextModeKind::Mode80x43 => write!(f, "80x43"),
            TextModeKind::Mode80x50 => write!(f, "80x50"),
            TextModeKind::Mode160x50 => write!(f, "160x50"),
            TextModeKind::Mode160x100 => write!(f, "160x100"),
            TextModeKind::Mode320x100 => write!(f, "320x100"),
            TextModeKind::Mode320x200 => write!(f, "320x200"),
        }
    }
}

/// Text mode configuration
#[derive(Debug, Clone)]
pub struct TextMode {
    /// Mode identifier
    pub kind: TextModeKind,
    /// Number of columns (characters per row)
    pub cols: usize,
    /// Number of rows (character rows)
    pub rows: usize,
    /// Character cell width in pixels
    pub char_width: usize,
    /// Character cell height in pixels
    pub char_height: usize,
}

impl TextMode {
    /// Create a new text mode
    pub fn new(kind: TextModeKind) -> Self {
        let (cols, rows, char_width, char_height) = match kind {
            TextModeKind::Mode40x25 => (40, 25, 16, 16),
            TextModeKind::Mode80x25 => (80, 25, 8, 16),
            TextModeKind::Mode80x43 => (80, 43, 8, 11),
            TextModeKind::Mode80x50 => (80, 50, 8, 8),
            TextModeKind::Mode160x50 => (160, 50, 8, 16),
            TextModeKind::Mode160x100 => (160, 100, 8, 16),
            TextModeKind::Mode320x100 => (320, 100, 8, 16),
            TextModeKind::Mode320x200 => (320, 200, 8, 8),
        };

        TextMode {
            kind,
            cols,
            rows,
            char_width,
            char_height,
        }
    }

    /// Get the total width in pixels
    #[allow(dead_code)]
    pub fn pixel_width(&self) -> usize {
        self.cols * self.char_width
    }

    /// Get the total height in pixels
    #[allow(dead_code)]
    pub fn pixel_height(&self) -> usize {
        self.rows * self.char_height
    }

    /// Check if a screen position is valid
    #[inline(always)]
    pub fn is_valid_position(&self, col: usize, row: usize) -> bool {
        col < self.cols && row < self.rows
    }
}

impl Default for TextMode {
    fn default() -> Self {
        TextMode::new(TextModeKind::Mode80x25)
    }
}

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

    #[test]
    fn test_mode_dimensions() {
        let mode_80x25 = TextMode::new(TextModeKind::Mode80x25);
        assert_eq!(mode_80x25.cols, 80);
        assert_eq!(mode_80x25.rows, 25);
        assert_eq!(mode_80x25.char_width, 8);
        assert_eq!(mode_80x25.char_height, 16);
        assert_eq!(mode_80x25.pixel_width(), 640);
        assert_eq!(mode_80x25.pixel_height(), 400);
    }

    #[test]
    fn test_mode_parsing() {
        assert_eq!(
            TextModeKind::from_str("80x25"),
            Some(TextModeKind::Mode80x25)
        );
        assert_eq!(
            TextModeKind::from_str("80x50"),
            Some(TextModeKind::Mode80x50)
        );
        assert_eq!(TextModeKind::from_str("invalid"), None);
    }

    #[test]
    fn test_mode_display() {
        let mode = TextModeKind::Mode80x25;
        assert_eq!(format!("{}", mode), "80x25");
    }
}