initial implementation

Author: raphamorim

docs/docs/features/soft-character-protocol.md

@@ -0,0 +1,77 @@
+---
+title: 'VT320 Soft Character (DRCS)'
+language: 'en'
+---
+
+# VT320 Soft Character (DRCS)
+
+Rio implements VT320 terminal's Dynamically Redefinable Character Set (DRCS) functionality, also known as "soft characters". The implementation allows terminals to receive, store, and display custom character glyphs defined by the application.
+
+## Overview
+
+The VT320 terminal supported downloadable character sets that allowed applications to define custom glyphs within the terminal's character grid. This implementation provides:
+
+1. A parser for OSC (Operating System Command) sequences used to define and select soft characters.
+2. A handler trait for terminal implementations to handle soft character operations.
+3. Storage for multiple DRCS character sets
+4. Utility functions for converting between DRCS bitmaps and text representations
+
+## OSC Commands
+
+This implementation supports the following OSC commands:
+
+- **OSC 53** - Define a soft character:
+
+```bash
+OSC 53 ; char_code ; width ; height ; base64_data ST
+```
+  
+- **OSC 54** - Select a DRCS character set:
+
+```bash
+OSC 54 ; set_id ST
+```
+  
+- **OSC 153** - Reset all soft characters:
+
+```bash
+OSC 153 ST
+```
+
+## Usage Example
+
+Here's how to use the DRCS implementation in your terminal:
+
+```rust
+// Define a custom smiley face character as character code 65 ('A') with 8x8 dimensions
+let smiley_data = vec![0x3C, 0x42, 0xA5, 0x81, 0x99, 0xA5, 0x42, 0x3C];
+terminal.define_soft_character(65, 8, 8, smiley_data);
+
+// Select DRCS set 1
+terminal.select_drcs_set(1);
+
+// Display the character
+if terminal.is_drcs_character(65) {
+    // Render the character at the current cursor position
+    terminal.render_drcs_character(65);
+}
+```
+
+## Integration with Terminal Emulator
+
+To integrate this DRCS implementation into your terminal emulator:
+
+1. Import the `drcs` module
+2. Implement the `DrcsHandler` trait for your terminal state
+3. Add handling for OSC 53, OSC 54, and OSC 153 in your OSC dispatch function
+
+## Character Bitmap Format
+
+The DRCS characters are stored as 1-bit-per-pixel bitmaps, packed into bytes. The bitmap data is organized row by row, with each row padded to a byte boundary. The bits are ordered from most significant to least significant within each byte.
+
+For example, an 8x8 character would require 8 bytes of data (one byte per row).
+
+## Resources
+
+- [VT320 Terminal Reference Manual](https://vt100.net/dec/vt320/soft_characters)
+- [DRCS Technical Documentation](https://vt100.net/docs/vt320-uu/chapter4.html#S4.10.5)

rio-backend/src/ansi/drcs.rs

@@ -0,0 +1,173 @@
+/// DRCS (Dynamically Redefinable Character Set) support for VT320 terminal
+/// Implements handling for the soft character set functionality
+/// Based on https://vt100.net/dec/vt320/soft_characters
+
+use rustc_hash::FxHashMap;
+use std::str;
+use base64::engine::general_purpose::STANDARD as Base64;
+use base64::Engine;
+
+#[derive(Debug)]
+pub struct DrcsCharacter {
+    pub data: Vec<u8>,
+    pub width: u8,
+    pub height: u8,
+}
+
+#[derive(Default, Debug)]
+pub struct DrcsSet {
+    characters: FxHashMap<u8, DrcsCharacter>,
+    // Current active DRCS set ID
+    active_set: u8,
+}
+
+impl DrcsSet {
+    pub fn new() -> Self {
+        Self {
+            characters: FxHashMap::default(),
+            active_set: 0,
+        }
+    }
+    pub fn define_character(&mut self, char_code: u8, width: u8, height: u8, data: Vec<u8>) {
+        self.characters.insert(
+            char_code,
+            DrcsCharacter {
+                data,
+                width,
+                height,
+            },
+        );
+    }
+    pub fn set_active_set(&mut self, set_id: u8) {
+        // Set the active DRCS character set
+        self.active_set = set_id;
+    }
+    pub fn get_character(&self, char_code: u8) -> Option<&DrcsCharacter> {
+        self.characters.get(&char_code)
+    }
+    pub fn clear(&mut self) {
+        self.characters.clear();
+    }
+}
+
+/// Parse OSC parameters for DRCS soft character definition
+pub fn parse_drcs(params: &[&[u8]]) -> Option<(u8, u8, u8, Vec<u8>)> {
+    // Format: OSC 53 ; char_code ; width ; height ; base64_data ST
+    if params.len() < 5 {
+        return None;
+    }
+
+    // Parse character code
+    let char_code = str::from_utf8(params[1])
+        .ok()?
+        .parse::<u8>()
+        .ok()?;
+
+    // Parse width and height
+    let width = str::from_utf8(params[2])
+        .ok()?
+        .parse::<u8>()
+        .ok()?;
+    
+    let height = str::from_utf8(params[3])
+        .ok()?
+        .parse::<u8>()
+        .ok()?;
+
+    // Parse base64 data
+    let bitmap_data = Base64.decode(params[4]).ok()?;
+
+    // Verify the bitmap data has the expected size
+    let expected_size = ((width as usize) * (height as usize) + 7) / 8; // ceil(width * height / 8)
+    if bitmap_data.len() != expected_size {
+        return None;
+    }
+
+    Some((char_code, width, height, bitmap_data))
+}
+
+/// Parse OSC parameters for selecting a DRCS set
+pub fn parse_drcs_select(params: &[&[u8]]) -> Option<u8> {
+    // Format: OSC 54 ; set_id ST
+    if params.len() < 2 {
+        return None;
+    }
+
+    // Parse set ID
+    str::from_utf8(params[1])
+        .ok()?
+        .parse::<u8>()
+        .ok()
+}
+
+
+// Convert a DRCS bitmap to a displayable format as string
+// Rio case need to be sugarloaf
+pub fn drcs_to_string(data: &[u8], width: u8, height: u8) -> String {
+    let mut result = String::new();
+
+    for y in 0..height {
+        for x in 0..width {
+            let byte_index = (y as usize * width as usize + x as usize) / 8;
+            let bit_index = 7 - ((y as usize * width as usize + x as usize) % 8);
+
+            if byte_index < data.len() {
+                let pixel = (data[byte_index] >> bit_index) & 1;
+                result.push(if pixel == 1 { '█' } else { ' ' });
+            } else {
+                result.push('?');
+            }
+        }
+        result.push('\n');
+    }
+
+    result
+}
+
+/// Create a DRCS bitmap from a text representation
+pub fn string_to_drcs(text: &str, width: u8, height: u8) -> Vec<u8> {
+    let mut data = vec![0u8; ((width as usize * height as usize) + 7) / 8];
+
+    for (i, c) in text.chars().enumerate() {
+        if i >= width as usize * height as usize {
+            break;
+        }
+
+        let y = i / width as usize;
+        let x = i % width as usize;
+
+        if c != ' ' {
+            let byte_index = (y * width as usize + x) / 8;
+            let bit_index = 7 - ((y * width as usize + x) % 8);
+
+            data[byte_index] |= 1 << bit_index;
+        }
+    }
+
+    data
+}
+
+pub fn test() {
+    // Define a simple character (a smiley face)
+    let _smiley_data = string_to_drcs(
+        "  ####  \
+         #      #\
+         # #  # #\
+         #      #\
+         #  ##  #\
+         # #  # #\
+         #      #\
+         #      #\
+          ####  ",
+        8, 8
+    );
+
+    // Define the smiley face as character code 65 ('A')
+    // terminal.define_soft_character(65, 8, 8, smiley_data);
+
+    // if terminal.is_drcs_character(65) {
+        // if let Some(bitmap) = terminal.render_drcs_character(65) {
+            // let visual = utils::drcs_to_string(&bitmap, 8, 8);
+            // println!("DRCS character 65:\n{}", visual);
+        // }
+}

rio-backend/src/ansi/mod.rs

@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 pub mod charset;
 pub mod control;
 pub mod graphics;
+pub mod drcs;
 pub mod iterm2_image_protocol;
 pub mod mode;
 pub mod sixel;

rio-backend/src/crosswords/mod.rs

@@ -21,6 +21,8 @@ pub mod search;
 pub mod square;
 pub mod vi_mode;
 
+use crate::ansi::drcs::DrcsSet;
+use rustc_hash::FxHashMap;
 use crate::ansi::graphics::GraphicCell;
 use crate::ansi::graphics::Graphics;
 use crate::ansi::graphics::TextureRef;
@@ -456,6 +458,12 @@ where
 
     // Currently inactive keyboard mode stack.
     inactive_keyboard_mode_stack: Vec<KeyboardModes>,
+
+    /// The DRCS character sets
+    drcs_sets: FxHashMap<u8, DrcsSet>,
+
+    /// The currently active DRCS set
+    active_drcs_set: u8,
 }
 
 impl<U: EventListener> Crosswords<U> {
@@ -506,6 +514,8 @@ impl<U: EventListener> Crosswords<U> {
             current_directory: None,
             keyboard_mode_stack: Default::default(),
             inactive_keyboard_mode_stack: Default::default(),
+            drcs_sets: FxHashMap::default(),
+            active_drcs_set: 0,
         }
     }
 
@@ -1350,6 +1360,29 @@ impl<U: EventListener> Crosswords<U> {
 
         point
     }
+
+    fn get_or_create_drcs_set(&mut self, set_id: u8) -> &mut DrcsSet {
+        self.drcs_sets.entry(set_id).or_insert_with(DrcsSet::new)
+    }
+
+    fn active_drcs_set(&mut self) -> &mut DrcsSet {
+        self.get_or_create_drcs_set(self.active_drcs_set)
+    }
+
+    pub fn is_drcs_character(&self, char_code: u8) -> bool {
+        self.drcs_sets
+            .get(&self.active_drcs_set)
+            .and_then(|set| set.get_character(char_code))
+            .is_some()
+    }
+
+    /// Render a DRCS character to a bitmap
+    pub fn render_drcs_character(&self, char_code: u8) -> Option<Vec<u8>> {
+        self.drcs_sets
+            .get(&self.active_drcs_set)
+            .and_then(|set| set.get_character(char_code))
+            .map(|character| character.data.clone())
+    }
 }
 
 impl<U: EventListener> Handler for Crosswords<U> {
@@ -1712,6 +1745,8 @@ impl<U: EventListener> Handler for Crosswords<U> {
             .damage_line(line, self.grid.cursor.pos.col.0, old_col);
     }
 
+
+
     #[inline]
     fn goto_line(&mut self, line: Line) {
         self.goto(line, self.grid.cursor.pos.col)
@@ -2612,6 +2647,19 @@ impl<U: EventListener> Handler for Crosswords<U> {
             .send_event(RioEvent::PtyWrite(text), self.window_id);
     }
 
+    fn define_soft_character(&mut self, char_code: u8, width: u8, height: u8, data: Vec<u8>) {
+        let drcs_set = self.active_drcs_set();
+        drcs_set.define_character(char_code, width, height, data);
+    }
+
+    fn select_drcs_set(&mut self, set_id: u8) {
+        self.active_drcs_set = set_id;
+    }
+
+    fn reset_soft_characters(&mut self) {
+        self.drcs_sets.clear();
+    }
+
     #[inline]
     fn graphics_attribute(&mut self, pi: u16, pa: u16) {
         // From Xterm documentation: