Improve VT102 compliance

config/src/lib.rs

@@ -1065,6 +1065,24 @@ pub struct Config {
     #[serde(default)]
     pub default_cursor_style: DefaultCursorStyle,
 
+    /// Specifies how often blinking text (normal speed) transitions
+    /// between visible and invisible, expressed in milliseconds.
+    /// Setting this to 0 disables slow text blinking.  Note that this
+    /// value is approximate due to the way that the system event loop
+    /// schedulers manage timers; non-zero values will be at least the
+    /// interval specified with some degree of slop.
+    #[serde(default = "default_text_blink_rate")]
+    pub text_blink_rate: u64,
+
+    /// Specifies how often blinking text (rapid speed) transitions
+    /// between visible and invisible, expressed in milliseconds.
+    /// Setting this to 0 disables rapid text blinking.  Note that this
+    /// value is approximate due to the way that the system event loop
+    /// schedulers manage timers; non-zero values will be at least the
+    /// interval specified with some degree of slop.
+    #[serde(default = "default_text_blink_rate_rapid")]
+    pub text_blink_rate_rapid: u64,
+
     /// If non-zero, specifies the period (in seconds) at which various
     /// statistics are logged.  Note that there is a minimum period of
     /// 10 seconds.
@@ -1121,6 +1139,9 @@ pub struct Config {
     #[serde(default = "default_word_boundary")]
     pub selection_word_boundary: String,
 
+    #[serde(default = "default_enq_answerback")]
+    pub enq_answerback: String,
+
     #[serde(default = "default_true")]
     pub adjust_window_size_when_changing_font_size: bool,
 
@@ -1189,6 +1210,10 @@ fn default_word_boundary() -> String {
     " \t\n{[}]()\"'`".to_string()
 }
 
+fn default_enq_answerback() -> String {
+    "".to_string()
+}
+
 fn default_one_point_oh_f64() -> f64 {
     1.0
 }
@@ -1715,6 +1740,14 @@ fn default_cursor_blink_rate() -> u64 {
     800
 }
 
+fn default_text_blink_rate() -> u64 {
+    500
+}
+
+fn default_text_blink_rate_rapid() -> u64 {
+    250
+}
+
 fn default_swap_backspace_and_delete() -> bool {
     // cfg!(target_os = "macos")
     // See: https://github.com/wez/wezterm/issues/88

config/src/terminal.rs

@@ -34,4 +34,8 @@ impl wezterm_term::TerminalConfiguration for TermConfig {
     fn alternate_buffer_wheel_scroll_speed(&self) -> u8 {
         configuration().alternate_buffer_wheel_scroll_speed
     }
+
+    fn enq_answerback(&self) -> String {
+        configuration().enq_answerback.clone()
+    }
 }

mux/src/renderable.rs

@@ -74,6 +74,7 @@ pub fn terminal_get_lines(
     term: &mut Terminal,
     lines: Range<StableRowIndex>,
 ) -> (StableRowIndex, Vec<Line>) {
+    let reverse = term.get_reverse_video();
     let screen = term.screen_mut();
     let phys_range = screen.stable_range(&lines);
     (
@@ -84,8 +85,9 @@ pub fn terminal_get_lines(
             .skip(phys_range.start)
             .take(phys_range.end - phys_range.start)
             .map(|line| {
-                let cloned = line.clone();
+                let mut cloned = line.clone();
                 line.clear_dirty();
+                cloned.set_reverse(reverse);
                 cloned
             })
             .collect(),

term/src/config.rs

@@ -72,4 +72,8 @@ pub trait TerminalConfiguration: std::fmt::Debug {
     fn alternate_buffer_wheel_scroll_speed(&self) -> u8 {
         3
     }
+
+    fn enq_answerback(&self) -> String {
+        "".to_string()
+    }
 }

term/src/terminalstate.rs

@@ -93,8 +93,10 @@ impl TabStop {
                     *t = false;
                 }
             }
-            TabulationClear::ClearAllCharacterTabStops
-            | TabulationClear::ClearCharacterTabStopsAtActiveLine => {
+            // If we want to exactly match VT100/xterm behavior, then
+            // we cannot honor ClearCharacterTabStopsAtActiveLine.
+            TabulationClear::ClearAllCharacterTabStops => {
+                // | TabulationClear::ClearCharacterTabStopsAtActiveLine
                 for t in &mut self.tabs {
                     *t = false;
                 }
@@ -240,6 +242,9 @@ pub struct TerminalState {
     /// Reverse Wraparound Mode
     reverse_wraparound_mode: bool,
 
+    /// Reverse video mode
+    reverse_video_mode: bool,
+
     /// https://vt100.net/docs/vt510-rm/DECOM.html
     /// When OriginMode is enabled, cursor is constrained to the
     /// scroll region and its position is relative to the scroll
@@ -290,6 +295,7 @@ pub struct TerminalState {
     g0_charset: CharSet,
     g1_charset: CharSet,
     shift_out: bool,
+    newline_mode: bool,
 
     tabs: TabStop,
 
@@ -475,6 +481,7 @@ impl TerminalState {
             // a dec terminal is false, because it is more useful this way.
             dec_auto_wrap: true,
             reverse_wraparound_mode: false,
+            reverse_video_mode: false,
             dec_origin_mode: false,
             insert: false,
             application_cursor_keys: false,
@@ -495,6 +502,7 @@ impl TerminalState {
             g0_charset: CharSet::Ascii,
             g1_charset: CharSet::DecLineDrawing,
             shift_out: false,
+            newline_mode: false,
             current_mouse_button: MouseButton::None,
             tabs: TabStop::new(size.physical_cols, 8),
             title: "wezterm".to_string(),
@@ -1028,6 +1036,9 @@ impl TerminalState {
                         buf.push(0x1b as char);
                     }
                     buf.push(c);
+                    if self.newline_mode && key == Enter {
+                        buf.push(0x0a as char);
+                    }
                 }
                 buf.as_str()
             }
@@ -1795,6 +1806,7 @@ impl TerminalState {
                 self.screen.saved_cursor().take();
 
                 self.reverse_wraparound_mode = false;
+                self.reverse_video_mode = false;
             }
             Device::RequestPrimaryDeviceAttributes => {
                 let mut ident = "\x1b[?65".to_string(); // Vt500
@@ -1819,6 +1831,12 @@ impl TerminalState {
                 self.writer.write(ST.as_bytes()).ok();
                 self.writer.flush().ok();
             }
+            Device::RequestTerminalParameters(a) => {
+                self.writer
+                    .write(format!("\x1b[{};1;1;128;128;1;0x", a + 2).as_bytes())
+                    .ok();
+                self.writer.flush().ok();
+            }
             Device::StatusReport => {
                 self.writer.write(b"\x1b[0n").ok();
                 self.writer.flush().ok();
@@ -1949,10 +1967,16 @@ impl TerminalState {
                 // We always output at our "best" rate
             }
 
-            Mode::SetDecPrivateMode(DecPrivateMode::Code(DecPrivateModeCode::ReverseVideo))
-            | Mode::ResetDecPrivateMode(DecPrivateMode::Code(DecPrivateModeCode::ReverseVideo)) => {
-                // I'm mostly intentionally ignoring this in favor
-                // of respecting the configured colors
+            Mode::SetDecPrivateMode(DecPrivateMode::Code(DecPrivateModeCode::ReverseVideo)) => {
+                // Turn on reverse video for all of the lines on the
+                // display.
+                self.reverse_video_mode = true;
+            }
+
+            Mode::ResetDecPrivateMode(DecPrivateMode::Code(DecPrivateModeCode::ReverseVideo)) => {
+                // Turn off reverse video for all of the lines on the
+                // display.
+                self.reverse_video_mode = false;
             }
 
             Mode::SetDecPrivateMode(DecPrivateMode::Code(DecPrivateModeCode::Select132Columns))
@@ -1977,6 +2001,13 @@ impl TerminalState {
                 self.insert = false;
             }
 
+            Mode::SetMode(TerminalMode::Code(TerminalModeCode::AutomaticNewline)) => {
+                self.newline_mode = true;
+            }
+            Mode::ResetMode(TerminalMode::Code(TerminalModeCode::AutomaticNewline)) => {
+                self.newline_mode = false;
+            }
+
             Mode::SetDecPrivateMode(DecPrivateMode::Code(DecPrivateModeCode::BracketedPaste)) => {
                 self.bracketed_paste = true;
             }
@@ -2824,6 +2855,7 @@ impl TerminalState {
         self.g0_charset = saved.g0_charset;
         self.g1_charset = saved.g1_charset;
         self.shift_out = false;
+        self.newline_mode = false;
     }
 
     fn perform_csi_sgr(&mut self, sgr: Sgr) {
@@ -2941,6 +2973,11 @@ impl TerminalState {
 
         Ok(zones)
     }
+
+    #[inline]
+    pub fn get_reverse_video(&self) -> bool {
+        self.reverse_video_mode
+    }
 }
 
 /// A helper struct for implementing `vtparse::VTActor` while compartmentalizing
@@ -3189,6 +3226,9 @@ impl<'a> Performer<'a> {
                     self.cursor.y = y;
                     self.wrap_next = false;
                 }
+                if self.newline_mode {
+                    self.cursor.x = 0;
+                }
             }
             ControlCode::CarriageReturn => {
                 if self.cursor.x >= self.left_and_right_margins.start {
@@ -3258,6 +3298,15 @@ impl<'a> Performer<'a> {
             ControlCode::ShiftOut => {
                 self.shift_out = true;
             }
+
+            ControlCode::Enquiry => {
+                let response = self.config.enq_answerback();
+                if response.len() > 0 {
+                    write!(self.writer, "{}", response).ok();
+                    self.writer.flush().ok();
+                }
+            }
+
             _ => log::warn!("unhandled ControlCode {:?}", control),
         }
     }
@@ -3318,6 +3367,23 @@ impl<'a> Performer<'a> {
             Esc::Code(EscCode::DecSaveCursorPosition) => self.dec_save_cursor(),
             Esc::Code(EscCode::DecRestoreCursorPosition) => self.dec_restore_cursor(),
 
+            Esc::Code(EscCode::DecDoubleHeightTopHalfLine) => {
+                let idx = self.screen.phys_row(self.cursor.y);
+                self.screen.line_mut(idx).set_double_height_top();
+            }
+            Esc::Code(EscCode::DecDoubleHeightBottomHalfLine) => {
+                let idx = self.screen.phys_row(self.cursor.y);
+                self.screen.line_mut(idx).set_double_height_bottom();
+            }
+            Esc::Code(EscCode::DecDoubleWidthLine) => {
+                let idx = self.screen.phys_row(self.cursor.y);
+                self.screen.line_mut(idx).set_double_width();
+            }
+            Esc::Code(EscCode::DecSingleWidthLine) => {
+                let idx = self.screen.phys_row(self.cursor.y);
+                self.screen.line_mut(idx).set_single_width();
+            }
+
             Esc::Code(EscCode::DecScreenAlignmentDisplay) => {
                 // This one is just to make vttest happy;
                 // its original purpose was for aligning the CRT.
@@ -3351,6 +3417,7 @@ impl<'a> Performer<'a> {
                 self.insert = false;
                 self.dec_auto_wrap = true;
                 self.reverse_wraparound_mode = false;
+                self.reverse_video_mode = false;
                 self.dec_origin_mode = false;
                 self.use_private_color_registers_for_each_graphic = false;
                 self.color_map = default_color_map();
@@ -3369,6 +3436,7 @@ impl<'a> Performer<'a> {
                 self.g0_charset = CharSet::Ascii;
                 self.g1_charset = CharSet::DecLineDrawing;
                 self.shift_out = false;
+                self.newline_mode = false;
                 self.tabs = TabStop::new(self.screen().physical_cols, 8);
                 self.palette.take();
                 self.top_and_bottom_margins = 0..self.screen().physical_rows as VisibleRowIndex;

term/src/test/mod.rs

@@ -703,6 +703,26 @@ fn test_dec_special_graphics() {
     );
 }
 
+/// Test double-width / double-height sequences.
+#[test]
+fn test_dec_double_width() {
+    let mut term = TestTerm::new(4, 50, 0);
+
+    term.print("\u{1b}#3line1\r\nline2\u{1b}#4\r\nli\u{1b}#6ne3\r\n\u{1b}#5line4");
+    assert_visible_contents(
+        &term,
+        file!(),
+        line!(),
+        &["line1", "line2", "line3", "line4"],
+    );
+
+    let lines = term.screen().visible_lines();
+    assert!(lines[0].is_double_height_top());
+    assert!(lines[1].is_double_height_bottom());
+    assert!(lines[2].is_double_width());
+    assert!(lines[3].is_single_width());
+}
+
 /// Test the behavior of wrapped lines when we resize the terminal
 /// wider and then narrower.
 #[test]