Refactor (#37)

* Patch refactor render/input/plugin (#22)

重新构建整体架构，包括：

渲染模块
输入处理模块
新增插件系统框架

* Feat insert (#23)

* Insert mode

* 完善render_lexme (#24)

* 完善render_lexme换行和\t

* 解决退出时屏幕没有刷新的问题

---------

Co-authored-by: sparkzky <sparkhhhhhhhhh@outlook.com>

* 优化渲染模块，采用局部渲染提高渲染速度 (#26)

* insertMode添加tab处理 (#25)

* 修复buffer在最后个字符cursor右移时崩溃的问题 (#27)

* worksapce模式，支持查看工作区内容，动态打开工作区文件等操作 (#33)

* 将共用结构体移动到held_core中，增加部分插件相关的interface (#34)

- 增加插件系统
- 更改部分项目结构

* normal mode (#28)

* normal mode

* 实现了功能的自定义(除了delete_some)

* 纠正default.yaml: 'G' -> 'shift-G'

* 删除单词，移动到下一单词

* 移动undo, redo等到buffer模块

移动到前一单词，下一单词末尾

* CMD_COUNTER作为Application的成员变量

* Feat search (#32)

* feat search

* 修改default.yaml

* 修改usize溢出bug，修改exec_search前后部分按键不能使用

---------

Co-authored-by: zhuweihao12138 <746026882@qq.com>
Co-authored-by: GnoCiYeH <heyicong@dragonos.org>

* Feat Command (#29)

* Add command mode

* modified to resolve the conflict

* get command mode modified

* worksapce模式，支持查看工作区内容，动态打开工作区文件等操作 (#33)

* 将共用结构体移动到held_core中，增加部分插件相关的interface (#34)

- 增加插件系统
- 更改部分项目结构

---------

Co-authored-by: GnoCiYeH <heyicong@dragonos.org>

* patch the error of command mode (#35)

* feat-replace (#31)

* 增加Replace模式
---------

Co-authored-by: sparkzky <sparkhhhhhhhhh@outlook.com>
Co-authored-by: GnoCiYeH <heyicong@dragonos.org>

* Patch fix (#36)

* patch the error of command mode

* 进一步修复文件移动引起的错误

* 修改import, default.yaml

---------

Co-authored-by: zhou <2628735358@qq.com>

---------

Co-authored-by: Z YS <202330452442@mail.scut.edu.cn>
Co-authored-by: sparkzky <146502758+sparkzky@users.noreply.github.com>
Co-authored-by: sparkzky <sparkhhhhhhhhh@outlook.com>
Co-authored-by: Weihao Zhu <134527871+zhuweihao12138@users.noreply.github.com>
Co-authored-by: zhuweihao12138 <746026882@qq.com>
Co-authored-by: laokengwt <143977175+laokengwt@users.noreply.github.com>
Co-authored-by: 火花 <sparkhhhhhhhhhh@outlook.com>
Co-authored-by: zhou <2628735358@qq.com>

Cargo.toml

@@ -5,6 +5,9 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[workspace]
+members = ["held_core", "test/test_render_plugin"]
+
 [features]
 dragonos = []
 
@@ -26,3 +29,20 @@ serde_yaml = "0.9"
 
 # 定义标志位
 bitflags = "2.4.2"
+
+walkdir = "2.5.0"
+
+held_core = { path = "./held_core" }
+unicode-segmentation = "1.12.0"
+syntect = "5.2.0"
+error-chain = "0.12.4"
+yaml-rust = "0.4.5"
+app_dirs2 = "2.5.5"
+linked-hash-map = "0.5.6"
+strum = { version = "^0.26.3", features = ["std","derive"] }
+smallvec = "1.13.2"
+dlopen2 = "0.7.0"
+
+[build-dependencies]
+regex = "1.10"
+

build.rs

@@ -0,0 +1,73 @@
+use std::{
+    env,
+    fs::{read_dir, read_to_string, File},
+    io::Write,
+    path::PathBuf,
+};
+
+use regex::Regex;
+
+const COMMAND_REGEX: &str = r"pub fn (.*)\(app: &mut Application\) -> Result<\(\)>";
+
+fn main() {
+    generate_handler();
+}
+
+fn generate_handler() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let out_file_pathbuf = PathBuf::new().join(out_dir).join("handle_map");
+
+    let mut out_file = File::create(out_file_pathbuf).unwrap();
+    out_file
+        .write(
+            r"{
+    let mut handles: HashMap<&'static str, fn(&mut Application) -> Result<()>> = HashMap::new();
+"
+            .as_bytes(),
+        )
+        .unwrap();
+
+    let expression = Regex::new(COMMAND_REGEX).expect("Failed to compile command matching regex");
+    let readdir = read_dir("./src/application/handler/").unwrap();
+
+    for entry in readdir {
+        if let Ok(entry) = entry {
+            let path = entry.path();
+            let module_name = entry
+                .file_name()
+                .into_string()
+                .unwrap()
+                .split('.')
+                .next()
+                .unwrap()
+                .to_owned();
+
+            let content = read_to_string(path).unwrap();
+            for captures in expression.captures_iter(&content) {
+                let function_name = captures.get(1).unwrap().as_str();
+                write(&mut out_file, &module_name, function_name);
+            }
+        }
+    }
+
+    out_file
+        .write(
+            r"
+    handles
+}"
+            .as_bytes(),
+        )
+        .unwrap();
+}
+
+fn write(output: &mut File, module_name: &str, function_name: &str) {
+    output
+        .write(
+            format!(
+                "    handles.insert(\"{}::{}\", {}::{});\n",
+                module_name, function_name, module_name, function_name
+            )
+            .as_bytes(),
+        )
+        .unwrap();
+}

held_core/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "held_core"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+crossterm = "0.27"

held_core/src/control.rs

@@ -0,0 +1 @@
+

held_core/src/interface/app.rs

@@ -0,0 +1,21 @@
+use super::{get_application, APPLICATION};
+
+pub trait App {
+    fn exit(&mut self);
+
+    fn to_insert_mode(&mut self);
+
+    fn to_normal_mode(&mut self);
+}
+
+pub fn exit() {
+    get_application().exit();
+}
+
+pub fn to_insert_mode() {
+    get_application().to_insert_mode();
+}
+
+pub fn to_normal_mode() {
+    get_application().to_normal_mode();
+}

held_core/src/interface/buffer.rs

@@ -0,0 +1,7 @@
+pub trait Buffer {
+    fn insert_char(&mut self);
+
+    fn new_line(&mut self);
+
+    fn insert_tab(&mut self);
+}

held_core/src/interface/cursor.rs

@@ -0,0 +1,41 @@
+use crate::utils::position::Position;
+
+use super::get_application;
+
+pub trait Cursor {
+    fn move_left(&mut self);
+
+    fn move_right(&mut self);
+
+    fn move_up(&mut self);
+
+    fn move_down(&mut self);
+
+    fn move_to_start_of_line(&mut self);
+
+    fn screen_cursor_position(&self) -> Position;
+}
+
+pub fn screen_cursor_position() -> Position {
+    get_application().screen_cursor_position()
+}
+
+pub fn move_down() {
+    get_application().move_down()
+}
+
+pub fn move_up() {
+    get_application().move_up()
+}
+
+pub fn move_left() {
+    get_application().move_left()
+}
+
+pub fn move_right() {
+    get_application().move_right()
+}
+
+pub fn move_to_start_of_line() {
+    get_application().move_to_start_of_line()
+}

held_core/src/interface/mod.rs

@@ -0,0 +1,24 @@
+use app::App;
+use buffer::Buffer;
+use cursor::Cursor;
+use monitor::Monitor;
+use workspace::Workspace;
+
+pub mod app;
+pub mod buffer;
+pub mod cursor;
+pub mod monitor;
+pub mod render;
+pub mod terminal;
+pub mod workspace;
+
+pub trait ApplicationInterface: App + Buffer + Cursor + Monitor + Workspace {}
+pub static mut APPLICATION: Option<&'static mut dyn ApplicationInterface> = None;
+
+pub(crate) fn get_application() -> &'static mut &'static mut dyn ApplicationInterface {
+    unsafe {
+        APPLICATION
+            .as_mut()
+            .expect("The application has not been initialized!")
+    }
+}

held_core/src/interface/monitor.rs

@@ -0,0 +1,5 @@
+pub trait Monitor {
+    fn scroll_to_cursor(&mut self);
+
+    fn scroll_to_center(&mut self);
+}

held_core/src/interface/render.rs

@@ -0,0 +1 @@
+

held_core/src/interface/terminal.rs

@@ -0,0 +1,4 @@
+pub trait TerminalInfo {
+    fn width() -> usize;
+    fn height() -> usize;
+}

held_core/src/interface/workspace.rs

@@ -0,0 +1,5 @@
+pub trait Workspace {
+    fn save_file(&mut self);
+
+    fn undo(&mut self);
+}

held_core/src/lib.rs

@@ -0,0 +1,30 @@
+pub mod control;
+pub mod interface;
+pub mod plugin;
+pub mod theme;
+pub mod utils;
+pub mod view;
+
+#[macro_export]
+macro_rules! declare_plugin {
+    ($app:ty, $constructor:path) => {
+        use held_core::interface::ApplicationInterface;
+        use held_core::interface::APPLICATION;
+
+        #[no_mangle]
+        pub unsafe extern "C" fn init_plugin_application(
+            app: &'static mut dyn ApplicationInterface,
+        ) {
+            APPLICATION = Some(app);
+        }
+
+        #[no_mangle]
+        pub extern "C" fn plugin_create() -> *mut dyn $crate::plugin::Plugin {
+            // 确保构造器正确，所以做了这一步骤，来显示声明签名
+            let constructor: fn() -> $app = $constructor;
+            let object = constructor();
+            let boxed: Box<dyn $crate::plugin::Plugin> = Box::new(object);
+            Box::into_raw(boxed)
+        }
+    };
+}

held_core/src/plugin.rs

@@ -0,0 +1,14 @@
+use crate::view::render::ContentRenderBuffer;
+
+pub trait Plugin {
+    fn name(&self) -> &'static str;
+
+    fn init(&self);
+
+    fn deinit(&self);
+
+    // 渲染文本内容部分时会触发该回调，可以返回想要在content中渲染的buffer
+    fn on_render_content(&self) -> Vec<ContentRenderBuffer> {
+        vec![]
+    }
+}

held_core/src/theme.rs

@@ -0,0 +1 @@
+

held_core/src/utils/distance.rs

@@ -0,0 +1,27 @@
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Distance {
+    pub lines: usize,
+    pub offset: usize,
+}
+
+impl Distance {
+    /// 计算字符串覆盖的距离
+    ///
+    /// /// # Examples
+    ///
+    /// ```
+    /// use crate::buffer::distance::Distance;
+    ///
+    /// let data = "data\ndistance";
+    /// assert_eq!(Distance::of_str(data), Distance{
+    ///     lines: 1,
+    ///     offset: 8
+    /// });
+    /// ```
+    pub fn of_str(from: &str) -> Distance {
+        Distance {
+            lines: from.chars().filter(|&c| c == '\n').count(),
+            offset: from.split('\n').last().map(|l| l.len()).unwrap_or(0),
+        }
+    }
+}

held_core/src/utils/mod.rs

@@ -0,0 +1,4 @@
+pub mod distance;
+pub mod position;
+pub mod range;
+pub mod rectangle;

held_core/src/utils/position.rs

@@ -0,0 +1,69 @@
+use std::{
+    cmp::Ordering,
+    ops::{Add, AddAssign},
+};
+
+use super::distance::Distance;
+
+#[derive(Copy, Clone, Debug, Default, PartialEq)]
+pub struct Position {
+    pub line: usize,
+    pub offset: usize,
+}
+
+impl Position {
+    pub fn new(line: usize, offset: usize) -> Position {
+        Position { line, offset }
+    }
+}
+
+impl PartialOrd for Position {
+    fn partial_cmp(&self, other: &Position) -> Option<Ordering> {
+        Some(if self.line < other.line {
+            Ordering::Less
+        } else if self.line > other.line {
+            Ordering::Greater
+        } else if self.offset < other.offset {
+            Ordering::Less
+        } else if self.offset > other.offset {
+            Ordering::Greater
+        } else {
+            Ordering::Equal
+        })
+    }
+}
+
+impl Add<Distance> for Position {
+    type Output = Position;
+
+    fn add(self, distance: Distance) -> Self::Output {
+        let offset = if distance.lines > 0 {
+            distance.offset
+        } else {
+            self.offset + distance.offset
+        };
+
+        Position {
+            line: self.line + distance.lines,
+            offset,
+        }
+    }
+}
+
+impl AddAssign<Distance> for Position {
+    fn add_assign(&mut self, distance: Distance) {
+        self.line += distance.lines;
+        self.offset = if distance.lines > 0 {
+            distance.offset
+        } else {
+            self.offset + distance.offset
+        };
+    }
+}
+
+impl From<(usize, usize)> for Position {
+    fn from(tuple: (usize, usize)) -> Self {
+        let (line, offset) = tuple;
+        Position::new(line, offset)
+    }
+}

held_core/src/utils/range.rs

@@ -0,0 +1,59 @@
+use crate::utils::position::Position;
+
+/// Range: 左开右闭区间
+#[derive(Clone, Debug, PartialEq, Default)]
+pub struct Range {
+    start: Position,
+    end: Position,
+}
+
+impl Range {
+    pub fn new(start: Position, end: Position) -> Range {
+        if start > end {
+            Range {
+                start: end,
+                end: start,
+            }
+        } else {
+            Range { start, end }
+        }
+    }
+
+    pub fn start(&self) -> Position {
+        self.start
+    }
+
+    pub fn end(&self) -> Position {
+        self.end
+    }
+
+    /// Whether or not the range includes the specified position.
+    /// The range is exclusive, such that its ending position is not included.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use scribe::buffer::{Position, Range};
+    ///
+    /// // Builder a range.
+    /// let range = Range::new(
+    ///     Position{ line: 0, offset: 0 },
+    ///     Position{ line: 1, offset: 5 }
+    /// );
+    ///
+    /// assert!(range.includes(
+    ///     &Position{ line: 1, offset: 0 }
+    /// ));
+    ///
+    /// assert!(range.includes(
+    ///     &Position{ line: 1, offset: 4 }
+    /// ));
+    ///
+    /// assert!(!range.includes(
+    ///     &Position{ line: 1, offset: 5 }
+    /// ));
+    /// ```
+    pub fn includes(&self, position: &Position) -> bool {
+        position >= &self.start() && position < &self.end()
+    }
+}

held_core/src/utils/rectangle.rs

@@ -0,0 +1,7 @@
+use super::position::Position;
+
+pub struct Rectangle {
+    pub position: Position,
+    pub width: usize,
+    pub height: usize,
+}

held_core/src/view/colors.rs

@@ -0,0 +1,20 @@
+use crossterm::style::Color;
+
+/// A convenience type used to represent a foreground/background
+/// color combination. Provides generic/convenience variants to
+/// discourage color selection outside of the theme, whenever possible.
+#[derive(Clone, Copy, Debug, PartialEq, Default)]
+pub enum Colors {
+    #[default]
+    Default, // default/background
+    Focused,    // default/alt background
+    Inverted,   // background/default
+    Insert,     // white/green
+    Warning,    // white/yellow
+    PathMode,   // white/pink
+    SearchMode, // white/purple
+    SelectMode, // white/blue
+    CustomForeground(Color),
+    CustomFocusedForeground(Color),
+    Custom(Color, Color),
+}

held_core/src/view/mod.rs

@@ -0,0 +1,3 @@
+pub mod colors;
+pub mod render;
+pub mod style;

held_core/src/view/render/cell.rs

@@ -0,0 +1,18 @@
+use crate::view::{colors::Colors, style::CharStyle};
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct Cell {
+    pub content: char,
+    pub colors: Colors,
+    pub style: CharStyle,
+}
+
+impl Cell {
+    pub fn new(content: char, colors: Colors, style: CharStyle) -> Cell {
+        Cell {
+            content,
+            colors,
+            style,
+        }
+    }
+}

held_core/src/view/render/mod.rs

@@ -0,0 +1,56 @@
+use std::str::Chars;
+
+use cell::Cell;
+
+use crate::utils::{position::Position, rectangle::Rectangle};
+
+use super::{colors::Colors, style::CharStyle};
+
+pub mod cell;
+pub struct ContentRenderBuffer {
+    pub rectangle: Rectangle,
+    pub cells: Vec<Option<Cell>>,
+}
+
+impl ContentRenderBuffer {
+    pub fn new(rectangle: Rectangle) -> ContentRenderBuffer {
+        let cells = vec![None; rectangle.height * rectangle.width];
+        ContentRenderBuffer { rectangle, cells }
+    }
+
+    pub fn set_cell(&mut self, position: Position, cell: Option<Cell>) {
+        let index = position.line * self.rectangle.width + position.offset;
+        if index < self.cells.len() {
+            self.cells[index] = cell;
+        }
+    }
+
+    pub fn put_buffer(
+        &mut self,
+        position: Position,
+        buffer: String,
+        style: CharStyle,
+        colors: Colors,
+    ) {
+        let mut line = position.line;
+        let mut offset = position.offset;
+        for c in buffer.chars() {
+            let index = line * self.rectangle.width + offset;
+            if index < self.cells.len() {
+                let cell = Cell {
+                    content: c,
+                    colors,
+                    style,
+                };
+                self.cells[index] = Some(cell);
+                offset += 1;
+                if offset == self.rectangle.width {
+                    line += 1;
+                    offset = 0;
+                }
+            } else {
+                break;
+            }
+        }
+    }
+}

held_core/src/view/style.rs

@@ -0,0 +1,8 @@
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+pub enum CharStyle {
+    #[default]
+    Default,
+    Bold,
+    Reverse,
+    Italic,
+}

src/app.rs

@@ -1,67 +0,0 @@
-use std::{io, sync::Arc};
-
-use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
-
-use crate::{
-    config::appconfig::AppSetting,
-    utils::{file::FileManager, ui::uicore::Ui},
-};
-
-pub struct Application {
-    file_manager: FileManager,
-    bak: bool,
-    ui: Arc<Ui>,
-}
-
-impl Application {
-    pub fn new(file_path: Option<String>, setting: AppSetting) -> io::Result<Self> {
-        let bak;
-        let mut file = if file_path.is_some() {
-            bak = true;
-            FileManager::new(file_path.unwrap())?
-        } else {
-            bak = false;
-            FileManager::new("held.tmp".to_string())?
-        };
-
-        // 将文件数据读入buf
-        let buf = file.init(bak)?;
-
-        Ok(Self {
-            file_manager: file,
-            bak,
-            ui: Ui::new(Arc::new(buf), setting),
-        })
-    }
-
-    fn init(&mut self) -> io::Result<()> {
-        Ui::init_ui()?;
-
-        if !self.bak {
-            self.ui.start_page_ui()?;
-        }
-
-        Ok(())
-    }
-
-    pub fn run(&mut self) -> io::Result<()> {
-        enable_raw_mode()?;
-        self.init()?;
-        match self.ui.ui_loop() {
-            Ok(store) => {
-                if store {
-                    let buffer = &self.ui.core.lock().unwrap().buffer;
-                    self.file_manager.store(buffer)?
-                } else if self.file_manager.is_first_open() {
-                    self.file_manager.delete_files()?;
-                }
-            }
-            Err(_) => {
-                // 补救措施：恢复备份文件
-                todo!()
-            }
-        }
-        disable_raw_mode()?;
-        Ok(())
-    }
-}

src/application/handler/app.rs

@@ -0,0 +1,59 @@
+use crate::application::mode::command::CommandData;
+use crate::application::mode::{ModeData, ModeKey};
+use crate::application::Application;
+use crate::errors::*;
+
+pub fn exit(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Exit);
+    Ok(())
+}
+
+pub fn exit_with_check(app: &mut Application) -> Result<()> {
+    if let Some(ref buf) = app.workspace.current_buffer {
+        if buf.modified() {
+            // 输出提示(todo)
+            if let ModeData::Command(ref mut command_data) = app.mode {
+                command_data.reset();
+            }
+            app.switch_mode(ModeKey::Normal);
+        } else {
+            app.switch_mode(ModeKey::Exit);
+        }
+    }
+    Ok(())
+}
+
+pub fn to_insert_mode(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Insert);
+    Ok(())
+}
+
+pub fn to_normal_mode(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Normal);
+    Ok(())
+}
+
+pub fn to_workspace_mode(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Workspace);
+    Ok(())
+}
+
+pub fn to_command_mode(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Command);
+    Ok(())
+}
+
+pub fn to_search_mode(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Search);
+    Ok(())
+}
+
+pub fn to_delete_mode(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Delete);
+    Ok(())
+}
+
+pub fn to_replace_mode(app: &mut Application) -> Result<()> {
+    app.switch_mode(ModeKey::Replace);
+    Ok(())
+}

src/application/handler/buffer.rs

@@ -0,0 +1,81 @@
+use crossterm::event::KeyCode;
+use held_core::utils::position::Position;
+
+use crate::application::Application;
+use crate::errors::*;
+
+use super::cursor;
+
+pub fn insert_char(app: &mut Application) -> Result<()> {
+    if let Some(key) = app.monitor.last_key {
+        if let KeyCode::Char(c) = key.code {
+            app.workspace.current_buffer.as_mut().unwrap().insert(c);
+            cursor::move_right(app)?;
+        }
+    }
+    Ok(())
+}
+
+pub fn insert_char_on_replace(app: &mut Application) -> Result<()> {
+    if let Some(key) = app.monitor.last_key {
+        if let KeyCode::Char(c) = key.code {
+            app.workspace
+                .current_buffer
+                .as_mut()
+                .unwrap()
+                .replace_on_cursor(c.to_string());
+            cursor::move_right(app)?;
+        }
+    }
+    Ok(())
+}
+
+pub fn new_line(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.insert('\n');
+    }
+    Ok(())
+}
+
+pub fn insert_tab(app: &mut Application) -> Result<()> {
+    if let Some(buffer) = app.workspace.current_buffer.as_mut() {
+        let tab_len = app.perferences.borrow().tab_width();
+        let width = tab_len - (buffer.cursor.offset) % tab_len;
+        if app.perferences.borrow().soft_tab() {
+            let tab_str = " ".repeat(width);
+            buffer.insert(tab_str);
+            buffer.cursor.move_to(Position {
+                line: buffer.cursor.line,
+                offset: buffer.cursor.offset + width,
+            });
+        } else {
+            buffer.insert("\t");
+            buffer.cursor.move_to(Position {
+                line: buffer.cursor.line,
+                offset: buffer.cursor.offset + width,
+            });
+        }
+    }
+    Ok(())
+}
+
+pub fn redo(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.redo();
+    }
+    Ok(())
+}
+
+pub fn save_file(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.save()?;
+    }
+    Ok(())
+}
+
+pub fn undo(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.undo();
+    }
+    Ok(())
+}

src/application/handler/command.rs

@@ -0,0 +1,106 @@
+use std::collections::HashMap;
+
+use crossterm::event::KeyCode;
+use smallvec::SmallVec;
+
+use crate::application::handler::{app, buffer};
+use crate::application::mode::{ModeData, ModeKey};
+use crate::application::Application;
+use crate::errors::*;
+
+use lazy_static::lazy_static;
+
+lazy_static! {
+    static ref COMMAND: HashMap<String, SmallVec<[fn(&mut Application) -> Result<()>; 4]>> = {
+        let mut cmd_map =
+            HashMap::<String, SmallVec<[fn(&mut Application) -> Result<()>; 4]>>::new();
+
+        cmd_map.insert(
+            "q".to_string(),
+            SmallVec::from_vec(vec![
+                app::exit_with_check as fn(&mut Application) -> Result<()>,
+            ]),
+        );
+        cmd_map.insert(
+            "q!".to_string(),
+            SmallVec::from_vec(vec![app::exit as fn(&mut Application) -> Result<()>]),
+        );
+        cmd_map.insert(
+            "w".to_string(),
+            SmallVec::from_vec(vec![
+                buffer::save_file as fn(&mut Application) -> Result<()>,
+            ]),
+        );
+        cmd_map.insert(
+            "wq".to_string(),
+            SmallVec::from_vec(vec![
+                buffer::save_file as fn(&mut Application) -> Result<()>,
+                app::exit as fn(&mut Application) -> Result<()>,
+            ]),
+        );
+        cmd_map
+    };
+}
+
+pub fn commit_and_execute(app: &mut Application) -> Result<()> {
+    let cmd = match app.mode {
+        ModeData::Command(ref mut command_data) => command_data.input.clone(),
+        _ => String::new(),
+    };
+    // 匹配命令执行
+    match COMMAND.get(&cmd).cloned() {
+        Some(fucs) => {
+            for fuc in fucs {
+                fuc(app)?;
+            }
+            // 执行完函数清空数据
+            if let ModeData::Command(ref mut command_data) = app.mode {
+                command_data.reset();
+            }
+            if app.mode_key != ModeKey::Exit {
+                app::to_normal_mode(app)?;
+            }
+        }
+        None => {
+            if let ModeData::Command(ref mut command_data) = app.mode {
+                command_data.reset();
+            }
+            app::to_normal_mode(app)?;
+        }
+    }
+    // 匹配完reset
+    if let ModeData::Command(ref mut command_data) = app.mode {
+        command_data.reset();
+    }
+    Ok(())
+}
+
+pub fn insert_command(app: &mut Application) -> Result<()> {
+    if let Some(key) = app.monitor.last_key {
+        if let KeyCode::Char(c) = key.code {
+            if let ModeData::Command(ref mut command_data) = app.mode {
+                command_data.input.insert(command_data.input.len(), c);
+            }
+        }
+    }
+    Ok(())
+}
+
+pub fn backspace(app: &mut Application) -> Result<()> {
+    if let ModeData::Command(ref mut command_data) = app.mode {
+        if command_data.input.is_empty() {
+            return app::to_normal_mode(app);
+        } else {
+            command_data.input.remove(command_data.input.len() - 1);
+        }
+    }
+    Ok(())
+}
+
+pub fn to_normal_mode(app: &mut Application) -> Result<()> {
+    if let ModeData::Command(ref mut command_data) = app.mode {
+        command_data.reset();
+    }
+    app.switch_mode(ModeKey::Normal);
+    Ok(())
+}

src/application/handler/cursor.rs

@@ -0,0 +1,48 @@
+use crate::application::Application;
+use crate::errors::*;
+
+pub fn move_left(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.cursor.move_left();
+        app.monitor.scroll_to_cursor(buffer)?;
+    }
+    Ok(())
+}
+
+pub fn move_right(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.cursor.move_right();
+        app.monitor.scroll_to_cursor(buffer)?;
+    }
+    Ok(())
+}
+
+pub fn move_up(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.cursor.move_up();
+        app.monitor.scroll_to_cursor(buffer)?;
+    }
+    Ok(())
+}
+
+pub fn move_down(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.cursor.move_down();
+        app.monitor.scroll_to_cursor(buffer)?;
+    }
+    Ok(())
+}
+
+pub fn move_to_start_of_line(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.cursor.move_to_start_of_line();
+    }
+    Ok(())
+}
+
+pub fn move_to_end_of_line(app: &mut Application) -> Result<()> {
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        buffer.cursor.move_to_end_of_line();
+    }
+    Ok(())
+}

src/application/handler/delete.rs

@@ -0,0 +1,37 @@
+use held_core::utils::position::Position;
+use held_core::utils::range::Range;
+
+use crate::application::mode::motion::locate_next_words_begin;
+use crate::application::Application;
+use crate::errors::*;
+
+use super::normal::{self};
+
+pub fn delete_words(app: &mut Application) -> Result<()> {
+    let count = app.cmd_counter.max(1);
+    let buf = app.workspace.current_buffer.as_mut().unwrap();
+    let current_pos = &buf.cursor.position;
+    let search_range = if let Some(str) = buf.read_rest(&current_pos) {
+        str
+    } else {
+        return Ok(());
+    };
+    let next_words_pos = locate_next_words_begin(count, &search_range, current_pos);
+    let del_range = Range::new(*current_pos, next_words_pos);
+    buf.delete_range(del_range);
+    normal::reset(app)?;
+    Ok(())
+}
+
+pub fn delete_lines(app: &mut Application) -> Result<()> {
+    let count = app.cmd_counter;
+    let buf = app.workspace.current_buffer.as_mut().unwrap();
+    let start_pos = Position::new(buf.cursor.line, 0);
+    let end_pos = Position::new(
+        start_pos.line + count.min(buf.line_count() - start_pos.line).max(1),
+        0,
+    );
+    buf.delete_range(Range::new(start_pos, end_pos));
+    normal::reset(app)?;
+    Ok(())
+}

src/application/handler/insert.rs

@@ -0,0 +1,15 @@
+use held_core::utils::position::Position;
+
+use crate::application::Application;
+use crate::errors::*;
+
+pub fn backspace(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        // 在第一行第一列时不执行删除操作
+        if buffer.cursor.position != Position::new(0, 0) {
+            buffer.cursor.move_left();
+            buffer.delete();
+        }
+    }
+    Ok(())
+}

src/application/handler/mod.rs

@@ -0,0 +1,18 @@
+use std::collections::HashMap;
+
+use super::Application;
+use crate::errors::*;
+mod app;
+mod buffer;
+mod command;
+mod cursor;
+mod delete;
+mod insert;
+mod monitor;
+mod normal;
+mod search;
+mod workspace;
+
+pub fn handle_map() -> HashMap<&'static str, fn(&mut Application) -> Result<()>> {
+    include!(concat!(env!("OUT_DIR"), "/handle_map"))
+}

src/application/handler/monitor.rs

@@ -0,0 +1,32 @@
+use crate::application::Application;
+use crate::errors::*;
+
+pub fn scroll_to_cursor(app: &mut Application) -> Result<()> {
+    if let Some(ref buffer) = app.workspace.current_buffer {
+        app.monitor.scroll_to_cursor(buffer)?;
+    }
+    Ok(())
+}
+
+pub fn scroll_to_center(app: &mut Application) -> Result<()> {
+    if let Some(ref buffer) = app.workspace.current_buffer {
+        app.monitor.scroll_to_center(buffer)?;
+    }
+    Ok(())
+}
+
+pub fn scroll_to_first_line(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.cursor.move_to_first_line();
+        app.monitor.scroll_to_cursor(buffer)?;
+    }
+    Ok(())
+}
+
+pub fn scroll_to_last_line(app: &mut Application) -> Result<()> {
+    if let Some(ref mut buffer) = app.workspace.current_buffer {
+        buffer.cursor.move_to_last_line();
+        app.monitor.scroll_to_cursor(buffer)?;
+    }
+    Ok(())
+}

src/application/handler/normal.rs

@@ -0,0 +1,177 @@
+use crossterm::event::KeyCode;
+use held_core::utils::position::Position;
+use held_core::utils::range::Range;
+use unicode_segmentation::UnicodeSegmentation;
+
+use crate::application::mode::motion;
+use crate::application::Application;
+use crate::errors::*;
+
+pub fn count_cmd(app: &mut Application) -> Result<()> {
+    if let Some(key) = app.monitor.last_key {
+        if let KeyCode::Char(ch) = key.code {
+            if let Some(digit) = ch.to_digit(10) {
+                let count = &mut app.cmd_counter;
+                *count *= 10;
+                *count += digit as usize;
+            }
+        }
+    }
+    Ok(())
+}
+
+// 可以指定执行次数的命令，数字必须先于命令字符；而命令字符可以在配置文件指定
+
+pub fn move_down_n(app: &mut Application) -> Result<()> {
+    let count = app.cmd_counter.max(1);
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        for _ in 0..count.min(buffer.line_count() - buffer.cursor.line) {
+            buffer.cursor.move_down();
+        }
+        app.monitor.scroll_to_cursor(buffer).unwrap();
+        reset(app)?;
+    }
+    Ok(())
+}
+
+pub fn move_up_n(app: &mut Application) -> Result<()> {
+    let count = app.cmd_counter.max(1);
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        for _ in 0..count.min(buffer.cursor.line) {
+            buffer.cursor.move_up();
+        }
+        app.monitor.scroll_to_cursor(buffer).unwrap();
+        reset(app)?;
+    }
+    Ok(())
+}
+
+pub fn move_to_target_line(app: &mut Application) -> Result<()> {
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        let count = app.cmd_counter;
+        if count > 0 {
+            let target_line = count.min(buffer.line_count());
+            let offset = buffer.cursor.offset;
+            if !buffer
+                .cursor
+                .move_to(Position::new(target_line - 1, offset))
+            {
+                let target_offset = buffer
+                    .data()
+                    .lines()
+                    .nth(target_line - 1)
+                    .unwrap()
+                    .graphemes(true)
+                    .count();
+                buffer
+                    .cursor
+                    .move_to(Position::new(target_line - 1, target_offset));
+            }
+        }
+        app.monitor.scroll_to_cursor(buffer).unwrap();
+        reset(app)?;
+    }
+    Ok(())
+}
+
+pub fn move_left_n(app: &mut Application) -> Result<()> {
+    let mut count = app.cmd_counter.max(1);
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        let offset = buffer.cursor.offset;
+        count = count.min(offset);
+        for _ in 0..count {
+            buffer.cursor.move_left();
+        }
+        app.monitor.scroll_to_cursor(buffer)?;
+        reset(app)?;
+    }
+    Ok(())
+}
+
+pub fn move_right_n(app: &mut Application) -> Result<()> {
+    let mut count = app.cmd_counter.max(1);
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        let max_offset = buffer
+            .data()
+            .lines()
+            .nth(buffer.cursor.line)
+            .unwrap()
+            .graphemes(true)
+            .count();
+        let offset = buffer.cursor.offset;
+        count = count.min(max_offset - offset);
+        for _ in 0..count {
+            buffer.cursor.move_right();
+        }
+        app.monitor.scroll_to_cursor(buffer)?;
+        reset(app)?;
+    }
+    Ok(())
+}
+
+pub fn reset(app: &mut Application) -> Result<()> {
+    app.cmd_counter = 0;
+    Ok(())
+}
+
+pub fn move_to_next_words(app: &mut Application) -> Result<()> {
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        let current_pos = buffer.cursor.position;
+        // 从当前位置向后搜索
+        let search_range = if let Some(str) = buffer.read_rest(&current_pos) {
+            str
+        } else {
+            return Ok(());
+        };
+        let count = app.cmd_counter;
+        let next_words_pos =
+            motion::locate_next_words_begin(count.max(1), &search_range, &current_pos);
+        buffer.cursor.move_to(next_words_pos);
+        app.monitor.scroll_to_cursor(buffer)?;
+        reset(app)?;
+    }
+    Ok(())
+}
+
+pub fn move_to_prev_words(app: &mut Application) -> Result<()> {
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        let current_pos = buffer.cursor.position;
+        // + Distance {
+        //     lines: 0,
+        //     offset: 1,
+        // }; // 由于是左闭右开区间，所以需要向后移动一个字符
+        // 从当前位置向前搜索
+        let search_range =
+            if let Some(str) = buffer.read(&Range::new(Position::new(0, 0), current_pos)) {
+                str
+            } else {
+                return Ok(());
+            };
+        let count = app.cmd_counter;
+        let prev_words_pos =
+            motion::locate_previous_words(count.max(1), &search_range, &current_pos);
+        buffer.cursor.move_to(prev_words_pos);
+        app.monitor.scroll_to_cursor(buffer)?;
+        reset(app)?;
+    }
+    Ok(())
+}
+
+pub fn move_to_next_words_end(app: &mut Application) -> Result<()> {
+    if let Some(buffer) = &mut app.workspace.current_buffer {
+        let current_pos = buffer.cursor.position;
+        // 从当前位置向后搜索
+        let search_range = if let Some(str) = buffer.read_rest(&current_pos) {
+            str
+        } else {
+            return Ok(());
+        };
+        let count = app.cmd_counter;
+        let next_words_pos =
+            motion::locate_next_words_end(count.max(1), &search_range, &current_pos);
+        buffer.cursor.move_to(next_words_pos);
+        app.monitor.scroll_to_cursor(buffer)?;
+        reset(app)?;
+    }
+    Ok(())
+}

src/application/handler/search.rs

@@ -0,0 +1,84 @@
+use crate::application::mode::ModeData;
+use crate::application::Application;
+use crate::errors::*;
+use crossterm::event::KeyCode;
+use held_core::utils::{position::Position, range::Range};
+
+pub fn exec_search(app: &mut Application) -> Result<()> {
+    if let ModeData::Search(ref mut search_data) = app.mode {
+        search_data.is_exec_search = true;
+        if let Some(ref mut buffer) = app.workspace.current_buffer {
+            let search_string = search_data.search_string.clone();
+            let search_result = buffer.search(&search_string);
+
+            let fixed_offset = search_string.len();
+            let ranges: Vec<Range> = search_result
+                .into_iter()
+                .map(|pos| {
+                    let end_position = Position {
+                        line: pos.line,
+                        offset: pos.offset + fixed_offset,
+                    };
+                    Range::new(pos, end_position)
+                })
+                .collect();
+
+            search_data.search_result = ranges;
+        }
+    }
+    Ok(())
+}
+
+pub fn input_search_data(app: &mut Application) -> Result<()> {
+    if let Some(key) = app.monitor.last_key {
+        if let KeyCode::Char(c) = key.code {
+            if let ModeData::Search(ref mut search_data) = app.mode {
+                if search_data.is_exec_search == false {
+                    search_data
+                        .search_string
+                        .insert(search_data.search_string.len(), c);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub fn backspace(app: &mut Application) -> Result<()> {
+    if let ModeData::Search(ref mut search_data) = app.mode {
+        if search_data.is_exec_search == false && search_data.search_string.len() > 0 {
+            search_data
+                .search_string
+                .remove(search_data.search_string.len() - 1);
+        }
+    }
+    Ok(())
+}
+
+pub fn last_result(app: &mut Application) -> Result<()> {
+    if let ModeData::Search(ref mut search_data) = app.mode {
+        if search_data.is_exec_search == true && search_data.search_result.len() != 1 {
+            search_data.search_result_index =
+                (search_data.search_result_index + search_data.search_result.len() - 2)
+                    % (search_data.search_result.len() - 1);
+        }
+    }
+    Ok(())
+}
+
+pub fn next_result(app: &mut Application) -> Result<()> {
+    if let ModeData::Search(ref mut search_data) = app.mode {
+        if search_data.is_exec_search == true && search_data.search_result.len() != 1 {
+            search_data.search_result_index =
+                (search_data.search_result_index + 1) % (search_data.search_result.len() - 1);
+        }
+    }
+    Ok(())
+}
+
+pub fn clear(app: &mut Application) -> Result<()> {
+    if let ModeData::Search(ref mut search_data) = app.mode {
+        search_data.clear();
+    }
+    Ok(())
+}

src/application/handler/workspace.rs

@@ -0,0 +1,34 @@
+use crate::application::mode::{ModeData, ModeKey};
+use crate::application::Application;
+use crate::errors::*;
+
+pub fn to_normal_mode(app: &mut Application) -> Result<()> {
+    if let ModeData::Workspace(ref mode) = app.mode {
+        app.workspace.select_buffer(mode.prev_buffer_id);
+    }
+    app.switch_mode(ModeKey::Normal);
+    Ok(())
+}
+
+pub fn move_down(app: &mut Application) -> Result<()> {
+    if let ModeData::Workspace(ref mut mode) = app.mode {
+        mode.move_down();
+    }
+    Ok(())
+}
+
+pub fn move_up(app: &mut Application) -> Result<()> {
+    if let ModeData::Workspace(ref mut mode) = app.mode {
+        mode.move_up();
+    }
+    Ok(())
+}
+
+pub fn enter(app: &mut Application) -> Result<()> {
+    if let ModeData::Workspace(ref mut mode) = app.mode {
+        if mode.open(&mut app.workspace, &mut app.monitor)? {
+            to_normal_mode(app)?;
+        }
+    }
+    Ok(())
+}

src/application/mod.rs

@@ -0,0 +1,217 @@
+use crate::{
+    errors::*,
+    modules::input::{InputLoader, InputMapper},
+    plugin::system::PluginSystem,
+};
+use crossterm::{event::Event, terminal::disable_raw_mode};
+use held_core::plugin::Plugin;
+use mode::{
+    command::CommandData, error::ErrorRenderer, search::SearchData, workspace::WorkspaceModeData,
+    ModeData, ModeKey, ModeRenderer, ModeRouter,
+};
+use smallvec::SmallVec;
+use state::ApplicationStateData;
+
+use std::{cell::RefCell, collections::HashMap, mem, rc::Rc, sync::Arc};
+
+use crate::{
+    config::appconfig::AppSetting,
+    modules::perferences::{Perferences, PerferencesManager},
+    utils::{file::FileManager, ui::uicore::Ui},
+    view::monitor::Monitor,
+    workspace::Workspace,
+};
+
+mod handler;
+pub mod mode;
+pub mod plugin_interafce;
+pub mod state;
+
+pub struct Application {
+    file_manager: FileManager,
+    bak: bool,
+    ui: Arc<Ui>,
+    pub workspace: Workspace,
+    pub monitor: Monitor,
+    pub perferences: Rc<RefCell<dyn Perferences>>,
+    pub mode: ModeData,
+    mode_key: ModeKey,
+    mode_history: HashMap<ModeKey, ModeData>,
+    input_map: HashMap<
+        String,
+        HashMap<
+            String,
+            SmallVec<[fn(&mut crate::Application) -> std::result::Result<(), Error>; 4]>,
+        >,
+    >,
+    plugin_system: Rc<RefCell<PluginSystem>>,
+    pub state_data: ApplicationStateData,
+    pub cmd_counter: usize,
+}
+
+impl Application {
+    pub fn new(file_path: Option<String>, setting: AppSetting, args: &[String]) -> Result<Self> {
+        let bak;
+        let mut file = if file_path.is_some() {
+            bak = true;
+            FileManager::new(file_path.unwrap())?
+        } else {
+            bak = false;
+            FileManager::new("held.tmp".to_string())?
+        };
+
+        // 将文件数据读入buf
+        let buf = file.init(bak)?;
+
+        let perferences = PerferencesManager::load()?;
+
+        let plugin_system = Rc::new(RefCell::new(PluginSystem::init_system(
+            perferences.borrow().plugins_path()?,
+        )));
+
+        let input_map = InputLoader::load(perferences.borrow().input_config_path()?)?;
+        let mut monitor = Monitor::new(perferences.clone(), plugin_system.clone())?;
+        let workspace = Workspace::create_workspace(&mut monitor, perferences.borrow(), args)?;
+        Ok(Self {
+            file_manager: file,
+            bak,
+            ui: Ui::new(Arc::new(buf), setting),
+            workspace,
+            monitor,
+            perferences,
+            mode: ModeData::Normal,
+            mode_key: ModeKey::Normal,
+            mode_history: HashMap::new(),
+            input_map,
+            plugin_system,
+            state_data: ApplicationStateData::default(),
+            cmd_counter: 0,
+        })
+    }
+
+    fn init(&mut self) -> Result<()> {
+        // Ui::init_ui()?;
+        // PluginSystem::init_system();
+        // self.monitor.terminal.clear().unwrap();
+        self.init_modes()?;
+        self.plugin_system.borrow().init();
+        // if !self.bak {
+        //     self.ui.start_page_ui()?;
+        // }
+
+        Ok(())
+    }
+
+    fn init_modes(&mut self) -> Result<()> {
+        self.mode_history.insert(ModeKey::Normal, ModeData::Normal);
+        self.mode_history.insert(ModeKey::Insert, ModeData::Insert);
+        self.mode_history
+            .insert(ModeKey::Command, ModeData::Command(CommandData::new()));
+        self.mode_history
+            .insert(ModeKey::Replace, ModeData::Replace);
+        self.mode_history
+            .insert(ModeKey::Error, ModeData::Error(Error::default()));
+        self.mode_history.insert(ModeKey::Exit, ModeData::Exit);
+        self.mode_history.insert(
+            ModeKey::Workspace,
+            ModeData::Workspace(WorkspaceModeData::new(
+                &mut self.workspace,
+                &mut self.monitor,
+            )?),
+        );
+        self.mode_history.insert(ModeKey::Delete, ModeData::Delete);
+        self.mode_history
+            .insert(ModeKey::Search, ModeData::Search(SearchData::new()));
+        Ok(())
+    }
+
+    pub fn run(&mut self) -> Result<()> {
+        self.init()?;
+
+        loop {
+            self.render()?;
+            self.listen_event()?;
+
+            if let ModeKey::Exit = &self.mode_key {
+                disable_raw_mode()?;
+                return Ok(());
+            }
+        }
+
+        // 主线程
+        match self.ui.ui_loop() {
+            Ok(store) => {
+                if store {
+                    let buffer = &self.ui.core.lock().unwrap().buffer;
+                    self.file_manager.store(buffer)?
+                } else if self.file_manager.is_first_open() {
+                    self.file_manager.delete_files()?;
+                }
+            }
+            Err(_) => {
+                // 补救措施：恢复备份文件
+                todo!()
+            }
+        }
+        disable_raw_mode()?;
+        Ok(())
+    }
+
+    fn listen_event(&mut self) -> Result<()> {
+        let event = self.monitor.listen()?;
+        self.handle_input(event)?;
+        Ok(())
+    }
+
+    fn render(&mut self) -> Result<()> {
+        if let Err(err) = ModeRouter::render(&mut self.workspace, &mut self.monitor, &mut self.mode)
+        {
+            ErrorRenderer::render(
+                &mut self.workspace,
+                &mut self.monitor,
+                &mut ModeData::Error(err),
+            )?;
+        }
+        Ok(())
+    }
+
+    pub fn switch_mode(&mut self, mode_key: ModeKey) {
+        if self.mode_key == mode_key {
+            return;
+        }
+
+        let mut mode = self.mode_history.remove(&mode_key).unwrap();
+
+        mem::swap(&mut self.mode, &mut mode);
+
+        self.mode_history.insert(self.mode_key, mode);
+
+        self.mode_key = mode_key;
+    }
+
+    fn handle_input(&mut self, event: Event) -> Result<()> {
+        let key = InputMapper::event_map_str(event);
+        if key.is_none() {
+            return Ok(());
+        }
+
+        let key = key.unwrap();
+        if let Some(mode_key) = self.mode_key.to_string() {
+            if let Some(mapper) = self.input_map.get(&mode_key) {
+                if let Some(commands) = mapper.get(&key).cloned() {
+                    for command in commands {
+                        command(self)?;
+                    }
+                } else {
+                    if let Some(commands) = mapper.get("_").cloned() {
+                        for command in commands {
+                            command(self)?;
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

src/application/mode/command.rs

@@ -0,0 +1,76 @@
+use std::{collections::HashMap, process::CommandArgs};
+
+use held_core::{
+    utils::position::Position,
+    view::{colors::Colors, style::CharStyle},
+};
+
+use crate::view::status_data::StatusLineData;
+
+use super::{ModeData, ModeRenderer};
+
+const EDITED_NO_STORE: &'static str = "Changes have not been saved";
+const NOT_FOUNT_CMD: &'static str = "Command Not Fount";
+
+pub(super) struct CommandRenderer;
+
+impl ModeRenderer for CommandRenderer {
+    fn render(
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+        mode: &mut super::ModeData,
+    ) -> super::Result<()> {
+        let line = monitor.height()? - 1;
+        let mut presenter = monitor.build_presenter()?;
+
+        if let Some(buffer) = &workspace.current_buffer {
+            let data = buffer.data();
+            presenter.print_buffer(buffer, &data, &workspace.syntax_set, None, None)?;
+
+            let mode_name_data = StatusLineData {
+                content: " COMMAND ".to_string(),
+                color: Colors::Inverted,
+                style: CharStyle::Bold,
+            };
+
+            let cmd_str = if let ModeData::Command(command_data) = mode {
+                command_data.input.clone()
+            } else {
+                String::new()
+            };
+            let command_line_str = ":".to_owned() + &cmd_str;
+            let command_data = StatusLineData {
+                content: command_line_str.clone(),
+                color: Colors::Default,
+                style: CharStyle::Default,
+            };
+
+            presenter.print_status_line(&[mode_name_data, command_data])?;
+
+            let offset = " COMMAND ".len() + command_line_str.len();
+            presenter.set_cursor(Position { line, offset });
+
+            presenter.present()?;
+        } else {
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct CommandData {
+    pub input: String,
+}
+
+impl CommandData {
+    pub fn new() -> Self {
+        CommandData {
+            input: String::new(),
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.input.clear();
+    }
+}

src/application/mode/delete.rs

@@ -0,0 +1,39 @@
+use held_core::view::{colors::Colors, style::CharStyle};
+
+use super::ModeRenderer;
+use crate::{
+    errors::*,
+    view::status_data::{buffer_status_data, StatusLineData},
+};
+pub(super) struct DeleteRenderer;
+
+impl ModeRenderer for DeleteRenderer {
+    fn render(
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+        _mode: &mut super::ModeData,
+    ) -> Result<()> {
+        let mut presenter = monitor.build_presenter()?;
+
+        if let Some(buffer) = &workspace.current_buffer {
+            warn!("Delete buffer id: {}", buffer.id.unwrap());
+            let data = buffer.data();
+            presenter.print_buffer(buffer, &data, &workspace.syntax_set, None, None)?;
+
+            let mode_name_data = StatusLineData {
+                content: " DELETE ".to_string(),
+                color: Colors::Inverted,
+                style: CharStyle::Bold,
+            };
+            presenter.print_status_line(&[
+                mode_name_data,
+                buffer_status_data(&workspace.current_buffer),
+            ])?;
+
+            presenter.present()?;
+        } else {
+        }
+
+        Ok(())
+    }
+}

src/application/mode/error.rs

@@ -0,0 +1,16 @@
+use super::ModeRenderer;
+use crate::{application::mode::ModeData, errors::*};
+pub struct ErrorRenderer;
+
+impl ModeRenderer for ErrorRenderer {
+    fn render(
+        _workspace: &mut crate::workspace::Workspace,
+        _monitor: &mut crate::view::monitor::Monitor,
+        mode: &mut super::ModeData,
+    ) -> Result<()> {
+        if let ModeData::Error(e) = mode {
+            panic!("{e:?}");
+        }
+        todo!()
+    }
+}

src/application/mode/insert.rs

@@ -0,0 +1,37 @@
+use held_core::view::{colors::Colors, style::CharStyle};
+
+use crate::view::status_data::{buffer_status_data, StatusLineData};
+
+use super::ModeRenderer;
+
+pub(super) struct InsertRenderer;
+
+impl ModeRenderer for InsertRenderer {
+    fn render(
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+        _mode: &mut super::ModeData,
+    ) -> super::Result<()> {
+        let mut presenter = monitor.build_presenter()?;
+
+        if let Some(buffer) = &workspace.current_buffer {
+            let data = buffer.data();
+            presenter.print_buffer(buffer, &data, &workspace.syntax_set, None, None)?;
+
+            let mode_name_data = StatusLineData {
+                content: " INSERT ".to_string(),
+                color: Colors::Inverted,
+                style: CharStyle::Bold,
+            };
+            presenter.print_status_line(&[
+                mode_name_data,
+                buffer_status_data(&workspace.current_buffer),
+            ])?;
+
+            presenter.present()?;
+        } else {
+        }
+
+        Ok(())
+    }
+}

src/application/mode/mod.rs

@@ -0,0 +1,170 @@
+use std::collections::HashMap;
+
+use crate::errors::*;
+use crate::{view::monitor::Monitor, workspace::Workspace};
+use command::{CommandData, CommandRenderer};
+use delete::DeleteRenderer;
+use error::ErrorRenderer;
+use error_chain::bail;
+use insert::InsertRenderer;
+use linked_hash_map::LinkedHashMap;
+use normal::NormalRenderer;
+use replace::ReplaceRenderer;
+use search::{SearchData, SearchRenderer};
+use smallvec::SmallVec;
+use strum::EnumIter;
+use workspace::{WorkspaceModeData, WorkspaceRender};
+use yaml_rust::Yaml;
+
+use super::handler::handle_map;
+use super::Application;
+
+pub mod command;
+pub mod delete;
+pub mod error;
+mod insert;
+pub mod motion;
+pub mod normal;
+mod replace;
+pub mod search;
+pub mod workspace;
+
+pub enum ModeData {
+    Normal,
+    Error(Error),
+    Exit,
+    Insert,
+    Command(CommandData),
+    Workspace(WorkspaceModeData),
+    Search(SearchData),
+    Delete,
+    Replace, // Other(OtherData)
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, EnumIter)]
+pub enum ModeKey {
+    Normal,
+    Error,
+    Exit,
+    Insert,
+    Command,
+    Workspace,
+    Search,
+    Delete,
+    Replace,
+}
+
+impl ModeKey {
+    pub fn to_string(&self) -> Option<String> {
+        match self {
+            ModeKey::Normal => Some("normal".into()),
+            ModeKey::Insert => Some("insert".into()),
+            ModeKey::Command => Some("command".into()),
+            ModeKey::Workspace => Some("workspace".into()),
+            ModeKey::Search => Some("search".into()),
+            ModeKey::Delete => Some("delete".into()),
+            ModeKey::Replace => Some("replace".into()),
+            _ => None,
+        }
+    }
+
+    pub fn generate_handle_map(
+        &self,
+        mode_map: &mut HashMap<
+            String,
+            HashMap<String, SmallVec<[fn(&mut Application) -> Result<()>; 4]>>,
+        >,
+        extra: Option<&LinkedHashMap<Yaml, Yaml>>,
+        default: &LinkedHashMap<Yaml, Yaml>,
+    ) -> Result<()> {
+        let handle_map = handle_map();
+        let mut command_map =
+            HashMap::<String, SmallVec<[fn(&mut Application) -> Result<()>; 4]>>::new();
+        if let Some(mode) = self.to_string() {
+            if let Some(yaml) = default.get(&Yaml::String(mode.clone())) {
+                if let Some(keys) = yaml.as_hash() {
+                    self.parse_mode_keybindings(keys, &handle_map, &mut command_map)?;
+                }
+            }
+
+            if let Some(extra) = extra {
+                if let Some(yaml) = extra.get(&Yaml::String(mode.clone())) {
+                    if let Some(keys) = yaml.as_hash() {
+                        self.parse_mode_keybindings(keys, &handle_map, &mut command_map)?;
+                    }
+                }
+            }
+            mode_map.insert(mode, command_map);
+        }
+
+        Ok(())
+    }
+
+    fn parse_mode_keybindings(
+        &self,
+        keybindings: &LinkedHashMap<Yaml, Yaml>,
+        handle_map: &HashMap<&str, fn(&mut Application) -> Result<()>>,
+        result: &mut HashMap<String, SmallVec<[fn(&mut Application) -> Result<()>; 4]>>,
+    ) -> Result<()> {
+        for (key, handle) in keybindings {
+            if let Some(key) = key.as_str() {
+                let mut closures = SmallVec::new();
+
+                match handle {
+                    Yaml::String(command_key) => {
+                        closures.push(
+                            *handle_map
+                                .get(command_key.as_str())
+                                .ok_or_else(|| format!("command \"{command_key:?}\" not found"))?,
+                        );
+                    }
+                    Yaml::Array(commands) => {
+                        for command in commands {
+                            let command_key = command.as_str().ok_or_else(|| {
+                                format!(
+                                    "Keymap command \"{:?}\" couldn't be parsed as a string",
+                                    command
+                                )
+                            })?;
+
+                            closures.push(
+                                *handle_map.get(command_key).ok_or_else(|| {
+                                    format!("command \"{command_key:?}\" not found")
+                                })?,
+                            );
+                        }
+                    }
+                    _ => {
+                        bail!(format!("conmand: \"{handle:?}\" couldn't be parsed"));
+                    }
+                }
+
+                result.insert(key.to_string(), closures);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub trait ModeRenderer {
+    fn render(workspace: &mut Workspace, monitor: &mut Monitor, mode: &mut ModeData) -> Result<()>;
+}
+
+pub struct ModeRouter;
+
+impl ModeRenderer for ModeRouter {
+    fn render(workspace: &mut Workspace, monitor: &mut Monitor, mode: &mut ModeData) -> Result<()> {
+        match mode {
+            ModeData::Normal => NormalRenderer::render(workspace, monitor, mode),
+            ModeData::Error(_) => ErrorRenderer::render(workspace, monitor, mode),
+            ModeData::Insert => InsertRenderer::render(workspace, monitor, mode),
+            ModeData::Command(_) => CommandRenderer::render(workspace, monitor, mode),
+            ModeData::Workspace(_) => WorkspaceRender::render(workspace, monitor, mode),
+            ModeData::Search(_) => SearchRenderer::render(workspace, monitor, mode),
+            ModeData::Replace => ReplaceRenderer::render(workspace, monitor, mode),
+            ModeData::Exit => todo!(),
+            ModeData::Delete => DeleteRenderer::render(workspace, monitor, mode),
+        }
+    }
+}

src/application/mode/motion.rs

@@ -0,0 +1,161 @@
+use held_core::utils::position::Position;
+
+pub fn locate_next_words_begin(count: usize, str: &str, current_pos: &Position) -> Position {
+    let s = str.as_bytes();
+    let mut left = 0;
+    let mut right = left;
+    for _ in 0..count {
+        while left <= right && right < s.len() {
+            let lchar = s[left] as char;
+            let rchar = s[right] as char;
+            if lchar.is_alphanumeric() {
+                left += 1;
+                right += 1;
+                continue;
+            }
+            if rchar.is_alphanumeric() {
+                left = right;
+                break;
+            }
+            right += 1;
+        }
+    }
+    right = right.min(s.len() - 1);
+    // 向下移动的行数
+    let down_line = str[..right].matches('\n').count();
+
+    let new_offset = if let Some(idx) = str[..right].rfind('\n') {
+        // 即目标位置到行首的距离
+        right - idx - 1
+    } else {
+        // 新旧行之间没有换行符
+        current_pos.offset + right
+    };
+    let pos = Position::new(current_pos.line + down_line, new_offset);
+    return pos;
+}
+
+pub fn locate_previous_words(count: usize, str: &str, current_pos: &Position) -> Position {
+    if str.len() == 0 {
+        return *current_pos;
+    }
+    let s = str.as_bytes();
+    let mut left = s.len() - 1;
+    let mut right = left;
+    for _ in 0..count {
+        while left <= right && left > 0 {
+            let lchar = s[left] as char;
+            let rchar = s[right] as char;
+            if !rchar.is_alphanumeric() {
+                left -= 1;
+                right -= 1;
+                continue;
+            }
+            if !lchar.is_alphanumeric() {
+                right = left;
+                break;
+            }
+            left -= 1;
+        }
+    }
+    let up_line = str[left..].matches('\n').count();
+    let new_line = current_pos.line - up_line;
+    let new_line_len = str.lines().nth(new_line).unwrap().len();
+    let new_offset = if let Some(back_offset) = str[left..].find('\n') {
+        // back_offset为目标位置到行尾的距离
+        // new_line_len - back_offset为目标位置到行首的距离
+        new_line_len - back_offset + 1
+    } else {
+        // 新旧行之间没有换行符
+        current_pos.offset - (s.len() - 1 - left)
+    };
+    return Position::new(new_line, new_offset);
+}
+
+pub fn locate_next_words_end(count: usize, str: &str, current_pos: &Position) -> Position {
+    let s = str.as_bytes();
+    let mut left = 0;
+    let mut right = left;
+    let mut tmp_pos = right;
+    for _ in 0..count {
+        while left <= right && right < s.len() {
+            let lchar = s[left] as char;
+            let rchar = s[right] as char;
+            if !lchar.is_alphanumeric() {
+                left += 1;
+                right += 1;
+                continue;
+            }
+            if !rchar.is_alphanumeric() {
+                if right == tmp_pos + 1 {
+                    left = right;
+                    continue;
+                }
+                right -= 1;
+                left = right;
+                tmp_pos = right;
+                break;
+            }
+            right += 1;
+        }
+    }
+    right = right.min(s.len() - 1);
+    // 向下移动的行数
+    let down_line = str[..right].matches('\n').count();
+
+    let new_offset = if let Some(idx) = str[..right].rfind('\n') {
+        // 即目标位置到行首的距离
+        right - idx - 1
+    } else {
+        // 新旧行之间没有换行符
+        current_pos.offset + right
+    };
+    let pos = Position::new(current_pos.line + down_line, new_offset);
+    return pos;
+}
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn next_word_test() {
+        let mut v = Vec::new();
+        v.push("pub fn locate_next_words(count: usize, str\n: &str) -> Position {");
+        v.push(stringify!(let new_offset = if let Some(idx) = str[..mt
+            ch.start()].rfind('\n')));
+        v.push(";\nmod utils;\nmod view;\nmod workspace;\n");
+
+        assert_eq!(next_word_search(1, v[0], 0), 4);
+        assert_eq!(next_word_search(1, v[0], 4), 7);
+
+        assert_eq!(next_word_search(1, v[1], 0), 4);
+        assert_eq!(next_word_search(1, v[1], 3), 4);
+
+        assert_eq!(next_word_search(1, v[2], 0), 2);
+        assert_eq!(next_word_search(2, v[2], 0), 6);
+    }
+
+    fn next_word_search(count: usize, str: &str, at: usize) -> usize {
+        let s = str.as_bytes();
+        let mut left = at;
+        let mut right = left;
+        for _ in 0..count {
+            while left <= right && right < s.len() {
+                let lchar = s[left] as char;
+                let rchar = s[right] as char;
+                if rchar.is_ascii_punctuation() && right != at {
+                    break;
+                }
+                if lchar.is_alphanumeric() {
+                    left += 1;
+                    right += 1;
+                    continue;
+                }
+                if rchar.is_alphanumeric() {
+                    left = right;
+                    break;
+                }
+                right += 1;
+            }
+        }
+        return right;
+    }
+}

src/application/mode/normal.rs

@@ -0,0 +1,39 @@
+use held_core::view::{colors::Colors, style::CharStyle};
+
+use super::ModeRenderer;
+use crate::{
+    errors::*,
+    view::status_data::{buffer_status_data, StatusLineData},
+};
+pub(super) struct NormalRenderer;
+
+impl ModeRenderer for NormalRenderer {
+    fn render(
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+        _mode: &mut super::ModeData,
+    ) -> Result<()> {
+        let mut presenter = monitor.build_presenter()?;
+
+        if let Some(buffer) = &workspace.current_buffer {
+            warn!("normal buffer id: {}", buffer.id.unwrap());
+            let data = buffer.data();
+            presenter.print_buffer(buffer, &data, &workspace.syntax_set, None, None)?;
+
+            let mode_name_data = StatusLineData {
+                content: " NORMAL ".to_string(),
+                color: Colors::Inverted,
+                style: CharStyle::Bold,
+            };
+            presenter.print_status_line(&[
+                mode_name_data,
+                buffer_status_data(&workspace.current_buffer),
+            ])?;
+
+            presenter.present()?;
+        } else {
+        }
+
+        Ok(())
+    }
+}

src/application/mode/replace.rs

@@ -0,0 +1,37 @@
+use crate::view::status_data::{buffer_status_data, StatusLineData};
+use held_core::view::colors::Colors;
+use held_core::view::style::CharStyle;
+
+use super::ModeRenderer;
+
+pub(super) struct ReplaceRenderer;
+
+impl ModeRenderer for ReplaceRenderer {
+    fn render(
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+        _mode: &mut super::ModeData,
+    ) -> super::Result<()> {
+        let mut presenter = monitor.build_presenter()?;
+
+        if let Some(buffer) = &workspace.current_buffer {
+            let data = buffer.data();
+            presenter.print_buffer(buffer, &data, &workspace.syntax_set, None, None)?;
+
+            let mode_name_data = StatusLineData {
+                content: " REPLACE ".to_string(),
+                color: Colors::Inverted,
+                style: CharStyle::Bold,
+            };
+            presenter.print_status_line(&[
+                mode_name_data,
+                buffer_status_data(&workspace.current_buffer),
+            ])?;
+
+            presenter.present()?;
+        } else {
+        }
+
+        Ok(())
+    }
+}

src/application/mode/search.rs

@@ -0,0 +1,101 @@
+use super::ModeRenderer;
+use crate::{
+    errors::*,
+    view::status_data::{buffer_status_data, StatusLineData},
+};
+use held_core::{
+    utils::range::Range,
+    view::{colors::Colors, style::CharStyle},
+};
+pub(super) struct SearchRenderer;
+
+impl ModeRenderer for SearchRenderer {
+    fn render(
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+        _mode: &mut super::ModeData,
+    ) -> Result<()> {
+        let mut presenter = monitor.build_presenter()?;
+
+        if let Some(buffer) = &workspace.current_buffer {
+            let data = buffer.data();
+
+            if let super::ModeData::Search(ref search_data) = _mode {
+                let highlight_search_string = search_data.search_result.clone();
+
+                let collected_ranges: Vec<(Range, CharStyle, Colors)> =
+                    if !highlight_search_string.is_empty() {
+                        highlight_search_string
+                            .iter()
+                            .map(|range| (range.clone(), CharStyle::Bold, Colors::Inverted))
+                            .collect()
+                    } else {
+                        Vec::new()
+                    };
+
+                let highlight_search_string_slice: Option<&[(Range, CharStyle, Colors)]> =
+                    if !collected_ranges.is_empty() {
+                        Some(collected_ranges.as_slice())
+                    } else {
+                        None
+                    };
+
+                presenter.print_buffer(
+                    buffer,
+                    &data,
+                    &workspace.syntax_set,
+                    highlight_search_string_slice,
+                    None,
+                )?;
+
+                let mode_name_data = StatusLineData {
+                    content: " Search/".to_string(),
+                    color: Colors::Inverted,
+                    style: CharStyle::Bold,
+                };
+
+                let search_data = StatusLineData {
+                    content: search_data.search_string.clone(),
+                    color: Colors::Default,
+                    style: CharStyle::Default,
+                };
+
+                presenter.print_status_line(&[
+                    mode_name_data,
+                    search_data,
+                    buffer_status_data(&workspace.current_buffer),
+                ])?;
+
+                presenter.present()?;
+            } else {
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct SearchData {
+    pub search_string: String,
+    pub is_exec_search: bool,
+    pub search_result_index: usize,
+    pub search_result: Vec<Range>,
+}
+
+impl SearchData {
+    pub fn new() -> Self {
+        Self {
+            search_string: String::new(),
+            is_exec_search: false,
+            search_result_index: 0,
+            search_result: Vec::new(),
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.search_string.clear();
+        self.is_exec_search = false;
+        self.search_result_index = 0;
+        self.search_result.clear();
+    }
+}

src/application/mode/workspace.rs

@@ -0,0 +1,316 @@
+use std::{collections::HashSet, os::unix::fs::MetadataExt, path::PathBuf};
+
+use crossterm::style::Color;
+use error_chain::bail;
+use held_core::{
+    utils::{position::Position, range::Range},
+    view::{colors::Colors, style::CharStyle},
+};
+use unicode_segmentation::UnicodeSegmentation;
+use walkdir::{DirEntry, DirEntryExt, WalkDir};
+
+use super::{ModeData, ModeRenderer};
+use crate::{
+    buffer::Buffer,
+    errors::*,
+    view::{monitor::Monitor, status_data::StatusLineData},
+    workspace::Workspace,
+};
+pub struct WorkspaceModeData {
+    path: PathBuf,
+    selected_index: usize,
+    selected_path: PathBuf,
+    current_render_index: usize,
+    max_index: usize,
+    opened_dir_inos: HashSet<u64>,
+    buffer_id: usize,
+    pub prev_buffer_id: usize,
+    highlight_ranges: Vec<(Range, CharStyle, Colors)>,
+}
+
+impl WorkspaceModeData {
+    pub fn new(workspace: &mut Workspace, monitor: &mut Monitor) -> Result<WorkspaceModeData> {
+        if !workspace.path.is_dir() {
+            bail!("The workspace must be a directory!");
+        }
+
+        let mut opened_dir_inos = HashSet::new();
+        opened_dir_inos.insert(workspace.path.metadata()?.ino());
+
+        let prev_buffer_id = workspace.current_buffer.as_ref().unwrap().id()?;
+
+        let buffer = Buffer::new();
+        let buffer_id = workspace.add_buffer(buffer);
+        monitor.init_buffer(workspace.current_buffer.as_mut().unwrap())?;
+
+        workspace.select_buffer(prev_buffer_id);
+
+        Ok(WorkspaceModeData {
+            path: workspace.path.clone(),
+            selected_index: 0,
+            opened_dir_inos,
+            buffer_id: buffer_id,
+            prev_buffer_id,
+            highlight_ranges: Vec::new(),
+            current_render_index: 0,
+            max_index: 0,
+            selected_path: workspace.path.clone(),
+        })
+    }
+
+    fn update_max_index(&mut self) {
+        self.max_index = self.current_render_index - 1;
+    }
+
+    pub(super) fn render_workspace_tree(
+        &mut self,
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+    ) -> Result<()> {
+        if !workspace.select_buffer(self.buffer_id) {
+            bail!("Not Workspace Buffer!");
+        }
+
+        self.current_render_index = 0;
+
+        if let Some(ref mut buffer) = workspace.current_buffer {
+            buffer.delete_range(Range::new(
+                Position { line: 0, offset: 0 },
+                Position {
+                    line: buffer.line_count(),
+                    offset: usize::MAX,
+                },
+            ));
+            buffer.cursor.move_to(Position { line: 0, offset: 0 });
+            self.highlight_ranges.resize(0, Default::default());
+        }
+
+        let mut depth = 0;
+        let root = self.path.clone();
+        self.render_dir(workspace, &root, &mut depth);
+
+        if let Some(ref mut buffer) = workspace.current_buffer {
+            buffer.cursor.move_to(Position {
+                line: self.selected_index,
+                offset: 0,
+            });
+            monitor.scroll_to_cursor(buffer)?;
+        }
+
+        let mut presenter = monitor.build_presenter()?;
+
+        let buffer = workspace.current_buffer.as_ref().unwrap();
+        let buffer_data = buffer.data();
+        presenter.print_buffer(
+            buffer,
+            &buffer_data,
+            &workspace.syntax_set,
+            Some(&self.highlight_ranges),
+            None,
+        )?;
+
+        let mode_name_data = StatusLineData {
+            content: " WORKSPACE ".to_string(),
+            color: Colors::Inverted,
+            style: CharStyle::Bold,
+        };
+        let workspace_path_data = StatusLineData {
+            content: format!(" {}", self.path.display()),
+            color: Colors::Focused,
+            style: CharStyle::Bold,
+        };
+        presenter.print_status_line(&[mode_name_data, workspace_path_data])?;
+        presenter.present()?;
+
+        monitor.terminal.set_cursor(None)?;
+        monitor.terminal.present()?;
+
+        self.update_max_index();
+        Ok(())
+    }
+
+    fn entry_sort(a: &DirEntry, b: &DirEntry) -> std::cmp::Ordering {
+        if a.file_type().is_dir() && b.file_type().is_dir() {
+            return a.file_name().cmp(b.file_name());
+        }
+
+        if a.file_type().is_dir() {
+            return std::cmp::Ordering::Less;
+        } else if b.file_type().is_dir() {
+            return std::cmp::Ordering::Greater;
+        }
+
+        a.file_name().cmp(b.file_name())
+    }
+
+    // 需要当前buffer为workspace buffer才能调用该方法
+    fn render_dir(&mut self, workspace: &mut Workspace, root_path: &PathBuf, depth: &mut usize) {
+        let walkdir = WalkDir::new(root_path)
+            .max_depth(1)
+            .sort_by(Self::entry_sort);
+
+        let mut iter = walkdir.into_iter();
+
+        if let Some(entry) = iter.next() {
+            if let Ok(entry) = entry {
+                let target_modified = workspace
+                    .get_buffer_with_ino(entry.ino())
+                    .map(|x| x.modified());
+
+                let buffer = workspace.current_buffer.as_mut().unwrap();
+                let ino = entry.ino();
+                buffer.cursor.move_down();
+                self.print_entry(
+                    buffer,
+                    entry,
+                    *depth,
+                    self.opened_dir_inos.contains(&ino),
+                    target_modified,
+                );
+                *depth += 1;
+                if !self.opened_dir_inos.contains(&ino) {
+                    return;
+                }
+            }
+        }
+
+        for entry in iter {
+            if let Ok(entry) = entry {
+                self.render_entry(workspace, entry, depth);
+            }
+        }
+    }
+
+    fn render_entry(&mut self, workspace: &mut Workspace, entry: DirEntry, depth: &mut usize) {
+        let target_modified = workspace
+            .get_buffer_with_ino(entry.ino())
+            .map(|x| x.modified());
+        let buffer = workspace.current_buffer.as_mut().unwrap();
+        if entry.file_type().is_dir() {
+            if self.opened_dir_inos.contains(&entry.ino()) {
+                self.render_dir(workspace, &entry.path().to_path_buf(), depth);
+                *depth -= 1;
+            } else {
+                self.print_entry(buffer, entry, *depth, false, target_modified);
+            }
+        } else {
+            self.print_entry(buffer, entry, *depth, false, target_modified);
+        }
+    }
+
+    fn print_entry(
+        &mut self,
+        buffer: &mut Buffer,
+        entry: DirEntry,
+        depth: usize,
+        is_open: bool,
+        target_buffer_modified: Option<bool>,
+    ) {
+        let prefix = " ".repeat(depth)
+            + if entry.file_type().is_dir() {
+                if is_open {
+                    "- "
+                } else {
+                    "+ "
+                }
+            } else {
+                "| "
+            };
+
+        buffer.insert(&prefix);
+        buffer.cursor.move_to(Position {
+            line: buffer.cursor.line,
+            offset: buffer.cursor.offset + prefix.graphemes(true).count(),
+        });
+
+        let start = buffer.cursor.position;
+        let file_name = entry.file_name().to_str().unwrap_or_default();
+
+        buffer.insert(file_name);
+        buffer.cursor.move_to(Position {
+            line: buffer.cursor.line,
+            offset: buffer.cursor.offset + file_name.graphemes(true).count(),
+        });
+        let end = buffer.cursor.position;
+
+        buffer.insert("\n");
+        buffer.cursor.move_down();
+
+        if self.selected_index == self.current_render_index {
+            self.highlight_ranges.push((
+                Range::new(start, end),
+                CharStyle::Bold,
+                Colors::CustomForeground(Color::Cyan),
+            ));
+
+            self.selected_path = entry.into_path();
+        } else if let Some(modified) = target_buffer_modified {
+            if modified {
+                self.highlight_ranges.push((
+                    Range::new(start, end),
+                    CharStyle::Bold,
+                    Colors::CustomForeground(Color::Yellow),
+                ));
+            } else {
+                self.highlight_ranges.push((
+                    Range::new(start, end),
+                    CharStyle::Bold,
+                    Colors::CustomForeground(Color::Green),
+                ));
+            }
+        }
+
+        self.current_render_index += 1;
+    }
+
+    /// 打开当前选择的节点，若返回true则表示打开的是文件而非dir，需要回退normal模式
+    pub fn open(&mut self, workspace: &mut Workspace, monitor: &mut Monitor) -> Result<bool> {
+        if self.selected_path.is_dir() {
+            let ino = self.selected_path.metadata()?.ino();
+            if self.opened_dir_inos.contains(&ino) {
+                self.opened_dir_inos.remove(&ino);
+            } else {
+                self.opened_dir_inos.insert(ino);
+            }
+
+            Ok(false)
+        } else {
+            let buffer = Buffer::from_file(&self.selected_path)?;
+            let id = workspace.add_buffer(buffer);
+            workspace.select_buffer(id);
+            monitor.init_buffer(workspace.current_buffer.as_mut().unwrap())?;
+            self.prev_buffer_id = id;
+            Ok(true)
+        }
+    }
+
+    pub fn move_down(&mut self) {
+        if self.selected_index == self.max_index {
+            return;
+        }
+        self.selected_index += 1;
+    }
+
+    pub fn move_up(&mut self) {
+        if self.selected_index == 0 {
+            return;
+        }
+        self.selected_index -= 1;
+    }
+}
+
+pub struct WorkspaceRender;
+
+impl ModeRenderer for WorkspaceRender {
+    fn render(
+        workspace: &mut crate::workspace::Workspace,
+        monitor: &mut crate::view::monitor::Monitor,
+        mode: &mut super::ModeData,
+    ) -> super::Result<()> {
+        if let ModeData::Workspace(mode_data) = mode {
+            return mode_data.render_workspace_tree(workspace, monitor);
+        } else {
+            bail!("Workspace mode cannot receive data other than WorkspaceModeData")
+        }
+    }
+}

src/application/plugin_interafce/app.rs

@@ -0,0 +1,17 @@
+use held_core::interface::app::App;
+
+use crate::application::Application;
+
+impl App for Application {
+    fn exit(&mut self) {
+        todo!()
+    }
+
+    fn to_insert_mode(&mut self) {
+        todo!()
+    }
+
+    fn to_normal_mode(&mut self) {
+        todo!()
+    }
+}

src/application/plugin_interafce/buffer.rs

@@ -0,0 +1,17 @@
+use held_core::interface;
+
+use crate::application::Application;
+
+impl interface::buffer::Buffer for Application {
+    fn insert_char(&mut self) {
+        todo!()
+    }
+
+    fn new_line(&mut self) {
+        todo!()
+    }
+
+    fn insert_tab(&mut self) {
+        todo!()
+    }
+}

src/application/plugin_interafce/cursor.rs

@@ -0,0 +1,29 @@
+use held_core::interface;
+
+use crate::application::Application;
+
+impl interface::cursor::Cursor for Application {
+    fn move_left(&mut self) {
+        todo!()
+    }
+
+    fn move_right(&mut self) {
+        todo!()
+    }
+
+    fn move_up(&mut self) {
+        todo!()
+    }
+
+    fn move_down(&mut self) {
+        todo!()
+    }
+
+    fn move_to_start_of_line(&mut self) {
+        todo!()
+    }
+
+    fn screen_cursor_position(&self) -> held_core::utils::position::Position {
+        self.state_data.cursor_state.screen_position
+    }
+}

src/application/plugin_interafce/mod.rs

@@ -0,0 +1,11 @@
+use held_core::interface::{app::App, ApplicationInterface};
+
+use super::Application;
+
+pub mod app;
+pub mod buffer;
+pub mod cursor;
+pub mod monitor;
+pub mod workspace;
+
+impl ApplicationInterface for Application {}

src/application/plugin_interafce/monitor.rs

@@ -0,0 +1,13 @@
+use held_core::interface;
+
+use crate::application::Application;
+
+impl interface::monitor::Monitor for Application {
+    fn scroll_to_cursor(&mut self) {
+        todo!()
+    }
+
+    fn scroll_to_center(&mut self) {
+        todo!()
+    }
+}

src/application/plugin_interafce/workspace.rs

@@ -0,0 +1,13 @@
+use held_core::interface;
+
+use crate::application::Application;
+
+impl interface::workspace::Workspace for Application {
+    fn save_file(&mut self) {
+        todo!()
+    }
+
+    fn undo(&mut self) {
+        todo!()
+    }
+}

src/application/state.rs

@@ -0,0 +1,13 @@
+use held_core::utils::position::Position;
+
+/// 用于记录当前实时更新的状态信息
+/// 因为某些插件可能需要获取实时的状态信息，所以所有实时的状态都可能需要更新到这里
+#[derive(Debug, Default)]
+pub struct ApplicationStateData {
+    pub cursor_state: CursorStateData,
+}
+
+#[derive(Debug, Default)]
+pub struct CursorStateData {
+    pub screen_position: Position,
+}

src/buffer/cursor.rs

@@ -0,0 +1,502 @@
+use std::{
+    cell::RefCell,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
+
+use unicode_segmentation::UnicodeSegmentation;
+
+use super::{GapBuffer, Position};
+
+#[derive(Clone)]
+pub struct Cursor {
+    pub data: Rc<RefCell<GapBuffer>>,
+    pub position: Position,
+    /// 限制上下移动时，offset不会溢出
+    sticky_offset: usize,
+}
+
+impl Deref for Cursor {
+    type Target = Position;
+
+    fn deref(&self) -> &Position {
+        &self.position
+    }
+}
+
+impl DerefMut for Cursor {
+    fn deref_mut(&mut self) -> &mut Position {
+        &mut self.position
+    }
+}
+
+impl Cursor {
+    pub fn new(data: Rc<RefCell<GapBuffer>>, position: Position) -> Cursor {
+        Cursor {
+            data,
+            position,
+            sticky_offset: position.offset,
+        }
+    }
+
+    pub fn move_to(&mut self, position: Position) -> bool {
+        if self.data.borrow().in_bounds(&position) {
+            self.position = position;
+
+            // 缓冲当前offset
+            self.sticky_offset = position.offset;
+
+            return true;
+        }
+        false
+    }
+
+    pub fn move_up(&mut self) {
+        if self.line == 0 {
+            return;
+        }
+
+        let target_line = self.line - 1;
+        let new_position = Position {
+            line: target_line,
+            offset: self.sticky_offset,
+        };
+
+        if !self.move_to(new_position) {
+            let mut target_offset = 0;
+            for (line_number, line) in self.data.borrow().to_string().lines().enumerate() {
+                if line_number == target_line {
+                    target_offset = line.graphemes(true).count();
+                    break;
+                }
+            }
+            self.move_to(Position {
+                line: target_line,
+                offset: target_offset,
+            });
+
+            self.sticky_offset = new_position.offset;
+        }
+    }
+
+    pub fn move_down(&mut self) {
+        let target_line = self.line + 1;
+        let new_position = Position {
+            line: target_line,
+            offset: self.sticky_offset,
+        };
+
+        if !self.move_to(new_position) {
+            let mut target_offset = 0;
+            for (line_number, line) in self.data.borrow().to_string().lines().enumerate() {
+                if line_number == target_line {
+                    target_offset = line.graphemes(true).count();
+                }
+            }
+            self.move_to(Position {
+                line: target_line,
+                offset: target_offset,
+            });
+
+            self.sticky_offset = new_position.offset;
+        }
+    }
+
+    pub fn move_left(&mut self) {
+        if self.offset == 0 {
+            if self.line == 0 {
+                return;
+            }
+            let offset = self
+                .data
+                .borrow()
+                .to_string()
+                .lines()
+                .nth(self.line - 1)
+                .unwrap()
+                .graphemes(true)
+                .count();
+
+            let new_position = Position {
+                line: self.line - 1,
+                offset,
+            };
+            self.move_to(new_position);
+        } else {
+            let new_position = Position {
+                line: self.line,
+                offset: self.offset - 1,
+            };
+            self.move_to(new_position);
+        }
+    }
+
+    pub fn move_right(&mut self) {
+        let max_offset = self
+            .data
+            .borrow()
+            .to_string()
+            .lines()
+            .nth(self.line)
+            .unwrap_or_default()
+            .graphemes(true)
+            .count();
+
+        if max_offset == 0 {
+            return;
+        }
+
+        if self.offset + 1 > max_offset
+            && self.line + 1 <= self.data.borrow().to_string().lines().count()
+        {
+            let new_position = Position {
+                line: self.line + 1,
+                offset: 0,
+            };
+            self.move_to(new_position);
+        } else {
+            let new_position = Position {
+                line: self.line,
+                offset: self.offset + 1,
+            };
+            self.move_to(new_position);
+        }
+    }
+
+    pub fn move_to_start_of_line(&mut self) {
+        let new_position = Position {
+            line: self.line,
+            offset: 0,
+        };
+        self.move_to(new_position);
+    }
+
+    pub fn move_to_end_of_line(&mut self) {
+        let data = self.data.borrow().to_string();
+        let current_line = data.lines().nth(self.line);
+        if let Some(line) = current_line {
+            let new_position = Position {
+                line: self.line,
+                offset: line.graphemes(true).count(),
+            };
+            self.move_to(new_position);
+        }
+    }
+
+    pub fn move_to_last_line(&mut self) {
+        // Figure out the number and length of the last line.
+        let mut line = 0;
+        let mut length = 0;
+        for c in self.data.borrow().to_string().graphemes(true) {
+            if c == "\n" {
+                line += 1;
+                length = 0;
+            } else {
+                length += 1;
+            }
+        }
+
+        let target_position = if length < self.sticky_offset {
+            // Current offset is beyond the last line's length; move to the end of it.
+            Position {
+                line,
+                offset: length,
+            }
+        } else {
+            // Current offset is available on the last line; go there.
+            Position {
+                line,
+                offset: self.sticky_offset,
+            }
+        };
+        self.move_to(target_position);
+    }
+
+    pub fn move_to_first_line(&mut self) {
+        // Figure out the length of the first line.
+        let length = self
+            .data
+            .borrow()
+            .to_string()
+            .lines()
+            .nth(0)
+            .map(|line| line.graphemes(true).count())
+            .unwrap_or(0);
+
+        let target_position = if length < self.sticky_offset {
+            // Current offset is beyond the first line's length; move to the end of it.
+            Position {
+                line: 0,
+                offset: length,
+            }
+        } else {
+            // Current offset is available on the first line; go there.
+            Position {
+                line: 0,
+                offset: self.sticky_offset,
+            }
+        };
+        self.move_to(target_position);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::buffer::{Cursor, GapBuffer, Position};
+    use std::cell::RefCell;
+    use std::rc::Rc;
+
+    #[test]
+    fn move_up_goes_to_eol_if_offset_would_be_out_of_range() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "This is a test.\nAnother line that is longer.".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 1,
+                offset: 20,
+            },
+        );
+        cursor.move_up();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 15);
+    }
+
+    #[test]
+    fn move_down_goes_to_eol_if_offset_would_be_out_of_range() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "Another line that is longer.\nThis is a test.".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 0,
+                offset: 20,
+            },
+        );
+        cursor.move_down();
+        assert_eq!(cursor.line, 1);
+        assert_eq!(cursor.offset, 15);
+    }
+
+    #[test]
+    fn move_up_counts_graphemes_as_a_single_offset() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "First नी\nSecond line".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 1,
+                offset: 11,
+            },
+        );
+        cursor.move_up();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 7);
+    }
+
+    #[test]
+    fn move_down_counts_graphemes_as_a_single_offset() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "First line\nSecond नी".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 0,
+                offset: 10,
+            },
+        );
+        cursor.move_down();
+        assert_eq!(cursor.line, 1);
+        assert_eq!(cursor.offset, 8);
+    }
+
+    #[test]
+    fn move_up_persists_offset_across_shorter_lines() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "First line that is longer.\nThis is a test.\nAnother line that is longer.".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 2,
+                offset: 20,
+            },
+        );
+        cursor.move_up();
+        cursor.move_up();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 20);
+    }
+
+    #[test]
+    fn move_down_persists_offset_across_shorter_lines() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "First line that is longer.\nThis is a test.\nAnother line that is longer.".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 0,
+                offset: 20,
+            },
+        );
+        cursor.move_down();
+        cursor.move_down();
+        assert_eq!(cursor.line, 2);
+        assert_eq!(cursor.offset, 20);
+    }
+
+    #[test]
+    fn move_to_sets_persisted_offset() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "First line that is longer.\nThis is a test.\nAnother line that is longer.".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 0,
+                offset: 20,
+            },
+        );
+        cursor.move_to(Position { line: 1, offset: 5 });
+        cursor.move_down();
+        assert_eq!(cursor.line, 2);
+        assert_eq!(cursor.offset, 5);
+    }
+
+    #[test]
+    fn move_to_start_of_line_sets_offset_to_zero() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "This is a test.\nAnother line.".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 1, offset: 5 });
+        cursor.move_to_start_of_line();
+        assert_eq!(cursor.line, 1);
+        assert_eq!(cursor.offset, 0);
+    }
+
+    #[test]
+    fn move_to_end_of_line_counts_graphemes_as_a_single_offset() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new("First नी".to_string())));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 0 });
+        cursor.move_to_end_of_line();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 7);
+    }
+
+    #[test]
+    fn move_to_end_of_line_sets_offset_the_line_length() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "This is a test.\nAnother line.".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 5 });
+        cursor.move_to_end_of_line();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 15);
+    }
+
+    #[test]
+    fn move_up_does_nothing_if_at_the_start_of_line() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new("This is a test.".to_string())));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 0 });
+        cursor.move_up();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 0);
+    }
+
+    #[test]
+    fn move_left_does_nothing_if_at_the_start_of_line() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new("This is a test.".to_string())));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 0 });
+        cursor.move_left();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 0);
+    }
+
+    #[test]
+    fn move_to_last_line_counts_graphemes_as_a_single_offset() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "First line\nLast नी".to_string(),
+        )));
+        let mut cursor = Cursor::new(
+            buffer,
+            Position {
+                line: 0,
+                offset: 10,
+            },
+        );
+        cursor.move_to_last_line();
+        assert_eq!(cursor.line, 1);
+        assert_eq!(cursor.offset, 6);
+    }
+
+    #[test]
+    fn move_to_last_line_moves_to_same_offset_on_last_line() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "first\nsecond\nlast".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 2 });
+        cursor.move_to_last_line();
+        assert_eq!(cursor.line, 2);
+        assert_eq!(cursor.offset, 2);
+    }
+
+    #[test]
+    fn move_to_last_line_moves_to_end_of_last_line_if_offset_would_be_out_of_range() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "first\nsecond\nlast".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 5 });
+        cursor.move_to_last_line();
+        assert_eq!(cursor.line, 2);
+        assert_eq!(cursor.offset, 4);
+    }
+
+    #[test]
+    fn move_to_last_line_moves_last_line_when_it_is_a_trailing_newline() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "first\nsecond\nlast\n".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 2 });
+        cursor.move_to_last_line();
+        assert_eq!(cursor.line, 3);
+        assert_eq!(cursor.offset, 0);
+    }
+
+    #[test]
+    fn move_to_first_line_counts_graphemes_as_a_single_offset() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "First नी\nLast line".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 0, offset: 9 });
+        cursor.move_to_first_line();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 7);
+    }
+
+    #[test]
+    fn move_to_first_line_moves_to_same_offset_on_first_line() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "first\nsecond\nlast".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 1, offset: 2 });
+        cursor.move_to_first_line();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 2);
+    }
+
+    #[test]
+    fn move_to_first_line_moves_to_end_of_first_line_if_offset_would_be_out_of_range() {
+        let buffer = Rc::new(RefCell::new(GapBuffer::new(
+            "first\nsecond\nlast".to_string(),
+        )));
+        let mut cursor = Cursor::new(buffer, Position { line: 1, offset: 6 });
+        cursor.move_to_first_line();
+        assert_eq!(cursor.line, 0);
+        assert_eq!(cursor.offset, 5);
+    }
+}

src/buffer/gap_buffer.rs

@@ -0,0 +1,463 @@
+use std::{borrow::Borrow, fmt};
+
+use held_core::utils::position::Position;
+use unicode_segmentation::UnicodeSegmentation;
+
+use held_core::utils::range::Range;
+
+/// GapBuffer 增加减少重分配的buffer
+/// 在一整块buffer中有一段gap(空闲空间)将整块buffer分为两段，以实现插入删除等操作的高效率（减少重分配）
+/// 数据结构：
+///     |       data        |               gap         |       data        |
+///     |               gap_start------>gap_length<-----|                   |
+pub struct GapBuffer {
+    data: Vec<u8>,
+    gap_start: usize,
+    gap_length: usize,
+}
+
+impl GapBuffer {
+    pub fn new<T: AsRef<str>>(data: T) -> GapBuffer {
+        let mut buf = data.as_ref().as_bytes().to_owned();
+        let capacity = buf.capacity();
+        let gap_start = buf.len();
+        let gap_length = capacity - gap_start;
+        unsafe {
+            buf.set_len(capacity);
+        }
+
+        GapBuffer {
+            data: buf,
+            gap_start: gap_start,
+            gap_length: gap_length,
+        }
+    }
+
+    pub fn insert(&mut self, data: &str, position: &Position) {
+        if data.len() > self.gap_length {
+            // 先将gap区域移动到最后，不然会出现两段gap
+            let offset = self.data.capacity();
+            self.move_gap(offset);
+            // 扩容
+            self.data.reserve(data.len());
+
+            let capacity = self.data.capacity();
+            self.gap_length = capacity - self.gap_start;
+            unsafe {
+                self.data.set_len(capacity);
+            }
+        }
+
+        let offset = match self.find_offset(position) {
+            Some(offset) => offset,
+            None => return,
+        };
+        // println!("{:?}", self.data);
+        self.move_gap(offset);
+        // println!("{:?}", self.data);
+        self.write_to_gap(data);
+        // println!("{:?}", self.data);
+        // println!("start {} length {}", self.gap_start, self.gap_length);
+    }
+
+    pub fn read(&self, range: &Range) -> Option<String> {
+        let start_offset = match self.find_offset(&range.start()) {
+            Some(offset) => offset,
+            None => return None,
+        };
+
+        let end_offset = match self.find_offset(&range.end()) {
+            Some(offset) => offset,
+            None => return None,
+        };
+
+        let data = if start_offset < self.gap_start && end_offset > self.gap_start {
+            let mut data =
+                String::from_utf8_lossy(&self.data[start_offset..self.gap_start]).into_owned();
+            data.push_str(
+                String::from_utf8_lossy(&self.data[self.gap_start + self.gap_length..end_offset])
+                    .borrow(),
+            );
+            data
+        } else {
+            String::from_utf8_lossy(&self.data[start_offset..end_offset]).into_owned()
+        };
+
+        Some(data)
+    }
+
+    pub fn read_rest(&self, position: &Position) -> Option<String> {
+        let offset = match self.find_offset(position) {
+            Some(offset) => offset,
+            None => return None,
+        };
+
+        let data = if offset < self.gap_start {
+            let mut data = String::from_utf8_lossy(&self.data[offset..self.gap_start]).into_owned();
+            data.push_str(
+                String::from_utf8_lossy(&self.data[self.gap_start + self.gap_length..]).borrow(),
+            );
+            data
+        } else {
+            String::from_utf8_lossy(&self.data[offset..]).into_owned()
+        };
+
+        Some(data)
+    }
+
+    // | data | gap |   data    |
+    pub fn delete(&mut self, range: &Range) {
+        let start_offset = match self.find_offset(&range.start()) {
+            Some(offset) => offset,
+            None => return,
+        };
+
+        self.move_gap(start_offset);
+
+        match self.find_offset(&range.end()) {
+            Some(offset) => {
+                self.gap_length = offset - self.gap_start;
+            }
+            None => {
+                // 确定delete后gap长度
+
+                // 尝试跳过一行查找，若找到，则end在原gap区域中，若找不到，则end超出data范围或者在末尾
+                let start_of_next_line = Position {
+                    line: range.end().line + 1,
+                    offset: 0,
+                };
+
+                match self.find_offset(&start_of_next_line) {
+                    Some(offset) => {
+                        self.gap_length = offset - self.gap_start;
+                    }
+                    None => {
+                        self.gap_length = self.data.len() - self.gap_start;
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn in_bounds(&self, position: &Position) -> bool {
+        return self.find_offset(position).is_some();
+    }
+
+    /// 将对应的position映射为具体在buffer中的offset
+    pub fn find_offset(&self, position: &Position) -> Option<usize> {
+        let first = String::from_utf8_lossy(&self.data[..self.gap_start]);
+        let mut line = 0;
+        let mut line_offset = 0;
+        for (offset, grapheme) in (*first).grapheme_indices(true) {
+            if line == position.line && line_offset == position.offset {
+                return Some(offset);
+            }
+
+            if grapheme == "\n" {
+                line += 1;
+                line_offset = 0;
+            } else {
+                line_offset += 1;
+            }
+        }
+
+        // |    data1    |   gap  |   data2    |
+        // 当data1最后个字符为'\n'时，若刚好匹配到，则实际offset为data2的开头
+        if line == position.line && line_offset == position.offset {
+            return Some(self.gap_start + self.gap_length);
+        }
+
+        let second = String::from_utf8_lossy(&self.data[self.gap_start + self.gap_length..]);
+        for (offset, grapheme) in (*second).grapheme_indices(true) {
+            if line == position.line && line_offset == position.offset {
+                return Some(self.gap_start + self.gap_length + offset);
+            }
+
+            if grapheme == "\n" {
+                line += 1;
+                line_offset = 0;
+            } else {
+                line_offset += 1;
+            }
+        }
+
+        // |    data1    |   gap  |   data2    |
+        // 当data2最后个字符为'\n'时，若刚好匹配到，则实际offset为data2的结尾
+        if line == position.line && line_offset == position.offset {
+            return Some(self.data.len());
+        }
+
+        None
+    }
+
+    pub fn move_gap(&mut self, offset: usize) {
+        if self.gap_length == 0 {
+            self.gap_start = offset;
+            return;
+        }
+
+        match offset.cmp(&self.gap_start) {
+            std::cmp::Ordering::Less => {
+                for index in (offset..self.gap_start).rev() {
+                    self.data[index + self.gap_length] = self.data[index];
+                }
+
+                self.gap_start = offset;
+            }
+            std::cmp::Ordering::Equal => {}
+            std::cmp::Ordering::Greater => {
+                for index in self.gap_start + self.gap_length..offset {
+                    self.data[index - self.gap_length] = self.data[index];
+                }
+
+                self.gap_start = offset - self.gap_length;
+            }
+        }
+    }
+
+    // 写gap区域
+    fn write_to_gap(&mut self, data: &str) {
+        assert!(self.gap_length >= data.bytes().len());
+        for byte in data.bytes() {
+            self.data[self.gap_start] = byte;
+            self.gap_start += 1;
+            self.gap_length -= 1;
+        }
+    }
+}
+
+impl fmt::Display for GapBuffer {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let first_half = String::from_utf8_lossy(&self.data[..self.gap_start]);
+        let second_half = String::from_utf8_lossy(&self.data[self.gap_start + self.gap_length..]);
+
+        write!(f, "{}{}", first_half, second_half)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use held_core::utils::range::Range;
+
+    use crate::buffer::{GapBuffer, Position};
+
+    #[test]
+    fn move_gap_works() {
+        let mut gb = GapBuffer::new("This is a test.");
+        gb.move_gap(0);
+        assert_eq!(gb.to_string(), "This is a test.");
+    }
+
+    #[test]
+    fn inserting_at_the_start_works() {
+        let mut gb = GapBuffer::new("toolkit");
+
+        // This insert serves to move the gap to the start of the buffer.
+        gb.insert(" ", &Position { line: 0, offset: 0 });
+        assert_eq!(gb.to_string(), " toolkit");
+
+        // We insert enough data (more than twice original capacity) to force
+        // a re-allocation, which, with the gap at the start and when handled
+        // incorrectly, will create a split/two-segment gap. Bad news.
+        gb.insert("scribe text", &Position { line: 0, offset: 0 });
+        assert_eq!(gb.to_string(), "scribe text toolkit");
+    }
+
+    #[test]
+    fn inserting_in_the_middle_works() {
+        let mut gb = GapBuffer::new("    editor");
+
+        // Same deal as above "at the start" test, where we want to move
+        // the gap into the middle and then force a reallocation to check
+        // that pre-allocation gap shifting is working correctly.
+        gb.insert(" ", &Position { line: 0, offset: 4 });
+        gb.insert("scribe", &Position { line: 0, offset: 4 });
+        assert_eq!(gb.to_string(), "    scribe editor");
+    }
+
+    #[test]
+    fn inserting_at_the_end_works() {
+        let mut gb = GapBuffer::new("This is a test.");
+        gb.insert(
+            " Seriously.",
+            &Position {
+                line: 0,
+                offset: 15,
+            },
+        );
+        assert_eq!(gb.to_string(), "This is a test. Seriously.");
+    }
+
+    #[test]
+    fn inserting_in_different_spots_twice_works() {
+        let mut gb = GapBuffer::new("This is a test.");
+        gb.insert("Hi. ", &Position { line: 0, offset: 0 });
+        gb.insert(
+            " Thank you.",
+            &Position {
+                line: 0,
+                offset: 19,
+            },
+        );
+        assert_eq!(gb.to_string(), "Hi. This is a test. Thank you.");
+    }
+
+    #[test]
+    fn inserting_at_an_invalid_position_does_nothing() {
+        let mut gb = GapBuffer::new("This is a test.");
+        gb.insert(
+            " Seriously.",
+            &Position {
+                line: 0,
+                offset: 35,
+            },
+        );
+        assert_eq!(gb.to_string(), "This is a test.");
+    }
+
+    #[test]
+    fn inserting_after_a_grapheme_cluster_works() {
+        let mut gb = GapBuffer::new("scribe नी");
+        gb.insert(" library", &Position { line: 0, offset: 8 });
+        assert_eq!(gb.to_string(), "scribe नी library");
+    }
+
+    #[test]
+    fn deleting_works() {
+        let mut gb = GapBuffer::new("This is a test.\nSee what happens.");
+        let start = Position { line: 0, offset: 8 };
+        let end = Position { line: 1, offset: 4 };
+        gb.delete(&Range::new(start, end));
+        assert_eq!(gb.to_string(), "This is what happens.");
+    }
+
+    #[test]
+    fn inserting_then_deleting_at_the_start_works() {
+        let mut gb = GapBuffer::new("");
+        gb.insert("This is a test.", &Position { line: 0, offset: 0 });
+        let start = Position { line: 0, offset: 0 };
+        let end = Position { line: 0, offset: 1 };
+        gb.delete(&Range::new(start, end));
+        assert_eq!(gb.to_string(), "his is a test.");
+    }
+
+    #[test]
+    fn deleting_immediately_after_the_end_of_the_gap_widens_the_gap() {
+        let mut gb = GapBuffer::new("This is a test.");
+        let mut start = Position { line: 0, offset: 8 };
+        let mut end = Position { line: 0, offset: 9 };
+        gb.delete(&Range::new(start, end));
+        assert_eq!(gb.to_string(), "This is  test.");
+        assert_eq!(gb.gap_length, 1);
+
+        start = Position { line: 0, offset: 9 };
+        end = Position {
+            line: 0,
+            offset: 10,
+        };
+        gb.delete(&Range::new(start, end));
+        assert_eq!(gb.to_string(), "This is  est.");
+        assert_eq!(gb.gap_length, 2);
+    }
+
+    #[test]
+    fn deleting_to_an_out_of_range_line_deletes_to_the_end_of_the_buffer() {
+        let mut gb = GapBuffer::new("scribe\nlibrary");
+        let start = Position { line: 0, offset: 6 };
+        let end = Position {
+            line: 2,
+            offset: 10,
+        };
+        gb.delete(&Range::new(start, end));
+        assert_eq!(gb.to_string(), "scribe");
+    }
+
+    #[test]
+    fn deleting_to_an_out_of_range_column_deletes_to_the_end_of_the_buffer() {
+        let mut gb = GapBuffer::new("scribe\nlibrary");
+        let start = Position { line: 0, offset: 0 };
+        let end = Position {
+            line: 0,
+            offset: 100,
+        };
+        gb.delete(&Range::new(start, end));
+        assert_eq!(gb.to_string(), "library");
+    }
+
+    #[test]
+    fn deleting_after_a_grapheme_cluster_works() {
+        let mut gb = GapBuffer::new("scribe नी library");
+        let start = Position { line: 0, offset: 8 };
+        let end = Position {
+            line: 0,
+            offset: 16,
+        };
+        gb.delete(&Range::new(start, end));
+        assert_eq!(gb.to_string(), "scribe नी");
+    }
+
+    #[test]
+    fn read_does_not_include_gap_contents_when_gap_is_at_start_of_range() {
+        // Create a buffer and a range that captures the first character.
+        let mut gb = GapBuffer::new("scribe");
+        let range = Range::new(
+            Position { line: 0, offset: 0 },
+            Position { line: 0, offset: 1 },
+        );
+
+        // Delete the first character, which will move the gap buffer to the start.
+        gb.delete(&range);
+        assert_eq!(gb.to_string(), "cribe");
+
+        // Ask for the first character, which would include the deleted
+        // value, if the read function isn't smart enough to skip it.
+        assert_eq!(gb.read(&range).unwrap(), "c");
+    }
+
+    #[test]
+    fn read_does_not_include_gap_contents_when_gap_is_in_middle_of_range() {
+        let mut gb = GapBuffer::new("scribe");
+
+        // Delete data from the middle of the buffer, which will move the gap there.
+        gb.delete(&Range::new(
+            Position { line: 0, offset: 2 },
+            Position { line: 0, offset: 4 },
+        ));
+        assert_eq!(gb.to_string(), "scbe");
+
+        // Request a range that extends from the start to the finish.
+        let range = Range::new(
+            Position { line: 0, offset: 0 },
+            Position { line: 0, offset: 4 },
+        );
+        assert_eq!(gb.read(&range).unwrap(), "scbe");
+    }
+
+    #[test]
+    fn reading_after_a_grapheme_cluster_works() {
+        let gb = GapBuffer::new("scribe नी library");
+        let range = Range::new(
+            Position { line: 0, offset: 8 },
+            Position {
+                line: 0,
+                offset: 16,
+            },
+        );
+        assert_eq!(gb.read(&range).unwrap(), " library");
+    }
+
+    #[test]
+    fn in_bounds_considers_grapheme_clusters() {
+        let gb = GapBuffer::new("scribe नी library");
+        let in_bounds = Position {
+            line: 0,
+            offset: 16,
+        };
+        let out_of_bounds = Position {
+            line: 0,
+            offset: 17,
+        };
+        assert!(gb.in_bounds(&in_bounds));
+        assert!(!gb.in_bounds(&out_of_bounds));
+    }
+}

src/buffer/mod.rs

@@ -0,0 +1,201 @@
+use crate::errors::*;
+use std::cell::RefCell;
+use std::fs::File;
+use std::io::{ErrorKind, Write};
+use std::path::{Path, PathBuf};
+use std::rc::Rc;
+use std::{fs, io};
+
+use cursor::Cursor;
+use held_core::utils::position::Position;
+use operation::history::History;
+use operation::{Operation, OperationGroup};
+use syntect::parsing::SyntaxReference;
+
+use crate::errors::Error;
+use held_core::utils::range::Range;
+
+// Published API
+pub use self::gap_buffer::GapBuffer;
+
+mod cursor;
+mod gap_buffer;
+mod operation;
+
+pub struct Buffer {
+    pub id: Option<usize>,
+    data: Rc<RefCell<GapBuffer>>,
+    pub path: Option<PathBuf>,
+    pub cursor: Cursor,
+    history: History,
+    operation_group: Option<OperationGroup>,
+    pub syntax_definition: Option<SyntaxReference>,
+    pub change_callback: Option<Box<dyn Fn(Position)>>,
+}
+
+impl Default for Buffer {
+    fn default() -> Self {
+        let data = Rc::new(RefCell::new(GapBuffer::new(String::new())));
+        let cursor = Cursor::new(data.clone(), Position { line: 0, offset: 0 });
+        let mut history = History::new();
+        history.mark();
+
+        Buffer {
+            id: None,
+            data: data.clone(),
+            path: None,
+            cursor,
+            history: History::new(),
+            operation_group: None,
+            syntax_definition: None,
+            change_callback: None,
+        }
+    }
+}
+
+impl Buffer {
+    pub fn new() -> Buffer {
+        Buffer::default()
+    }
+
+    pub fn from_file(path: &Path) -> io::Result<Buffer> {
+        let content = fs::read_to_string(path)?;
+
+        let data = Rc::new(RefCell::new(GapBuffer::new(content)));
+        let cursor = Cursor::new(data.clone(), Position { line: 0, offset: 0 });
+
+        let mut buffer = Buffer {
+            id: None,
+            data: data.clone(),
+            path: Some(path.canonicalize()?),
+            cursor,
+            history: History::new(),
+            operation_group: None,
+            syntax_definition: None,
+            change_callback: None,
+        };
+
+        buffer.history.mark();
+
+        Ok(buffer)
+    }
+
+    pub fn data(&self) -> String {
+        self.data.borrow().to_string()
+    }
+
+    pub fn save(&mut self) -> io::Result<()> {
+        let mut file = if let Some(ref path) = self.path {
+            File::create(path)?
+        } else {
+            File::create(PathBuf::new())?
+        };
+
+        file.write_all(self.data().to_string().as_bytes())?;
+
+        self.history.mark();
+
+        Ok(())
+    }
+
+    pub fn file_name(&self) -> Option<String> {
+        self.path.as_ref().and_then(|p| {
+            p.file_name()
+                .and_then(|f| f.to_str().map(|s| s.to_string()))
+        })
+    }
+
+    pub fn undo(&mut self) {
+        // Look for an operation to undo. First, check if there's an open, non-empty
+        // operation group. If not, try taking the last operation from the buffer history.
+        let operation: Option<Box<dyn Operation>> = match self.operation_group.take() {
+            Some(group) => {
+                if group.is_empty() {
+                    self.history.previous()
+                } else {
+                    Some(Box::new(group))
+                }
+            }
+            None => self.history.previous(),
+        };
+
+        // If we found an eligible operation, reverse it.
+        if let Some(mut op) = operation {
+            op.reverse(self);
+        }
+    }
+
+    pub fn redo(&mut self) {
+        // Look for an operation to apply.
+        if let Some(mut op) = self.history.next() {
+            op.run(self);
+        }
+    }
+
+    pub fn read(&self, range: &Range) -> Option<String> {
+        self.data.borrow().read(range)
+    }
+
+    pub fn read_rest(&self, position: &Position) -> Option<String> {
+        self.data.borrow().read_rest(position)
+    }
+
+    pub fn search(&self, needle: &str) -> Vec<Position> {
+        let mut results = Vec::new();
+
+        for (line, data) in self.data().lines().enumerate() {
+            for (offset, _) in data.char_indices() {
+                let haystack = &data[offset..];
+
+                // Check haystack length before slicing it and comparing bytes with needle.
+                if haystack.len() >= needle.len()
+                    && needle.as_bytes() == &haystack.as_bytes()[..needle.len()]
+                {
+                    results.push(Position { line, offset });
+                }
+            }
+        }
+
+        results
+    }
+
+    pub fn modified(&self) -> bool {
+        !self.history.at_mark()
+    }
+
+    pub fn line_count(&self) -> usize {
+        self.data().chars().filter(|&c| c == '\n').count() + 1
+    }
+
+    pub fn reload(&mut self) -> io::Result<()> {
+        // Load content from disk.
+        let path = self.path.as_ref().ok_or(ErrorKind::NotFound)?;
+        let content = fs::read_to_string(path)?;
+
+        self.replace(content);
+
+        // We mark the history at points where the
+        // buffer is in sync with its file equivalent.
+        self.history.mark();
+
+        Ok(())
+    }
+
+    /// 文件拓展名
+    pub fn file_extension(&self) -> Option<String> {
+        self.path.as_ref().and_then(|p| {
+            p.extension().and_then(|e| {
+                if !e.is_empty() {
+                    return Some(e.to_string_lossy().into_owned());
+                }
+
+                None
+            })
+        })
+    }
+
+    pub fn id(&self) -> Result<usize> {
+        self.id
+            .ok_or_else(|| Error::from("Buffer ID doesn't exist"))
+    }
+}

src/buffer/operation/delete.rs

@@ -0,0 +1,81 @@
+use crate::buffer::{Buffer, Position, Range};
+
+use super::Operation;
+
+#[derive(Clone)]
+pub struct Delete {
+    content: Option<String>,
+    range: Range,
+}
+
+impl Operation for Delete {
+    fn run(&mut self, buffer: &mut crate::buffer::Buffer) {
+        self.content = buffer.data.borrow().read(&self.range);
+
+        buffer.data.borrow_mut().delete(&self.range);
+
+        if let Some(ref callback) = buffer.change_callback {
+            callback(self.range.start());
+        }
+    }
+
+    fn reverse(&mut self, buffer: &mut crate::buffer::Buffer) {
+        if let Some(ref content) = self.content {
+            buffer
+                .data
+                .borrow_mut()
+                .insert(content, &self.range.start());
+
+            // Run the change callback, if present.
+            if let Some(ref callback) = buffer.change_callback {
+                callback(self.range.start())
+            }
+        }
+    }
+
+    fn clone_operation(&self) -> Box<dyn Operation> {
+        Box::new(self.clone())
+    }
+}
+
+impl Delete {
+    /// Creates a new empty delete operation.
+    pub fn new(range: Range) -> Delete {
+        Delete {
+            content: None,
+            range,
+        }
+    }
+}
+
+impl Buffer {
+    // 删除当前cursor指向的字符
+    pub fn delete(&mut self) {
+        let mut end = Position {
+            line: self.cursor.line,
+            offset: self.cursor.offset + 1,
+        };
+
+        // 下一行的行首
+        if !self.data.borrow().in_bounds(&end) {
+            end.line += 1;
+            end.offset = 0;
+        }
+
+        let start = self.cursor.position;
+        self.delete_range(Range::new(start, end));
+    }
+
+    pub fn delete_range(&mut self, range: Range) {
+        // Build and run a delete operation.
+        let mut op = Delete::new(range);
+        op.run(self);
+
+        // Store the operation in the history
+        // object so that it can be undone.
+        match self.operation_group {
+            Some(ref mut group) => group.add(Box::new(op)),
+            None => self.history.add(Box::new(op)),
+        };
+    }
+}

src/buffer/operation/group.rs

@@ -0,0 +1,69 @@
+use crate::buffer::Buffer;
+
+use super::Operation;
+
+pub struct OperationGroup {
+    operations: Vec<Box<dyn Operation>>,
+}
+
+impl Operation for OperationGroup {
+    fn run(&mut self, buffer: &mut Buffer) {
+        for operation in &mut self.operations {
+            operation.run(buffer);
+        }
+    }
+
+    fn reverse(&mut self, buffer: &mut Buffer) {
+        for operation in &mut self.operations.iter_mut().rev() {
+            operation.reverse(buffer);
+        }
+    }
+
+    fn clone_operation(&self) -> Box<dyn Operation> {
+        Box::new(OperationGroup {
+            operations: self
+                .operations
+                .iter()
+                .map(|o| (*o).clone_operation())
+                .collect(),
+        })
+    }
+}
+
+impl OperationGroup {
+    pub fn new() -> OperationGroup {
+        OperationGroup {
+            operations: Vec::new(),
+        }
+    }
+
+    pub fn add(&mut self, operation: Box<dyn Operation>) {
+        self.operations.push(operation);
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.operations.is_empty()
+    }
+}
+
+impl Buffer {
+    // 开启一个操作组
+    pub fn start_operation_group(&mut self) {
+        // Create an operation group, if one doesn't already exist.
+        match self.operation_group {
+            Some(_) => (),
+            None => {
+                self.operation_group = Some(OperationGroup::new());
+            }
+        }
+    }
+
+    pub fn end_operation_group(&mut self) {
+        // Push an open operation group on to the history stack, if one exists.
+        if let Some(group) = self.operation_group.take() {
+            if !group.is_empty() {
+                self.history.add(Box::new(group))
+            }
+        }
+    }
+}

src/buffer/operation/history.rs

@@ -0,0 +1,69 @@
+use super::Operation;
+
+pub struct History {
+    previous: Vec<Box<dyn Operation>>,
+    next: Vec<Box<dyn Operation>>,
+    marked_position: Option<usize>,
+}
+
+impl History {
+    /// Creates a new empty operation history.
+    pub fn new() -> History {
+        History {
+            previous: Vec::new(),
+            next: Vec::new(),
+            marked_position: None,
+        }
+    }
+
+    /// Store an operation that has already been run.
+    pub fn add(&mut self, operation: Box<dyn Operation>) {
+        self.previous.push(operation);
+        self.next.clear();
+
+        // Clear marked position if we've replaced a prior operation.
+        if let Some(position) = self.marked_position {
+            if position >= self.previous.len() {
+                self.marked_position = None
+            }
+        }
+    }
+
+    /// Navigate the history backwards.
+    pub fn previous(&mut self) -> Option<Box<dyn Operation>> {
+        match self.previous.pop() {
+            Some(operation) => {
+                // We've found a previous operation. Before we return it, store a
+                // clone of it so that it can be re-applied as a redo operation.
+                self.next.push(operation.clone_operation());
+                Some(operation)
+            }
+            None => None,
+        }
+    }
+
+    /// Navigate the history forwards.
+    pub fn next(&mut self) -> Option<Box<dyn Operation>> {
+        match self.next.pop() {
+            Some(operation) => {
+                // We've found a subsequent operation. Before we return it, store a
+                // clone of it so that it can be re-applied as an undo operation, again.
+                self.previous.push(operation.clone_operation());
+                Some(operation)
+            }
+            None => None,
+        }
+    }
+
+    pub fn mark(&mut self) {
+        self.marked_position = Some(self.previous.len())
+    }
+
+    pub fn at_mark(&self) -> bool {
+        if let Some(position) = self.marked_position {
+            self.previous.len() == position
+        } else {
+            false
+        }
+    }
+}

src/buffer/operation/insert.rs

@@ -0,0 +1,99 @@
+use unicode_segmentation::UnicodeSegmentation;
+
+use crate::buffer::{Buffer, Position, Range};
+
+use super::Operation;
+
+#[derive(Clone)]
+pub struct Insert {
+    content: String,
+    position: Position,
+}
+
+impl Operation for Insert {
+    fn run(&mut self, buffer: &mut Buffer) {
+        buffer
+            .data
+            .borrow_mut()
+            .insert(&self.content, &self.position);
+
+        // Run the change callback, if present.
+        if let Some(ref callback) = buffer.change_callback {
+            callback(self.position)
+        }
+    }
+
+    fn reverse(&mut self, buffer: &mut Buffer) {
+        // The line count of the content tells us the line number for the end of the
+        // range (just add the number of new lines to the starting line).
+        let line_count = self.content.chars().filter(|&c| c == '\n').count() + 1;
+        let end_line = self.position.line + line_count - 1;
+
+        let end_offset = if line_count == 1 {
+            // If there's only one line, the range starts and ends on the same line, and so its
+            // offset needs to take the original insertion location into consideration.
+            self.position.offset + self.content.graphemes(true).count()
+        } else {
+            // If there are multiple lines, the end of the range doesn't
+            // need to consider the original insertion location.
+            match self.content.split('\n').last() {
+                Some(line) => line.graphemes(true).count(),
+                None => return,
+            }
+        };
+
+        // Now that we have the required info,
+        // build the end position and total range.
+        let end_position = Position {
+            line: end_line,
+            offset: end_offset,
+        };
+        let range = Range::new(self.position, end_position);
+
+        // Remove the content we'd previously inserted.
+        buffer.data.borrow_mut().delete(&range);
+
+        // Run the change callback, if present.
+        if let Some(ref callback) = buffer.change_callback {
+            callback(self.position)
+        }
+    }
+
+    fn clone_operation(&self) -> Box<dyn Operation> {
+        Box::new(self.clone())
+    }
+}
+
+impl Insert {
+    /// Creates a new empty insert operation.
+    pub fn new(content: String, position: Position) -> Insert {
+        Insert { content, position }
+    }
+}
+
+impl Buffer {
+    /// Inserts `data` into the buffer at the cursor position.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use scribe::Buffer;
+    ///
+    /// let mut buffer = Buffer::new();
+    /// buffer.insert("scribe");
+    /// assert_eq!(buffer.data(), "scribe");
+    /// ```
+    pub fn insert<T: Into<String>>(&mut self, data: T) {
+        // Build and run an insert operation.
+        let mut op = Insert::new(data.into(), self.cursor.position);
+
+        op.run(self);
+
+        // Store the operation in the history
+        // object so that it can be undone.
+        match self.operation_group {
+            Some(ref mut group) => group.add(Box::new(op)),
+            None => self.history.add(Box::new(op)),
+        };
+    }
+}

src/buffer/operation/mod.rs

@@ -0,0 +1,14 @@
+pub use self::group::OperationGroup;
+use crate::buffer::Buffer;
+
+mod delete;
+pub mod group;
+pub mod history;
+mod insert;
+mod replace;
+
+pub trait Operation {
+    fn run(&mut self, buffer: &mut Buffer);
+    fn reverse(&mut self, buffer: &mut Buffer);
+    fn clone_operation(&self) -> Box<dyn Operation>;
+}

src/buffer/operation/replace.rs

@@ -0,0 +1,135 @@
+use std::{cell::RefCell, rc::Rc};
+
+use crate::buffer::{cursor::Cursor, Buffer, GapBuffer, Position};
+
+use super::Operation;
+
+#[derive(Clone)]
+pub struct Replace {
+    old_content: String,
+    new_content: String,
+}
+
+impl Operation for Replace {
+    fn run(&mut self, buffer: &mut Buffer) {
+        replace_content(self.new_content.clone(), buffer);
+    }
+
+    fn reverse(&mut self, buffer: &mut Buffer) {
+        replace_content(self.old_content.clone(), buffer);
+    }
+
+    fn clone_operation(&self) -> Box<dyn Operation> {
+        Box::new(self.clone())
+    }
+}
+
+impl Replace {
+    /// Creates a new empty insert operation.
+    pub fn new(old_content: String, new_content: String) -> Replace {
+        Replace {
+            old_content,
+            new_content,
+        }
+    }
+}
+
+impl Buffer {
+    /// Replaces the buffer's contents with the provided data. This method will
+    /// make best efforts to retain the full cursor position, then cursor line,
+    /// and will ultimately fall back to resetting the cursor to its initial
+    /// (0,0) position if these fail. The buffer's ID, syntax definition, and
+    /// change callback are always persisted.
+    ///
+    /// <div class="warning">
+    ///   As this is a reversible operation, both the before and after buffer
+    ///   contents are kept in-memory, which for large buffers may be relatively
+    ///   expensive. To help avoid needless replacements, this method will
+    ///   ignore requests that don't actually change content. Despite this, use
+    ///   this operation judiciously; it is designed for wholesale replacements
+    ///   (e.g. external formatting tools) that cannot be broken down into
+    ///   selective delete/insert operations.
+    /// </div>
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use scribe::buffer::{Buffer, Position};
+    ///
+    /// let mut buffer = Buffer::new();
+    /// buffer.insert("scribe\nlibrary\n");
+    /// buffer.cursor.move_to(Position { line: 1, offset: 1 });
+    /// buffer.replace("new\ncontent");
+    ///
+    /// assert_eq!(buffer.data(), "new\ncontent");
+    /// assert_eq!(*buffer.cursor, Position{ line: 1, offset: 1 });
+    /// ```
+    pub fn replace<T: Into<String> + AsRef<str>>(&mut self, content: T) {
+        let old_content = self.data();
+
+        // Ignore replacements that don't change content.
+        if content.as_ref() == old_content {
+            return;
+        }
+
+        // Build and run an insert operation.
+        let mut op = Replace::new(self.data(), content.into());
+        op.run(self);
+
+        // Store the operation in the history object so that it can be undone.
+        match self.operation_group {
+            Some(ref mut group) => group.add(Box::new(op)),
+            None => self.history.add(Box::new(op)),
+        };
+    }
+
+    pub fn replace_on_cursor<T: Into<String> + AsRef<str>>(&mut self, content: T) {
+        let old_content = self.data();
+        let offset = self.cursor.offset;
+        let line_number = self.cursor.line;
+        let lines: Vec<&str> = old_content.lines().collect();
+        let mut new_content = old_content.clone();
+
+        // 计算目标行的起始和结束位置
+        let mut line_start = 0;
+        let mut line_count = 0;
+
+        for (_, line) in lines.iter().enumerate() {
+            if line_count == line_number {
+                let line_end = line_start + offset;
+                if new_content.remove(line_end) == '\n' {
+                    new_content.insert(line_end, '\n');
+                }
+                new_content.insert_str(line_end, &content.into());
+                break;
+            }
+            line_start += line.len() + 1; // +1 是为了加上换行符的长度
+            line_count += 1;
+        }
+
+        self.replace(new_content);
+    }
+}
+
+fn replace_content(content: String, buffer: &mut Buffer) {
+    // Create a new gap buffer and associated cursor with the new content.
+    let data = Rc::new(RefCell::new(GapBuffer::new(content)));
+    let mut cursor = Cursor::new(data.clone(), Position { line: 0, offset: 0 });
+
+    // Try to retain cursor position or line of the current gap buffer.
+    if !cursor.move_to(*buffer.cursor) {
+        cursor.move_to(Position {
+            line: buffer.cursor.line,
+            offset: 0,
+        });
+    }
+
+    // Do the replacement.
+    buffer.data = data;
+    buffer.cursor = cursor;
+
+    // Run the change callback, if present.
+    if let Some(ref callback) = buffer.change_callback {
+        callback(Position::default())
+    }
+}

src/config/lastline_cmd.rs

@@ -6,7 +6,7 @@ use crate::utils::{
     buffer::LineState,
     ui::{
         event::WarpUiCallBackType,
-        uicore::{UiCore, APP_INFO, CONTENT_WINSIZE},
+        uicore::{UiCore, APP_INTERNAL_INFOMATION, CONTENT_WINSIZE},
         InfoLevel,
     },
 };
@@ -63,7 +63,7 @@ impl LastLineCommand {
 
             ret
         } else {
-            let mut info = APP_INFO.lock().unwrap();
+            let mut info = APP_INTERNAL_INFOMATION.lock().unwrap();
             info.level = InfoLevel::Info;
             info.info = NOT_FOUNT_CMD.to_string();
             return WarpUiCallBackType::None;
@@ -82,7 +82,7 @@ impl LastLineCommand {
         if ui.edited() {
             // 编辑过但不保存？
             // 更新警示信息
-            let mut info = APP_INFO.lock().unwrap();
+            let mut info = APP_INTERNAL_INFOMATION.lock().unwrap();
             info.level = InfoLevel::Warn;
             info.info = EDITED_NO_STORE.to_string();
             return WarpUiCallBackType::None;
@@ -96,7 +96,7 @@ impl LastLineCommand {
 
     fn goto(ui: &mut MutexGuard<UiCore>, args: &str) -> WarpUiCallBackType {
         if args.is_empty() {
-            let mut info = APP_INFO.lock().unwrap();
+            let mut info = APP_INTERNAL_INFOMATION.lock().unwrap();
             info.level = InfoLevel::Info;
             info.info = "Useage: {goto}|{gt} {row}{' '|','|';'|':'|'/'}{col}".to_string();
             return WarpUiCallBackType::None;
@@ -112,7 +112,7 @@ impl LastLineCommand {
         };
 
         if y.is_err() {
-            let mut info = APP_INFO.lock().unwrap();
+            let mut info = APP_INTERNAL_INFOMATION.lock().unwrap();
             info.level = InfoLevel::Info;
             info.info = "Useage: goto {row}({' '|','|';'|':'|'/'}{col})".to_string();
             return WarpUiCallBackType::None;
@@ -170,7 +170,7 @@ impl LastLineCommand {
         for s in args {
             let line = usize::from_str_radix(s, 10);
             if line.is_err() {
-                APP_INFO.lock().unwrap().info = format!("\"{s}\" is not a number");
+                APP_INTERNAL_INFOMATION.lock().unwrap().info = format!("\"{s}\" is not a number");
                 return WarpUiCallBackType::None;
             }
 
@@ -196,7 +196,8 @@ impl LastLineCommand {
                 for arg in args {
                     let line = usize::from_str_radix(arg, 10);
                     if line.is_err() {
-                        APP_INFO.lock().unwrap().info = format!("\"{arg}\" is not a number");
+                        APP_INTERNAL_INFOMATION.lock().unwrap().info =
+                            format!("\"{arg}\" is not a number");
                         return WarpUiCallBackType::None;
                     }
 
@@ -224,7 +225,8 @@ impl LastLineCommand {
                 for arg in args {
                     let line = usize::from_str_radix(arg, 10);
                     if line.is_err() {
-                        APP_INFO.lock().unwrap().info = format!("\"{arg}\" is not a number");
+                        APP_INTERNAL_INFOMATION.lock().unwrap().info =
+                            format!("\"{arg}\" is not a number");
                         return WarpUiCallBackType::None;
                     }
 
@@ -252,7 +254,8 @@ impl LastLineCommand {
                 for arg in args {
                     let line = usize::from_str_radix(arg, 10);
                     if line.is_err() {
-                        APP_INFO.lock().unwrap().info = format!("\"{arg}\" is not a number");
+                        APP_INTERNAL_INFOMATION.lock().unwrap().info =
+                            format!("\"{arg}\" is not a number");
                         return WarpUiCallBackType::None;
                     }
 
@@ -273,7 +276,8 @@ impl LastLineCommand {
                 let offset = ui.buffer.offset() + ui.cursor.y() as usize;
                 let count = ui.buffer.delete_lines(offset, offset + 1);
                 if count != 0 {
-                    APP_INFO.lock().unwrap().info = format!("Successfully deleted {count} row");
+                    APP_INTERNAL_INFOMATION.lock().unwrap().info =
+                        format!("Successfully deleted {count} row");
                 }
                 ui.render_content(0, CONTENT_WINSIZE.read().unwrap().rows as usize)
                     .unwrap();
@@ -282,7 +286,8 @@ impl LastLineCommand {
             1 => {
                 let line = usize::from_str_radix(args[0], 10);
                 if line.is_err() {
-                    APP_INFO.lock().unwrap().info = format!("\"{}\" is not a number", args[0]);
+                    APP_INTERNAL_INFOMATION.lock().unwrap().info =
+                        format!("\"{}\" is not a number", args[0]);
                     return WarpUiCallBackType::None;
                 }
 
@@ -291,7 +296,8 @@ impl LastLineCommand {
                 let offset = ui.buffer.offset() + line;
                 let count = ui.buffer.delete_lines(offset, offset + 1);
                 if count != 0 {
-                    APP_INFO.lock().unwrap().info = format!("Successfully deleted {count} row");
+                    APP_INTERNAL_INFOMATION.lock().unwrap().info =
+                        format!("Successfully deleted {count} row");
                 }
                 ui.render_content(0, CONTENT_WINSIZE.read().unwrap().rows as usize)
                     .unwrap();
@@ -302,14 +308,15 @@ impl LastLineCommand {
                 let end = usize::from_str_radix(args[1], 10);
 
                 if start.is_err() || end.is_err() {
-                    APP_INFO.lock().unwrap().info =
+                    APP_INTERNAL_INFOMATION.lock().unwrap().info =
                         "Useage: (dl)|(delete) {start}({'-'}{end})".to_string();
                     return WarpUiCallBackType::None;
                 }
 
                 let count = ui.buffer.delete_lines(start.unwrap() - 1, end.unwrap() - 1);
                 if count != 0 {
-                    APP_INFO.lock().unwrap().info = format!("Successfully deleted {count} row");
+                    APP_INTERNAL_INFOMATION.lock().unwrap().info =
+                        format!("Successfully deleted {count} row");
                 }
 
                 ui.render_content(0, CONTENT_WINSIZE.read().unwrap().rows as usize)

src/errors.rs

@@ -0,0 +1,40 @@
+use error_chain::error_chain;
+
+impl Default for Error {
+    fn default() -> Self {
+        Self(ErrorKind::Unreachable, Default::default())
+    }
+}
+
+error_chain! {
+    errors {
+        EmptyWorkspace {
+            description("the workspace is empty")
+            display("the workspace is empty")
+        }
+        MissingPath {
+            description("buffer doesn't have a path")
+            display("buffer doesn't have a path")
+        }
+        MissingScope {
+            description("couldn't find any scopes at the cursor position")
+            display("couldn't find any scopes at the cursor position")
+        }
+        MissingSyntax {
+            description("no syntax definition for the current buffer")
+            display("no syntax definition for the current buffer")
+        }
+        Unreachable {
+            description("Unreachable error")
+            display("Unreachable error")
+        }
+    }
+
+    foreign_links {
+        Io(std::io::Error) #[cfg(unix)];
+        ParsingError(syntect::parsing::ParsingError);
+        ScopeError(syntect::parsing::ScopeError);
+        SyntaxLoadingError(syntect::LoadingError);
+        DlopenError(dlopen2::Error);
+    }
+}

src/main.rs

@@ -1,19 +1,37 @@
-use std::{fs::File, io};
+#![feature(duration_millis_float)]
 
-use app::Application;
+use std::{env, fs::File};
+
+use application::Application;
 use clap::Parser;
 use config::{appconfig::DeserializeAppOption, cmd::CmdConfig};
 use utils::log_util::Log;
 
-mod app;
+mod application;
+mod buffer;
 mod config;
+mod errors;
+mod modules;
+mod plugin;
+mod util;
 mod utils;
+mod view;
+mod workspace;
 
 #[macro_use]
 extern crate log;
 extern crate simplelog;
 
-fn main() -> io::Result<()> {
+use crate::errors::*;
+
+pub static mut APPLICATION: Option<Application> = None;
+
+pub fn get_application() -> &'static mut Application {
+    unsafe { APPLICATION.as_mut().unwrap() }
+}
+
+fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
     let config = CmdConfig::parse();
     Log::init(config.level)?;
 
@@ -26,5 +44,11 @@ fn main() -> io::Result<()> {
         setting = serde_yaml::from_reader::<File, DeserializeAppOption>(file?).unwrap_or_default();
     }
 
-    Application::new(config.file, setting.to_app_setting())?.run()
+    let application = Application::new(config.file, setting.to_app_setting(), &args)?;
+
+    unsafe {
+        APPLICATION = Some(application);
+    }
+
+    get_application().run()
 }

src/modules/input/default.yaml

@@ -0,0 +1,116 @@
+normal:
+  left: cursor::move_left
+  right: cursor::move_right
+  up: cursor::move_up
+  down: cursor::move_down
+  ctrl-c: app::exit
+  i: app::to_insert_mode
+  ':': app::to_command_mode
+  a: 
+    - app::to_insert_mode
+    - cursor::move_right
+  shift-A: 
+    - app::to_insert_mode
+    - cursor::move_to_end_of_line
+  shift-I: 
+    - app::to_insert_mode
+    - cursor::move_to_start_of_line
+  backspace: cursor::move_left
+  escape: normal::reset
+  shift-L: cursor::move_to_end_of_line
+  shift-H: cursor::move_to_start_of_line
+  shift-T: monitor::scroll_to_first_line
+  shift-B: monitor::scroll_to_last_line
+  shift-G: normal::move_to_target_line
+  shift-O: 
+    - cursor::move_to_start_of_line
+    - buffer::new_line
+  o: 
+    - cursor::move_to_end_of_line
+    - buffer::new_line
+    - cursor::move_down
+  j: normal::move_down_n
+  k: normal::move_up_n
+  h: normal::move_left_n
+  l: normal::move_right_n
+  d: app::to_delete_mode
+  w: app::to_workspace_mode
+  /: app::to_search_mode
+  n: normal::move_to_next_words
+  b: normal::move_to_prev_words
+  e: normal::move_to_next_words_end
+  u: buffer::undo
+  ctrl-r: buffer::redo
+  num: normal::count_cmd
+  shift-R: app::to_replace_mode
+insert:
+  escape: app::to_normal_mode
+  left: cursor::move_left
+  right: cursor::move_right
+  up: cursor::move_up
+  down: cursor::move_down
+  ctrl-c: app::exit
+  ctrl-s: buffer::save_file
+  ctrl-z: buffer::undo
+  enter: 
+    - buffer::new_line
+    - cursor::move_down
+    - cursor::move_to_start_of_line
+  backspace: insert::backspace
+  tab: buffer::insert_tab
+  _: 
+    - buffer::insert_char
+command:
+  escape: command::to_normal_mode
+  backspace: command::backspace
+  enter: command::commit_and_execute
+  _:
+    - command::insert_command
+
+workspace:
+  up: workspace::move_up
+  down: workspace::move_down
+  enter: workspace::enter
+  escape: workspace::to_normal_mode
+  ctrl-c: app::exit
+search:
+  /:
+  - search::clear 
+  - app::to_search_mode
+  backspace: search::backspace
+  escape: 
+  - search::clear
+  - app::to_normal_mode
+  enter: search::exec_search
+  up: search::last_result
+  down: search::next_result
+  ctrl-c: app::exit
+  _:  search::input_search_data
+delete:
+  ctrl-c: app::exit
+  escape: app::to_normal_mode
+  w: 
+    - delete::delete_words
+    - app::to_normal_mode
+  d: 
+    - delete::delete_lines
+    - cursor::move_to_start_of_line
+    - app::to_normal_mode
+
+replace:
+  escape: app::to_normal_mode
+  left: cursor::move_left
+  right: cursor::move_right
+  up: cursor::move_up
+  down: cursor::move_down
+  ctrl-c: app::exit
+  ctrl-s: buffer::save_file
+  ctrl-z: buffer::undo
+  enter: 
+    - buffer::new_line
+    - cursor::move_down
+    - cursor::move_to_start_of_line
+  backspace: insert::backspace
+  tab: buffer::insert_tab
+  _: 
+    - buffer::insert_char_on_replace

src/modules/input/mod.rs

@@ -0,0 +1,168 @@
+use std::{collections::HashMap, ffi::OsStr, fs::read_to_string, path::PathBuf};
+
+use crate::{
+    application::{mode::ModeKey, Application},
+    errors::*,
+};
+use crossterm::event::{Event, KeyEvent, KeyEventKind, KeyModifiers};
+use linked_hash_map::LinkedHashMap;
+
+use smallvec::SmallVec;
+use strum::IntoEnumIterator;
+use yaml_rust::{Yaml, YamlLoader};
+
+const INPUT_CONFIG_NAME: &str = "input.yaml";
+pub struct InputLoader;
+
+impl InputLoader {
+    pub fn load(
+        path: PathBuf,
+    ) -> Result<HashMap<String, HashMap<String, SmallVec<[fn(&mut Application) -> Result<()>; 4]>>>>
+    {
+        #[cfg(not(feature = "dragonos"))]
+        let data = Self::load_user(path)?;
+        #[cfg(feature = "dragonos")]
+        let data = None;
+        let default = Self::load_default()?;
+        let handle_map = Self::generate_handle_map(
+            data,
+            default
+                .as_hash()
+                .ok_or_else(|| "default input config didn't return a hash of key bindings")?,
+        )?;
+        Ok(handle_map)
+    }
+
+    fn generate_handle_map(
+        extra_data: Option<LinkedHashMap<Yaml, Yaml>>,
+        default: &LinkedHashMap<Yaml, Yaml>,
+    ) -> Result<HashMap<String, HashMap<String, SmallVec<[fn(&mut Application) -> Result<()>; 4]>>>>
+    {
+        let mut handle_map = HashMap::new();
+        for mode_key in ModeKey::iter() {
+            mode_key.generate_handle_map(&mut handle_map, extra_data.as_ref(), default)?;
+        }
+        Ok(handle_map)
+    }
+
+    fn load_user(path: PathBuf) -> Result<Option<LinkedHashMap<Yaml, Yaml>>> {
+        let readdir = path.read_dir()?;
+        let mut entries = readdir
+            .filter_map(|f| f.ok())
+            .map(|f| f.path())
+            .filter(|f| f.is_file())
+            .filter(|f| {
+                f.file_name().is_some() && f.file_name().unwrap() == OsStr::new(INPUT_CONFIG_NAME)
+            });
+
+        let entry = entries.next();
+        if let Some(entry) = entry {
+            let yaml = YamlLoader::load_from_str(&read_to_string(entry.clone())?)
+                .chain_err(|| format!("Couldn't parse input config file: {:?}", entry))?
+                .into_iter()
+                .next()
+                .chain_err(|| "No input document found")?;
+            let yaml_hash = yaml
+                .as_hash()
+                .ok_or_else(|| "extra input config didn't return a hash of key bindings")?;
+
+            return Ok(Some(yaml_hash.clone()));
+        }
+
+        Ok(None)
+    }
+
+    fn load_default() -> Result<Yaml> {
+        YamlLoader::load_from_str(include_str!("default.yaml"))
+            .chain_err(|| "Couldn't parse default input config file")?
+            .into_iter()
+            .next()
+            .chain_err(|| "No default input document found")
+    }
+}
+
+pub struct InputMapper;
+
+impl InputMapper {
+    pub fn event_map_str(event: Event) -> Option<String> {
+        match event {
+            Event::FocusGained => None,
+            Event::FocusLost => None,
+            Event::Key(key_event) => {
+                return Some(Self::key_event_map_str(key_event));
+            }
+            Event::Mouse(_) => None,
+            Event::Paste(_) => None,
+            Event::Resize(_, _) => None,
+        }
+    }
+
+    fn key_event_map_str(event: KeyEvent) -> String {
+        if let KeyEventKind::Press = event.kind {
+            let mut modifier = String::new();
+            if event.modifiers.contains(KeyModifiers::CONTROL) {
+                modifier.push_str("ctrl-");
+            }
+            if event.modifiers.contains(KeyModifiers::ALT) {
+                modifier.push_str("alt-");
+            }
+            if event.modifiers.contains(KeyModifiers::SHIFT) {
+                modifier.push_str("shift-");
+            }
+            let keycode_str = match event.code {
+                crossterm::event::KeyCode::Backspace => "backspace".into(),
+                crossterm::event::KeyCode::Enter => "enter".into(),
+                crossterm::event::KeyCode::Left => "left".into(),
+                crossterm::event::KeyCode::Right => "right".into(),
+                crossterm::event::KeyCode::Up => "up".into(),
+                crossterm::event::KeyCode::Down => "down".into(),
+                crossterm::event::KeyCode::Home => "home".into(),
+                crossterm::event::KeyCode::End => "end".into(),
+                crossterm::event::KeyCode::PageUp => "pageup".into(),
+                crossterm::event::KeyCode::PageDown => "pagedown".into(),
+                crossterm::event::KeyCode::Tab => "tab".into(),
+                crossterm::event::KeyCode::BackTab => "backtab".into(),
+                crossterm::event::KeyCode::Delete => "delete".into(),
+                crossterm::event::KeyCode::Insert => "insert".into(),
+                crossterm::event::KeyCode::F(f) => format!("f{f}"),
+                crossterm::event::KeyCode::Char(c) => {
+                    if c.is_digit(10) {
+                        "num".to_string()
+                    } else {
+                        c.into()
+                    }
+                }
+                crossterm::event::KeyCode::Null => "".into(),
+                crossterm::event::KeyCode::Esc => "escape".into(),
+                crossterm::event::KeyCode::CapsLock => "caps_lock".into(),
+                crossterm::event::KeyCode::ScrollLock => "scroll_lock".into(),
+                crossterm::event::KeyCode::NumLock => "num_lock".into(),
+                crossterm::event::KeyCode::PrintScreen => "print_screen".into(),
+                crossterm::event::KeyCode::Pause => "pause".into(),
+                crossterm::event::KeyCode::Menu => "menu".into(),
+                crossterm::event::KeyCode::KeypadBegin => "keypad_begin".into(),
+                crossterm::event::KeyCode::Media(_) => "".into(),
+                crossterm::event::KeyCode::Modifier(modifier_key_code) => match modifier_key_code {
+                    crossterm::event::ModifierKeyCode::LeftShift
+                    | crossterm::event::ModifierKeyCode::IsoLevel3Shift
+                    | crossterm::event::ModifierKeyCode::IsoLevel5Shift
+                    | crossterm::event::ModifierKeyCode::RightShift => "shift".into(),
+                    crossterm::event::ModifierKeyCode::LeftControl
+                    | crossterm::event::ModifierKeyCode::RightControl => "ctrl".into(),
+                    crossterm::event::ModifierKeyCode::LeftAlt
+                    | crossterm::event::ModifierKeyCode::RightAlt => "alt".into(),
+                    crossterm::event::ModifierKeyCode::RightSuper
+                    | crossterm::event::ModifierKeyCode::LeftSuper => "super".into(),
+                    crossterm::event::ModifierKeyCode::RightHyper
+                    | crossterm::event::ModifierKeyCode::LeftHyper => "hyper".into(),
+                    crossterm::event::ModifierKeyCode::RightMeta
+                    | crossterm::event::ModifierKeyCode::LeftMeta => "meta".into(),
+                },
+            };
+
+            format!("{}{}", modifier, keycode_str)
+        } else {
+            "".into()
+        }
+    }
+}

src/modules/mod.rs

@@ -0,0 +1,8 @@
+use app_dirs2::AppInfo;
+
+pub mod input;
+pub mod perferences;
+const APP_INFO: AppInfo = AppInfo {
+    name: "held",
+    author: "DragonOS Community",
+};

src/modules/perferences/default.yaml

@@ -0,0 +1,2 @@
+soft_tab: true
+tab_width: 4

src/modules/perferences/mod.rs

@@ -0,0 +1,145 @@
+use crate::{errors::*, utils::ui::uicore::APP_INTERNAL_INFOMATION};
+use app_dirs2::{app_dir, AppDataType, AppInfo};
+use std::{
+    cell::RefCell,
+    path::{Path, PathBuf},
+    rc::Rc,
+};
+use yaml::YamlPerferences;
+use yaml_rust::{Yaml, YamlLoader};
+
+use super::APP_INFO;
+
+pub mod yaml;
+
+const SYNTAX_PATH: &str = "syntaxes";
+const THEME_PATH: &str = "themes";
+const INPUT_CONFIG_PATH: &str = "input";
+const PLUGINS_PATH: &str = "plugins";
+const THEME_KET: &str = "theme";
+const LANGUAGE_KEY: &str = "language";
+const LANGUAGE_SYNTAX_KEY: &str = "syntax";
+const LINE_WRAPPING_KEY: &str = "line_wrapping";
+const SOFT_TAB_KEY: &str = "soft_tab";
+const TAB_WIDTH_KEY: &str = "tab_width";
+
+pub trait Perferences {
+    /// 载入
+    fn load(&mut self);
+
+    /// 是否自动换行
+    fn line_wrapping(&self) -> bool;
+
+    // tab宽度
+    fn tab_width(&self) -> usize;
+
+    // 是否使用空格模拟tab
+    fn soft_tab(&self) -> bool;
+
+    // 设置的主题文件路径
+    fn theme_path(&self) -> Result<PathBuf> {
+        #[cfg(not(feature = "dragonos"))]
+        {
+            app_dir(AppDataType::UserConfig, &APP_INFO, THEME_PATH)
+                .chain_err(|| "Couldn't create a themes directory or build a path tp it")
+        }
+        #[cfg(feature = "dragonos")]
+        Ok(PathBuf::new())
+    }
+
+    // 输入映射配置文件路径
+    fn input_config_path(&self) -> Result<PathBuf> {
+        #[cfg(not(feature = "dragonos"))]
+        {
+            app_dir(AppDataType::UserConfig, &APP_INFO, INPUT_CONFIG_PATH)
+                .chain_err(|| "Couldn't create a themes directory or build a path tp it")
+        }
+        #[cfg(feature = "dragonos")]
+        Ok(PathBuf::new())
+    }
+
+    // 插件路径
+    fn plugins_path(&self) -> Result<PathBuf> {
+        #[cfg(not(feature = "dragonos"))]
+        {
+            app_dir(AppDataType::UserConfig, &APP_INFO, PLUGINS_PATH)
+                .chain_err(|| "Couldn't create a themes directory or build a path tp it")
+        }
+        #[cfg(feature = "dragonos")]
+        Ok(PathBuf::new())
+    }
+
+    // 设置的主题名字
+    fn theme_name(&self) -> Option<String>;
+
+    // 返回设置的语法定义：例：test.rs -> rs test.cpp -> cpp
+    fn syntax_definition_name(&self, path: &Path) -> Option<String>;
+}
+
+pub struct PerferencesManager;
+
+impl PerferencesManager {
+    pub fn load() -> Result<Rc<RefCell<dyn Perferences>>> {
+        match Self::load_extend()? {
+            Some(_) => todo!(),
+            None => return Ok(Rc::new(RefCell::new(Self::load_default_perferences()?))),
+        }
+    }
+
+    pub fn user_syntax_path() -> Result<PathBuf> {
+        app_dir(AppDataType::UserConfig, &APP_INFO, SYNTAX_PATH)
+            .chain_err(|| "Couldn't create syntax directory or build a path to it.")
+    }
+
+    fn load_default_perferences() -> Result<YamlPerferences> {
+        let yaml = YamlLoader::load_from_str(include_str!("default.yaml"))
+            .chain_err(|| "Couldn't parse default config file")?
+            .into_iter()
+            .next()
+            .chain_err(|| "No default preferences document found")?;
+
+        Ok(YamlPerferences::new(yaml))
+    }
+
+    fn load_extend() -> Result<Option<Rc<RefCell<dyn Perferences>>>> {
+        // 可能涉及加载其他格式的配置文件
+        Ok(None)
+    }
+}
+
+#[cfg(test)]
+pub struct DummyPerferences;
+#[cfg(test)]
+impl Perferences for DummyPerferences {
+    fn line_wrapping(&self) -> bool {
+        true
+    }
+
+    fn tab_width(&self) -> usize {
+        2
+    }
+
+    fn soft_tab(&self) -> bool {
+        true
+    }
+
+    fn theme_path(&self) -> Result<PathBuf> {
+        todo!()
+    }
+
+    fn theme_name(&self) -> Option<String> {
+        todo!()
+    }
+
+    fn load(&mut self) {
+        todo!()
+    }
+
+    fn syntax_definition_name(&self, path: &Path) -> Option<String> {
+        todo!()
+    }
+
+    fn input_config_path(&self) -> Result<PathBuf> {
+        todo!()
+    }
+}

src/modules/perferences/yaml.rs

@@ -0,0 +1,55 @@
+use std::path::PathBuf;
+
+use super::{
+    Perferences, APP_INFO, LINE_WRAPPING_KEY, SOFT_TAB_KEY, TAB_WIDTH_KEY, THEME_KET, THEME_PATH,
+};
+use crate::{
+    errors::*,
+    modules::perferences::{LANGUAGE_KEY, LANGUAGE_SYNTAX_KEY, SYNTAX_PATH},
+};
+use app_dirs2::{app_dir, AppDataType};
+use yaml_rust::Yaml;
+
+pub struct YamlPerferences {
+    data: Yaml,
+}
+
+impl YamlPerferences {
+    pub fn new(yaml: Yaml) -> YamlPerferences {
+        YamlPerferences { data: yaml }
+    }
+}
+
+impl Perferences for YamlPerferences {
+    fn load(&mut self) {
+        todo!()
+    }
+
+    fn line_wrapping(&self) -> bool {
+        self.data[LINE_WRAPPING_KEY].as_bool().unwrap_or(true)
+    }
+
+    fn tab_width(&self) -> usize {
+        self.data[TAB_WIDTH_KEY].as_i64().unwrap_or(4) as usize
+    }
+
+    fn soft_tab(&self) -> bool {
+        self.data[SOFT_TAB_KEY].as_bool().unwrap_or(true)
+    }
+
+    fn theme_name(&self) -> Option<String> {
+        self.data[THEME_KET].as_str().map(|x| x.to_owned())
+    }
+
+    fn syntax_definition_name(&self, path: &std::path::Path) -> Option<String> {
+        if let Some(extension) = path.extension().and_then(|f| f.to_str()) {
+            if let Some(syntax_definition) =
+                self.data[LANGUAGE_KEY][extension][LANGUAGE_SYNTAX_KEY].as_str()
+            {
+                return Some(syntax_definition.to_string());
+            }
+        }
+
+        None
+    }
+}

src/plugin/mod.rs

@@ -0,0 +1,43 @@
+use dlopen2::wrapper::{Container, WrapperApi};
+use held_core::{
+    interface::ApplicationInterface, plugin::Plugin, view::render::ContentRenderBuffer,
+};
+
+pub mod system;
+
+#[derive(WrapperApi)]
+pub struct PluginApi {
+    plugin_create: unsafe fn() -> *mut dyn Plugin,
+    init_plugin_application: unsafe fn(app: &'static mut dyn ApplicationInterface),
+}
+
+#[allow(dead_code)]
+pub struct PluginInstance {
+    // 顺序不能反，需要确保plugin在container之前销毁
+    plugin: Box<dyn Plugin>,
+    container: Container<PluginApi>,
+}
+
+impl PluginInstance {
+    pub fn new(plugin: Box<dyn Plugin>, container: Container<PluginApi>) -> PluginInstance {
+        PluginInstance { plugin, container }
+    }
+}
+
+impl Plugin for PluginInstance {
+    fn name(&self) -> &'static str {
+        self.plugin.name()
+    }
+
+    fn init(&self) {
+        self.plugin.init()
+    }
+
+    fn deinit(&self) {
+        self.plugin.deinit()
+    }
+
+    fn on_render_content(&self) -> Vec<ContentRenderBuffer> {
+        self.plugin.on_render_content()
+    }
+}

src/plugin/system.rs

@@ -0,0 +1,82 @@
+use crate::{errors::*, get_application};
+use dlopen2::wrapper::Container;
+use held_core::{plugin::Plugin, view::render::ContentRenderBuffer};
+use std::{collections::HashMap, path::PathBuf, rc::Rc};
+use walkdir::WalkDir;
+
+use crate::plugin::PluginApi;
+
+use super::PluginInstance;
+
+pub struct PluginSystem {
+    plugins: HashMap<&'static str, Rc<PluginInstance>>,
+}
+
+unsafe impl Send for PluginSystem {}
+unsafe impl Sync for PluginSystem {}
+
+impl PluginSystem {
+    fn new() -> Self {
+        Self {
+            plugins: HashMap::new(),
+        }
+    }
+
+    pub fn init_system(pulgin_dir: PathBuf) -> PluginSystem {
+        let mut system = PluginSystem::new();
+        system.load_pulgins(pulgin_dir);
+        system
+    }
+
+    pub fn load_pulgins(&mut self, pulgin_dir: PathBuf) {
+        for entry in WalkDir::new(pulgin_dir) {
+            if let Ok(entry) = entry {
+                if entry.file_type().is_file() {
+                    let path = entry.into_path();
+                    if let Err(e) = unsafe { self.load_pulgin(&path) } {
+                        error!("load pulgin: {:?}, load error: {e:?}", path)
+                    }
+                }
+            }
+        }
+    }
+
+    pub unsafe fn load_pulgin(&mut self, pulgin_path: &PathBuf) -> Result<()> {
+        let container: Container<PluginApi> = Container::load(pulgin_path)?;
+        let plugin_raw = container.plugin_create();
+        let plugin = Box::from_raw(plugin_raw);
+        self.plugins.insert(
+            plugin.name(),
+            Rc::new(PluginInstance::new(plugin, container)),
+        );
+        Ok(())
+    }
+}
+
+impl Plugin for PluginSystem {
+    fn name(&self) -> &'static str {
+        ""
+    }
+
+    fn init(&self) {
+        for (_, plugin) in self.plugins.iter() {
+            unsafe { plugin.container.init_plugin_application(get_application()) };
+            plugin.init();
+        }
+    }
+
+    fn deinit(&self) {
+        for (_, plugin) in self.plugins.iter() {
+            plugin.deinit();
+        }
+    }
+
+    fn on_render_content(&self) -> Vec<ContentRenderBuffer> {
+        let mut ret = vec![];
+        for (_, plugin) in self.plugins.iter() {
+            ret.append(&mut plugin.on_render_content());
+        }
+
+        ret
+    }
+}

src/themes/solarized_dark.tmTheme

@@ -0,0 +1,2061 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>name</key>
+	<string>Solarized Dark</string>
+	<key>settings</key>
+	<array>
+		<dict>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#002B36</string>
+				<key>caret</key>
+				<string>#839496</string>
+				<key>foreground</key>
+				<string>#b2b2b2</string>
+				<key>invisibles</key>
+				<string>#073642</string>
+				<key>lineHighlight</key>
+				<string>#303030</string>
+				<key>selection</key>
+				<string>#EEE8D5</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Comment</string>
+			<key>scope</key>
+			<string>comment</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>String</string>
+			<key>scope</key>
+			<string>string</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>StringNumber</string>
+			<key>scope</key>
+			<string>string</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Regexp</string>
+			<key>scope</key>
+			<string>string.regexp</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Number</string>
+			<key>scope</key>
+			<string>constant.numeric</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#D33682</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Variable</string>
+			<key>scope</key>
+			<string>variable.language, variable.other</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Keyword</string>
+			<key>scope</key>
+			<string>keyword</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Storage</string>
+			<key>scope</key>
+			<string>storage</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Class name</string>
+			<key>scope</key>
+			<string>entity.name.class, entity.name.type.class</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Function name</string>
+			<key>scope</key>
+			<string>entity.name.function</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Variable start</string>
+			<key>scope</key>
+			<string>punctuation.definition.variable</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Embedded code markers</string>
+			<key>scope</key>
+			<string>punctuation.section.embedded.begin, punctuation.section.embedded.end</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Built-in constant</string>
+			<key>scope</key>
+			<string>constant.language, meta.preprocessor</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Support.construct</string>
+			<key>scope</key>
+			<string>support.function.construct, keyword.other.new</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>User-defined constant</string>
+			<key>scope</key>
+			<string>constant.character, constant.other</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Inherited class</string>
+			<key>scope</key>
+			<string>entity.other.inherited-class</string>
+			<key>settings</key>
+			<dict/>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Function argument</string>
+			<key>scope</key>
+			<string>variable.parameter</string>
+			<key>settings</key>
+			<dict/>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tag name</string>
+			<key>scope</key>
+			<string>entity.name.tag</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tag start/end</string>
+			<key>scope</key>
+			<string>punctuation.definition.tag.html, punctuation.definition.tag.begin, punctuation.definition.tag.end</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tag attribute</string>
+			<key>scope</key>
+			<string>entity.other.attribute-name</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#93A1A1</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Library function</string>
+			<key>scope</key>
+			<string>support.function</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Continuation</string>
+			<key>scope</key>
+			<string>punctuation.separator.continuation</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Library constant</string>
+			<key>scope</key>
+			<string>support.constant</string>
+			<key>settings</key>
+			<dict/>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Library class/type</string>
+			<key>scope</key>
+			<string>support.type, support.class</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Library Exception</string>
+			<key>scope</key>
+			<string>support.type.exception</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Special</string>
+			<key>scope</key>
+			<string>keyword.other.special-method</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Library variable</string>
+			<key>scope</key>
+			<string>support.other.variable</string>
+			<key>settings</key>
+			<dict/>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Invalid</string>
+			<key>scope</key>
+			<string>invalid</string>
+			<key>settings</key>
+			<dict/>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Quoted String</string>
+			<key>scope</key>
+			<string>string.quoted.double, string.quoted.single</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Quotes</string>
+			<key>scope</key>
+			<string>punctuation.definition.string.begin, punctuation.definition.string.end</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: Property name (body)</string>
+			<key>scope</key>
+			<string>entity.name.tag.css, support.type.property-name.css, meta.property-name.css, support.type.property-name.scss</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: @ rules (purple)</string>
+			<key>scope</key>
+			<string>punctuation.definition.keyword.scss, punctuation.definition.keyword.css, keyword.control.at-rule.charset.css, keyword.control.at-rule.charset.scss, keyword.control.each.css, keyword.control.each.scss, keyword.control.else.css, keyword.control.else.scss, keyword.control.at-rule.import.css, keyword.control.at-rule.import.scss, keyword.control.at-rule.fontface.css, keyword.control.at-rule.fontface.scss, keyword.control.for.css, keyword.control.for.scss, keyword.control.at-rule.function.css, keyword.control.at-rule.function.scss, keyword.control.if.css, keyword.control.if.scss, keyword.control.at-rule.include.scss, keyword.control.at-rule.media.css, keyword.control.at-rule.media.scss, keyword.control.at-rule.font-face.css, keyword.control.at-rule.font-face.scss, meta.at-rule.import.css, variable.other.less, variable.declaration.less, variable.interpolation.less, meta.at-rule.media.scss</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#6C71c4</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: Numeric Value (blue)</string>
+			<key>scope</key>
+			<string>constant.numeric.css, keyword.other.unit.css, keyword.unit.css, constant.other.color.rgb-value.css, constant.numeric.scss, constant.other.color.rgb-value.scss, keyword.other.unit.scss, punctuation.definition.constant.scss, punctuation.definition.constant.css, constant.other.rgb-value.css</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: String, value and constants (azure)</string>
+			<key>scope</key>
+			<string>variable.parameter.url.scss, meta.property-value.css, meta.property-value.scss, support.constant.property-value.scss, support.constant.font-name.scss, string.quoted.single.css, string.quoted.double.css, constant.character.escaped.css, string.quoted.variable.parameter.url, punctuation.definition.string.begin.scss, punctuation.definition.string.begin.css, punctuation.definition.string.end.scss, punctuation.definition.string.end.css, support.constant.property-value.css</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: !Important (red)</string>
+			<key>scope</key>
+			<string>keyword.other.important.css, keyword.other.important.scss</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: Standard color value (orange)</string>
+			<key>scope</key>
+			<string>support.constant.color, invalid.deprecated.color.w3c-non-standard-color-name.scss</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4b16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: : , () (body)</string>
+			<key>scope</key>
+			<string>punctuation.terminator.rule.css, punctuation.section.function.css, punctuation.section.function.scss, punctuation.separator.key-value.csspunctuation.scss, punctuation.css, keyword.operator.less, entity.name.tag.wildcard.scss, entity.name.tag.wildcard.css, entity.name.tag.reference.scss</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#657B83</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: Selector > [] and non-spec tags (body)</string>
+			<key>scope</key>
+			<string>meta.selector.css</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#657B83</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: Tag (green)</string>
+			<key>scope</key>
+			<string>entity.name.tag.css, entity.name.tag.scss</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS .class (yellow)</string>
+			<key>scope</key>
+			<string>entity.other.attribute-name.class.css, entity.other.less.mixin</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS: #id (yellow)</string>
+			<key>scope</key>
+			<string>source.css entity.other.attribute-name.id, source.scss entity.other.attribute-name.id</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>CSS :pseudo (orange)</string>
+			<key>scope</key>
+			<string>entity.other.attribute-name.pseudo-element.css, entity.other.attribute-name.pseudo-class.css</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SCSS: Variables (pink)</string>
+			<key>scope</key>
+			<string>variable, variable.scss</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#D33682</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>JS: Function Name</string>
+			<key>scope</key>
+			<string>meta.function.js, entity.name.function.js, support.function.dom.js</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>JS: Source</string>
+			<key>scope</key>
+			<string>text.html.basic source.js.embedded.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>JS: Function</string>
+			<key>scope</key>
+			<string>storage.type.function.js</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>JS: Numeric Constant</string>
+			<key>scope</key>
+			<string>constant.numeric.js</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>JS: []</string>
+			<key>scope</key>
+			<string>meta.brace.square.js</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>JS: Storage Type</string>
+			<key>scope</key>
+			<string>storage.type.js</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>()</string>
+			<key>scope</key>
+			<string>meta.brace.round, punctuation.definition.parameters.begin.js, punctuation.definition.parameters.end.js</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#93A1A1</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>{}</string>
+			<key>scope</key>
+			<string>meta.brace.curly.js</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: Doctype</string>
+			<key>scope</key>
+			<string>entity.name.tag.doctype.html, meta.tag.sgml.html, string.quoted.double.doctype.identifiers-and-DTDs.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: Comment Block</string>
+			<key>scope</key>
+			<string>comment.block.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: Script</string>
+			<key>scope</key>
+			<string>entity.name.tag.script.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: Style</string>
+			<key>scope</key>
+			<string>source.css.embedded.html string.quoted.double.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: Text</string>
+			<key>scope</key>
+			<string>text.html.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: =</string>
+			<key>scope</key>
+			<string>text.html.basic meta.tag.other.html, text.html.basic meta.tag.any.html, text.html.basic meta.tag.block.any, text.html.basic meta.tag.inline.any, text.html.basic meta.tag.structure.any.html, text.html.basic source.js.embedded.html, punctuation.separator.key-value.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#657B83</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: something=</string>
+			<key>scope</key>
+			<string>text.html.basic entity.other.attribute-name.html</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#657B83</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: "</string>
+			<key>scope</key>
+			<string>text.html.basic meta.tag.structure.any.html punctuation.definition.string.begin.html, punctuation.definition.string.begin.html, punctuation.definition.string.end.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: &lt;tag&gt;</string>
+			<key>scope</key>
+			<string>entity.name.tag.block.any.html</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: style</string>
+			<key>scope</key>
+			<string>source.css.embedded.html entity.name.tag.style.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: &lt;style&gt;</string>
+			<key>scope</key>
+			<string>entity.name.tag.style.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: {}</string>
+			<key>scope</key>
+			<string>text.html.basic, punctuation.section.property-list.css</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>HTML: Embeddable</string>
+			<key>scope</key>
+			<string>source.css.embedded.html, comment.block.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Variable definition</string>
+			<key>scope</key>
+			<string>punctuation.definition.variable.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Function Name</string>
+			<key>scope</key>
+			<string>meta.function.method.with-arguments.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#657B83</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Variable</string>
+			<key>scope</key>
+			<string>variable.language.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Function</string>
+			<key>scope</key>
+			<string>entity.name.function.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Keyword Control</string>
+			<key>scope</key>
+			<string>keyword.control.ruby, keyword.control.def.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Class</string>
+			<key>scope</key>
+			<string>keyword.control.class.ruby, meta.class.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Class Name</string>
+			<key>scope</key>
+			<string>entity.name.type.class.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Keyword</string>
+			<key>scope</key>
+			<string>keyword.control.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Support Class</string>
+			<key>scope</key>
+			<string>support.class.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Special Method</string>
+			<key>scope</key>
+			<string>keyword.other.special-method.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Constant</string>
+			<key>scope</key>
+			<string>constant.language.ruby, constant.numeric.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Constant Other</string>
+			<key>scope</key>
+			<string>variable.other.constant.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: :symbol</string>
+			<key>scope</key>
+			<string>constant.other.symbol.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Punctuation Section ''</string>
+			<key>scope</key>
+			<string>punctuation.section.embedded.ruby, punctuation.definition.string.begin.ruby, punctuation.definition.string.end.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: Special Method</string>
+			<key>scope</key>
+			<string>keyword.other.special-method.ruby</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Include</string>
+			<key>scope</key>
+			<string>keyword.control.import.include.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: erb =</string>
+			<key>scope</key>
+			<string>text.html.ruby meta.tag.inline.any.html</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Ruby: erb ""</string>
+			<key>scope</key>
+			<string>text.html.ruby punctuation.definition.string.begin, text.html.ruby punctuation.definition.string.end</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Quoted Single</string>
+			<key>scope</key>
+			<string>punctuation.definition.string.begin, punctuation.definition.string.end</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Class Names</string>
+			<key>scope</key>
+			<string>support.class.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#93A1A1</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: []</string>
+			<key>scope</key>
+			<string>keyword.operator.index-start.php, keyword.operator.index-end.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Array</string>
+			<key>scope</key>
+			<string>meta.array.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Array()</string>
+			<key>scope</key>
+			<string>meta.array.php support.function.construct.php, meta.array.empty.php support.function.construct.php</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Array Construct</string>
+			<key>scope</key>
+			<string>support.function.construct.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Array Begin</string>
+			<key>scope</key>
+			<string>punctuation.definition.array.begin, punctuation.definition.array.end</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Numeric Constant</string>
+			<key>scope</key>
+			<string>constant.numeric.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: New</string>
+			<key>scope</key>
+			<string>keyword.other.new.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: ::</string>
+			<key>scope</key>
+			<string>keyword.operator.class</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#93A1A1</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Other Property</string>
+			<key>scope</key>
+			<string>variable.other.property.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Class</string>
+			<key>scope</key>
+			<string>storage.modifier.extends.php, storage.type.class.php, keyword.operator.class.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Semicolon</string>
+			<key>scope</key>
+			<string>punctuation.terminator.expression.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Inherited Class</string>
+			<key>scope</key>
+			<string>meta.other.inherited-class.php</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Storage Type</string>
+			<key>scope</key>
+			<string>storage.type.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Function</string>
+			<key>scope</key>
+			<string>entity.name.function.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Function Construct</string>
+			<key>scope</key>
+			<string>support.function.construct.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Function Call</string>
+			<key>scope</key>
+			<string>entity.name.type.class.php, meta.function-call.php, meta.function-call.static.php, meta.function-call.object.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Comment</string>
+			<key>scope</key>
+			<string>keyword.other.phpdoc</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Source Emebedded</string>
+			<key>scope</key>
+			<string>source.php.embedded.block.html</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>PHP: Storage Type Function</string>
+			<key>scope</key>
+			<string>storage.type.function.php</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: constant</string>
+			<key>scope</key>
+			<string>constant.numeric.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: Meta Preprocessor</string>
+			<key>scope</key>
+			<string>meta.preprocessor.c.include, meta.preprocessor.macro.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: Keyword</string>
+			<key>scope</key>
+			<string>keyword.control.import.define.c, keyword.control.import.include.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: Function Preprocessor</string>
+			<key>scope</key>
+			<string>entity.name.function.preprocessor.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: include &lt;something.c&gt;</string>
+			<key>scope</key>
+			<string>meta.preprocessor.c.include string.quoted.other.lt-gt.include.c, meta.preprocessor.c.include punctuation.definition.string.begin.c, meta.preprocessor.c.include punctuation.definition.string.end.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: Function</string>
+			<key>scope</key>
+			<string>support.function.C99.c, support.function.any-method.c, entity.name.function.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#93A1A1</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: "</string>
+			<key>scope</key>
+			<string>punctuation.definition.string.begin.c, punctuation.definition.string.end.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>C: Storage Type</string>
+			<key>scope</key>
+			<string>storage.type.c</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>diff: header</string>
+			<key>scope</key>
+			<string>meta.diff, meta.diff.header</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#B58900</string>
+				<key>fontStyle</key>
+				<string>italic</string>
+				<key>foreground</key>
+				<string>#EEE8D5</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>diff: deleted</string>
+			<key>scope</key>
+			<string>markup.deleted</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#EEE8D5</string>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>diff: changed</string>
+			<key>scope</key>
+			<string>markup.changed</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#EEE8D5</string>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>diff: inserted</string>
+			<key>scope</key>
+			<string>markup.inserted</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#EEE8D5</string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>reST raw</string>
+			<key>scope</key>
+			<string>text.restructuredtext markup.raw</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Other: Removal</string>
+			<key>scope</key>
+			<string>other.package.exclude, other.remove</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Other: Add</string>
+			<key>scope</key>
+			<string>other.add</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: {}</string>
+			<key>scope</key>
+			<string>punctuation.section.group.tex , punctuation.definition.arguments.begin.latex, punctuation.definition.arguments.end.latex, punctuation.definition.arguments.latex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: {text}</string>
+			<key>scope</key>
+			<string>meta.group.braces.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Other Math</string>
+			<key>scope</key>
+			<string>string.other.math.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: {var}</string>
+			<key>scope</key>
+			<string>variable.parameter.function.latex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Math \\</string>
+			<key>scope</key>
+			<string>punctuation.definition.constant.math.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Constant Math</string>
+			<key>scope</key>
+			<string>text.tex.latex constant.other.math.tex, constant.other.general.math.tex, constant.other.general.math.tex, constant.character.math.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Other Math String</string>
+			<key>scope</key>
+			<string>string.other.math.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: $</string>
+			<key>scope</key>
+			<string>punctuation.definition.string.begin.tex, punctuation.definition.string.end.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: \label</string>
+			<key>scope</key>
+			<string>keyword.control.label.latex, text.tex.latex constant.other.general.math.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: \label { }</string>
+			<key>scope</key>
+			<string>variable.parameter.definition.label.latex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Function</string>
+			<key>scope</key>
+			<string>support.function.be.latex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Support Function Section</string>
+			<key>scope</key>
+			<string>support.function.section.latex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Support Function</string>
+			<key>scope</key>
+			<string>support.function.general.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Comment</string>
+			<key>scope</key>
+			<string>punctuation.definition.comment.tex, comment.line.percentage.tex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Tex: Reference Label</string>
+			<key>scope</key>
+			<string>keyword.control.ref.latex</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Python: storage</string>
+			<key>scope</key>
+			<string>storage.type.class.python, storage.type.function.python, storage.modifier.global.python</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Python: import</string>
+			<key>scope</key>
+			<string>keyword.control.import.python, keyword.control.import.from.python</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Python: Support.exception</string>
+			<key>scope</key>
+			<string>support.type.exception.python</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: builtin</string>
+			<key>scope</key>
+			<string>support.function.builtin.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: variable</string>
+			<key>scope</key>
+			<string>variable.other.normal.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: DOT_FILES</string>
+			<key>scope</key>
+			<string>source.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#268BD2</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: meta scope in loop</string>
+			<key>scope</key>
+			<string>meta.scope.for-in-loop.shell, variable.other.loop.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: ""</string>
+			<key>scope</key>
+			<string>punctuation.definition.string.end.shell, punctuation.definition.string.begin.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: Meta Block</string>
+			<key>scope</key>
+			<string>meta.scope.case-block.shell, meta.scope.case-body.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: []</string>
+			<key>scope</key>
+			<string>punctuation.definition.logical-expression.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Shell: Comment</string>
+			<key>scope</key>
+			<string>comment.line.number-sign.shell</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Java: import</string>
+			<key>scope</key>
+			<string>keyword.other.import.java</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#CB4B16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Java: meta-import</string>
+			<key>scope</key>
+			<string>storage.modifier.import.java</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Java: Class</string>
+			<key>scope</key>
+			<string>meta.class.java storage.modifier.java</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Java: /* comment */</string>
+			<key>scope</key>
+			<string>source.java comment.block</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Java: /* @param */</string>
+			<key>scope</key>
+			<string>comment.block meta.documentation.tag.param.javadoc keyword.other.documentation.param.javadoc</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string></string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Perl: variables</string>
+			<key>scope</key>
+			<string>punctuation.definition.variable.perl, variable.other.readwrite.global.perl, variable.other.predefined.perl, keyword.operator.comparison.perl</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#B58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Perl: functions</string>
+			<key>scope</key>
+			<string>support.function.perl</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#859900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Perl: comments</string>
+			<key>scope</key>
+			<string>comment.line.number-sign.perl</string>
+			<key>settings</key>
+			<dict>
+				<key>fontStyle</key>
+				<string>italic</string>
+				<key>foreground</key>
+				<string>#586E75</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Perl: quotes</string>
+			<key>scope</key>
+			<string>punctuation.definition.string.begin.perl, punctuation.definition.string.end.perl</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#2AA198</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>Perl: \char</string>
+			<key>scope</key>
+			<string>constant.character.escape.perl</string>
+			<key>settings</key>
+			<dict>
+				<key>foreground</key>
+				<string>#DC322F</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>Name</key>
+			<string>Markdown punctuation</string>
+			<key>scope</key>
+			<string>markup.list, text.html.markdown punctuation.definition, meta.separator.markdown</string>
+			<key>settings</key>
+				<dict>
+					<key>foreground</key>
+					<string>#CB4b16</string>
+				</dict>
+		</dict>
+		<dict>
+			<key>Name</key>
+			<string>Markdown heading</string>
+			<key>scope</key>
+			<string>markup.heading</string>
+			<key>settings</key>
+				<dict>
+					<key>foreground</key>
+					<string>#268BD2</string>
+				</dict>
+		</dict>
+		<dict>
+			<key>Name</key>
+			<string>Markdown text inside some block element</string>
+			<key>scope</key>
+			<string>markup.quote, meta.paragraph.list</string>
+			<key>settings</key>
+				<dict>
+					<key>foreground</key>
+					<string>#2AA198</string>
+				</dict>
+		</dict>
+		<dict>
+			<key>Name</key>
+			<string>Markdown em</string>
+			<key>scope</key>
+			<string>markup.italic</string>
+			<key>settings</key>
+				<dict>
+					<key>fontStyle</key>
+					<string>italic</string>
+				</dict>
+		</dict>
+		<dict>
+			<key>Name</key>
+			<string>Markdown strong</string>
+			<key>scope</key>
+			<string>markup.bold</string>
+			<key>settings</key>
+				<dict>
+					<key>fontStyle</key>
+					<string>bold</string>
+				</dict>
+		</dict>
+		<dict>
+			<key>Name</key>
+			<string>Markdown reference</string>
+			<key>scope</key>
+			<string>markup.underline.link.markdown, meta.link.inline punctuation.definition.metadata, meta.link.reference.markdown punctuation.definition.constant, meta.link.reference.markdown constant.other.reference</string>
+			<key>settings</key>
+				<dict>
+					<key>foreground</key>
+					<string>#B58900</string>
+				</dict>
+		</dict>
+		<dict>
+			<key>Name</key>
+			<string>Markdown linebreak</string>
+			<key>scope</key>
+			<string>meta.paragraph.markdown meta.dummy.line-break</string>
+			<key>settings</key>
+				<dict>
+					<key>background</key>
+					<string>#6C71c4</string>
+				</dict>
+		</dict>
+		<!-- GitGutter -->
+		<dict>
+		  <key>name</key>
+		  <string>GitGutter deleted</string>
+		  <key>scope</key>
+		  <string>markup.deleted.git_gutter</string>
+		  <key>settings</key>
+		  <dict>
+		    <key>foreground</key>
+		    <string>#F92672</string>
+		  </dict>
+		</dict>
+		<dict>
+		  <key>name</key>
+		  <string>GitGutter inserted</string>
+		  <key>scope</key>
+		  <string>markup.inserted.git_gutter</string>
+		  <key>settings</key>
+		  <dict>
+		    <key>foreground</key>
+		    <string>#A6E22E</string>
+		  </dict>
+		</dict>
+		<dict>
+		  <key>name</key>
+		  <string>GitGutter changed</string>
+		  <key>scope</key>
+		  <string>markup.changed.git_gutter</string>
+		  <key>settings</key>
+		  <dict>
+		    <key>foreground</key>
+		    <string>#967EFB</string>
+		  </dict>
+		</dict>
+		<!-- Sublime Linter -->
+		<dict>
+			<key>name</key>
+			<string>SublimeLinter Annotations</string>
+			<key>scope</key>
+			<string>sublimelinter.notes</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#eee8d5</string>
+				<key>foreground</key>
+				<string>#eee8d5</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SublimeLinter Error Outline</string>
+			<key>scope</key>
+			<string>sublimelinter.outline.illegal</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#93a1a1</string>
+				<key>foreground</key>
+				<string>#93a1a1</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SublimeLinter Error Underline</string>
+			<key>scope</key>
+			<string>sublimelinter.underline.illegal</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#dc322f</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SublimeLinter Warning Outline</string>
+			<key>scope</key>
+			<string>sublimelinter.outline.warning</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#839496</string>
+				<key>foreground</key>
+				<string>#839496</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SublimeLinter Warning Underline</string>
+			<key>scope</key>
+			<string>sublimelinter.underline.warning</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#b58900</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SublimeLinter Violation Outline</string>
+			<key>scope</key>
+			<string>sublimelinter.outline.violation</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#657b83</string>
+				<key>foreground</key>
+				<string>#657b83</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SublimeLinter Violation Underline</string>
+			<key>scope</key>
+			<string>sublimelinter.underline.violation</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#cb4b16</string>
+			</dict>
+		</dict>
+		<dict>
+			<key>name</key>
+			<string>SublimeBracketHighlighter</string>
+			<key>scope</key>
+			<string>brackethighlighter.all</string>
+			<key>settings</key>
+			<dict>
+				<key>background</key>
+				<string>#002b36</string>
+				<key>foreground</key>
+				<string>#cb4b16</string>
+			</dict>
+		</dict>
+	</array>
+	<key>uuid</key>
+	<string>A4299D9B-1DE5-4BC4-87F6-A757E71B1597</string>
+</dict>
+</plist>

src/util/line_iterator.rs

@@ -0,0 +1,63 @@
+pub struct LineIterator<'a> {
+    data: &'a str,
+    line_number: usize,
+    line_start: usize,
+    line_end: usize,
+    done: bool,
+}
+
+impl<'a> LineIterator<'a> {
+    pub fn new(data: &str) -> LineIterator {
+        LineIterator {
+            data,
+            line_number: 0,
+            line_start: 0,
+            line_end: 0,
+            done: false,
+        }
+    }
+
+    fn out_of_data(&self) -> bool {
+        self.line_end == self.data.len()
+    }
+}
+
+impl<'a> Iterator for LineIterator<'a> {
+    type Item = (usize, &'a str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.done {
+            return None;
+        }
+
+        // Move the range beyond its previous position.
+        self.line_start = self.line_end;
+
+        // We track trailing newlines because, if the buffer ends immediately
+        // after one, we want to return one last line on the next iteration.
+        let mut trailing_newline = false;
+
+        // Find the next line range.
+        for c in self.data[self.line_start..].chars() {
+            // Extend the current line range to include this char.
+            self.line_end += c.len_utf8();
+
+            if c == '\n' {
+                trailing_newline = true;
+                break;
+            }
+        }
+
+        let line = Some((self.line_number, &self.data[self.line_start..self.line_end]));
+
+        // Flag the iterator as done as soon as we've exhausted its data,
+        // and have given one last line for data with a trailing newline.
+        if self.out_of_data() && !trailing_newline {
+            self.done = true;
+        } else {
+            self.line_number += 1;
+        }
+
+        line
+    }
+}

src/util/mod.rs

@@ -0,0 +1 @@
+pub mod line_iterator;

src/utils/buffer.rs

@@ -13,7 +13,7 @@ use crossterm::style::Color;
 
 use super::{
     style::StyleManager,
-    ui::uicore::{APP_INFO, CONTENT_WINSIZE},
+    ui::uicore::{APP_INTERNAL_INFOMATION, CONTENT_WINSIZE},
 };
 
 #[derive(Debug, Default, Clone)]
@@ -223,7 +223,7 @@ impl EditBuffer {
         if previous_line.flags.contains(LineState::LOCKED)
             || cur_line.flags.contains(LineState::LOCKED)
         {
-            APP_INFO.lock().unwrap().info = "Row is locked".to_string();
+            APP_INTERNAL_INFOMATION.lock().unwrap().info = "Row is locked".to_string();
             return (false, 0);
         }
 
@@ -444,7 +444,7 @@ impl EditBuffer {
         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() {
+            if rchar.is_ascii_punctuation() && right != x as usize {
                 break;
             }
             if !(lchar == ' ' || lchar == '\t') {
@@ -476,7 +476,7 @@ impl EditBuffer {
         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() {
+            if rchar.is_ascii_punctuation() && right != x as usize {
                 break;
             }
             if lchar == ' ' || lchar == '\t' {
@@ -511,7 +511,7 @@ impl EditBuffer {
             let lchar = line[left as usize] as char;
             let rchar = line[right as usize] as char;
 
-            if lchar.is_ascii_punctuation() && left != x.into() {
+            if lchar.is_ascii_punctuation() && left != x as i32 {
                 return Some(left as usize);
             }
             if rchar == ' ' || rchar == '\t' {
@@ -521,7 +521,7 @@ impl EditBuffer {
             }
 
             if lchar == ' ' || lchar == '\t' {
-                if left + 1 == x.into() {
+                if left + 1 == x as i32 {
                     right = left;
                     continue;
                 }
@@ -541,7 +541,7 @@ impl EditBuffer {
             let lchar = line[left as usize] as char;
             let rchar = line[right as usize] as char;
 
-            if lchar.is_ascii_punctuation() && left != x.into() {
+            if lchar.is_ascii_punctuation() && left != x as i32 {
                 return left as usize;
             }
             if rchar == ' ' || rchar == '\t' {
@@ -551,7 +551,7 @@ impl EditBuffer {
             }
 
             if lchar == ' ' || lchar == '\t' {
-                if left + 1 == x.into() {
+                if left + 1 == x as i32 {
                     right = left;
                     continue;
                 }

src/utils/ui/event.rs

@@ -4,7 +4,7 @@ use crate::utils::{buffer::LineState, cursor::CursorCrtl, style::StyleManager};
 
 use super::{
     mode::mode::ModeType,
-    uicore::{UiCore, APP_INFO, CONTENT_WINSIZE, DEF_STYLE, UI_CMD_HEIGHT},
+    uicore::{UiCore, APP_INTERNAL_INFOMATION, CONTENT_WINSIZE, DEF_STYLE, UI_CMD_HEIGHT},
 };
 
 pub const TAB_STR: &'static str = "        ";
@@ -62,7 +62,7 @@ pub trait KeyEventCallback {
 
         let line = ui.buffer.get_line(y);
         if line.flags.contains(LineState::LOCKED) {
-            APP_INFO.lock().unwrap().info = "Row is locked".to_string();
+            APP_INTERNAL_INFOMATION.lock().unwrap().info = "Row is locked".to_string();
             return Ok(WarpUiCallBackType::None);
         }
         self.left(ui)?;

src/utils/ui/mod.rs

@@ -9,12 +9,12 @@ pub mod mode;
 pub mod uicore;
 
 #[derive(Debug)]
-pub struct AppInfo {
+pub struct AppInternalInfomation {
     pub level: InfoLevel,
     pub info: String,
 }
 
-impl AppInfo {
+impl AppInternalInfomation {
     pub fn reset(&mut self) {
         self.level = InfoLevel::Info;
         self.info = String::new();

src/utils/ui/mode/mode.rs

@@ -10,7 +10,7 @@ use crate::utils::input::KeyEventType;
 
 use crate::utils::terminal::TermManager;
 
-use crate::utils::ui::uicore::{UiCore, APP_INFO, TAB_SIZE};
+use crate::utils::ui::uicore::{UiCore, APP_INTERNAL_INFOMATION, TAB_SIZE};
 use crate::utils::ui::{
     event::KeyEventCallback,
     uicore::{CONTENT_WINSIZE, DEF_STYLE},
@@ -596,7 +596,7 @@ impl KeyEventCallback for Insert {
 
         let line = ui.buffer.get_line(line_idx);
         if line.flags.contains(LineState::LOCKED) {
-            APP_INFO.lock().unwrap().info = "Row is locked".to_string();
+            APP_INTERNAL_INFOMATION.lock().unwrap().info = "Row is locked".to_string();
             return Ok(WarpUiCallBackType::None);
         }
         ui.buffer.input_enter(col, line_idx);
@@ -664,7 +664,7 @@ impl KeyEventCallback for Insert {
 
         let line = ui.buffer.get_line(y);
         if line.flags.contains(LineState::LOCKED) {
-            APP_INFO.lock().unwrap().info = "Row is locked".to_string();
+            APP_INTERNAL_INFOMATION.lock().unwrap().info = "Row is locked".to_string();
             return Ok(WarpUiCallBackType::None);
         }
 

src/utils/ui/uicore.rs

@@ -23,7 +23,7 @@ use crate::utils::input::Input;
 use super::{
     mode::mode::{Command, InputMode, Insert, LastLine, ModeType},
     mode::normal::Normal,
-    AppInfo,
+    AppInternalInfomation,
 };
 
 lazy_static! {
@@ -31,10 +31,11 @@ lazy_static! {
     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()
-    });
+    pub static ref APP_INTERNAL_INFOMATION: Mutex<AppInternalInfomation> =
+        Mutex::new(AppInternalInfomation {
+            level: InfoLevel::Info,
+            info: String::new()
+        });
 }
 
 pub static TAB_SIZE: AtomicU16 = AtomicU16::new(4);
@@ -108,7 +109,7 @@ impl UiCore {
         self.cursor.set_prefix_mode(true);
         self.cursor.move_to(store_x, store_y)?;
 
-        let mut info = APP_INFO.lock().unwrap();
+        let mut info = APP_INTERNAL_INFOMATION.lock().unwrap();
         info.level.set_style()?;
         self.cursor
             .write_with_pos(&info.info, size.cols / 3, cmd_y, false)?;

src/view/colors/map.rs

@@ -0,0 +1,100 @@
+use crossterm::style::Color;
+use held_core::view::colors::Colors;
+use syntect::highlighting::Theme;
+
+use super::to_rgb;
+
+pub trait ColorMap {
+    fn map_colors(&self, colors: Colors) -> Colors;
+}
+
+impl ColorMap for Theme {
+    fn map_colors(&self, colors: Colors) -> Colors {
+        let fg = self.settings.foreground.map(to_rgb).unwrap_or(Color::Rgb {
+            r: 255,
+            g: 255,
+            b: 255,
+        });
+
+        let bg = self
+            .settings
+            .background
+            .map(to_rgb)
+            .unwrap_or(Color::Rgb { r: 0, g: 0, b: 0 });
+
+        let alt_bg = self
+            .settings
+            .line_highlight
+            .map(to_rgb)
+            .unwrap_or(Color::Rgb {
+                r: 55,
+                g: 55,
+                b: 55,
+            });
+
+        match colors {
+            Colors::Default => Colors::CustomForeground(fg),
+            Colors::Focused => Colors::Custom(fg, alt_bg),
+            Colors::Inverted => Colors::Custom(bg, fg),
+            Colors::Insert => Colors::Custom(
+                Color::Rgb {
+                    r: 255,
+                    g: 255,
+                    b: 255,
+                },
+                Color::Rgb { r: 0, g: 180, b: 0 },
+            ),
+            Colors::Warning => Colors::Custom(
+                Color::Rgb {
+                    r: 255,
+                    g: 255,
+                    b: 255,
+                },
+                Color::Rgb {
+                    r: 240,
+                    g: 140,
+                    b: 20,
+                },
+            ),
+            Colors::PathMode => Colors::Custom(
+                Color::Rgb {
+                    r: 255,
+                    g: 255,
+                    b: 255,
+                },
+                Color::Rgb {
+                    r: 255,
+                    g: 20,
+                    b: 137,
+                },
+            ),
+            Colors::SearchMode => Colors::Custom(
+                Color::Rgb {
+                    r: 255,
+                    g: 255,
+                    b: 255,
+                },
+                Color::Rgb {
+                    r: 120,
+                    g: 0,
+                    b: 120,
+                },
+            ),
+            Colors::SelectMode => Colors::Custom(
+                Color::Rgb {
+                    r: 255,
+                    g: 255,
+                    b: 255,
+                },
+                Color::Rgb {
+                    r: 0,
+                    g: 120,
+                    b: 160,
+                },
+            ),
+            Colors::CustomForeground(custom_fg) => Colors::CustomForeground(custom_fg),
+            Colors::CustomFocusedForeground(custom_fg) => Colors::Custom(custom_fg, alt_bg),
+            Colors::Custom(custom_fg, custom_bg) => Colors::Custom(custom_fg, custom_bg),
+        }
+    }
+}

src/view/colors/mod.rs

@@ -0,0 +1,12 @@
+pub mod map;
+
+use crossterm::style::Color;
+use syntect::highlighting::Color as RGBAColor;
+
+pub fn to_rgb(highlight_color: RGBAColor) -> Color {
+    Color::Rgb {
+        r: highlight_color.r,
+        g: highlight_color.g,
+        b: highlight_color.b,
+    }
+}

src/view/mod.rs

@@ -0,0 +1,7 @@
+pub mod colors;
+pub mod monitor;
+pub mod presenter;
+pub mod render;
+pub mod status_data;
+pub mod terminal;
+pub mod theme_loadler;

src/view/monitor/mod.rs

@@ -0,0 +1,132 @@
+use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc};
+
+use super::{
+    presenter::Presenter,
+    render::{render_buffer::CachedRenderBuffer, render_state::RenderState},
+    terminal::{cross_terminal::CrossTerminal, Terminal},
+    theme_loadler::ThemeLoader,
+};
+use crate::errors::*;
+use crate::modules::perferences::Perferences;
+use crate::{buffer::Buffer, plugin::system::PluginSystem};
+use crossterm::event::{Event, KeyEvent};
+use scroll_controller::ScrollController;
+use syntect::highlighting::{Theme, ThemeSet};
+
+pub mod scroll_controller;
+
+/// 管理所有的显示
+pub struct Monitor {
+    pub terminal: Arc<Box<dyn Terminal>>,
+    theme_set: ThemeSet,
+    pub perference: Rc<RefCell<dyn Perferences>>,
+    scroll_controllers: HashMap<usize, ScrollController>,
+    render_caches: HashMap<usize, Rc<RefCell<HashMap<usize, RenderState>>>>,
+    pub last_key: Option<KeyEvent>,
+    pub cached_render_buffer: Rc<RefCell<CachedRenderBuffer>>,
+    pub plugin_system: Rc<RefCell<PluginSystem>>,
+}
+
+impl Monitor {
+    pub fn new(
+        perference: Rc<RefCell<dyn Perferences>>,
+        plugin_system: Rc<RefCell<PluginSystem>>,
+    ) -> Result<Monitor> {
+        let terminal = CrossTerminal::new()?;
+        let cached_render_buffer = CachedRenderBuffer::new(terminal.width()?, terminal.height()?);
+        let theme_set = ThemeLoader::new(perference.borrow().theme_path()?).load()?;
+        Ok(Monitor {
+            terminal: Arc::new(Box::new(terminal)),
+            theme_set,
+            perference,
+            scroll_controllers: HashMap::new(),
+            render_caches: HashMap::new(),
+            last_key: None,
+            cached_render_buffer: Rc::new(RefCell::new(cached_render_buffer)),
+            plugin_system,
+        })
+    }
+
+    pub fn init_buffer(&mut self, buffer: &mut Buffer) -> Result<()> {
+        let id = buffer.id()?;
+        self.scroll_controllers.insert(
+            id,
+            ScrollController::new(self.terminal.clone(), buffer.cursor.line),
+        );
+        let render_cache = Rc::new(RefCell::new(HashMap::new()));
+        self.render_caches.insert(id, render_cache.clone());
+
+        // 回调清除render_cache
+        buffer.change_callback = Some(Box::new(move |change_position| {
+            render_cache
+                .borrow_mut()
+                .retain(|&k, _| k < change_position.line);
+        }));
+        Ok(())
+    }
+
+    pub fn deinit_buffer(&mut self, buffer: &Buffer) -> Result<()> {
+        let id = buffer.id()?;
+        self.scroll_controllers.remove(&id);
+        self.render_caches.remove(&id);
+        Ok(())
+    }
+
+    pub fn listen(&mut self) -> Result<Event> {
+        let ev = self.terminal.listen()?;
+        if let Event::Key(key) = ev {
+            self.last_key.replace(key);
+        }
+        Ok(ev)
+    }
+
+    pub fn width(&self) -> Result<usize> {
+        self.terminal.width()
+    }
+
+    pub fn height(&self) -> Result<usize> {
+        self.terminal.height()
+    }
+
+    pub fn get_theme(&self, name: &String) -> Option<Theme> {
+        self.theme_set.themes.get(name).cloned()
+    }
+
+    pub fn first_theme(&self) -> Option<Theme> {
+        self.theme_set
+            .themes
+            .first_key_value()
+            .map(|(_, v)| v.clone())
+    }
+
+    pub fn build_presenter(&mut self) -> Result<Presenter> {
+        Presenter::new(self)
+    }
+
+    pub fn get_render_cache(&self, buffer: &Buffer) -> &Rc<RefCell<HashMap<usize, RenderState>>> {
+        self.render_caches.get(&buffer.id.unwrap()).unwrap()
+    }
+
+    pub fn get_scroll_controller(&mut self, buffer: &Buffer) -> &mut ScrollController {
+        self.scroll_controllers
+            .entry(buffer.id.unwrap())
+            .or_insert(ScrollController::new(self.terminal.clone(), 0))
+    }
+
+    pub fn scroll_to_cursor(&mut self, buffer: &Buffer) -> Result<()> {
+        self.get_scroll_controller(buffer)
+            .scroll_into_monitor(buffer)
+    }
+
+    pub fn scroll_to_center(&mut self, buffer: &Buffer) -> Result<()> {
+        self.get_scroll_controller(buffer).scroll_to_center(buffer)
+    }
+
+    pub fn scroll_up(&mut self, buffer: &Buffer, count: usize) {
+        self.get_scroll_controller(buffer).scroll_up(count);
+    }
+
+    pub fn scroll_down(&mut self, buffer: &Buffer, count: usize) {
+        self.get_scroll_controller(buffer).scroll_down(count);
+    }
+}

src/view/monitor/scroll_controller.rs

@@ -0,0 +1,55 @@
+use crate::errors::*;
+use crate::{buffer::Buffer, view::terminal::Terminal};
+use std::sync::Arc;
+
+/// 对于滚动操作的抽象对象
+///
+/// 外部通过line_offset方法获取滚动后buffer的offset
+pub struct ScrollController {
+    terminal: Arc<Box<dyn Terminal>>,
+    line_offset: usize,
+}
+
+impl ScrollController {
+    pub fn new(terminal: Arc<Box<dyn Terminal>>, init_line_index: usize) -> ScrollController {
+        ScrollController {
+            terminal,
+            line_offset: init_line_index,
+        }
+    }
+
+    // 若将buffer指针指向的行滚动到显示区域顶部
+    pub fn scroll_into_monitor(&mut self, buffer: &Buffer) -> Result<()> {
+        let terminal_height = self.terminal.height()? - 1;
+        if self.line_offset > buffer.cursor.line {
+            self.line_offset = buffer.cursor.line;
+        } else if self.line_offset + terminal_height - 1 < buffer.cursor.line {
+            self.line_offset = buffer.cursor.line - terminal_height + 1;
+        }
+        Ok(())
+    }
+
+    // 将buffer指针指向的行滚动到显示区域中间区域
+    pub fn scroll_to_center(&mut self, buffer: &Buffer) -> Result<()> {
+        self.line_offset = buffer
+            .cursor
+            .line
+            .saturating_sub(self.terminal.height()?.saturating_div(2));
+        Ok(())
+    }
+
+    // 向上滚动n行
+    pub fn scroll_up(&mut self, line_count: usize) {
+        self.line_offset = self.line_offset.saturating_sub(line_count);
+    }
+
+    // 向下滚动n行
+    pub fn scroll_down(&mut self, line_count: usize) {
+        self.line_offset = self.line_offset.saturating_add(line_count);
+    }
+
+    // 返回当前的offset
+    pub fn line_offset(&mut self) -> usize {
+        self.line_offset
+    }
+}

src/view/presenter.rs

@@ -0,0 +1,155 @@
+use std::{borrow::Cow, cell::RefCell, fmt::Debug, rc::Rc};
+
+use super::{
+    colors::map::ColorMap,
+    monitor::Monitor,
+    render::{
+        lexeme_mapper::LexemeMapper,
+        render_buffer::{Cell, RenderBuffer},
+    },
+    status_data::StatusLineData,
+};
+use crate::{
+    buffer::Buffer, errors::*, util::line_iterator::LineIterator, view::render::renderer::Renderer,
+};
+use held_core::{
+    utils::{position::Position, range::Range},
+    view::{colors::Colors, style::CharStyle},
+};
+use syntect::{highlighting::Theme, parsing::SyntaxSet};
+
+pub struct Presenter<'a> {
+    view: &'a mut Monitor,
+    theme: Theme,
+    present_buffer: RenderBuffer<'a>,
+    cursor_position: Option<Position>,
+}
+
+impl<'a> Presenter<'a> {
+    pub fn new(monitor: &mut Monitor) -> Result<Presenter> {
+        let theme_name = monitor.perference.borrow().theme_name();
+        let mut theme = monitor
+            .first_theme()
+            .ok_or_else(|| format!("Couldn't find anyone theme"))?;
+        if let Some(theme_name) = theme_name {
+            theme = monitor
+                .get_theme(&theme_name)
+                .ok_or_else(|| format!("Couldn't find \"{}\" theme", theme_name))?;
+        }
+        let present_buffer = RenderBuffer::new(
+            monitor.width()?,
+            monitor.height()?,
+            monitor.cached_render_buffer.clone(),
+        );
+        Ok(Presenter {
+            view: monitor,
+            theme,
+            present_buffer,
+            cursor_position: None,
+        })
+    }
+
+    pub fn set_cursor(&mut self, position: Position) {
+        self.cursor_position = Some(position);
+    }
+
+    pub fn present(&self) -> Result<()> {
+        for (position, cell) in self.present_buffer.iter() {
+            self.view
+                .terminal
+                .print(
+                    &position,
+                    cell.style,
+                    self.theme.map_colors(cell.colors),
+                    &cell.content,
+                )
+                .unwrap();
+        }
+
+        self.view.terminal.set_cursor(self.cursor_position)?;
+        self.view.terminal.present()?;
+        Ok(())
+    }
+
+    pub fn print_status_line(&mut self, datas: &[StatusLineData]) -> Result<()> {
+        let line_width = self.view.terminal.width()?;
+        let line = self.view.terminal.height()? - 1;
+
+        let count = datas.len();
+        let mut offset = 0;
+        // 从左往右输出，最后一个参数在最后
+        for (index, data) in datas.iter().enumerate() {
+            let content = match count {
+                1 => {
+                    format!("{:width$}", data.content, width = line_width)
+                }
+                _ => {
+                    if index == count - 1 {
+                        format!(
+                            "{:width$}",
+                            data.content,
+                            width = line_width.saturating_sub(offset)
+                        )
+                    } else {
+                        data.content.to_owned()
+                    }
+                }
+            };
+
+            let len = content.len();
+            warn!("line {line}, offset {offset}, content {content}");
+            self.print(&Position { line, offset }, data.style, data.color, content);
+            offset += len;
+        }
+
+        Ok(())
+    }
+
+    // 按照预设渲染buffer
+    pub fn print_buffer(
+        &mut self,
+        buffer: &Buffer,
+        buffer_data: &'a str,
+        syntax_set: &'a SyntaxSet,
+        highlights: Option<&'a [(Range, CharStyle, Colors)]>,
+        lexeme_mapper: Option<&'a mut dyn LexemeMapper>,
+    ) -> Result<()> {
+        let scroll_offset = self.view.get_scroll_controller(buffer).line_offset();
+        let lines = LineIterator::new(&buffer_data);
+
+        let cursor_position = Renderer::new(
+            buffer,
+            &mut self.present_buffer,
+            &**self.view.terminal,
+            &*self.view.perference.borrow(),
+            highlights,
+            self.view.get_render_cache(buffer),
+            &self.theme,
+            syntax_set,
+            scroll_offset,
+            &mut self.view.plugin_system.borrow_mut(),
+        )
+        .render(lines, lexeme_mapper)?;
+
+        match cursor_position {
+            Some(position) => self.set_cursor(position),
+            None => self.cursor_position = None,
+        }
+
+        Ok(())
+    }
+
+    pub fn print<C>(&mut self, position: &Position, style: CharStyle, colors: Colors, content: C)
+    where
+        C: Into<Cow<'a, str>> + Debug,
+    {
+        self.present_buffer.set_cell(
+            *position,
+            Cell {
+                content: content.into(),
+                style,
+                colors,
+            },
+        );
+    }
+}

src/view/render/lexeme_mapper.rs

@@ -0,0 +1,15 @@
+use held_core::utils::position::Position;
+
+#[derive(Debug, PartialEq)]
+pub enum MappedLexeme<'a> {
+    Focused(&'a str),
+    Blurred(&'a str),
+}
+
+/// 词素映射器
+/// 在渲染时会优先按照词素映射器映射的风格进行映射
+///
+/// 例：按照正则表达式搜索文本时，聚焦正则匹配的部分
+pub trait LexemeMapper {
+    fn map<'x>(&'x mut self, lexeme: &str, position: Position) -> Vec<MappedLexeme<'x>>;
+}

src/view/render/line_number_string_iter.rs

@@ -0,0 +1,34 @@
+use crate::buffer::Buffer;
+
+const PADDING_SIZE: usize = 2;
+pub struct LineNumberStringIter {
+    current: usize,
+    max_width: usize,
+}
+
+impl LineNumberStringIter {
+    pub fn new(buffer: &Buffer, offset: usize) -> LineNumberStringIter {
+        let line_count = buffer.line_count();
+        LineNumberStringIter {
+            current: offset,
+            max_width: line_count.to_string().len(),
+        }
+    }
+
+    pub fn width(&self) -> usize {
+        self.max_width + PADDING_SIZE
+    }
+}
+
+impl Iterator for LineNumberStringIter {
+    type Item = String;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.current += 1;
+        Some(format!(
+            " {:>width$} ",
+            self.current,
+            width = self.max_width
+        ))
+    }
+}

src/view/render/mod.rs

@@ -0,0 +1,5 @@
+pub mod lexeme_mapper;
+pub mod line_number_string_iter;
+pub mod render_buffer;
+pub mod render_state;
+pub mod renderer;

src/view/render/render_buffer.rs

@@ -0,0 +1,159 @@
+use std::{borrow::Cow, cell::RefCell, rc::Rc};
+
+use held_core::view::{colors::Colors, style::CharStyle};
+use unicode_segmentation::UnicodeSegmentation;
+
+use held_core::utils::position::Position;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Cell<'a> {
+    pub content: Cow<'a, str>,
+    pub colors: Colors,
+    pub style: CharStyle,
+}
+
+impl<'c> Default for Cell<'c> {
+    fn default() -> Self {
+        Self {
+            content: " ".into(),
+            colors: Default::default(),
+            style: Default::default(),
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct CachedCell {
+    pub content: String,
+    pub colors: Colors,
+    pub style: CharStyle,
+}
+
+#[derive(Debug)]
+pub struct CachedRenderBuffer {
+    pub cells: Vec<Option<CachedCell>>,
+}
+
+impl CachedRenderBuffer {
+    pub fn new(width: usize, height: usize) -> CachedRenderBuffer {
+        CachedRenderBuffer {
+            cells: vec![None; width * height],
+        }
+    }
+
+    // 返回对应index是否与cell相等
+    pub fn compare_and_update(&mut self, cell: &Cell, index: usize) -> bool {
+        if index < self.cells.len() {
+            let cache = &mut self.cells[index];
+            let cell_content = String::from_iter(cell.content.chars());
+
+            let equal = if let Some(cache) = cache {
+                let equal = cache.colors == cell.colors
+                    && cache.style == cell.style
+                    && cache.content == cell_content;
+
+                equal
+            } else {
+                false
+            };
+
+            if !equal {
+                let mut cache_cell = CachedCell::default();
+                let content_len = cell_content.len();
+                cache_cell.colors = cell.colors;
+                cache_cell.style = cell.style;
+                cache_cell.content = cell_content;
+                for i in (index + 1)..(index + content_len) {
+                    self.cells[i] = None
+                }
+
+                self.cells[index] = Some(cache_cell);
+            }
+
+            return equal;
+        } else {
+            return false;
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RenderBuffer<'a> {
+    width: usize,
+    height: usize,
+    cells: Vec<Cell<'a>>,
+    cached: Rc<RefCell<CachedRenderBuffer>>,
+}
+
+impl<'a> RenderBuffer<'a> {
+    pub fn new(
+        width: usize,
+        height: usize,
+        cached: Rc<RefCell<CachedRenderBuffer>>,
+    ) -> RenderBuffer<'a> {
+        RenderBuffer {
+            width,
+            height,
+            cells: vec![Cell::default(); width * height],
+            cached,
+        }
+    }
+
+    pub fn set_cell(&mut self, position: Position, cell: Cell<'a>) {
+        if position.line >= self.height || position.offset >= self.width {
+            return;
+        }
+        let index = position.line * self.width + position.offset;
+        if index < self.cells.len() {
+            self.cells[index] = cell;
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.cells = vec![Cell::default(); self.width * self.height];
+    }
+
+    pub fn iter(&self) -> RenderBufferIter {
+        RenderBufferIter::new(self)
+    }
+}
+
+pub struct RenderBufferIter<'a> {
+    index: usize,
+    width: usize,
+    cells: &'a Vec<Cell<'a>>,
+    cached: Rc<RefCell<CachedRenderBuffer>>,
+}
+
+impl<'a> RenderBufferIter<'a> {
+    pub fn new(render_buffer: &'a RenderBuffer) -> RenderBufferIter<'a> {
+        RenderBufferIter {
+            index: 0,
+            width: render_buffer.width,
+            cells: &render_buffer.cells,
+            cached: render_buffer.cached.clone(),
+        }
+    }
+}
+
+impl<'a> Iterator for RenderBufferIter<'a> {
+    type Item = (Position, &'a Cell<'a>);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.index < self.cells.len() {
+            let position = Position {
+                line: self.index / self.width,
+                offset: self.index % self.width,
+            };
+
+            let index = self.index;
+            let cell = &self.cells[self.index];
+            self.index += cell.content.graphemes(true).count().max(1);
+
+            if !self.cached.borrow_mut().compare_and_update(cell, index) {
+                return Some((position, cell));
+            }
+        }
+        None
+    }
+}

src/view/render/render_state.rs

@@ -0,0 +1,20 @@
+use syntect::{
+    highlighting::{HighlightState, Highlighter},
+    parsing::{ParseState, ScopeStack, SyntaxReference},
+};
+
+/// 记录某一个渲染状态
+#[derive(Debug, Clone, PartialEq)]
+pub struct RenderState {
+    pub highlight: HighlightState,
+    pub parse: ParseState,
+}
+
+impl RenderState {
+    pub fn new(highlighter: &Highlighter, syntax: &SyntaxReference) -> RenderState {
+        Self {
+            highlight: HighlightState::new(highlighter, ScopeStack::new()),
+            parse: ParseState::new(syntax),
+        }
+    }
+}

src/view/render/renderer.rs

@@ -0,0 +1,521 @@
+use std::borrow::Cow;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::str::FromStr;
+
+use crate::modules::perferences::Perferences;
+use crate::plugin::system::PluginSystem;
+use crate::view::colors::to_rgb;
+use crate::{buffer::Buffer, util::line_iterator::LineIterator, view::terminal::Terminal};
+use crate::{errors::*, get_application};
+use crossterm::style::Color;
+use held_core::plugin::Plugin;
+use held_core::utils::position::Position;
+use held_core::utils::range::Range;
+use held_core::view::colors::Colors;
+use held_core::view::render::ContentRenderBuffer;
+use held_core::view::style::CharStyle;
+use syntect::highlighting::{HighlightIterator, Highlighter, Style, Theme};
+use syntect::parsing::{ScopeStack, SyntaxSet};
+
+use unicode_segmentation::UnicodeSegmentation;
+
+use super::line_number_string_iter::LineNumberStringIter;
+use super::render_buffer::Cell;
+use super::render_state::RenderState;
+use super::{lexeme_mapper::LexemeMapper, render_buffer::RenderBuffer};
+
+const RENDER_CACHE_FREQUENCY: usize = 100;
+
+pub struct Renderer<'a, 'p> {
+    buffer: &'a Buffer,
+    render_buffer: &'a mut RenderBuffer<'p>,
+    terminal: &'a dyn Terminal,
+    theme: &'a Theme,
+    highlight_ranges: Option<&'a [(Range, CharStyle, Colors)]>,
+    scroll_offset: usize,
+    line_number_iter: LineNumberStringIter,
+    content_start_of_line: usize,
+    cached_render_state: &'a Rc<RefCell<HashMap<usize, RenderState>>>,
+    syntax_set: &'a SyntaxSet,
+    screen_position: Position,
+    buffer_position: Position,
+    cursor_position: Option<Position>,
+    current_style: Style,
+    perferences: &'a dyn Perferences,
+    plugin_system: &'a mut PluginSystem,
+}
+
+impl<'a, 'p> Renderer<'a, 'p> {
+    pub fn new(
+        buffer: &'a Buffer,
+        render_buffer: &'a mut RenderBuffer<'p>,
+        terminal: &'a dyn Terminal,
+        perferences: &'a dyn Perferences,
+        highlight_ranges: Option<&'a [(Range, CharStyle, Colors)]>,
+        cached_render_state: &'a Rc<RefCell<HashMap<usize, RenderState>>>,
+        theme: &'a Theme,
+        syntax_set: &'a SyntaxSet,
+        scroll_offset: usize,
+        plugin_system: &'a mut PluginSystem,
+    ) -> Renderer<'a, 'p> {
+        let line_number_iter = LineNumberStringIter::new(buffer, scroll_offset);
+        let content_start_of_line = line_number_iter.width() + 1;
+        Self {
+            buffer,
+            render_buffer,
+            terminal,
+            theme,
+            scroll_offset,
+            syntax_set,
+            cached_render_state,
+            screen_position: Position::default(),
+            buffer_position: Position::default(),
+            cursor_position: None,
+            current_style: Style::default(),
+            perferences,
+            highlight_ranges,
+            line_number_iter,
+            content_start_of_line,
+            plugin_system,
+        }
+    }
+
+    pub fn render(
+        &mut self,
+        lines: LineIterator<'a>,
+        mut lexeme_mapper: Option<&mut dyn LexemeMapper>,
+    ) -> Result<Option<Position>> {
+        self.terminal.set_cursor(None)?;
+        self.render_line_number();
+
+        let highlighter = Highlighter::new(&self.theme);
+        let syntax_definition = self
+            .buffer
+            .syntax_definition
+            .as_ref()
+            .ok_or("Buffer has no syntax definition")?;
+
+        let focused_style = Renderer::mapper_keyword_style(&highlighter);
+        let blurred_style = Renderer::mapper_comment_style(&highlighter);
+
+        let (cached_line_num, mut state) = self
+            .current_cached_render_state()
+            .unwrap_or((0, RenderState::new(&highlighter, syntax_definition)));
+
+        for (line_num, line_data) in lines {
+            if line_num >= cached_line_num {
+                if line_num % RENDER_CACHE_FREQUENCY == 0 {
+                    self.cached_render_state
+                        .borrow_mut()
+                        .insert(line_num, state.clone());
+                }
+
+                if self.before_visible() {
+                    self.try_to_advance_to_next_line(&line_data);
+                    continue;
+                }
+
+                if self.after_visible() {
+                    break;
+                }
+
+                let events = state
+                    .parse
+                    .parse_line(&line_data, self.syntax_set)
+                    .chain_err(|| "Failed to parse buffer")?;
+
+                let styled_lexemes =
+                    HighlightIterator::new(&mut state.highlight, &events, &line_data, &highlighter);
+
+                for (style, lexeme) in styled_lexemes {
+                    if let Some(ref mut mapper) = lexeme_mapper {
+                        let mapped_lexemes = mapper.map(lexeme, self.buffer_position);
+                        for mapped_lexeme in mapped_lexemes {
+                            match mapped_lexeme {
+                                super::lexeme_mapper::MappedLexeme::Focused(val) => {
+                                    self.current_style = focused_style;
+                                    self.render_lexeme(val.to_string());
+                                }
+                                super::lexeme_mapper::MappedLexeme::Blurred(val) => {
+                                    self.current_style = blurred_style;
+                                    self.render_lexeme(val.to_string());
+                                }
+                            }
+                        }
+                    } else {
+                        self.current_style = style;
+                        self.render_lexeme(lexeme);
+                    }
+                }
+            }
+
+            self.try_to_advance_to_next_line(&line_data);
+        }
+
+        self.render_plugins()?;
+
+        Ok(self.cursor_position)
+    }
+
+    fn mapper_keyword_style(highlighter: &Highlighter) -> Style {
+        highlighter.style_for_stack(
+            ScopeStack::from_str("keyword")
+                .unwrap_or_default()
+                .as_slice(),
+        )
+    }
+
+    fn render_plugins(&mut self) -> Result<()> {
+        let plugin_buffers = self.plugin_system.on_render_content();
+        for plugin_buffer in plugin_buffers {
+            self.render_plugin(plugin_buffer)?;
+        }
+        Ok(())
+    }
+
+    fn render_plugin(&mut self, buffer: ContentRenderBuffer) -> Result<()> {
+        let mut line = 0;
+        let mut offset = 0;
+        let init_pos = buffer.rectangle.position;
+
+        warn!("plugin cells {:?}", buffer.cells);
+        for cell in buffer.cells {
+            if let Some(cell) = cell {
+                self.render_cell(
+                    Position {
+                        line: init_pos.line + line,
+                        offset: init_pos.offset + offset,
+                    },
+                    cell.style,
+                    cell.colors,
+                    cell.content.to_string(),
+                );
+            }
+
+            offset += 1;
+            if offset == buffer.rectangle.width {
+                offset = 0;
+                line += 1;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn mapper_comment_style(highlighter: &Highlighter) -> Style {
+        highlighter.style_for_stack(
+            ScopeStack::from_str("keyword")
+                .unwrap_or_default()
+                .as_slice(),
+        )
+    }
+
+    fn current_cached_render_state(&self) -> Option<(usize, RenderState)> {
+        self.cached_render_state
+            .borrow()
+            .iter()
+            .filter(|(k, _)| **k < self.scroll_offset)
+            .max_by(|a, b| a.0.cmp(b.0))
+            .map(|x| (*x.0, x.1.clone()))
+    }
+
+    fn after_visible(&self) -> bool {
+        self.screen_position.line >= (self.terminal.height().unwrap() - 1)
+    }
+
+    fn before_visible(&self) -> bool {
+        self.buffer_position.line < self.scroll_offset
+    }
+
+    fn inside_visible(&self) -> bool {
+        !self.before_visible() && !self.after_visible()
+    }
+
+    fn set_cursor(&mut self) {
+        if self.inside_visible() && *self.buffer.cursor == self.buffer_position {
+            self.cursor_position = Some(self.screen_position);
+            get_application().state_data.cursor_state.screen_position = self.screen_position;
+        }
+    }
+
+    fn on_cursor_line(&self) -> bool {
+        self.buffer.cursor.line == self.buffer_position.line
+    }
+
+    fn try_to_advance_to_next_line(&mut self, line: &str) {
+        if line.chars().last().map(|x| x == '\n').unwrap_or(false) {
+            self.advance_to_next_line();
+        }
+    }
+
+    fn advance_to_next_line(&mut self) {
+        if self.inside_visible() {
+            self.set_cursor();
+            self.render_rest_of_line();
+            self.screen_position.line += 1;
+        }
+
+        self.buffer_position.line += 1;
+        self.buffer_position.offset = 0;
+        self.render_line_number();
+    }
+
+    fn render_rest_of_line(&mut self) {
+        let on_cursor_line = self.on_cursor_line();
+        for offset in self.screen_position.offset..self.terminal.width().unwrap() {
+            let colors = if on_cursor_line {
+                Colors::Focused
+            } else {
+                Colors::Default
+            };
+
+            self.render_cell(
+                Position {
+                    line: self.screen_position.line,
+                    offset,
+                },
+                CharStyle::Default,
+                colors,
+                " ",
+            );
+        }
+    }
+
+    fn render_line_number(&mut self) {
+        if !self.inside_visible() {
+            return;
+        }
+        let line_number = self.line_number_iter.next().unwrap();
+        let is_on_cursor_line = self.on_cursor_line();
+
+        let style = if is_on_cursor_line {
+            CharStyle::Bold
+        } else {
+            CharStyle::Default
+        };
+        // 渲染行号
+        self.render_cell(
+            Position {
+                line: self.screen_position.line,
+                offset: 0,
+            },
+            style,
+            Colors::Focused,
+            line_number,
+        );
+
+        // 行号后的gap
+        let gap_color = if is_on_cursor_line {
+            Colors::Focused
+        } else {
+            Colors::Default
+        };
+        self.render_cell(
+            Position {
+                line: self.screen_position.line,
+                offset: self.line_number_iter.width(),
+            },
+            style,
+            gap_color,
+            " ",
+        );
+
+        self.screen_position.offset = self.line_number_iter.width() + 1;
+    }
+
+    fn render_lexeme<T: Into<Cow<'a, str>>>(&mut self, lexeme: T) {
+        for character in lexeme.into().graphemes(true) {
+            if character == "\n" {
+                continue;
+            }
+
+            self.set_cursor();
+
+            let token_color = to_rgb(self.current_style.foreground);
+            let (style, color) = self.current_char_style(token_color);
+
+            if self.perferences.line_wrapping()
+                && self.screen_position.offset == self.terminal.width().unwrap() - 1
+            {
+                self.render_cell(self.screen_position, style, color, character.to_string());
+                self.buffer_position.offset += 1;
+
+                // 屏幕上换行但是渲染原来的line
+                let prefix_len = self.content_start_of_line;
+                let prefix = " ".repeat(prefix_len);
+                self.screen_position.offset = 0;
+                self.screen_position.line += 1;
+                self.render_cell(
+                    Position {
+                        line: self.screen_position.line,
+                        offset: self.screen_position.offset,
+                    },
+                    style,
+                    Colors::Default,
+                    prefix,
+                );
+                self.screen_position.offset += prefix_len;
+            } else if character == "\t" {
+                let tab_len = self.perferences.tab_width();
+                let width = tab_len - (self.screen_position.offset + 1) % tab_len;
+                let tab_str = " ".repeat(width);
+                self.render_lexeme(tab_str);
+            } else {
+                self.render_cell(self.screen_position, style, color, character.to_string());
+                self.screen_position.offset += 1;
+                self.buffer_position.offset += 1;
+            }
+
+            // 退出循环前更新
+            self.set_cursor();
+        }
+    }
+
+    fn render_cell<C: Into<Cow<'p, str>>>(
+        &mut self,
+        position: Position,
+        style: CharStyle,
+        colors: Colors,
+        content: C,
+    ) {
+        self.render_buffer.set_cell(
+            position,
+            Cell {
+                content: content.into(),
+                colors,
+                style,
+            },
+        );
+    }
+
+    fn current_char_style(&self, token_color: Color) -> (CharStyle, Colors) {
+        let (style, colors) = match self.highlight_ranges {
+            Some(highlight_ranges) => {
+                for (range, style, colors) in highlight_ranges {
+                    if range.includes(&self.buffer_position) {
+                        // 修正背景色
+                        let fix_colors = if let Colors::CustomForeground(color) = colors {
+                            if self.on_cursor_line() {
+                                Colors::CustomFocusedForeground(*color)
+                            } else {
+                                *colors
+                            }
+                        } else {
+                            *colors
+                        };
+                        return (*style, fix_colors);
+                    }
+                }
+
+                // We aren't inside one of the highlighted areas.
+                // Fall back to other styling considerations.
+                if self.on_cursor_line() {
+                    (
+                        CharStyle::Default,
+                        Colors::CustomFocusedForeground(token_color),
+                    )
+                } else {
+                    (CharStyle::Default, Colors::CustomForeground(token_color))
+                }
+            }
+            None => {
+                if self.on_cursor_line() {
+                    (
+                        CharStyle::Default,
+                        Colors::CustomFocusedForeground(token_color),
+                    )
+                } else {
+                    (CharStyle::Default, Colors::CustomForeground(token_color))
+                }
+            }
+        };
+
+        (style, colors)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        cell::RefCell,
+        collections::HashMap,
+        io::{BufReader, Cursor},
+        path::Path,
+        rc::Rc,
+    };
+
+    use syntect::{highlighting::ThemeSet, parsing::SyntaxSet};
+
+    use crate::{
+        buffer::Buffer,
+        modules::perferences::DummyPerferences,
+        util::line_iterator::LineIterator,
+        view::{
+            colors::map::ColorMap,
+            render::render_buffer::{CachedRenderBuffer, RenderBuffer},
+            terminal::{cross_terminal::CrossTerminal, Terminal},
+        },
+    };
+
+    use super::Renderer;
+
+    #[test]
+    fn test_display() {
+        let terminal = CrossTerminal::new().unwrap();
+        let mut buffer = Buffer::from_file(Path::new("src/main.rs")).unwrap();
+        let mut render_buffer = RenderBuffer::new(
+            terminal.width().unwrap(),
+            terminal.height().unwrap(),
+            Rc::new(RefCell::new(CachedRenderBuffer::new(
+                terminal.width().unwrap(),
+                terminal.height().unwrap(),
+            ))),
+        );
+        let perferences = DummyPerferences;
+        let cached_render_state = Rc::new(RefCell::new(HashMap::new()));
+
+        let mut reader = BufReader::new(Cursor::new(include_str!(
+            "../../themes/solarized_dark.tmTheme"
+        )));
+        let theme = ThemeSet::load_from_reader(&mut reader).unwrap();
+        let syntax_set = SyntaxSet::load_defaults_newlines();
+        let definition = buffer
+            .file_extension()
+            .and_then(|ex| syntax_set.find_syntax_by_extension(&ex))
+            .or_else(|| Some(syntax_set.find_syntax_plain_text()))
+            .cloned();
+
+        buffer.syntax_definition = definition;
+        let binding = buffer.data();
+        {
+            let mut renderer = Renderer::new(
+                &buffer,
+                &mut render_buffer,
+                &terminal,
+                &perferences,
+                None,
+                &cached_render_state,
+                &theme,
+                &syntax_set,
+                0,
+                todo!(),
+            );
+            renderer.render(LineIterator::new(&binding), None).unwrap();
+        }
+
+        for (position, cell) in render_buffer.iter() {
+            terminal
+                .print(
+                    &position,
+                    cell.style,
+                    theme.map_colors(cell.colors),
+                    &cell.content,
+                )
+                .unwrap();
+        }
+
+        terminal.present().unwrap();
+    }
+}

src/view/status_data.rs

@@ -0,0 +1,37 @@
+use held_core::view::{colors::Colors, style::CharStyle};
+
+use crate::buffer::Buffer;
+
+pub struct StatusLineData {
+    pub content: String,
+    pub color: Colors,
+    pub style: CharStyle,
+}
+
+pub fn buffer_status_data(buffer: &Option<Buffer>) -> StatusLineData {
+    if let Some(buffer) = buffer {
+        let modified = buffer.modified();
+        let (title, style) = buffer
+            .path
+            .as_ref()
+            .map(|path| {
+                if modified {
+                    (format!(" {}*", path.to_string_lossy()), CharStyle::Bold)
+                } else {
+                    (format!(" {}", path.to_string_lossy()), CharStyle::Default)
+                }
+            })
+            .unwrap_or_default();
+        StatusLineData {
+            content: title,
+            color: Colors::Focused,
+            style,
+        }
+    } else {
+        StatusLineData {
+            content: String::new(),
+            color: Colors::Focused,
+            style: CharStyle::Default,
+        }
+    }
+}

src/view/terminal/cross_terminal.rs

@@ -0,0 +1,186 @@
+use std::{
+    cell::{RefCell, RefMut},
+    io::{stdout, Write},
+};
+
+use crossterm::{
+    event::Event,
+    terminal::{self, disable_raw_mode},
+    QueueableCommand,
+};
+use held_core::{
+    utils::position::Position,
+    view::{colors::Colors, style::CharStyle},
+};
+
+use super::{Terminal, MIN_HEIGHT, MIN_WIDTH, TERMINAL_EXECUTE_ERROR};
+use crate::errors::*;
+
+#[derive(Debug)]
+pub struct CrossTerminal {
+    ansi_buffer: RefCell<Vec<u8>>,
+}
+
+unsafe impl Send for CrossTerminal {}
+unsafe impl Sync for CrossTerminal {}
+
+impl CrossTerminal {
+    pub fn new() -> Result<CrossTerminal> {
+        crossterm::terminal::enable_raw_mode()?;
+        let terminal = CrossTerminal {
+            ansi_buffer: RefCell::default(),
+        };
+        terminal.clear()?;
+        terminal.present()?;
+        Ok(terminal)
+    }
+
+    fn buffer(&self) -> RefMut<Vec<u8>> {
+        return self.ansi_buffer.borrow_mut();
+    }
+
+    fn update_style(&self, char_style: CharStyle, colors: Colors) -> Result<()> {
+        self.buffer().queue(crossterm::style::SetAttribute(
+            crossterm::style::Attribute::Reset,
+        ))?;
+
+        match char_style {
+            CharStyle::Default => {
+                self.buffer().queue(crossterm::style::SetAttribute(
+                    crossterm::style::Attribute::Reset,
+                ))?;
+            }
+            CharStyle::Bold => {
+                self.buffer().queue(crossterm::style::SetAttribute(
+                    crossterm::style::Attribute::Bold,
+                ))?;
+            }
+            CharStyle::Reverse => {
+                self.buffer().queue(crossterm::style::SetAttribute(
+                    crossterm::style::Attribute::Reverse,
+                ))?;
+            }
+            CharStyle::Italic => {
+                self.buffer().queue(crossterm::style::SetAttribute(
+                    crossterm::style::Attribute::Italic,
+                ))?;
+            }
+        }
+
+        match colors {
+            Colors::Default => {
+                self.buffer().queue(crossterm::style::ResetColor)?;
+            }
+            Colors::CustomForeground(color) => {
+                self.buffer()
+                    .queue(crossterm::style::SetForegroundColor(color))?;
+            }
+            Colors::Custom(fg, bg) => {
+                self.buffer()
+                    .queue(crossterm::style::SetForegroundColor(fg))?;
+                self.buffer()
+                    .queue(crossterm::style::SetBackgroundColor(bg))?;
+            }
+            _ => {
+                unreachable!();
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl Terminal for CrossTerminal {
+    fn listen(&self) -> Result<Event> {
+        crossterm::event::read().chain_err(|| "Handle event io error")
+    }
+
+    fn clear(&self) -> Result<()> {
+        self.buffer()
+            .queue(crossterm::style::SetAttribute(
+                crossterm::style::Attribute::Reset,
+            ))
+            .chain_err(|| TERMINAL_EXECUTE_ERROR)
+            .map(|_| ())?;
+        self.buffer()
+            .queue(terminal::Clear(terminal::ClearType::All))
+            .chain_err(|| TERMINAL_EXECUTE_ERROR)
+            .map(|_| ())?;
+        Ok(())
+    }
+
+    fn present(&self) -> Result<()> {
+        stdout().write_all(&self.buffer())?;
+        stdout().flush()?;
+        self.buffer().clear();
+        Ok(())
+    }
+
+    fn width(&self) -> Result<usize> {
+        let (width, _) = crossterm::terminal::size()?;
+        return Ok(width.max(MIN_WIDTH).into());
+    }
+
+    fn height(&self) -> Result<usize> {
+        let (_, height) = crossterm::terminal::size()?;
+        return Ok(height.max(MIN_HEIGHT).into());
+    }
+
+    fn set_cursor(&self, position: Option<Position>) -> Result<()> {
+        match position {
+            Some(position) => {
+                self.buffer()
+                    .queue(crossterm::cursor::MoveTo(
+                        position.offset as u16,
+                        position.line as u16,
+                    ))
+                    .unwrap()
+                    .queue(crossterm::cursor::Show)
+                    .chain_err(|| TERMINAL_EXECUTE_ERROR)?;
+            }
+            None => {
+                self.buffer()
+                    .queue(crossterm::cursor::Hide)
+                    .chain_err(|| TERMINAL_EXECUTE_ERROR)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn set_cursor_type(&self, cursor_type: crossterm::cursor::SetCursorStyle) -> Result<()> {
+        self.buffer()
+            .queue(cursor_type)
+            .chain_err(|| TERMINAL_EXECUTE_ERROR)
+            .map(|_| ())
+    }
+
+    fn print(
+        &self,
+        position: &Position,
+        char_style: CharStyle,
+        colors: Colors,
+        content: &str,
+    ) -> Result<()> {
+        self.update_style(char_style, colors)?;
+        self.set_cursor(Some(*position))?;
+        self.buffer().queue(crossterm::style::Print(content))?;
+        Ok(())
+    }
+
+    fn suspend(&self) {
+        let _ = self.clear();
+        let _ = self.set_cursor(Some(Position::from((0, 0))));
+        let _ = stdout().write_all(&self.buffer());
+        let _ = stdout().flush();
+
+        self.buffer().clear();
+    }
+}
+
+impl Drop for CrossTerminal {
+    fn drop(&mut self) {
+        self.suspend();
+        let _ = disable_raw_mode();
+    }
+}

src/view/terminal/mod.rs

@@ -0,0 +1,27 @@
+use std::fmt::Debug;
+
+use crate::errors::*;
+use crossterm::event::Event;
+use held_core::utils::position::Position;
+use held_core::view::colors::Colors;
+use held_core::view::style::CharStyle;
+
+pub mod cross_terminal;
+
+pub(super) const MIN_WIDTH: u16 = 10;
+pub(super) const MIN_HEIGHT: u16 = 10;
+
+pub const TERMINAL_EXECUTE_ERROR: &'static str = "Terminal IO Error";
+
+#[allow(dead_code)]
+pub trait Terminal: Send + Sync + Debug {
+    fn listen(&self) -> Result<Event>;
+    fn clear(&self) -> Result<()>;
+    fn present(&self) -> Result<()>;
+    fn width(&self) -> Result<usize>;
+    fn height(&self) -> Result<usize>;
+    fn set_cursor(&self, _: Option<Position>) -> Result<()>;
+    fn set_cursor_type(&self, _: crossterm::cursor::SetCursorStyle) -> Result<()>;
+    fn print(&self, _: &Position, _: CharStyle, _: Colors, _: &str) -> Result<()>;
+    fn suspend(&self);
+}

src/view/theme_loadler.rs

@@ -0,0 +1,81 @@
+use crate::errors::*;
+use app_dirs2::{app_dir, AppDataType};
+use error_chain::bail;
+use std::{
+    collections::BTreeMap,
+    ffi::OsStr,
+    fs::File,
+    io::{BufReader, Cursor, Read, Seek},
+    path::PathBuf,
+};
+use syntect::highlighting::{Theme, ThemeSet};
+
+pub struct ThemeLoader {
+    path: PathBuf,
+    themes: BTreeMap<String, Theme>,
+}
+
+impl ThemeLoader {
+    pub fn new(path: PathBuf) -> ThemeLoader {
+        ThemeLoader {
+            path,
+            themes: BTreeMap::new(),
+        }
+    }
+
+    pub fn load(mut self) -> Result<ThemeSet> {
+        self.load_default();
+        #[cfg(not(feature = "dragonos"))]
+        {
+            self.load_user()?;
+        }
+
+        Ok(ThemeSet {
+            themes: self.themes,
+        })
+    }
+
+    fn load_user(&mut self) -> Result<()> {
+        let dir = self.path.read_dir()?;
+
+        let entries = dir
+            .filter_map(|f| f.ok())
+            .map(|f| f.path())
+            .filter(|f| f.is_file())
+            .filter(|f| f.extension() == Some(OsStr::new("tmTheme")));
+
+        for entry in entries {
+            if let Ok(file) = File::open(&entry) {
+                if let Some(name) = entry.file_stem() {
+                    if let Some(name) = name.to_str() {
+                        self.add_theme(name.into(), file);
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn load_default(&mut self) {
+        self.add_theme(
+            "solarized_dark".into(),
+            Cursor::new(include_str!("../themes/solarized_dark.tmTheme")),
+        );
+    }
+
+    fn add_theme<D: Read + Seek>(&mut self, name: String, data: D) {
+        let mut reader = BufReader::new(data);
+
+        match ThemeSet::load_from_reader(&mut reader) {
+            Ok(theme) => {
+                self.themes
+                    .insert(theme.name.clone().unwrap_or(name).to_owned(), theme);
+            }
+            Err(e) => {
+                // 主题加载出错不必直接退出
+                error!("Failed load theme: {name:?},error: {e:?}");
+            }
+        };
+    }
+}

src/workspace.rs

@@ -0,0 +1,186 @@
+use std::{
+    cell::Ref,
+    collections::HashMap,
+    env,
+    os::unix::fs::MetadataExt,
+    path::{Path, PathBuf},
+};
+
+use crate::{
+    errors::*,
+    modules::perferences::{Perferences, PerferencesManager},
+    view::monitor::Monitor,
+};
+use syntect::parsing::SyntaxSet;
+
+use crate::buffer::Buffer;
+
+pub struct Workspace {
+    pub path: PathBuf,
+    buffers: HashMap<usize, Buffer>,
+    // ino -> id
+    buffers_ino_map: HashMap<u64, usize>,
+    pub current_buffer: Option<Buffer>,
+    pub syntax_set: SyntaxSet,
+    buffer_ida: usize,
+}
+
+impl Workspace {
+    pub fn create_workspace(
+        monitor: &mut Monitor,
+        perferences: Ref<dyn Perferences>,
+        args: &[String],
+    ) -> Result<Workspace> {
+        let mut path_args = args.iter().skip(1).peekable();
+
+        let initial_dir = env::current_dir()?;
+        // 若第一个参数为dir，则修改工作区
+        if let Some(dir) = path_args.peek() {
+            let path = Path::new(dir);
+            if path.is_dir() {
+                env::set_current_dir(path.canonicalize()?)?;
+            }
+        }
+        let workspace_dir = env::current_dir()?;
+        #[cfg(feature = "dragonos")]
+        let syntax_path: Option<PathBuf> = None;
+        #[cfg(not(feature = "dragonos"))]
+        let syntax_path = PerferencesManager::user_syntax_path().map(Some)?;
+        let mut workspace = Workspace::new(&workspace_dir, syntax_path.as_deref())?;
+
+        if workspace_dir != initial_dir {
+            path_args.next();
+        }
+
+        for path_str in path_args {
+            let path = Path::new(path_str);
+            if path.is_dir() {
+                continue;
+            }
+
+            let syntax_ref = perferences
+                .syntax_definition_name(&path)
+                .and_then(|name| workspace.syntax_set.find_syntax_by_name(&name).cloned());
+
+            let buffer = if path.exists() {
+                let mut buffer = Buffer::from_file(&path)?;
+                buffer.syntax_definition = syntax_ref;
+                buffer
+            } else {
+                let mut buffer = Buffer::new();
+                buffer.syntax_definition = syntax_ref;
+
+                if path.is_absolute() {
+                    buffer.path = Some(path.to_path_buf());
+                } else {
+                    buffer.path = Some(workspace_dir.join(path))
+                }
+                buffer
+            };
+
+            workspace.add_buffer(buffer);
+            monitor.init_buffer(workspace.current_buffer.as_mut().unwrap())?;
+        }
+
+        Ok(workspace)
+    }
+
+    fn new(path: &Path, syntax_definitions: Option<&Path>) -> Result<Workspace> {
+        let mut syntax_set = SyntaxSet::load_defaults_newlines();
+        if let Some(syntax_definitions) = syntax_definitions {
+            if syntax_definitions.is_dir() {
+                if syntax_definitions.read_dir()?.count() > 0 {
+                    let mut builder = syntax_set.into_builder();
+                    builder.add_from_folder(syntax_definitions, true)?;
+                    syntax_set = builder.build();
+                }
+            }
+        }
+
+        Ok(Workspace {
+            path: path.canonicalize()?,
+            buffers: HashMap::new(),
+            buffers_ino_map: HashMap::new(),
+            current_buffer: None,
+            syntax_set,
+            buffer_ida: 0,
+        })
+    }
+
+    pub fn add_buffer(&mut self, mut buffer: Buffer) -> usize {
+        let id = self.alloc_buffer_id();
+        buffer.id = Some(id);
+
+        if let Some(ref path) = buffer.path {
+            if let Ok(metadata) = path.metadata() {
+                self.buffers_ino_map.insert(metadata.ino(), id);
+            }
+        }
+
+        self.buffers.insert(id, buffer);
+        self.select_buffer(id);
+
+        if let Some(buffer) = self.current_buffer.as_ref() {
+            if buffer.syntax_definition.is_none() {
+                let _ = self.update_current_syntax();
+            }
+        }
+
+        return id;
+    }
+
+    fn alloc_buffer_id(&mut self) -> usize {
+        self.buffer_ida += 1;
+        self.buffer_ida
+    }
+
+    pub fn get_buffer(&self, id: usize) -> Option<&Buffer> {
+        if let Some(ref buffer) = self.current_buffer {
+            if buffer.id.unwrap() == id {
+                return Some(buffer);
+            }
+        }
+        return self.buffers.get(&id);
+    }
+
+    pub fn get_buffer_with_ino(&self, ino: u64) -> Option<&Buffer> {
+        if let Some(id) = self.buffers_ino_map.get(&ino) {
+            return self.get_buffer(*id);
+        }
+        None
+    }
+
+    pub fn select_buffer(&mut self, id: usize) -> bool {
+        // 将当前buffer放回
+        if let Some(buffer) = self.current_buffer.take() {
+            if buffer.id.unwrap() == id {
+                self.current_buffer = Some(buffer);
+                return true;
+            }
+            self.buffers.insert(buffer.id.unwrap(), buffer);
+        }
+
+        // 选择新buffer
+        if let Some(buffer) = self.buffers.remove(&id) {
+            self.current_buffer = Some(buffer);
+            return true;
+        }
+
+        false
+    }
+
+    pub fn update_current_syntax(&mut self) -> Result<()> {
+        let buffer = self
+            .current_buffer
+            .as_mut()
+            .ok_or(ErrorKind::EmptyWorkspace)?;
+        let definition = buffer
+            .file_extension()
+            .and_then(|ex| self.syntax_set.find_syntax_by_extension(&ex))
+            .or_else(|| Some(self.syntax_set.find_syntax_plain_text()))
+            .cloned();
+        buffer.syntax_definition = definition;
+
+        Ok(())
+    }
+}