TAB key in TextEdit, fill the space with different sizes

crates/egui/Cargo.toml

@@ -98,3 +98,4 @@ log = { workspace = true, optional = true }
 puffin = { workspace = true, optional = true }
 ron = { version = "0.8", optional = true }
 serde = { version = "1", optional = true, features = ["derive", "rc"] }
+unicode-width = "0.1.11"

crates/egui/src/text_selection/text_cursor_state.rs

@@ -302,18 +302,108 @@ pub fn find_line_start(text: &str, current_index: CCursor) -> CCursor {
     // number of multi byte chars.
     // We need to know the char index to be able to correctly set the cursor
     // later.
-    let chars_count = text.chars().count();
+    let mut char_line_indexes: Vec<usize> = create_char_line_indexes(text);
+    let line_start_index = get_line_start_index(&mut char_line_indexes, current_index.index);
 
-    let position = text
-        .chars()
-        .rev()
-        .skip(chars_count - current_index.index)
-        .position(|x| x == '\n');
+    CCursor::new(line_start_index)
+}
+
+pub fn create_char_line_indexes(text: &str) -> Vec<usize> {
+    let mut line_indexes = vec![0];
+
+    let mut count = 0;
+    for c in text.chars() {
+        count += 1;
+        if c == '\n' {
+            line_indexes.push(count);
+        }
+    }
+    line_indexes.push(count);
+
+    line_indexes
+}
+
+pub fn get_line_start_index(line_indexes: &mut [usize], index: usize) -> usize {
+    let (_current_line, line_start) = get_line_and_start_index(line_indexes, index);
+    line_start
+}
+
+pub fn get_line_and_start_index(line_indexes: &mut [usize], index: usize) -> (usize, usize) {
+    let mut current_line = 1;
+    for (i, line_start) in line_indexes.iter().enumerate() {
+        current_line = i;
+        if *line_start > index {
+            break;
+        }
+    }
+
+    (current_line, line_indexes[current_line - 1])
+}
 
-    match position {
-        Some(pos) => CCursor::new(current_index.index - pos),
-        None => CCursor::new(0),
+pub fn get_current_column(text: &str, line_indexes: &mut [usize], index: usize) -> usize {
+    let (current_column, _total_column) =
+        get_current_column_total_column(text, line_indexes, index);
+    current_column
+}
+
+pub fn get_current_column_total_column(
+    text: &str,
+    line_indexes: &mut [usize],
+    index: usize,
+) -> (usize, usize) {
+    let (current_column, total_column, _total_line) =
+        get_current_column_total_column_line(text, line_indexes, index);
+    (current_column, total_column)
+}
+
+pub fn get_current_column_total_column_line(
+    text: &str,
+    line_indexes: &mut [usize],
+    index: usize,
+) -> (usize, usize, usize) {
+    let (current_column, _current_line, total_columns, total_lines) =
+        get_current_column_line_total_column_line(text, line_indexes, index);
+
+    (current_column, total_columns, total_lines)
+}
+
+pub fn get_current_column_line_total_column_line(
+    text: &str,
+    line_indexes: &mut [usize],
+    index: usize,
+) -> (usize, usize, usize, usize) {
+    let (current_line, line_start_index) = get_line_and_start_index(line_indexes, index);
+
+    let total_lines = line_indexes.len() - 1;
+
+    let mut i: usize = line_start_index;
+    let mut current_column: usize = 1;
+    let mut total_columns: usize = 0;
+    while let Some(c) = text.chars().nth(i) {
+        if c == '\n' {
+            break;
+        } else if c == '\t' {
+            total_columns += text::TAB_SIZE;
+        } else {
+            // The simple( not exact ) width :
+            // let width = match c.len_utf8() > 2 {
+            //     true => 2,
+            //     false => 1,
+            // };
+
+            // The exact width :
+            let width = unicode_width::UnicodeWidthChar::width_cjk(c).unwrap_or(2);
+
+            total_columns += width;
+        }
+
+        if i < index {
+            current_column = total_columns + 1;
+        }
+        i += 1;
     }
+
+    (current_column, current_line, total_columns, total_lines)
 }
 
 pub fn byte_index_from_char_index(s: &str, char_index: usize) -> usize {

crates/egui/src/widgets/text_edit/builder.rs

@@ -862,7 +862,7 @@ fn events(
                     // TODO(emilk): support removing indentation over a selection?
                     text.decrease_indentation(&mut ccursor);
                 } else {
-                    text.insert_text_at(&mut ccursor, "\t", char_limit);
+                    text.insert_tab_to_space(&mut ccursor, "\t", char_limit);
                 }
                 Some(CCursorRange::one(ccursor))
             }

crates/egui/src/widgets/text_edit/text_buffer.rs

@@ -86,6 +86,31 @@ pub trait TextBuffer {
         }
     }
 
+    fn insert_tab_to_space(
+        &mut self,
+        ccursor: &mut CCursor,
+        text_to_insert: &str,
+        char_limit: usize,
+    ) {
+        let tab_size: usize = TAB_SIZE;
+        let mut text_to_insert: String = text_to_insert.to_owned();
+        if text_to_insert == "\t" {
+            let mut line_indexes: Vec<usize> =
+                crate::text_selection::text_cursor_state::create_char_line_indexes(self.as_str());
+            let current_column = crate::text_selection::text_cursor_state::get_current_column(
+                self.as_str(),
+                &mut line_indexes,
+                ccursor.index,
+            );
+            let tab_size_gap = (current_column - 1) % tab_size;
+            let add_space_size = tab_size - tab_size_gap;
+
+            text_to_insert = " ".repeat(add_space_size);
+        }
+
+        self.insert_text_at(ccursor, &text_to_insert, char_limit);
+    }
+
     fn decrease_indentation(&mut self, ccursor: &mut CCursor) {
         let line_start = find_line_start(self.as_str(), *ccursor);