better keybindings and animated cursor

macos-click-through
keith 5 years ago
parent 66d9b05657
commit 44b545fa28

@ -1,4 +1,5 @@
use std::collections::HashMap;
use skulpin::skia_safe::{colors, Color4f};
use neovim_lib::{Neovim, NeovimApi};
@ -31,10 +32,10 @@ pub struct Style {
#[derive(new)]
pub struct GridLineCell {
pub grid: u16,
pub grid: usize,
pub text: String,
pub row: u16,
pub col_start: u16,
pub row: usize,
pub col_start: usize,
pub style_id: Option<u64>
}
@ -43,27 +44,36 @@ pub type GridCell = Option<(char, Style)>;
#[derive(new, Debug, Clone)]
pub struct DrawCommand {
pub text: String,
pub row: u16,
pub col_start: u16,
pub row: usize,
pub col_start: usize,
pub style: Style
}
#[derive(Clone)]
pub enum CursorType {
Block,
Horizontal,
Vertical
}
pub struct Editor {
pub nvim: Neovim,
pub grid: Vec<Vec<GridCell>>,
pub cursor_pos: (u16, u16),
pub size: (u16, u16),
pub cursor_pos: (usize, usize),
pub cursor_type: CursorType,
pub size: (usize, usize),
pub default_colors: Colors,
pub defined_styles: HashMap<u64, Style>,
pub previous_style: Option<Style>
}
impl Editor {
pub fn new(nvim: Neovim, width: u16, height: u16) -> Editor {
pub fn new(nvim: Neovim, width: usize, height: usize) -> Editor {
let mut editor = Editor {
nvim,
grid: Vec::new(),
cursor_pos: (0, 0),
cursor_type: CursorType::Block,
size: (width, height),
default_colors: Colors::new(Some(colors::WHITE), Some(colors::BLACK), Some(colors::GREY)),
defined_styles: HashMap::new(),
@ -91,7 +101,7 @@ impl Editor {
}
}
fn add_character(command: &mut Option<DrawCommand>, character: &char, row_index: u16, col_index: u16, style: Style) {
fn add_character(command: &mut Option<DrawCommand>, character: &char, row_index: usize, col_index: usize, style: Style) {
match command {
Some(command) => command.text.push(character.clone()),
None => {
@ -106,7 +116,7 @@ impl Editor {
add_command(&mut draw_commands, command);
command = None;
}
add_character(&mut command, &character, row_index as u16, col_index as u16, new_style.clone());
add_character(&mut command, &character, row_index as usize, col_index as usize, new_style.clone());
} else {
add_command(&mut draw_commands, command);
command = None;
@ -144,12 +154,62 @@ impl Editor {
self.previous_style = Some(style);
}
pub fn scroll_region(&mut self, top: isize, bot: isize, left: isize, right: isize, rows: isize, cols: isize) {
let (top, bot) = if rows > 0 {
(top + rows, bot)
} else if rows < 0 {
(top, bot + rows)
} else {
(top, bot)
};
let (left, right) = if cols > 0 {
(left + cols, right)
} else if rows < 0 {
(left, right + cols)
} else {
(left, right)
};
let width = right - left;
let height = bot - top;
let mut region = Vec::new();
for y in top..bot {
let row = &self.grid[y as usize];
let mut copied_section = Vec::new();
for x in left..right {
copied_section.push(row[x as usize].clone());
}
region.push(copied_section);
}
let new_top = top as isize - rows;
let new_left = left as isize - cols;
dbg!(top, bot, left, right, rows, cols, new_top, new_left);
for (y, row_section) in region.into_iter().enumerate() {
for (x, cell) in row_section.into_iter().enumerate() {
let y = new_top + y as isize;
if y >= 0 && y < self.grid.len() as isize {
let mut row = &mut self.grid[y as usize];
let x = new_left + x as isize;
if x >= 0 && x < row.len() as isize {
row[x as usize] = cell;
}
}
}
}
}
pub fn clear(&mut self) {
let (width, height) = self.size;
self.grid = vec![vec![None; width as usize]; height as usize];
}
pub fn resize(&mut self, new_width: u16, new_height: u16) {
pub fn resize(&mut self, new_width: usize, new_height: usize) {
self.nvim.ui_try_resize(new_width as i64, new_height as i64).expect("Resize failed");
self.size = (new_width, new_height);
}
@ -162,7 +222,7 @@ impl Editor {
self.default_colors = Colors::new(Some(foreground), Some(background), Some(special));
}
pub fn jump_cursor_to(&mut self, row: u16, col: u16) {
pub fn jump_cursor_to(&mut self, row: usize, col: usize) {
self.cursor_pos = (row, col);
}
}

@ -80,13 +80,15 @@ fn parse_keycode(keycode: VirtualKeyCode) -> Option<(String, bool)> {
VirtualKeyCode::Space => Some(("Space".to_string(), true)),
VirtualKeyCode::Apostrophe => Some(("'".to_string(), false)),
VirtualKeyCode::Backslash => Some(("Bslash".to_string(), true)),
VirtualKeyCode::Colon => Some((":".to_string(), false)),
VirtualKeyCode::Comma => Some((",".to_string(), false)),
VirtualKeyCode::Decimal => Some((".".to_string(), false)),
VirtualKeyCode::Divide => Some(("/".to_string(), false)),
VirtualKeyCode::Equals => Some(("=".to_string(), false)),
VirtualKeyCode::LBracket => Some(("[".to_string(), false)),
VirtualKeyCode::Minus => Some(("-".to_string(), false)),
VirtualKeyCode::Period => Some((".".to_string(), false)),
VirtualKeyCode::RBracket => Some(("]".to_string(), false)),
VirtualKeyCode::Semicolon => Some((";".to_string(), false)),
VirtualKeyCode::Slash => Some(("/".to_string(), false)),
VirtualKeyCode::Tab => Some(("<Tab>".to_string(), false)),
_ => None
}
}
@ -97,11 +99,6 @@ fn append_modifiers(modifiers: ModifiersState, keycode_text: String, special: bo
if modifiers.shift {
result = match result.as_ref() {
"," => "<".to_string(),
"." => ">".to_string(),
";" => ":".to_string(),
"=" => "+".to_string(),
"-" => "_".to_string(),
"1" => "!".to_string(),
"2" => "@".to_string(),
"3" => "#".to_string(),
@ -112,6 +109,16 @@ fn append_modifiers(modifiers: ModifiersState, keycode_text: String, special: bo
"8" => "*".to_string(),
"9" => "(".to_string(),
"0" => ")".to_string(),
"'" => "\"".to_string(),
"Bslash" => "|".to_string(),
"," => "<".to_string(),
"=" => "+".to_string(),
"[" => "{".to_string(),
"-" => "_".to_string(),
"." => ">".to_string(),
"]" => "}".to_string(),
";" => ":".to_string(),
"/" => "?".to_string(),
other => {
special = true;
format!("S-{}", result)

@ -1,4 +1,4 @@
//#![windows_subsystem = "windows"]
#![windows_subsystem = "windows"]
mod editor;
mod window;
@ -21,16 +21,16 @@ use editor::{Colors, Editor, GridLineCell, Style};
use skulpin::skia_safe::Color4f;
const INITIAL_WIDTH: u16 = 100;
const INITIAL_HEIGHT: u16 = 50;
const INITIAL_WIDTH: usize = 100;
const INITIAL_HEIGHT: usize = 50;
fn handle_grid_line(grid_line_arguments: &Vec<Value>, editor: &Arc<Mutex<Editor>>) {
if let [Value::Integer(grid_id), Value::Integer(row), Value::Integer(col_start), Value::Array(cells)] = grid_line_arguments.as_slice() {
let mut col_pos = col_start.as_u64().unwrap() as u16;
let mut col_pos = col_start.as_u64().unwrap() as usize;
for cell in cells.into_iter() {
if let Value::Array(cell_data) = cell {
let grid_id = grid_id.as_u64().unwrap() as u16;
let row = row.as_u64().unwrap() as u16;
let grid_id = grid_id.as_u64().unwrap() as usize;
let row = row.as_u64().unwrap() as usize;
let mut text = match cell_data.get(0).expect("Cell must have non zero size") {
Value::String(cell_text) => cell_text.as_str().expect("Could not process string").to_string(),
@ -47,7 +47,7 @@ fn handle_grid_line(grid_line_arguments: &Vec<Value>, editor: &Arc<Mutex<Editor>
}
let mut editor = editor.lock().unwrap();
let length = text.chars().count() as u16;
let length = text.chars().count();
editor.draw(GridLineCell::new(grid_id, text, row, col_pos, style_id));
col_pos = col_pos + length;
} else {
@ -67,7 +67,7 @@ fn handle_clear(_clear_arguments: &Vec<Value>, editor: &Arc<Mutex<Editor>>) {
fn handle_cursor_goto(cursor_goto_arguments: &Vec<Value>, editor: &Arc<Mutex<Editor>>) {
if let [Value::Integer(_grid_id), Value::Integer(row), Value::Integer(column)] = cursor_goto_arguments.as_slice() {
let mut editor = editor.lock().unwrap();
editor.jump_cursor_to(column.as_u64().unwrap() as u16, row.as_u64().unwrap() as u16);
editor.jump_cursor_to(column.as_u64().unwrap() as usize, row.as_u64().unwrap() as usize);
} else {
println!("Invalid cursor_goto format: {:?}", cursor_goto_arguments);
}
@ -107,7 +107,6 @@ fn handle_hl_attr_define(hl_attr_define_arguments: &Vec<Value>, editor: &Arc<Mut
Value::Integer(id), Value::Map(attributes), Value::Map(_terminal_attributes), Value::Array(_info)
] = hl_attr_define_arguments.as_slice() {
let id = id.as_u64().unwrap();
let mut editor = editor.lock().unwrap();
let mut style = Style::new(Colors::new(None, None, None));
for attribute in attributes {
if let (Value::String(name), value) = attribute {
@ -121,10 +120,28 @@ fn handle_hl_attr_define(hl_attr_define_arguments: &Vec<Value>, editor: &Arc<Mut
println!("Invalid attribute format");
}
}
let mut editor = editor.lock().unwrap();
editor.define_style(id, style);
}
}
fn handle_grid_scroll(grid_scroll_arguments: &Vec<Value>, editor: &Arc<Mutex<Editor>>) {
if let [
Value::Integer(_grid_id), Value::Integer(top), Value::Integer(bot), Value::Integer(left),
Value::Integer(right), Value::Integer(rows), Value::Integer(cols)
] = grid_scroll_arguments.as_slice() {
let top = top.as_u64().unwrap() as isize;
let bot = bot.as_u64().unwrap() as isize;
let left = left.as_u64().unwrap() as isize;
let right = right.as_u64().unwrap() as isize;
let rows = rows.as_i64().unwrap() as isize;
let cols = cols.as_i64().unwrap() as isize;
let mut editor = editor.lock().unwrap();
editor.scroll_region(top, bot, left, right, rows, cols);
}
}
fn handle_redraw_event(event_value: Value, editor: &Arc<Mutex<Editor>>) {
match event_value {
Value::Array(event_contents) => {
@ -137,10 +154,11 @@ fn handle_redraw_event(event_value: Value, editor: &Arc<Mutex<Editor>>) {
"grid_resize" => println!("grid_resize event ignored"),
"default_colors_set" => handle_default_colors(arguments, editor),
"hl_attr_define" => handle_hl_attr_define(arguments, editor),
"hl_group_set" => println!("hl_group_set event ignored"),
"grid_line" => handle_grid_line(arguments, &editor),
"grid_clear" => handle_clear(arguments, &editor),
"grid_cursor_goto" => handle_cursor_goto(arguments, &editor),
"hl_group_set" => println!("hl_group_set event ignored"),
"grid_scroll" => handle_grid_scroll(arguments, &editor),
other => println!("Unhandled redraw command {}", other)
}
},

@ -5,14 +5,14 @@ use skulpin::{CoordinateSystem, CoordinateSystemHelper, RendererBuilder};
use skulpin::skia_safe::{Canvas, Color4f, Font, FontStyle, Point, Paint, Rect, Typeface};
use skulpin::skia_safe::paint::Style;
use skulpin::skia_safe::matrix::ScaleToFit;
use skulpin::winit::dpi::LogicalSize;
use skulpin::winit::dpi::{LogicalSize, LogicalPosition};
use skulpin::winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent};
use skulpin::winit::event_loop::{ControlFlow, EventLoop};
use skulpin::winit::window::WindowBuilder;
use neovim_lib::NeovimApi;
use crate::editor::{DrawCommand, Editor, Colors};
use crate::editor::{DrawCommand, Editor, Colors, CursorType};
use crate::keybindings::construct_keybinding_string;
const FONT_NAME: &str = "Delugia Nerd Font";
@ -24,19 +24,24 @@ const FONT_SIZE: f32 = 14.0;
fn draw(
editor: &Arc<Mutex<Editor>>,
canvas: &mut Canvas,
cursor_pos: &mut (f32, f32),
font: &Font,
font_width: f32,
font_height: f32
) {
// let shaper = Shaper::new(None);
// if let Some((blob, _)) = shaper.shape_text_blob("This is a test ~==", font, false, 10000.0, Point::default()) {
// canvas.draw_text_blob(&blob, (50, 50), &paint);
// }
let (draw_commands, default_colors, cursor_pos) = {
let (draw_commands, default_colors, cursor_grid_pos, cursor_type) = {
let editor = editor.lock().unwrap();
(editor.build_draw_commands().clone(), editor.default_colors.clone(), editor.cursor_pos.clone())
(
editor.build_draw_commands().clone(),
editor.default_colors.clone(),
editor.cursor_pos.clone(),
editor.cursor_type.clone()
)
};
canvas.clear(default_colors.background.clone().unwrap().to_color());
@ -55,14 +60,37 @@ fn draw(
canvas.draw_str(&command.text, (x, y), &font, &foreground_paint);
}
let (cursor_grid_x, cursor_grid_y) = cursor_pos;
let cursor_x = cursor_grid_x as f32 * font_width;
let cursor_width = font_width / 8.0;
let cursor_y = cursor_grid_y as f32 * font_height;
let cursor_height = font_height;
let (cursor_grid_x, cursor_grid_y) = cursor_grid_pos;
let target_cursor_x = cursor_grid_x as f32 * font_width;
let target_cursor_y = cursor_grid_y as f32 * font_height;
let (previous_cursor_x, previous_cursor_y) = cursor_pos;
let cursor_x = (target_cursor_x - *previous_cursor_x) * 0.05 + *previous_cursor_x;
let cursor_y = (target_cursor_y - *previous_cursor_y) * 0.05 + *previous_cursor_y;
*cursor_pos = (cursor_x, cursor_y);
let cursor_width = match cursor_type {
CursorType::Vertical => font_width / 8.0,
CursorType::Horizontal | CursorType::Block => font_width
};
let cursor_height = match cursor_type {
CursorType::Horizontal => font_width / 8.0,
CursorType::Vertical | CursorType::Block => font_height
};
let cursor = Rect::new(cursor_x, cursor_y, cursor_x + cursor_width, cursor_y + cursor_height);
let cursor_paint = Paint::new(default_colors.foreground.unwrap(), None);
canvas.draw_rect(cursor, &cursor_paint);
if let CursorType::Block = cursor_type {
let text_paint = Paint::new(default_colors.background.unwrap(), None);
let editor = editor.lock().unwrap();
let character = editor.grid[cursor_grid_y][cursor_grid_x].clone()
.map(|(character, _)| character)
.unwrap_or(' ');
let text_y = cursor_y + font_height - font_height * 0.2;
canvas.draw_str(character.to_string(), (cursor_x, text_y), &font, &text_paint);
}
}
pub fn ui_loop(editor: Arc<Mutex<Editor>>) {
@ -95,6 +123,8 @@ pub fn ui_loop(editor: Arc<Mutex<Editor>>) {
.build(&window)
.expect("Failed to create renderer");
let mut cursor_pos = (0.0, 0.0);
// icu::init();
event_loop.run(move |event, _window_target, control_flow| {
@ -110,13 +140,13 @@ pub fn ui_loop(editor: Arc<Mutex<Editor>>) {
} => {
if new_size.width > 0.0 && new_size.height > 0.0 {
editor.lock().unwrap().resize(
(new_size.width as f32 / font_width) as u16,
(new_size.height as f32 / font_height) as u16
(new_size.width as f32 / font_width) as usize,
(new_size.height as f32 / font_height) as usize
)
}
},
Event:: WindowEvent {
Event::WindowEvent {
event: WindowEvent::KeyboardInput {
input,
..
@ -138,7 +168,7 @@ pub fn ui_loop(editor: Arc<Mutex<Editor>>) {
..
} => {
if let Err(e) = renderer.draw(&window, |canvas, _coordinate_system_helper| {
draw(&editor, canvas, &font, font_width, font_height);
draw(&editor, canvas, &mut cursor_pos, &font, font_width, font_height);
}) {
println!("Error during draw: {:?}", e);
*control_flow = ControlFlow::Exit

Loading…
Cancel
Save