Initial Support for Visual mode

Signed-off-by: Ahmed <>

Cargo.toml

@@ -9,12 +9,15 @@ members = [
   "rair",
   "test_file",
   "trees",
+  "visual",
 ]
 
 [workspace.dependencies]
 base64 = "0.22.1"
 bitflags = "2.6.0"
 clap = "4.5.17"
+cli-clipboard = "0.4.0"
+copypasta = "0.10.1"
 directories = "5.0.1"
 err-derive = "0.3.1"
 flate2 = "1.0.33"
@@ -24,22 +27,25 @@ nom = "7.1.3"
 parking_lot="0.12.3"
 pest = "2.7.12"
 pest_derive = "2.7.12"
+ratatui = "0.28.1"
 rustyline = "14.0.0"
 rustyline-derive = "0.10.0"
 serde = "1.0"
 serde_cbor = "0.11.2"
 serde_json = "1.0"
 tempfile = "3.12.0"
+winit = "0.30.5"
 yansi = "1.0.1"
 
+rair = {path = "./rair"}
 rair-cmd = {path = "./cmd"}
 rair-core = {path = "./core"}
 rair-env = {path = "./env"}
 rair-eval = {path = "./eval"}
 test_file = {path = "./test_file"}
 rair-io = {path = "./io"}
 rair-trees = {path = "./trees"}
-
+rair-visual = {path = "./visual"}
 [profile.release]
 codegen-units = 1
 lto = "fat"

core/src/helper.rs

@@ -95,7 +95,6 @@ pub struct CmdFunctions {
 }
 
 #[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize)]
-#[non_exhaustive]
 pub enum AddrMode {
     Vir,
     Phy,

core/src/hex/hex_env.rs

@@ -3,7 +3,7 @@ use crate::{is_color, Core, Writer};
 use std::io::Write;
 use yansi::Paint;
 
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct HexEnv {
     // color for banner and offsets
     pub banner: (u8, u8, u8),
@@ -89,7 +89,7 @@ impl HexEnv {
             separator: String::new(),
         }
     }
-    pub(super) fn get_env(&mut self, core: &mut Core) -> &Self {
+    pub fn get_env(&mut self, core: &mut Core) -> &Self {
         let env = core.env.read();
         let color = env.get_str("hex.headerColor").unwrap();
         self.banner = env.get_color(color).unwrap();

core/src/lib.rs

@@ -16,5 +16,6 @@ pub use self::commands::*;
 pub use self::core::*;
 pub use self::diff::*;
 pub use self::helper::*;
+pub use self::hex::*;
 pub use self::io::*;
 pub use self::writer::*;

eval/src/lib.rs

@@ -1,4 +1,4 @@
-use core::mem;
+use core::mem::{replace, swap, take};
 use rair_cmd::{Argument, Cmd, ParseTree, RedPipe};
 use rair_core::{Core, Writer};
 use std::{
@@ -7,6 +7,13 @@ use std::{
     process::{Child, Command, Stdio},
 };
 
+pub fn rair_eval_no_out(core: &mut Core, line: &str) {
+    let stdout = take(&mut core.stdout);
+    let stderr = take(&mut core.stderr);
+    rair_eval(core, line);
+    core.stdout = stdout;
+    core.stderr = stderr;
+}
 pub fn rair_eval(core: &mut Core, line: &str) {
     match ParseTree::construct(line) {
         Ok(tree) => evaluate(core, tree),
@@ -37,17 +44,17 @@ fn run_cmd(core: &mut Core, cmd: Cmd) {
     let mut child: Option<Child> = None;
     match *cmd.red_pipe {
         RedPipe::Redirect(arg) => match create_redirect(core, *arg) {
-            Ok(out) => stdout = Some(mem::replace(&mut core.stdout, out)),
+            Ok(out) => stdout = Some(replace(&mut core.stdout, out)),
             Err(e) => return writeln!(core.stderr, "{e}").unwrap(),
         },
         RedPipe::RedirectCat(arg) => match create_redirect_cat(core, *arg) {
-            Ok(out) => stdout = Some(mem::replace(&mut core.stdout, out)),
+            Ok(out) => stdout = Some(replace(&mut core.stdout, out)),
             Err(e) => return writeln!(core.stderr, "{e}").unwrap(),
         },
         RedPipe::Pipe(arg) => match create_pipe(core, arg) {
             Ok((process, writer)) => {
                 child = Some(process);
-                stdout = Some(mem::replace(&mut core.stdout, writer));
+                stdout = Some(replace(&mut core.stdout, writer));
             }
             Err(e) => return writeln!(core.stderr, "{e}").unwrap(),
         },
@@ -123,13 +130,13 @@ fn eval_non_literal_arg(core: &mut Core, cmd: Cmd) -> Result<String, String> {
     // change stderr and stdout
     let mut stderr = Writer::new_buf();
     let mut stdout = Writer::new_buf();
-    mem::swap(&mut core.stderr, &mut stderr);
-    mem::swap(&mut core.stdout, &mut stdout);
+    swap(&mut core.stderr, &mut stderr);
+    swap(&mut core.stdout, &mut stdout);
     // run command
     run_cmd(core, cmd);
     // restore stderr and stdout
-    mem::swap(&mut core.stderr, &mut stderr);
-    mem::swap(&mut core.stdout, &mut stdout);
+    swap(&mut core.stderr, &mut stderr);
+    swap(&mut core.stdout, &mut stdout);
 
     let err = stderr.utf8_string().unwrap();
     if err.is_empty() {

rair/Cargo.toml

@@ -23,6 +23,7 @@ rair-core = {workspace = true}
 rair-eval = {workspace = true}
 rair-io = {workspace = true}
 rair-trees = {workspace = true}
+rair-visual = {workspace = true}
 rustyline = {workspace = true}
 rustyline-derive = {workspace = true}
 yansi = {workspace = true}

rair/src/rair.rs

@@ -11,10 +11,12 @@ use cli::Args;
 use core::mem;
 use init::init_editor_from_core;
 use rair_core::{panic_msg, Core, Writer};
+use rair_visual::register_commands;
 use rpel::prompt_read_parse_evaluate_loop;
 
 fn main() {
     let mut core = Core::new();
+    register_commands(&mut core);
     let editor = init_editor_from_core(&mut core);
     let args = Args::parse().unwrap_or_else(|e| panic_msg(&mut core, &e, ""));
     match args {

visual/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "rair-visual"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+cli-clipboard = { workspace = true}
+parking_lot = {workspace = true}
+rair-core ={workspace = true}
+rair-eval = {workspace = true}
+rair-env = {workspace = true}
+rair-io = {workspace = true}
+ratatui = {workspace = true}

visual/src/commands/mod.rs

@@ -0,0 +1,9 @@
+mod visual_hex;
+
+use rair_core::Core;
+use visual_hex::VisualHex;
+
+pub fn register_commands(core: &mut Core) {
+    let vx = VisualHex::new(core);
+    core.add_command(vx);
+}

visual/src/commands/visual_hex/addresses.rs

@@ -0,0 +1,35 @@
+use crate::visual_hex::VisualHexEnv;
+
+use super::VisualHex;
+use rair_core::Core;
+use ratatui::prelude::*;
+use std::iter::once;
+
+impl VisualHex {
+    /// Finds the maximum width of any address that will be currently rendered
+    pub(super) fn max_address_str_width(&mut self, core: &mut Core, chunk: &Rect) -> u16 {
+        let loc = core.get_loc();
+        let size = self.calculate_bytes_to_render(chunk);
+        // we don't put the address of the last bytes, but we put the address
+        // and then the last byte is 16 + that address.
+        let max_loc = loc.saturating_add(size).saturating_sub(16);
+        format!("0x{:08x} ", max_loc).len() as u16
+    }
+    /// renders the column of all addresses + header
+    pub(super) fn render_addresses(
+        &mut self,
+        f: &mut Frame,
+        chunk: Rect,
+        core: &mut Core,
+        env: &VisualHexEnv,
+    ) {
+        // TODO center the header
+        let banner = env.render_addresses_banner(core);
+        let loc = core.get_loc();
+        // TODO overflow here
+        let addresses = (1..chunk.height as u64).map(|i| env.render_addresses(loc + 16 * (i - 1)));
+        let lines: Vec<_> = once(banner).chain(addresses).collect();
+        let text = Text::from(lines);
+        f.render_widget(text, chunk);
+    }
+}

visual/src/commands/visual_hex/ascii.rs

@@ -0,0 +1,47 @@
+use crate::visual_hex::VisualHexEnv;
+
+use super::{mode::Mode, VisualHex};
+use rair_core::Core;
+use ratatui::prelude::*;
+use std::collections::BTreeMap;
+
+impl VisualHex {
+    fn ascii_line<'a>(
+        &self,
+        loc: u64,
+        data: &BTreeMap<u64, u8>,
+        env: &'a VisualHexEnv,
+    ) -> Line<'a> {
+        let mut spans = Vec::with_capacity(16);
+        for j in 0..16 {
+            let byte = data.get(&(j + loc)).copied();
+            let span = env.render_ascii(byte);
+            let span = match &self.mode {
+                Mode::Edit(editor) => editor.span_ascii(span, loc + j),
+                Mode::Select(selector) => selector.span_ascii(span, loc + j),
+                _ => span,
+            };
+            spans.push(span);
+        }
+        Line::default().spans(spans)
+    }
+    pub(super) fn render_ascii(
+        &self,
+        f: &mut Frame,
+        chunk: Rect,
+        core: &Core,
+        data: &BTreeMap<u64, u8>,
+        env: &VisualHexEnv,
+    ) {
+        let mut lines: Vec<Line<'_>> = Vec::with_capacity(chunk.height as usize + 1);
+        lines.push(env.render_ascii_banner());
+
+        let loc = core.get_loc();
+
+        for i in 0..chunk.height as u64 {
+            lines.push(self.ascii_line(loc + i * 16, data, env));
+        }
+        let txt = Text::from(lines);
+        f.render_widget(txt, chunk);
+    }
+}

visual/src/commands/visual_hex/command.rs

@@ -0,0 +1,51 @@
+use ratatui::{
+    layout::{Position, Rect},
+    text::Line,
+    Frame,
+};
+use std::cmp::max;
+
+#[derive(Default)]
+pub struct Command {
+    input: String,
+    cursor: usize,
+}
+
+impl Command {
+    pub fn move_cursor_left(&mut self) {
+        self.cursor = self.cursor.saturating_sub(1);
+    }
+    pub fn move_cursor_right(&mut self) {
+        self.cursor = max(self.cursor.saturating_add(1), self.input.len())
+    }
+    pub fn delete_char(&mut self) {
+        if self.cursor == 0 {
+            return;
+        }
+        let from_left_to_custor = self.cursor - 1;
+        // Getting all characters before the selected character.
+        let before_char_to_delete = self.input.chars().take(from_left_to_custor);
+        // Getting all characters after selected character.
+        let after_char_to_delete = self.input.chars().skip(self.cursor);
+        self.input = before_char_to_delete.chain(after_char_to_delete).collect();
+        self.move_cursor_left();
+    }
+    pub fn enter_char(&mut self, c: char) {
+        let index = self
+            .input
+            .char_indices()
+            .map(|(i, _)| i)
+            .nth(self.cursor)
+            .unwrap_or(self.input.len());
+        self.input.insert(index, c);
+        self.move_cursor_right();
+    }
+    pub fn get_str(&self) -> &str {
+        &self.input
+    }
+    pub fn render(&self, f: &mut Frame, chunk: Rect) {
+        let input = Line::from(format!(":{}", self.input));
+        f.render_widget(input, chunk);
+        f.set_cursor_position(Position::new(chunk.x + self.cursor as u16 + 1, chunk.y));
+    }
+}