neovim-gtk/src/shell.rs
2017-12-31 12:47:50 +03:00

1176 lines
34 KiB
Rust

use std::cell::RefCell;
use std::rc::Rc;
use std::sync::{Arc, Condvar, Mutex};
use std::ops::Deref;
use std::thread;
use std::time::Duration;
use cairo;
use pango::{LayoutExt, FontDescription};
use gdk;
use gdk::{ModifierType, EventButton, EventMotion, EventType, EventScroll};
use gdk_sys;
use glib;
use gtk;
use gtk::prelude::*;
use pangocairo;
use neovim_lib::{Neovim, NeovimApi, Value};
use neovim_lib::neovim_api::Tabpage;
use settings::{Settings, FontSource};
use ui_model::{UiModel, Attrs, ModelRect};
use color::{ColorModel, Color, COLOR_BLACK, COLOR_WHITE, COLOR_RED};
use nvim::{self, RedrawEvents, GuiApi, RepaintMode, ErrorReport, NeovimClient, NeovimRef,
NeovimClientAsync};
use input;
use input::keyval_to_input_string;
use cursor::Cursor;
use ui::UiMutex;
use popup_menu::PopupMenu;
use tabline::Tabline;
use error;
use mode;
use render;
use render::CellMetrics;
const DEFAULT_FONT_NAME: &str = "DejaVu Sans Mono 12";
pub const MINIMUM_SUPPORTED_NVIM_VERSION: &str = "0.2.1";
macro_rules! idle_cb_call {
($state:ident.$cb:ident($( $x:expr ),*)) => (
glib::idle_add(move || {
if let Some(ref cb) = $state.borrow().$cb {
(&mut *cb.borrow_mut())($($x),*);
}
glib::Continue(false)
});
)
}
#[derive(Debug, Clone, Copy)]
enum ResizeStateEnum {
NvimResizeTimer(usize, usize),
NvimResizeRequest(usize, usize),
Wait,
}
pub struct ResizeState {
state: ResizeStateEnum,
timer: Option<glib::SourceId>,
}
impl ResizeState {
pub fn new() -> Self {
ResizeState {
state: ResizeStateEnum::Wait,
timer: None,
}
}
}
pub struct State {
pub model: UiModel,
pub color_model: ColorModel,
cur_attrs: Option<Attrs>,
mouse_enabled: bool,
nvim: Rc<NeovimClient>,
pub font_ctx: render::Context,
cursor: Option<Cursor>,
popup_menu: RefCell<PopupMenu>,
settings: Rc<RefCell<Settings>>,
pub mode: mode::Mode,
stack: gtk::Stack,
drawing_area: gtk::DrawingArea,
tabs: Tabline,
im_context: gtk::IMMulticontext,
error_area: error::ErrorArea,
resize_state: Rc<RefCell<ResizeState>>,
options: ShellOptions,
detach_cb: Option<Box<RefCell<FnMut() + Send + 'static>>>,
nvim_started_cb: Option<Box<RefCell<FnMut() + Send + 'static>>>,
}
impl State {
pub fn new(settings: Rc<RefCell<Settings>>, options: ShellOptions) -> State {
let drawing_area = gtk::DrawingArea::new();
let popup_menu = RefCell::new(PopupMenu::new(&drawing_area));
let font_ctx = render::Context::new(FontDescription::from_string(DEFAULT_FONT_NAME));
State {
model: UiModel::empty(),
color_model: ColorModel::new(),
nvim: Rc::new(NeovimClient::new()),
cur_attrs: None,
mouse_enabled: true,
font_ctx,
cursor: None,
popup_menu,
settings,
mode: mode::Mode::new(),
// UI
stack: gtk::Stack::new(),
drawing_area,
tabs: Tabline::new(),
im_context: gtk::IMMulticontext::new(),
error_area: error::ErrorArea::new(),
resize_state: Rc::new(RefCell::new(ResizeState::new())),
options,
detach_cb: None,
nvim_started_cb: None,
}
}
/// Return NeovimRef only if vim in non blocking state
///
/// Note that this call also do neovim api call get_mode
pub fn nvim_non_blocked(&self) -> Option<NeovimRef> {
self.nvim().and_then(NeovimRef::non_blocked)
}
pub fn nvim(&self) -> Option<NeovimRef> {
self.nvim.nvim()
}
pub fn nvim_clone(&self) -> Rc<NeovimClient> {
self.nvim.clone()
}
pub fn start_nvim_initialization(&self) -> bool {
if self.nvim.is_uninitialized() {
self.nvim.set_in_progress();
true
} else {
false
}
}
pub fn set_detach_cb<F>(&mut self, cb: Option<F>)
where
F: FnMut() + Send + 'static,
{
if cb.is_some() {
self.detach_cb = Some(Box::new(RefCell::new(cb.unwrap())));
} else {
self.detach_cb = None;
}
}
pub fn set_nvim_started_cb<F>(&mut self, cb: Option<F>)
where
F: FnMut() + Send + 'static,
{
if cb.is_some() {
self.nvim_started_cb = Some(Box::new(RefCell::new(cb.unwrap())));
} else {
self.nvim_started_cb = None;
}
}
pub fn get_font_desc(&self) -> &FontDescription {
self.font_ctx.font_description()
}
pub fn set_font_desc(&mut self, desc: &str) {
self.font_ctx.update(FontDescription::from_string(desc));
self.model.clear_glyphs();
self.try_nvim_resize();
self.on_redraw(&RepaintMode::All);
}
pub fn open_file(&self, path: &str) {
if let Some(mut nvim) = self.nvim() {
nvim.command(&format!("e {}", path)).report_err();
}
}
pub fn cd(&self, path: &str) {
if let Some(mut nvim) = self.nvim() {
nvim.command(&format!("cd {}", path)).report_err();
}
}
fn close_popup_menu(&self) {
if self.popup_menu.borrow().is_open() {
if let Some(mut nvim) = self.nvim() {
nvim.input("<Esc>").report_err();
}
}
}
fn queue_draw_area<M: AsRef<ModelRect>>(&mut self, rect_list: &[M]) {
// extends by items before, then after changes
let rects: Vec<_> = rect_list
.iter()
.map(|rect| rect.as_ref().clone())
.map(|mut rect| {
rect.extend_by_items(&self.model);
rect
})
.collect();
self.update_dirty_glyphs();
for mut rect in rects {
rect.extend_by_items(&self.model);
let (x, y, width, height) =
rect.to_area_extend_ink(&self.model, self.font_ctx.cell_metrics());
self.drawing_area.queue_draw_area(x, y, width, height);
}
}
#[inline]
fn update_dirty_glyphs(&mut self) {
render::shape_dirty(&self.font_ctx, &mut self.model, &self.color_model);
}
fn im_commit(&self, ch: &str) {
if let Some(mut nvim) = self.nvim() {
input::im_input(&mut nvim, ch);
}
}
fn calc_nvim_size(&self) -> (usize, usize) {
let &CellMetrics {
line_height,
char_width,
..
} = self.font_ctx.cell_metrics();
let alloc = self.drawing_area.get_allocation();
(
(alloc.width as f64 / char_width).trunc() as usize,
(alloc.height as f64 / line_height).trunc() as usize,
)
}
fn show_error_area(&self) {
let stack = self.stack.clone();
gtk::idle_add(move || {
stack.set_visible_child_name("Error");
Continue(false)
});
}
fn set_im_location(&self) {
let (row, col) = self.model.get_cursor();
let (x, y, width, height) =
ModelRect::point(col, row).to_area(self.font_ctx.cell_metrics());
self.im_context.set_cursor_location(&gdk::Rectangle {
x,
y,
width,
height,
});
self.im_context.reset();
}
fn try_nvim_resize(&self) {
let (columns, rows) = self.calc_nvim_size();
let mut resize_state = self.resize_state.borrow_mut();
match resize_state.state {
ResizeStateEnum::NvimResizeTimer(req_columns, req_rows) => {
if req_columns == columns && req_rows == rows {
return;
}
glib::source_remove(resize_state.timer.take().unwrap());
resize_state.state = ResizeStateEnum::Wait;
}
ResizeStateEnum::NvimResizeRequest(req_columns, req_rows) => {
if req_columns == columns && req_rows == rows {
return;
}
}
ResizeStateEnum::Wait => (),
}
let resize_state_ref = self.resize_state.clone();
let nvim = self.nvim.clone();
if self.model.rows == rows && self.model.columns == columns {
return;
}
resize_state.state = ResizeStateEnum::NvimResizeTimer(columns, rows);
resize_state.timer = Some(gtk::timeout_add(250, move || {
let mut resize_state = resize_state_ref.borrow_mut();
resize_state.state = ResizeStateEnum::NvimResizeRequest(columns, rows);
resize_state.timer = None;
if let Some(mut nvim) = nvim.nvim().and_then(NeovimRef::non_blocked) {
if let Err(err) = nvim.ui_try_resize(columns as u64, rows as u64) {
error!("Error trying resize nvim {}", err);
}
}
Continue(false)
}));
}
fn resize_main_window(&mut self) {
let &CellMetrics {
line_height,
char_width,
..
} = self.font_ctx.cell_metrics();
let width = self.drawing_area.get_allocated_width();
let height = self.drawing_area.get_allocated_height();
let request_height = (self.model.rows as f64 * line_height) as i32;
let request_width = (self.model.columns as f64 * char_width) as i32;
if width != request_width || height != request_height {
let window: gtk::Window = self.drawing_area
.get_toplevel()
.unwrap()
.downcast()
.unwrap();
let (win_width, win_height) = window.get_size();
let h_border = win_width - width;
let v_border = win_height - height;
window.resize(request_width + h_border, request_height + v_border);
}
}
fn edit_paste(&self, clipboard: &str) {
let nvim = self.nvim();
if let Some(mut nvim) = nvim {
if self.mode.is(&mode::NvimMode::Insert) || self.mode.is(&mode::NvimMode::Normal) {
let paste_code = format!("normal! \"{}P", clipboard);
nvim.command(&paste_code).report_err();
} else {
let paste_code = format!("<C-r>{}", clipboard);
nvim.input(&paste_code).report_err();
};
}
}
}
pub struct UiState {
mouse_pressed: bool,
scroll_delta: (f64, f64),
}
impl UiState {
pub fn new() -> UiState {
UiState {
mouse_pressed: false,
scroll_delta: (0.0, 0.0),
}
}
}
#[derive(Clone)]
pub struct ShellOptions {
nvim_bin_path: Option<String>,
open_path: Option<String>,
timeout: Option<Duration>,
}
impl ShellOptions {
pub fn new(
nvim_bin_path: Option<String>,
open_path: Option<String>,
timeout: Option<Duration>,
) -> Self {
ShellOptions {
nvim_bin_path,
open_path,
timeout,
}
}
}
pub struct Shell {
pub state: Arc<UiMutex<State>>,
ui_state: Rc<RefCell<UiState>>,
widget: gtk::Box,
}
impl Shell {
pub fn new(settings: Rc<RefCell<Settings>>, options: ShellOptions) -> Shell {
let shell = Shell {
state: Arc::new(UiMutex::new(State::new(settings, options))),
ui_state: Rc::new(RefCell::new(UiState::new())),
widget: gtk::Box::new(gtk::Orientation::Vertical, 0),
};
let shell_ref = Arc::downgrade(&shell.state);
shell.state.borrow_mut().cursor = Some(Cursor::new(shell_ref));
shell
}
pub fn is_nvim_initialized(&self) -> bool {
let state = self.state.borrow();
state.nvim.is_initialized()
}
pub fn init(&mut self) {
let state = self.state.borrow();
state.drawing_area.set_hexpand(true);
state.drawing_area.set_vexpand(true);
state.drawing_area.set_can_focus(true);
state.im_context.set_use_preedit(false);
let nvim_box = gtk::Box::new(gtk::Orientation::Vertical, 0);
nvim_box.pack_start(&*state.tabs, false, true, 0);
nvim_box.pack_start(&state.drawing_area, true, true, 0);
state.stack.add_named(&nvim_box, "Nvim");
state.stack.add_named(&*state.error_area, "Error");
self.widget.pack_start(&state.stack, true, true, 0);
state.drawing_area.set_events(
(gdk_sys::GDK_BUTTON_RELEASE_MASK | gdk_sys::GDK_BUTTON_PRESS_MASK |
gdk_sys::GDK_BUTTON_MOTION_MASK | gdk_sys::GDK_SCROLL_MASK |
gdk_sys::GDK_SMOOTH_SCROLL_MASK)
.bits() as i32,
);
let ref_state = self.state.clone();
let ref_ui_state = self.ui_state.clone();
state.drawing_area.connect_button_press_event(move |_, ev| {
gtk_button_press(
&mut *ref_state.borrow_mut(),
&mut *ref_ui_state.borrow_mut(),
ev,
)
});
let ref_state = self.state.clone();
let ref_ui_state = self.ui_state.clone();
state.drawing_area.connect_button_release_event(
move |_, ev| {
gtk_button_release(
&mut *ref_state.borrow_mut(),
&mut *ref_ui_state.borrow_mut(),
ev,
)
},
);
let ref_state = self.state.clone();
let ref_ui_state = self.ui_state.clone();
state.drawing_area.connect_motion_notify_event(
move |_, ev| {
gtk_motion_notify(
&mut *ref_state.borrow_mut(),
&mut *ref_ui_state.borrow_mut(),
ev,
)
},
);
let ref_state = self.state.clone();
state.drawing_area.connect_draw(
move |_, ctx| gtk_draw(&ref_state, ctx),
);
let ref_state = self.state.clone();
state.drawing_area.connect_key_press_event(move |_, ev| {
ref_state
.borrow_mut()
.cursor
.as_mut()
.unwrap()
.reset_state();
if ref_state.borrow().im_context.filter_keypress(ev) {
Inhibit(true)
} else {
let state = ref_state.borrow();
let nvim = state.nvim();
if let Some(mut nvim) = nvim {
input::gtk_key_press(&mut nvim, ev)
} else {
Inhibit(false)
}
}
});
let ref_state = self.state.clone();
state.drawing_area.connect_key_release_event(move |_, ev| {
ref_state.borrow().im_context.filter_keypress(ev);
Inhibit(false)
});
let ref_state = self.state.clone();
let ref_ui_state = self.ui_state.clone();
state.drawing_area.connect_scroll_event(move |_, ev| {
gtk_scroll_event(
&mut *ref_state.borrow_mut(),
&mut *ref_ui_state.borrow_mut(),
ev,
)
});
let ref_state = self.state.clone();
state.drawing_area.connect_focus_in_event(move |_, _| {
gtk_focus_in(&mut *ref_state.borrow_mut())
});
let ref_state = self.state.clone();
state.drawing_area.connect_focus_out_event(move |_, _| {
gtk_focus_out(&mut *ref_state.borrow_mut())
});
let ref_state = self.state.clone();
state.drawing_area.connect_realize(move |w| {
let ref_state = ref_state.clone();
let w = w.clone();
// sometime set_client_window does not work without idle_add
// and looks like not enabled im_context
gtk::idle_add(move || {
ref_state.borrow().im_context.set_client_window(
w.get_window().as_ref(),
);
Continue(false)
});
});
let ref_state = self.state.clone();
state.im_context.connect_commit(move |_, ch| {
ref_state.borrow().im_commit(ch)
});
let ref_state = self.state.clone();
state.drawing_area.connect_configure_event(move |_, _| {
ref_state.borrow().try_nvim_resize();
false
});
let ref_state = self.state.clone();
state.drawing_area.connect_size_allocate(
move |_, _| init_nvim(&ref_state),
);
}
#[cfg(unix)]
pub fn set_font_desc(&self, font_name: &str) {
self.state.borrow_mut().set_font_desc(font_name);
}
pub fn grab_focus(&self) {
self.state.borrow().drawing_area.grab_focus();
}
pub fn open_file(&self, path: &str) {
self.state.borrow().open_file(path);
}
pub fn cd(&self, path: &str) {
self.state.borrow().cd(path);
}
pub fn detach_ui(&mut self) {
let state = self.state.borrow();
let nvim = state.nvim();
if let Some(mut nvim) = nvim {
nvim.ui_detach().expect("Error in ui_detach");
}
}
pub fn edit_paste(&self) {
self.state.borrow().edit_paste("+");
}
pub fn edit_save_all(&self) {
let state = self.state.borrow();
let nvim = state.nvim();
if let Some(mut nvim) = nvim {
nvim.command(":wa").report_err();
}
}
pub fn set_detach_cb<F>(&self, cb: Option<F>)
where
F: FnMut() + Send + 'static,
{
let mut state = self.state.borrow_mut();
state.set_detach_cb(cb);
}
pub fn set_nvim_started_cb<F>(&self, cb: Option<F>)
where
F: FnMut() + Send + 'static,
{
let mut state = self.state.borrow_mut();
state.set_nvim_started_cb(cb);
}
}
impl Deref for Shell {
type Target = gtk::Box;
fn deref(&self) -> &gtk::Box {
&self.widget
}
}
fn gtk_focus_in(state: &mut State) -> Inhibit {
if let Some(mut nvim) = state.nvim_non_blocked() {
nvim.command("if exists('#FocusGained') | doautocmd FocusGained | endif")
.report_err();
}
state.im_context.focus_in();
state.cursor.as_mut().unwrap().enter_focus();
let point = state.model.cur_point();
state.on_redraw(&RepaintMode::Area(point));
Inhibit(false)
}
fn gtk_focus_out(state: &mut State) -> Inhibit {
if let Some(mut nvim) = state.nvim_non_blocked() {
nvim.command("if exists('#FocusLost') | doautocmd FocusLost | endif")
.report_err();
}
state.im_context.focus_out();
state.cursor.as_mut().unwrap().leave_focus();
let point = state.model.cur_point();
state.on_redraw(&RepaintMode::Area(point));
Inhibit(false)
}
fn gtk_scroll_event(state: &mut State, ui_state: &mut UiState, ev: &EventScroll) -> Inhibit {
if !state.mouse_enabled {
return Inhibit(false);
}
state.close_popup_menu();
match ev.get_direction() {
gdk::ScrollDirection::Right => {
mouse_input(state, "ScrollWheelRight", ev.get_state(), ev.get_position())
}
gdk::ScrollDirection::Left => {
mouse_input(state, "ScrollWheelLeft", ev.get_state(), ev.get_position())
}
gdk::ScrollDirection::Up => {
mouse_input(state, "ScrollWheelUp", ev.get_state(), ev.get_position())
}
gdk::ScrollDirection::Down => {
mouse_input(state, "ScrollWheelDown", ev.get_state(), ev.get_position())
}
gdk::ScrollDirection::Smooth => {
// Remember and accumulate scroll deltas, so slow scrolling still
// works.
ui_state.scroll_delta.0 += ev.as_ref().delta_x;
ui_state.scroll_delta.1 += ev.as_ref().delta_y;
// Perform scroll action for deltas with abs(delta) >= 1.
let x = ui_state.scroll_delta.0 as isize;
let y = ui_state.scroll_delta.1 as isize;
for _ in 0..x {
mouse_input(state, "ScrollWheelRight", ev.get_state(), ev.get_position())
}
for _ in 0..-x {
mouse_input(state, "ScrollWheelLeft", ev.get_state(), ev.get_position())
}
for _ in 0..y {
mouse_input(state, "ScrollWheelDown", ev.get_state(), ev.get_position())
}
for _ in 0..-y {
mouse_input(state, "ScrollWheelUp", ev.get_state(), ev.get_position())
}
// Subtract performed scroll deltas.
ui_state.scroll_delta.0 -= x as f64;
ui_state.scroll_delta.1 -= y as f64;
}
_ => (),
}
Inhibit(false)
}
fn gtk_button_press(shell: &mut State, ui_state: &mut UiState, ev: &EventButton) -> Inhibit {
if ev.get_event_type() != EventType::ButtonPress {
return Inhibit(false);
}
if shell.mouse_enabled {
ui_state.mouse_pressed = true;
match ev.get_button() {
1 => mouse_input(shell, "LeftMouse", ev.get_state(), ev.get_position()),
2 => mouse_input(shell, "MiddleMouse", ev.get_state(), ev.get_position()),
3 => mouse_input(shell, "RightMouse", ev.get_state(), ev.get_position()),
_ => (),
}
}
Inhibit(false)
}
fn mouse_input(shell: &mut State, input: &str, state: ModifierType, position: (f64, f64)) {
let &CellMetrics {
line_height,
char_width,
..
} = shell.font_ctx.cell_metrics();
let (x, y) = position;
let col = (x / char_width).trunc() as u64;
let row = (y / line_height).trunc() as u64;
let input_str = format!("{}<{},{}>", keyval_to_input_string(input, state), col, row);
let nvim = shell.nvim();
if let Some(mut nvim) = nvim {
nvim.input(&input_str).expect(
"Can't send mouse input event",
);
}
}
fn gtk_button_release(shell: &mut State, ui_state: &mut UiState, ev: &EventButton) -> Inhibit {
ui_state.mouse_pressed = false;
if shell.mouse_enabled {
match ev.get_button() {
1 => mouse_input(shell, "LeftRelease", ev.get_state(), ev.get_position()),
2 => mouse_input(shell, "MiddleRelease", ev.get_state(), ev.get_position()),
3 => mouse_input(shell, "RightRelease", ev.get_state(), ev.get_position()),
_ => (),
}
}
Inhibit(false)
}
fn gtk_motion_notify(shell: &mut State, ui_state: &mut UiState, ev: &EventMotion) -> Inhibit {
if shell.mouse_enabled && ui_state.mouse_pressed {
mouse_input(shell, "LeftDrag", ev.get_state(), ev.get_position());
}
Inhibit(false)
}
fn gtk_draw(state_arc: &Arc<UiMutex<State>>, ctx: &cairo::Context) -> Inhibit {
let state = state_arc.borrow();
if state.nvim.is_initialized() {
render::render(
ctx,
state.cursor.as_ref().unwrap(),
&state.font_ctx,
&state.model,
&state.color_model,
&state.mode,
);
} else if state.nvim.is_initializing() {
draw_initializing(&*state, ctx);
}
Inhibit(false)
}
fn show_nvim_start_error(err: &nvim::NvimInitError, state_arc: Arc<UiMutex<State>>) {
let source = err.source();
let cmd = err.cmd().unwrap().to_owned();
glib::idle_add(move || {
let state = state_arc.borrow();
state.nvim.set_error();
state.error_area.show_nvim_start_error(&source, &cmd);
state.show_error_area();
Continue(false)
});
}
fn show_nvim_init_error(err: &nvim::NvimInitError, state_arc: Arc<UiMutex<State>>) {
let source = err.source();
glib::idle_add(move || {
let state = state_arc.borrow();
state.nvim.set_error();
state.error_area.show_nvim_init_error(&source);
state.show_error_area();
Continue(false)
});
}
fn init_nvim_async(
state_arc: Arc<UiMutex<State>>,
options: ShellOptions,
cols: usize,
rows: usize,
) {
// execute nvim
let nvim = match nvim::start(
state_arc.clone(),
options.nvim_bin_path.as_ref(),
options.timeout,
) {
Ok(nvim) => nvim,
Err(err) => {
show_nvim_start_error(&err, state_arc);
return;
}
};
let nvim = set_nvim_to_state(state_arc.clone(), nvim);
// add callback on session end
let guard = nvim.borrow().unwrap().session.take_dispatch_guard();
let state_ref = state_arc.clone();
thread::spawn(move || {
guard.join().expect("Can't join dispatch thread");
glib::idle_add(move || {
state_ref.borrow().nvim.clear();
if let Some(ref cb) = state_ref.borrow().detach_cb {
(&mut *cb.borrow_mut())();
}
glib::Continue(false)
});
});
// attach ui
if let Err(err) = nvim::post_start_init(
nvim,
options.open_path.as_ref(),
cols as u64,
rows as u64,
)
{
show_nvim_init_error(&err, state_arc.clone());
} else {
set_nvim_initialized(state_arc);
}
}
fn set_nvim_to_state(state_arc: Arc<UiMutex<State>>, nvim: Neovim) -> NeovimClientAsync {
let pair = Arc::new((Mutex::new(None), Condvar::new()));
let pair2 = pair.clone();
let mut nvim = Some(nvim);
glib::idle_add(move || {
let nvim_aync = state_arc.borrow().nvim.set_nvim_async(nvim.take().unwrap());
let &(ref lock, ref cvar) = &*pair2;
let mut started = lock.lock().unwrap();
*started = Some(nvim_aync);
cvar.notify_one();
Continue(false)
});
// Wait idle set nvim properly
let &(ref lock, ref cvar) = &*pair;
let mut started = lock.lock().unwrap();
while started.is_none() {
started = cvar.wait(started).unwrap();
}
started.take().unwrap()
}
fn set_nvim_initialized(state_arc: Arc<UiMutex<State>>) {
glib::idle_add(clone!(state_arc => move || {
let mut state = state_arc.borrow_mut();
state.nvim.async_to_sync();
state.nvim.set_initialized();
state.cursor.as_mut().unwrap().start();
Continue(false)
}));
idle_cb_call!(state_arc.nvim_started_cb());
}
fn draw_initializing(state: &State, ctx: &cairo::Context) {
let layout = pangocairo::functions::create_layout(ctx).unwrap();
let desc = state.get_font_desc();
let alloc = state.drawing_area.get_allocation();
ctx.set_source_rgb(
state.color_model.bg_color.0,
state.color_model.bg_color.1,
state.color_model.bg_color.2,
);
ctx.paint();
layout.set_font_description(desc);
layout.set_text("Loading->");
let (width, height) = layout.get_pixel_size();
let x = alloc.width as f64 / 2.0 - width as f64 / 2.0;
let y = alloc.height as f64 / 2.0 - height as f64 / 2.0;
ctx.move_to(x, y);
ctx.set_source_rgb(
state.color_model.fg_color.0,
state.color_model.fg_color.1,
state.color_model.fg_color.2,
);
pangocairo::functions::update_layout(ctx, &layout);
pangocairo::functions::show_layout(ctx, &layout);
ctx.move_to(x + width as f64, y);
state.cursor.as_ref().unwrap().draw(
ctx,
&state.font_ctx,
&state.mode,
y,
false,
&state.color_model.bg_color,
);
}
fn init_nvim(state_ref: &Arc<UiMutex<State>>) {
let mut state = state_ref.borrow_mut();
if state.start_nvim_initialization() {
let (cols, rows) = state.calc_nvim_size();
state.model = UiModel::new(rows as u64, cols as u64);
state.resize_state.borrow_mut().state = ResizeStateEnum::NvimResizeRequest(cols, rows);
let state_arc = state_ref.clone();
let options = state.options.clone();
thread::spawn(move || init_nvim_async(state_arc, options, cols, rows));
}
}
impl RedrawEvents for State {
fn on_cursor_goto(&mut self, row: u64, col: u64) -> RepaintMode {
let repaint_area = self.model.set_cursor(row as usize, col as usize);
self.set_im_location();
RepaintMode::AreaList(repaint_area)
}
fn on_put(&mut self, text: &str) -> RepaintMode {
RepaintMode::Area(self.model.put(text, self.cur_attrs.as_ref()))
}
fn on_clear(&mut self) -> RepaintMode {
self.model.clear();
RepaintMode::All
}
fn on_eol_clear(&mut self) -> RepaintMode {
RepaintMode::Area(self.model.eol_clear())
}
fn on_resize(&mut self, columns: u64, rows: u64) -> RepaintMode {
let state = self.resize_state.borrow().state.clone();
match state {
ResizeStateEnum::NvimResizeTimer(..) => {
if self.model.columns != columns as usize || self.model.rows != rows as usize {
self.model = UiModel::new(rows, columns);
}
}
ResizeStateEnum::Wait |
ResizeStateEnum::NvimResizeRequest(..) => {
if self.model.columns != columns as usize || self.model.rows != rows as usize {
self.resize_state.borrow_mut().state = ResizeStateEnum::Wait;
self.model = UiModel::new(rows, columns);
self.resize_main_window();
}
}
}
if let Some(mut nvim) = self.nvim.nvim() {
self.color_model.theme.update(&mut *nvim);
}
RepaintMode::Nothing
}
fn on_redraw(&mut self, mode: &RepaintMode) {
match *mode {
RepaintMode::All => {
self.update_dirty_glyphs();
self.drawing_area.queue_draw();
}
RepaintMode::Area(ref rect) => self.queue_draw_area(&[rect]),
RepaintMode::AreaList(ref list) => self.queue_draw_area(&list.list),
RepaintMode::Nothing => (),
}
}
fn on_set_scroll_region(&mut self, top: u64, bot: u64, left: u64, right: u64) -> RepaintMode {
self.model.set_scroll_region(top, bot, left, right);
RepaintMode::Nothing
}
fn on_scroll(&mut self, count: i64) -> RepaintMode {
RepaintMode::Area(self.model.scroll(count))
}
fn on_highlight_set(&mut self, attrs: &[(Value, Value)]) -> RepaintMode {
let mut model_attrs = Attrs::new();
for &(ref key_val, ref val) in attrs {
if let Some(key) = key_val.as_str() {
match key {
"foreground" => {
if let Some(fg) = val.as_u64() {
model_attrs.foreground = Some(Color::from_indexed_color(fg));
}
}
"background" => {
if let Some(bg) = val.as_u64() {
model_attrs.background = Some(Color::from_indexed_color(bg));
}
}
"special" => {
if let Some(bg) = val.as_u64() {
model_attrs.special = Some(Color::from_indexed_color(bg));
}
}
"reverse" => model_attrs.reverse = true,
"bold" => model_attrs.bold = true,
"italic" => model_attrs.italic = true,
"underline" => model_attrs.underline = true,
"undercurl" => model_attrs.undercurl = true,
attr_key => println!("unknown attribute {}", attr_key),
};
} else {
panic!("attr key must be string");
}
}
self.cur_attrs = Some(model_attrs);
RepaintMode::Nothing
}
fn on_update_bg(&mut self, bg: i64) -> RepaintMode {
if bg >= 0 {
self.color_model.bg_color = Color::from_indexed_color(bg as u64);
} else {
self.color_model.bg_color = COLOR_BLACK;
}
RepaintMode::Nothing
}
fn on_update_fg(&mut self, fg: i64) -> RepaintMode {
if fg >= 0 {
self.color_model.fg_color = Color::from_indexed_color(fg as u64);
} else {
self.color_model.fg_color = COLOR_WHITE;
}
RepaintMode::Nothing
}
fn on_update_sp(&mut self, sp: i64) -> RepaintMode {
if sp >= 0 {
self.color_model.sp_color = Color::from_indexed_color(sp as u64);
} else {
self.color_model.sp_color = COLOR_RED;
}
RepaintMode::Nothing
}
fn on_mode_change(&mut self, mode: &str, idx: u64) -> RepaintMode {
self.mode.update(mode, idx as usize);
RepaintMode::Area(self.model.cur_point())
}
fn on_mouse(&mut self, on: bool) -> RepaintMode {
self.mouse_enabled = on;
RepaintMode::Nothing
}
fn on_busy(&mut self, busy: bool) -> RepaintMode {
if busy {
self.cursor.as_mut().unwrap().busy_on();
} else {
self.cursor.as_mut().unwrap().busy_off();
}
RepaintMode::Area(self.model.cur_point())
}
fn popupmenu_show(
&mut self,
menu: &[Vec<&str>],
selected: i64,
row: u64,
col: u64,
) -> RepaintMode {
let point = ModelRect::point(col as usize, row as usize);
let (x, y, width, height) = point.to_area(self.font_ctx.cell_metrics());
self.popup_menu.borrow_mut().show(
self,
menu,
selected,
x,
y,
width,
height,
);
RepaintMode::Nothing
}
fn popupmenu_hide(&mut self) -> RepaintMode {
self.popup_menu.borrow_mut().hide();
RepaintMode::Nothing
}
fn popupmenu_select(&mut self, selected: i64) -> RepaintMode {
self.popup_menu.borrow().select(selected);
RepaintMode::Nothing
}
fn tabline_update(
&mut self,
selected: Tabpage,
tabs: Vec<(Tabpage, Option<String>)>,
) -> RepaintMode {
self.tabs.update_tabs(&self.nvim, &selected, &tabs);
RepaintMode::Nothing
}
fn mode_info_set(
&mut self,
cursor_style_enabled: bool,
mode_info: Vec<nvim::ModeInfo>,
) -> RepaintMode {
self.mode.set_info(cursor_style_enabled, mode_info);
RepaintMode::Nothing
}
}
impl GuiApi for State {
fn set_font(&mut self, font_desc: &str) {
{
let mut settings = self.settings.borrow_mut();
settings.set_font_source(FontSource::Rpc);
}
self.set_font_desc(font_desc);
}
}