Updated systems to work correctly with multiwidth characters

Author: EmeraldPandaTurtle

Cargo.lock

@@ -14,6 +14,7 @@ doctest = false
 [dependencies]
 compact_str = "0.9.0"
 crossterm = "0.29.0"
+unicode-width = "0.2.1"
 
 [dev-dependencies]
 regex = "1.10.3"

Cargo.toml

@@ -0,0 +1,35 @@
+
+use ascii_forge::prelude::*;
+use std::{io, time::Duration};
+
+fn main() -> io::Result<()> {
+    // Will init the window for you, handling all required procedures.
+    let mut window = Window::init()?;
+
+    // Ask the system to handle panics for us.
+    handle_panics();
+
+    loop {
+        // Ask the window to draw, handle events, and fix sizing issues.
+        // Duration is the time for which to poll events before re-rendering.
+        window.update(Duration::from_millis(200))?;
+
+        // Render elements to the window
+        render!(
+            window,
+            vec2(0, 0) => [ "Normal: Hello World!" ],
+            vec2(0, 1) => [ "Wide: 👩‍👩‍👧‍👦 and 🚀" ],
+            vec2(0, 2) => [ "Mixed: a👩‍👩‍👧‍👦b🚀c" ],
+            vec2(0, 4) => [ "Press `Enter` to exit!".red() ],
+        );
+
+        // Check if the Enter Key was pressed, and exit the app if it was.
+        if event!(window, Event::Key(e) => e.code == KeyCode::Enter) {
+            break;
+        }
+    }
+
+    // Restore the window, enabling the window to function normally again
+    // If nothing will be run after this, once the window is dropped, this will be run implicitly.
+    window.restore()
+}

examples/multiwidth.rs

@@ -1,8 +1,9 @@
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 
-/// A 2d Vector that has no math, is only used as a pretty version of a tuple of u16s
+/// A 2d Vector
 /// Can be made from (u16, u16).
 /// Using a single u16.into() will create a vec2 where both values are the same.
+/// Basic Mathematic Operations are supported
 #[derive(Default, Debug, Eq, PartialEq, PartialOrd, Ord, Copy, Clone)]
 pub struct Vec2 {
     pub x: u16,

src/math.rs

@@ -50,14 +50,22 @@ impl Buffer {
 
     /// Sets a cell at the given location to the given cell
     pub fn set<C: Into<Cell>>(&mut self, loc: impl Into<Vec2>, cell: C) {
+        let loc = loc.into();
         let idx = self.index_of(loc);
 
         // Ignore if cell is out of bounds
         let Some(idx) = idx else {
             return;
         };
 
-        self.cells[idx] = cell.into();
+        let cell = cell.into();
+
+        // Overwrite the next cell if the character is wide
+        if cell.width() > 1 {
+            self.set(loc + vec2(1, 0), Cell::default());
+        }
+
+        self.cells[idx] = cell;
     }
 
     /// Sets all cells at the given location to the given cell
@@ -101,14 +109,23 @@ impl Buffer {
         assert!(self.size == other.size);
 
         let mut res = vec![];
+        let mut skip = 0;
 
         for x in 0..self.size.x {
             for y in 0..self.size.y {
-                if self.get((x, y)) != other.get((x, y)) {
-                    res.push((
-                        vec2(x, y),
-                        other.get((x, y)).expect("Cell should be in bounds"),
-                    ))
+                if skip > 0 {
+                    skip -= 1;
+                    continue;
+                }
+
+                let old = self.get((x, y));
+                let new = other.get((x, y));
+
+                if old != new {
+                    if let Some(new) = new {
+                        skip = new.width().saturating_sub(1) as usize;
+                        res.push((vec2(x, y), new))
+                    }
                 }
             }
         }

src/renderer/buffer.rs

@@ -2,12 +2,14 @@ use std::fmt::Display;
 
 use crate::prelude::*;
 use compact_str::{CompactString, ToCompactString};
+use unicode_width::UnicodeWidthStr;
 
 /// A cell that stores a symbol, and the style that will be applied to it.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Cell {
     text: CompactString,
     style: ContentStyle,
+    width: u16,
 }
 
 impl Default for Cell {
@@ -18,33 +20,45 @@ impl Default for Cell {
 
 impl Cell {
     pub fn new<S: Into<ContentStyle>>(text: impl Into<CompactString>, style: S) -> Self {
+        let text = text.into();
         Self {
-            text: text.into(),
+            width: text.width() as u16,
+            text,
             style: style.into(),
         }
     }
 
     pub fn string(string: impl AsRef<str>) -> Self {
+        let text = CompactString::new(string);
         Self {
-            text: CompactString::new(string),
+            width: text.width() as u16,
+            text,
             style: ContentStyle::default(),
         }
     }
 
     pub fn chr(chr: char) -> Self {
+        let text = chr.to_compact_string();
         Self {
-            text: chr.to_compact_string(),
+            width: text.width() as u16,
+            text,
             style: ContentStyle::default(),
         }
     }
 
     pub fn styled<D: Display>(content: StyledContent<D>) -> Self {
+        let text = CompactString::new(format!("{}", content.content()));
         Self {
-            text: CompactString::new(format!("{}", content.content())),
+            width: text.width() as u16,
+            text,
             style: *content.style(),
         }
     }
 
+    pub fn width(&self) -> u16 {
+        self.width
+    }
+
     pub fn is_empty(&self) -> bool {
         self.text.trim().is_empty()
     }