Feat statemachine (#16)

src/utils/buffer.rs

@@ -79,7 +79,6 @@ pub struct EditBuffer {
     locked_lines: RwLock<HashMap<usize, usize>>,
 }
 
-#[allow(unused)]
 impl EditBuffer {
     pub fn new(buf: Vec<u8>) -> Self {
         let mut lines = buf
@@ -157,6 +156,18 @@ impl EditBuffer {
         line.data.len() as u16
     }
 
+    pub fn get_linesize_abs(&self, line: u16) -> u16 {
+        let buf = self.buf.read().unwrap();
+        let line = buf.get(line as usize);
+        if line.is_none() {
+            return 0;
+        }
+
+        let line = line.unwrap();
+
+        line.data.len() as u16
+    }
+
     /// 外部接口，本结构体内部方法不应该使用，因为涉及offset计算
     pub fn remove_char(&self, x: u16, y: u16) {
         let mut buf = self.buf.write().unwrap();
@@ -379,7 +390,11 @@ impl EditBuffer {
 
     pub fn delete_line(&self, y: usize) {
         let mut buffer = self.buf.write().unwrap();
-        let line = buffer.get(y).unwrap();
+        let line = buffer.get(y);
+        if line.is_none() {
+            return;
+        }
+        let line = line.unwrap();
         if line.data.is_empty() {
             return;
         }
@@ -389,17 +404,20 @@ impl EditBuffer {
         }
     }
 
+    /// 删除 y 行 0..x 的字符
     pub fn delete_until_line_beg(&self, x: usize, y: usize) -> Option<usize> {
         let mut buffer = self.buf.write().unwrap();
         let line = buffer.get_mut(y).unwrap();
 
-        if line.data.len() < 2 {
+        let len = line.data.len();
+        if len < 2 {
             return None;
         }
-        line.data.drain(0..x);
+        line.data.drain(0..x.min(len - 1));
         return Some(x - 1);
     }
 
+    /// 删除 y 行 x..end 的字符
     pub fn delete_until_endl(&self, x: usize, y: usize) -> Option<usize> {
         let mut buffer = self.buf.write().unwrap();
         let line = buffer.get_mut(y).unwrap();
@@ -418,13 +436,17 @@ impl EditBuffer {
         let mut right = left;
         let linesize = self.get_linesize(y) as usize;
         let buf = self.buf.read().unwrap();
-        let line = buf
-            .get(self.offset.load(Ordering::SeqCst) + y as usize)
-            .unwrap();
+        let line = match buf.get(self.offset.load(Ordering::SeqCst) + y as usize) {
+            Some(line) => line,
+            None => return x as usize,
+        };
 
         while left <= right && right < linesize {
             let lchar = line[left] as char;
             let rchar = line[right] as char;
+            if rchar.is_ascii_punctuation() && right != x.into() {
+                break;
+            }
             if !(lchar == ' ' || lchar == '\t') {
                 left += 1;
                 right += 1;
@@ -446,13 +468,17 @@ impl EditBuffer {
         let mut right = left;
         let linesize = self.get_linesize(y) as usize;
         let buf = self.buf.read().unwrap();
-        let line = buf
-            .get(self.offset.load(Ordering::SeqCst) + y as usize)
-            .unwrap();
+        let line = match buf.get(self.offset.load(Ordering::SeqCst) + y as usize) {
+            Some(line) => line,
+            None => return x as usize,
+        };
 
         while left <= right && right < linesize {
             let lchar = line[left] as char;
             let rchar = line[right] as char;
+            if rchar.is_ascii_punctuation() && right != x.into() {
+                break;
+            }
             if lchar == ' ' || lchar == '\t' {
                 left += 1;
                 right += 1;
@@ -477,14 +503,17 @@ impl EditBuffer {
         let mut left = x as i32;
         let mut right = left;
         let buf = self.buf.read().unwrap();
-        let line = buf
-            .get(self.offset.load(Ordering::SeqCst) + y as usize)
-            .unwrap();
-
+        let line = match buf.get(self.offset.load(Ordering::SeqCst) + y as usize) {
+            Some(line) => line,
+            None => return Some(x as usize),
+        };
         while left <= right && left >= 0 {
             let lchar = line[left as usize] as char;
             let rchar = line[right as usize] as char;
 
+            if lchar.is_ascii_punctuation() && left != x.into() {
+                return Some(left as usize);
+            }
             if rchar == ' ' || rchar == '\t' {
                 left -= 1;
                 right -= 1;
@@ -503,6 +532,36 @@ impl EditBuffer {
         }
         return None;
     }
+    pub fn search_prevw_begin_abs(&self, x: u16, abs_y: u16) -> usize {
+        let mut left = x as i32;
+        let mut right = left;
+        let buf = self.buf.read().unwrap();
+        let line = buf.get(abs_y as usize).unwrap();
+        while left <= right && left >= 0 {
+            let lchar = line[left as usize] as char;
+            let rchar = line[right as usize] as char;
+
+            if lchar.is_ascii_punctuation() && left != x.into() {
+                return left as usize;
+            }
+            if rchar == ' ' || rchar == '\t' {
+                left -= 1;
+                right -= 1;
+                continue;
+            }
+
+            if lchar == ' ' || lchar == '\t' {
+                if left + 1 == x.into() {
+                    right = left;
+                    continue;
+                }
+                return left as usize + 1;
+            }
+
+            left -= 1;
+        }
+        return 0;
+    }
 }
 
 bitflags! {

src/utils/ui/mode/common.rs

@@ -0,0 +1,137 @@
+use std::{io, sync::MutexGuard};
+
+use crate::utils::{
+    terminal::TermManager,
+    ui::{
+        event::{KeyEventCallback, WarpUiCallBackType},
+        uicore::{UiCore, CONTENT_WINSIZE},
+    },
+};
+
+pub trait CommonOp: KeyEventCallback {
+    fn remove_line(&self, ui: &mut MutexGuard<UiCore>) -> io::Result<()> {
+        TermManager::clear_current_line()?;
+        TermManager::clear_under_cursor()?;
+        let y = ui.cursor.y() as usize;
+        let old_line_count = ui.buffer.line_count();
+        let old_offset = ui.buffer.offset();
+
+        let count = old_line_count - y as usize;
+        ui.buffer.delete_line(y + ui.buffer.offset() as usize);
+        ui.render_content(y as u16, count.max(1))?;
+
+        if y + old_offset == old_line_count - 1 {
+            self.up(ui)?;
+        }
+
+        if old_line_count == 1 {
+            ui.cursor.move_to_columu(0)?;
+            ui.buffer.insert_char('\n' as u8, 0, 0);
+            ui.render_content(0, 1)?;
+        }
+
+        Ok(())
+    }
+
+    fn remove_n_line(&self, ui: &mut MutexGuard<UiCore>, n: u16) -> io::Result<()> {
+        let linecount = ui.buffer.line_count() as u16;
+        let y = ui.cursor.y();
+
+        // 实际能删除的行数
+        let to_delete = n.min(linecount - y);
+        for _ in 0..to_delete {
+            self.remove_line(ui)?;
+        }
+        Ok(())
+    }
+    fn remove_word(&self, ui: &mut MutexGuard<UiCore>) -> io::Result<()> {
+        let x = ui.cursor.x();
+        let y = ui.cursor.y();
+        let next_word_pos = ui.buffer.search_nextw_begin(x, y);
+        let linesize = ui.buffer.get_linesize(y);
+
+        // 如果下一个单词在当前行，则删除当前单词
+        if next_word_pos < linesize.into() {
+            ui.buffer.remove_str(x, y, next_word_pos - x as usize);
+        } else {
+            // 如果下一个单词在下一行，则删除当前行剩余部分
+            self.left(ui)?;
+            ui.buffer.delete_line(y.into());
+            self.down(ui)?;
+        }
+        ui.render_content(y, 1)?;
+        return Ok(());
+    }
+    fn jump_to_next_word(&self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let x = ui.cursor.x();
+        let y = ui.cursor.y();
+        let pos = ui.buffer.search_nextw_begin(x, y);
+        let linesize = ui.buffer.get_linesize(y);
+        let abs_y = y + ui.buffer.offset() as u16;
+
+        if pos < linesize as usize {
+            // 如果下一个单词在当前行，则移动光标到该单词的起始位置
+            ui.cursor.move_to_columu(pos as u16)?;
+        } else if y as usize + ui.buffer.offset() < ui.buffer.line_count() - 1 {
+            // 如果当前行不是最后一行，则移动到下一行的单词起始位置
+            let next_word_pos = ui.buffer.search_nextw_begin(0, y + 1) as u16;
+            let next_linesize = ui.buffer.get_linesize_abs(abs_y + 1);
+            self.down(ui)?;
+            ui.cursor
+                .move_to_columu(next_word_pos.min(next_linesize - 1))?;
+            ui.cursor.highlight(Some(y))?;
+        } else {
+            // 如果当前行是最后一行，则移动到当前行的末尾
+            ui.cursor.move_to_columu(linesize as u16 - 1)?;
+        }
+        return Ok(WarpUiCallBackType::None);
+    }
+    fn move_to_line(&self, ui: &mut MutexGuard<UiCore>, line: u16) -> io::Result<()> {
+        let x = ui.cursor.x();
+        let y = ui.cursor.y();
+        let new_y = ui.buffer.goto_line(line as usize);
+        let new_x = x.min(ui.buffer.get_linesize(new_y)) as u16;
+        ui.cursor.move_to(new_x, new_y)?;
+        ui.render_content(0, CONTENT_WINSIZE.read().unwrap().rows as usize)?;
+        ui.cursor.highlight(Some(y))?;
+        return Ok(());
+    }
+
+    fn locate_prevw_begin(&self, ui: &mut MutexGuard<UiCore>, x: u16, abs_y: u16) -> (u16, u16) {
+        // 如果光标已在行首，则尝试移动到上一行的单词首字母
+        if x == 0 {
+            if abs_y == 0 {
+                return (0, 0);
+            }
+            let last_y = abs_y - 1;
+            let end_of_prev_line = ui.buffer.get_linesize_abs(last_y) - 1;
+            let prev_word_pos = ui.buffer.search_prevw_begin_abs(end_of_prev_line, last_y);
+            return (prev_word_pos as u16, last_y);
+        }
+
+        let prev_word_pos = ui.buffer.search_prevw_begin_abs(x, abs_y);
+
+        return (prev_word_pos as u16, abs_y);
+    }
+    fn locate_nextw_ending(&self, ui: &mut MutexGuard<UiCore>, x: u16, y: u16) -> (u16, u16) {
+        let linesize = ui.buffer.get_linesize(y) as usize;
+
+        // y的绝对位置
+        let abs_y = ui.buffer.offset() as u16 + y;
+        // 如果光标已经在当前行的末尾或最后一个字符(x + 2)，则尝试移动到下一行的末尾或单词末尾
+        if x as usize + 2 >= linesize {
+            if abs_y < ui.buffer.line_count() as u16 - 1 {
+                let next_end_pos = ui.buffer.search_nextw_end(0, y + 1) as u16;
+                return (next_end_pos, abs_y + 1);
+            } else {
+                // 如果已经是最后一行，则保持光标在当前行的末尾
+                let x = if linesize > 0 { linesize - 1 } else { 0 };
+                return (x as u16, abs_y);
+            }
+        }
+
+        let next_end_pos = ui.buffer.search_nextw_end(x, y) as u16;
+        // 如果下一个单词的末尾在当前行，则移动光标到该单词的末尾
+        return (next_end_pos.min(linesize as u16 - 1), abs_y);
+    }
+}

src/utils/ui/mode/mod.rs

@@ -1 +1,3 @@
+pub mod common;
 pub mod mode;
+pub mod normal;

src/utils/ui/mode/mode.rs

@@ -18,6 +18,8 @@ use crate::utils::ui::{
 
 use crate::utils::ui::event::WarpUiCallBackType;
 
+use super::normal::Normal;
+
 pub trait InputMode: KeyEventCallback + Debug {
     fn mode_type(&self) -> ModeType;
 
@@ -105,6 +107,7 @@ pub enum ModeType {
     Command,
     LastLine,
     Insert,
+    Normal,
 }
 
 impl InputMode for Command {
@@ -122,6 +125,11 @@ impl InputMode for Insert {
         ModeType::Insert
     }
 }
+impl InputMode for Normal {
+    fn mode_type(&self) -> ModeType {
+        ModeType::Normal
+    }
+}
 
 #[derive(Debug)]
 pub struct Command;
@@ -557,6 +565,10 @@ impl KeyEventCallback for Command {
                 return Ok(WarpUiCallBackType::None);
             }
 
+            b"n" => {
+                return Ok(WarpUiCallBackType::ChangMode(ModeType::Normal));
+            }
+
             b"H" => {
                 self.move_to_nlines_of_screen(ui, 0)?;
                 return Ok(WarpUiCallBackType::None);

src/utils/ui/mode/normal.rs

@@ -0,0 +1,651 @@
+// 为了不影响 Command 模式的功能，参考Vim源码单独实现临时的 Normal 模式用于演示
+
+// Normal模式下的状态机
+
+// 在 input_data() 中处理输入的数据，根据输入的数据进行状态转移，
+// 具体而言，根据输入数据及当前状态来更新状态机的参数，如命令字符，重复次数等
+
+// 在 handle() 中处理状态的转移，根据状态的变化执行相应的操作
+// handle() 是真正作用于 ui 和 buffer 的地方，可以在这里调用 buffer 的方法，更新 ui 的显示
+// 因此，NormalState 提供给 handle() 的参数应该具有足够的一般性，以适应不同的需求
+
+// 在 exit() 中处理状态的退出，清空状态
+
+// 由此为 ndw,ndd 等命令的实现提供了多重字符匹配之外的方案：
+// 状态机的下一个状态仅由输入 + 当前状态决定，避免了对输入的全局匹配
+
+// 另：静态 HashMap 比起 match 性能更好是真的吗？后续是否考虑更换为 HashMap？
+// 另：在现有框架下，增加一个新功能，需要在 input_data() 中增加一个分支，handle() 中增加一个分支
+// 是否有更简便的代码结构？
+
+// 参考：https://github.com/neovim/neovim/blob/master/src/nvim/normal.c#L89
+
+use lazy_static::lazy_static;
+
+use crate::utils::ui::event::KeyEventCallback;
+use crate::utils::ui::event::WarpUiCallBackType;
+use crate::utils::ui::uicore::UiCore;
+use crate::utils::ui::uicore::CONTENT_WINSIZE;
+use std::io;
+use std::sync::{Mutex, MutexGuard};
+
+use super::common::CommonOp;
+use super::mode::ModeType;
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub enum BufOpArg {
+    Around,    // 操作引号内乃至引号的内容
+    Inside,    // 操作引号内的内容
+    Line,      // 操作整行
+    Word,      // 操作单词
+    WordEnd,   // 操作单词的末尾
+    WordBegin, // 操作单词的开头
+    Block,     // 操作块
+}
+
+#[derive(Debug)]
+pub struct NormalState {
+    pub cmdchar: Option<char>,
+    pub count: Option<usize>,
+    pub count0: bool,
+    pub start_pos: Option<(u16, u16)>,
+    pub end_pos: Option<(u16, u16)>,
+    pub cmdbuf: Vec<u8>,
+    pub buf_op_arg: Option<BufOpArg>,
+}
+
+impl CommonOp for NormalState {}
+
+lazy_static! {
+    static ref NORMALSTATE: Mutex<NormalState> = Mutex::new(NormalState {
+        cmdchar: None,       // 命令开头的字符，通常决定了一类功能，如dw,dd系列命令
+        count: None,         // 命令的重复次数，如3j,4k
+        count0: false,       // 是否将0作为命令的一部分，在normal模式下，0是一个独立的命令，也可能是一个数字的一部分
+        start_pos: None,     // 作用区域的起始位置
+        end_pos: None,       // 作用区域的结束位置
+        cmdbuf: Vec::new(),  // 用于存储输入的命令，可以与状态的显示通用？
+        buf_op_arg: None // 用于指定操作的区域，如daw,diw
+    });
+}
+
+#[derive(Debug)]
+pub(crate) struct Normal;
+impl Normal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl KeyEventCallback for Normal {
+    fn backspace(&self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::None);
+    }
+    fn esc(&self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::ChangMode(ModeType::Command));
+    }
+
+    fn enter(&self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::None);
+    }
+    fn tab(&self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::None);
+    }
+    fn input_data(
+        &self,
+        ui: &mut MutexGuard<UiCore>,
+        data: &[u8],
+    ) -> io::Result<WarpUiCallBackType> {
+        let mut normal_state = NORMALSTATE.lock().unwrap();
+        normal_state.cmdbuf.extend_from_slice(data);
+        match data {
+            b"h" => {
+                normal_state.on_h_clicked();
+            }
+            b"j" => {
+                normal_state.on_j_clicked();
+            }
+            b"k" => {
+                normal_state.on_k_clicked();
+            }
+            b"l" => {
+                normal_state.on_l_clicked();
+            }
+            b"i" => {
+                normal_state.on_i_clicked();
+            }
+            b"d" => {
+                normal_state.on_d_clicked();
+            }
+            [b'1'..=b'9'] => {
+                normal_state.on_nonzero_clicked(data);
+            }
+            b"0" => {
+                normal_state.on_zero_clicked();
+            }
+            b"w" => {
+                normal_state.on_w_clicked();
+            }
+            b"g" => {
+                normal_state.on_g_clicked(ui);
+            }
+            b"G" => {
+                normal_state.on_G_clicked(ui);
+            }
+            b"b" => {
+                normal_state.on_b_clicked(ui);
+            }
+            b":" => {
+                if normal_state.cmdchar.is_none() {
+                    ui.cursor.store_pos();
+                    return Ok(WarpUiCallBackType::ChangMode(ModeType::LastLine));
+                }
+            }
+            b"$" => {
+                normal_state.on_dollar_clicked();
+            }
+            b"e" => {
+                normal_state.on_e_clicked(ui);
+            }
+            b"f" => {
+                normal_state.on_f_clicked();
+            }
+            b"F" => {
+                normal_state.on_F_clicked();
+            }
+            b"x" => {
+                normal_state.on_x_clicked();
+            }
+            _ => {}
+        }
+        return normal_state.handle(ui);
+    }
+}
+
+impl KeyEventCallback for NormalState {
+    fn backspace(&self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        ui.cursor.move_left(1)?;
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn esc(&self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::ChangMode(ModeType::Command));
+    }
+
+    fn enter(&self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn tab(&self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn input_data(
+        &self,
+        _ui: &mut MutexGuard<UiCore>,
+        _data: &[u8],
+    ) -> io::Result<WarpUiCallBackType> {
+        return Ok(WarpUiCallBackType::None);
+    }
+}
+impl NormalState {
+    pub fn reset(&mut self) {
+        self.cmdchar = None;
+        self.count = None;
+        self.count0 = false;
+        self.start_pos = None;
+        self.end_pos = None;
+        self.cmdbuf.clear();
+        self.buf_op_arg = None;
+    }
+
+    pub fn exec_0_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        ui.cursor.move_to_columu(0)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    pub fn on_h_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('h');
+        }
+    }
+    /// 向左移动数列
+    pub fn exec_h_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let old_x = ui.cursor.x();
+        let exec_count = match self.count {
+            Some(count) => count.min(old_x as usize),
+            None => {
+                if old_x == 0 {
+                    0
+                } else {
+                    1
+                }
+            } // 如果在第一列，不再向左移动，防止溢出
+        };
+        let new_x = old_x - exec_count as u16;
+        ui.cursor.move_to_columu(new_x)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    pub fn on_j_clicked(&mut self) {
+        self.cmdchar = Some('j');
+    }
+    /// 向下移动数行
+    pub fn exec_j_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let old_y = ui.cursor.y();
+        let old_abs_y = old_y + ui.buffer.offset() as u16;
+        // 限制最大移动行数
+        let exec_count = match self.count {
+            Some(count) => count.min(ui.buffer.line_count() - old_abs_y as usize - 1),
+            None => 1, // goto_line 会自动处理最大值
+        };
+        let old_offset = ui.buffer.offset();
+        let new_y = ui.buffer.goto_line(old_abs_y as usize + exec_count);
+        let new_linesize = ui.buffer.get_linesize(new_y);
+        let new_x = if new_linesize < ui.cursor.x() {
+            // 如果新行的长度小于原来的x坐标，将光标移动到新行的最后一个字符
+            new_linesize - 1
+        } else {
+            ui.cursor.x()
+        };
+        ui.cursor.move_to(new_x, new_y)?;
+        ui.cursor.highlight(Some(old_y))?;
+        // 如果移动后，buffer的offset发生了变化，需要重新渲染
+        if ui.buffer.offset() != old_offset {
+            ui.render_content(0, CONTENT_WINSIZE.read().unwrap().rows as usize)?;
+        }
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+    pub fn on_k_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('k');
+        }
+    }
+
+    /// 向上移动数行
+    pub fn exec_k_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let old_y = ui.cursor.y();
+        let old_abs_y = old_y + ui.buffer.offset() as u16;
+        // 限制最大移动行数
+        let exec_count = match self.count {
+            Some(count) => count.min(old_y as usize + ui.buffer.offset()),
+            None => {
+                if old_abs_y == 0 {
+                    0
+                } else {
+                    1
+                }
+            } // 如果在第一行，不再向上移动，防止溢出
+        };
+        let to_line = old_abs_y as usize - exec_count;
+        let old_offset = ui.buffer.offset();
+        let new_y = ui.buffer.goto_line(to_line);
+        let new_linesize = ui.buffer.get_linesize(new_y);
+        let new_x = if new_linesize < ui.cursor.x() {
+            // 如果新行的长度小于原来的x坐标，将光标移动到新行的最后一个字符
+            new_linesize - 1
+        } else {
+            ui.cursor.x()
+        };
+        ui.cursor.move_to(new_x, new_y)?;
+        ui.cursor.highlight(Some(old_y))?;
+        // 如果移动后，buffer的offset发生了变化，需要重新渲染
+        if old_offset != ui.buffer.offset() {
+            ui.render_content(0, CONTENT_WINSIZE.read().unwrap().rows as usize)?;
+        }
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    pub fn on_l_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('l');
+        }
+    }
+
+    /// 向右移动数列
+    pub fn exec_l_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let old_x = ui.cursor.x();
+        let linesize = ui.buffer.get_linesize(ui.cursor.y()) as usize;
+        let max_count = linesize - old_x as usize - 1;
+        let exec_count = match self.count {
+            Some(count) => count.min(max_count),
+            None => {
+                if old_x == linesize as u16 - 1 {
+                    0
+                } else {
+                    1
+                }
+            }
+        };
+        let new_x = old_x + exec_count as u16;
+        ui.cursor.move_to_columu(new_x)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    pub fn on_i_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('i');
+        }
+    }
+    pub fn exec_i_cmd(&mut self, _ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        self.exit()?;
+        return Ok(WarpUiCallBackType::ChangMode(ModeType::Insert));
+    }
+
+    /// 处理输入的非零数字
+    pub fn on_nonzero_clicked(&mut self, data: &[u8]) {
+        let count = self.count;
+        if count.is_none() {
+            // 如果count为空，将第一个输入的数字作为count
+            let count = data[0] - b'0';
+            self.count = Some(count as usize);
+        } else {
+            // 如果count不为空，将输入的数字添加到count的末尾
+            let mut count = count.unwrap();
+            count = count * 10 + (data[0] - b'0') as usize;
+            self.count = Some(count);
+        }
+        self.count0 = true; // 将后续输入的0作为执行次数的一部分
+    }
+
+    /// 处理输入的0
+    pub fn on_zero_clicked(&mut self) {
+        // 如果0是命令的一部分，不再处理
+        if !self.count0 && self.cmdchar.is_none() {
+            self.cmdchar = Some('0');
+            self.count0 = true;
+        }
+        let count = self.count;
+        // 如果输入的是0，且count不为空，将count扩大10倍
+        if count.is_some() {
+            let mut count = count.unwrap();
+            count = count * 10;
+            self.count = Some(count);
+        }
+    }
+
+    /// 处理输入的d
+    pub fn on_d_clicked(&mut self) {
+        match self.cmdchar {
+            None => {
+                // 处理d
+                self.cmdchar = Some('d');
+            }
+            Some('d') => {
+                // 处理dd
+                self.buf_op_arg = Some(BufOpArg::Line);
+            }
+            _ => {
+                self.reset();
+            }
+        }
+    }
+
+    pub fn exec_d_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let count = match self.count {
+            Some(count) => count as u16,
+            None => 1,
+        };
+        match self.buf_op_arg {
+            Some(BufOpArg::Line) => {
+                // 删除行
+                let result = self
+                    .remove_n_line(ui, count)
+                    .map(|_| WarpUiCallBackType::None);
+                self.reset();
+                return result;
+            }
+            Some(BufOpArg::Word) => {
+                // 删除单词
+                for _ in 0..count {
+                    self.remove_word(ui)?;
+                }
+                self.reset();
+                return Ok(WarpUiCallBackType::None);
+            }
+            _ => {
+                return Ok(WarpUiCallBackType::None);
+            }
+        }
+    }
+
+    pub fn on_w_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            // 按单词移动
+            self.cmdchar = Some('w');
+        } else {
+            // 按单词操作，具体由self.cmdchar决定
+            self.buf_op_arg = Some(BufOpArg::Word);
+        }
+    }
+
+    pub fn exec_w_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let count = match self.count {
+            Some(count) => count,
+            None => 1,
+        };
+        for _ in 0..count {
+            self.jump_to_next_word(ui)?;
+        }
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn on_g_clicked(&mut self, ui: &mut MutexGuard<UiCore>) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('g');
+        } else {
+            let first_line_size = ui.buffer.get_linesize(0);
+            self.end_pos = Some((ui.cursor.x().min(first_line_size - 1), 0));
+        }
+    }
+
+    fn exec_g_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let end_pos = self.end_pos;
+        if end_pos.is_none() {
+            return Ok(WarpUiCallBackType::None);
+        }
+        let old_y = ui.cursor.y();
+        let (x, y) = end_pos.unwrap();
+        let y = ui.buffer.goto_line(y.into());
+        ui.cursor.move_to(x as u16, y as u16)?;
+        ui.render_content(y, CONTENT_WINSIZE.read().unwrap().rows as usize)?;
+        ui.cursor.highlight(Some(old_y))?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    #[allow(non_snake_case)]
+    fn on_G_clicked(&mut self, _ui: &mut MutexGuard<UiCore>) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('G');
+        }
+    }
+
+    #[allow(non_snake_case)]
+    fn exec_G_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let lineidx = match self.count {
+            Some(count) => count - 1,
+            None => ui.buffer.line_count() - 1,
+        };
+        self.move_to_line(ui, lineidx as u16)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn on_b_clicked(&mut self, ui: &mut MutexGuard<UiCore>) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('b');
+        } else {
+            self.buf_op_arg = Some(BufOpArg::WordBegin);
+        }
+        let count = match self.count {
+            Some(count) => count,
+            None => 1,
+        };
+        let mut pos = (ui.cursor.x(), ui.cursor.y() + ui.buffer.offset() as u16);
+        for _ in 0..count {
+            pos = self.locate_prevw_begin(ui, pos.0, pos.1);
+        }
+        self.end_pos = Some(pos);
+    }
+
+    fn exec_b_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let end_pos = self.end_pos.unwrap();
+        self.move_to_line(ui, end_pos.1)?;
+        ui.cursor.move_to_columu(end_pos.0)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn on_dollar_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('$');
+        }
+    }
+
+    fn exec_dollar_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let line_end = ui.buffer.get_linesize(ui.cursor.y()) as u16 - 1;
+        ui.cursor.move_to_columu(line_end)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn on_e_clicked(&mut self, ui: &mut MutexGuard<UiCore>) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('e');
+        } else {
+            self.buf_op_arg = Some(BufOpArg::WordEnd);
+        }
+        let count = match self.count {
+            Some(count) => count,
+            None => 1,
+        };
+        let mut pos = (ui.cursor.x(), ui.cursor.y());
+        for _ in 0..count {
+            pos = self.locate_nextw_ending(ui, pos.0, pos.1);
+        }
+        self.end_pos = Some(pos);
+    }
+
+    fn exec_e_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let end_pos = self.end_pos;
+        if end_pos.is_none() {
+            return Ok(WarpUiCallBackType::None);
+        }
+        let end_pos = end_pos.unwrap();
+        self.move_to_line(ui, end_pos.1)?;
+        ui.cursor.move_to_columu(end_pos.0)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn on_f_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('f');
+        }
+    }
+
+    fn exec_f_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        if self.cmdbuf.len() < 2 {
+            return Ok(WarpUiCallBackType::None);
+        }
+        let to_find = self.cmdbuf.last().unwrap().clone() as char;
+        let old_x = ui.cursor.x();
+        let old_y = ui.cursor.y();
+        let line =
+            String::from_utf8_lossy(&ui.buffer.get_line(old_y)[old_x as usize..]).to_string();
+        let pos = line.find(to_find);
+        if pos.is_none() {
+            return Ok(WarpUiCallBackType::None);
+        }
+        ui.cursor
+            .move_to_columu((old_x + pos.unwrap() as u16) as u16)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    #[allow(non_snake_case)]
+    fn on_F_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('F');
+        }
+    }
+
+    #[allow(non_snake_case)]
+    fn exec_F_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        if self.cmdbuf.len() < 2 {
+            return Ok(WarpUiCallBackType::None);
+        }
+        let to_find = self.cmdbuf.last().unwrap().clone() as char;
+        let old_x = ui.cursor.x();
+        let old_y = ui.cursor.y();
+        let line =
+            String::from_utf8_lossy(&ui.buffer.get_line(old_y)[..old_x as usize]).to_string();
+        let pos = line.rfind(to_find);
+        if pos.is_none() {
+            return Ok(WarpUiCallBackType::None);
+        }
+        ui.cursor.move_to_columu(pos.unwrap() as u16)?;
+        self.reset();
+        return Ok(WarpUiCallBackType::None);
+    }
+
+    fn on_x_clicked(&mut self) {
+        if self.cmdchar.is_none() {
+            self.cmdchar = Some('x');
+        }
+    }
+
+    fn exec_x_cmd(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        let y = ui.cursor.y();
+        let x = ui.cursor.x();
+        if x < ui.buffer.get_linesize(y) - 1 {
+            ui.buffer.remove_char(x, y);
+            ui.render_content(y, 1)?;
+        }
+        return Ok(WarpUiCallBackType::None);
+    }
+}
+
+pub trait StateMachine {
+    fn handle(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType>;
+    fn exit(&mut self) -> io::Result<()>;
+}
+
+impl StateMachine for NormalState {
+    fn handle(&mut self, ui: &mut MutexGuard<UiCore>) -> io::Result<WarpUiCallBackType> {
+        if self.cmdchar.is_none() {
+            return Ok(WarpUiCallBackType::None);
+        }
+        match self.cmdchar.unwrap() {
+            'h' => self.exec_h_cmd(ui),
+            'j' => self.exec_j_cmd(ui),
+            'k' => self.exec_k_cmd(ui),
+            'l' => self.exec_l_cmd(ui),
+            'i' => self.exec_i_cmd(ui),
+            '0' => self.exec_0_cmd(ui),
+            'd' => self.exec_d_cmd(ui),
+            'w' => self.exec_w_cmd(ui),
+            'g' => self.exec_g_cmd(ui),
+            'G' => self.exec_G_cmd(ui),
+            'b' => self.exec_b_cmd(ui),
+            '$' => self.exec_dollar_cmd(ui),
+            'e' => self.exec_e_cmd(ui),
+            'f' => self.exec_f_cmd(ui),
+            'F' => self.exec_F_cmd(ui),
+            'x' => self.exec_x_cmd(ui),
+            _ => return Ok(WarpUiCallBackType::None),
+        }
+    }
+
+    fn exit(&mut self) -> io::Result<()> {
+        self.reset();
+        Ok(())
+    }
+}

src/utils/ui/uicore.rs

@@ -22,6 +22,7 @@ use crate::utils::input::Input;
 
 use super::{
     mode::mode::{Command, InputMode, Insert, LastLine, ModeType},
+    mode::normal::Normal,
     AppInfo,
 };
 
@@ -29,6 +30,7 @@ lazy_static! {
     static ref COMMAND: Arc<Command> = Arc::new(Command);
     static ref INSERT: Arc<Insert> = Arc::new(Insert);
     static ref LASTLINE: Arc<LastLine> = Arc::new(LastLine::new());
+    static ref NORMAL: Arc<Normal> = Arc::new(Normal::new());
     pub static ref APP_INFO: Mutex<AppInfo> = Mutex::new(AppInfo {
         level: InfoLevel::Info,
         info: String::new()
@@ -378,6 +380,7 @@ impl Ui {
                 ui.cursor.write(':')?;
             }
             ModeType::Insert => *self.mode.write().unwrap() = INSERT.clone(),
+            ModeType::Normal => *self.mode.write().unwrap() = NORMAL.clone(),
         }
 
         Ok(())