//! Vim support for Zed. #[cfg(test)]mod test; mod change_list;mod command;mod digraph;mod indent;mod insert;mod mode_indicator;mod motion;mod normal;mod object;mod replace;mod rewrap;mod state;mod surrounds;mod visual; use anyhow::Result;use collections::HashMap;use editor::{ movement::{self, FindRange}, Anchor, Bias, Editor, EditorEvent, EditorMode, ToPoint,};use gpui::{ actions, impl_actions, Action, AppContext, Axis, Entity, EventEmitter, KeyContext, KeystrokeEvent, Render, Subscription, View, ViewContext, WeakView,};use insert::{NormalBefore, TemporaryNormal};use language::{CursorShape, Point, Selection, SelectionGoal, TransactionId};pub use mode_indicator::ModeIndicator;use motion::Motion;use normal::search::SearchSubmit;use schemars::JsonSchema;use serde::Deserialize;use serde_derive::Serialize;use settings::{update_settings_file, Settings, SettingsSources, SettingsStore};use state::{Mode, Operator, RecordedSelection, SearchState, VimGlobals};use std::{mem, ops::Range, sync::Arc};use surrounds::SurroundsType;use theme::ThemeSettings;use ui::{px, IntoElement, VisualContext};use vim_mode_setting::VimModeSetting;use workspace::{self, Pane, ResizeIntent, Workspace}; use crate::state::ReplayableAction; /// Used to resize the current pane#[derive(Clone, Deserialize, PartialEq)]pub struct ResizePane(pub ResizeIntent); /// An Action to Switch between modes#[derive(Clone, Deserialize, PartialEq)]pub struct SwitchMode(pub Mode); /// PushOperator is used to put vim into a "minor" mode,/// where it's waiting for a specific next set of keystrokes./// For example 'd' needs a motion to complete.#[derive(Clone, Deserialize, PartialEq)]pub struct PushOperator(pub Operator); /// Number is used to manage vim's count. Pushing a digit/// multiplis the current value by 10 and adds the digit.#[derive(Clone, Deserialize, PartialEq)]struct Number(usize); #[derive(Clone, Deserialize, PartialEq)]struct SelectRegister(String); actions!( vim, [ ClearOperators, Tab, Enter, Object, InnerObject, FindForward, FindBackward, OpenDefaultKeymap, MaximizePane, ResetPaneSizes, ]); // in the workspace namespace so it's not filtered out when vim is disabled.actions!(workspace, [ToggleVimMode]); impl_actions!( vim, [ResizePane, SwitchMode, PushOperator, Number, SelectRegister]); /// Initializes the `vim` crate.pub fn init(cx: &mut AppContext) { vim_mode_setting::init(cx); VimSettings::register(cx); VimGlobals::register(cx); cx.observe_new_views(|editor: &mut Editor, cx| Vim::register(editor, cx)) .detach(); cx.observe_new_views(|workspace: &mut Workspace, _| { workspace.register_action(|workspace, _: &ToggleVimMode, cx| { let fs = workspace.app_state().fs.clone(); let currently_enabled = Vim::enabled(cx); update_settings_file::<VimModeSetting>(fs, cx, move |setting, _| { *setting = Some(!currently_enabled) }) }); workspace.register_action(|_, _: &OpenDefaultKeymap, cx| { cx.emit(workspace::Event::OpenBundledFile { text: settings::vim_keymap(), title: "Default Vim Bindings", language: "JSON", }); }); workspace.register_action(|workspace, _: &ResetPaneSizes, cx| { workspace.reset_pane_sizes(cx); }); workspace.register_action(|workspace, _: &MaximizePane, cx| { let pane = workspace.active_pane(); let Some(size) = workspace.bounding_box_for_pane(&pane) else { return; }; let theme = ThemeSettings::get_global(cx); let height = theme.buffer_font_size(cx) * theme.buffer_line_height.value(); let desired_size = if let Some(count) = Vim::take_count(cx) { height * count } else { px(10000.) }; workspace.resize_pane(Axis::Vertical, desired_size - size.size.height, cx) }); workspace.register_action(|workspace, action: &ResizePane, cx| { let count = Vim::take_count(cx).unwrap_or(1) as f32; let theme = ThemeSettings::get_global(cx); let Ok(font_id) = cx.text_system().font_id(&theme.buffer_font) else { return; }; let Ok(width) = cx .text_system() .advance(font_id, theme.buffer_font_size(cx), 'm') else { return; }; let height = theme.buffer_font_size(cx) * theme.buffer_line_height.value(); let (axis, amount) = match action.0 { ResizeIntent::Lengthen => (Axis::Vertical, height), ResizeIntent::Shorten => (Axis::Vertical, height * -1.), ResizeIntent::Widen => (Axis::Horizontal, width.width), ResizeIntent::Narrow => (Axis::Horizontal, width.width * -1.), }; workspace.resize_pane(axis, amount * count, cx); }); workspace.register_action(|workspace, _: &SearchSubmit, cx| { let vim = workspace .focused_pane(cx) .read(cx) .active_item() .and_then(|item| item.act_as::<Editor>(cx)) .and_then(|editor| editor.read(cx).addon::<VimAddon>().cloned()); let Some(vim) = vim else { return }; vim.view .update(cx, |_, cx| cx.defer(|vim, cx| vim.search_submit(cx))) }); }) .detach();} #[derive(Clone)]pub(crate) struct VimAddon { pub(crate) view: View<Vim>,} impl editor::Addon for VimAddon { fn extend_key_context(&self, key_context: &mut KeyContext, cx: &AppContext) { self.view.read(cx).extend_key_context(key_context, cx) } fn to_any(&self) -> &dyn std::any::Any { self }} /// The state pertaining to Vim mode.pub(crate) struct Vim { pub(crate) mode: Mode, pub last_mode: Mode, pub temp_mode: bool, pub exit_temporary_mode: bool, operator_stack: Vec<Operator>, pub(crate) replacements: Vec<(Range<editor::Anchor>, String)>, pub(crate) marks: HashMap<String, Vec<Anchor>>, pub(crate) stored_visual_mode: Option<(Mode, Vec<bool>)>, pub(crate) change_list: Vec<Vec<Anchor>>, pub(crate) change_list_position: Option<usize>, pub(crate) current_tx: Option<TransactionId>, pub(crate) current_anchor: Option<Selection<Anchor>>, pub(crate) undo_modes: HashMap<TransactionId, Mode>, selected_register: Option<char>, pub search: SearchState, editor: WeakView<Editor>, _subscriptions: Vec<Subscription>,} // Hack: Vim intercepts events dispatched to a window and updates the view in response.// This means it needs a VisualContext. The easiest way to satisfy that constraint is// to make Vim a "View" that is just never actually rendered.impl Render for Vim { fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement { gpui::Empty }} enum VimEvent { Focused,}impl EventEmitter<VimEvent> for Vim {} impl Vim { /// The namespace for Vim actions. const NAMESPACE: &'static str = "vim"; pub fn new(cx: &mut ViewContext<Editor>) -> View<Self> { let editor = cx.view().clone(); cx.new_view(|cx| Vim { mode: Mode::Normal, last_mode: Mode::Normal, temp_mode: false, exit_temporary_mode: false, operator_stack: Vec::new(), replacements: Vec::new(), marks: HashMap::default(), stored_visual_mode: None, change_list: Vec::new(), change_list_position: None, current_tx: None, current_anchor: None, undo_modes: HashMap::default(), selected_register: None, search: SearchState::default(), editor: editor.downgrade(), _subscriptions: vec![ cx.observe_keystrokes(Self::observe_keystrokes), cx.subscribe(&editor, |this, _, event, cx| { this.handle_editor_event(event, cx) }), ], }) } fn register(editor: &mut Editor, cx: &mut ViewContext<Editor>) { if !editor.use_modal_editing() { return; } let mut was_enabled = Vim::enabled(cx); let mut was_toggle = VimSettings::get_global(cx).toggle_relative_line_numbers; cx.observe_global::<SettingsStore>(move |editor, cx| { let enabled = Vim::enabled(cx); let toggle = VimSettings::get_global(cx).toggle_relative_line_numbers; if enabled && was_enabled && (toggle != was_toggle) { if toggle { let is_relative = editor .addon::<VimAddon>() .map(|vim| vim.view.read(cx).mode != Mode::Insert); editor.set_relative_line_number(is_relative, cx) } else { editor.set_relative_line_number(None, cx) } } was_toggle = VimSettings::get_global(cx).toggle_relative_line_numbers; if was_enabled == enabled { return; } was_enabled = enabled; if enabled { Self::activate(editor, cx) } else { Self::deactivate(editor, cx) } }) .detach(); if was_enabled { Self::activate(editor, cx) } } fn activate(editor: &mut Editor, cx: &mut ViewContext<Editor>) { let vim = Vim::new(cx); editor.register_addon(VimAddon { view: vim.clone() }); vim.update(cx, |_, cx| { Vim::action(editor, cx, |vim, action: &SwitchMode, cx| { vim.switch_mode(action.0, false, cx) }); Vim::action(editor, cx, |vim, action: &PushOperator, cx| { vim.push_operator(action.0.clone(), cx) }); Vim::action(editor, cx, |vim, _: &ClearOperators, cx| { vim.clear_operator(cx) }); Vim::action(editor, cx, |vim, n: &Number, cx| { vim.push_count_digit(n.0, cx); }); Vim::action(editor, cx, |vim, _: &Tab, cx| { vim.input_ignored(" ".into(), cx) }); Vim::action(editor, cx, |vim, _: &Enter, cx| { vim.input_ignored("\n".into(), cx) }); normal::register(editor, cx); insert::register(editor, cx); motion::register(editor, cx); command::register(editor, cx); replace::register(editor, cx); indent::register(editor, cx); rewrap::register(editor, cx); object::register(editor, cx); visual::register(editor, cx); change_list::register(editor, cx); digraph::register(editor, cx); cx.defer(|vim, cx| { vim.focused(false, cx); }) }) } fn deactivate(editor: &mut Editor, cx: &mut ViewContext<Editor>) { editor.set_cursor_shape(CursorShape::Bar, cx); editor.set_clip_at_line_ends(false, cx); editor.set_collapse_matches(false); editor.set_input_enabled(true); editor.set_autoindent(true); editor.selections.line_mode = false; editor.unregister_addon::<VimAddon>(); editor.set_relative_line_number(None, cx); if let Some(vim) = Vim::globals(cx).focused_vim() { if vim.entity_id() == cx.view().entity_id() { Vim::globals(cx).focused_vim = None; } } } /// Register an action on the editor. pub fn action<A: Action>( editor: &mut Editor, cx: &mut ViewContext<Vim>, f: impl Fn(&mut Vim, &A, &mut ViewContext<Vim>) + 'static, ) { let subscription = editor.register_action(cx.listener(f)); cx.on_release(|_, _, _| drop(subscription)).detach(); } pub fn editor(&self) -> Option<View<Editor>> { self.editor.upgrade() } pub fn workspace(&self, cx: &mut ViewContext<Self>) -> Option<View<Workspace>> { cx.window_handle() .downcast::<Workspace>() .and_then(|handle| handle.root(cx).ok()) } pub fn pane(&self, cx: &mut ViewContext<Self>) -> Option<View<Pane>> { self.workspace(cx) .map(|workspace| workspace.read(cx).focused_pane(cx)) } pub fn enabled(cx: &mut AppContext) -> bool { VimModeSetting::get_global(cx).0 } /// Called whenever an keystroke is typed so vim can observe all actions /// and keystrokes accordingly. fn observe_keystrokes(&mut self, keystroke_event: &KeystrokeEvent, cx: &mut ViewContext<Self>) { if self.exit_temporary_mode { self.exit_temporary_mode = false; // Don't switch to insert mode if the action is temporary_normal. if let Some(action) = keystroke_event.action.as_ref() { if action.as_any().downcast_ref::<TemporaryNormal>().is_some() { return; } } self.switch_mode(Mode::Insert, false, cx) } if let Some(action) = keystroke_event.action.as_ref() { // Keystroke is handled by the vim system, so continue forward if action.name().starts_with("vim::") { return; } } else if cx.has_pending_keystrokes() || keystroke_event.keystroke.is_ime_in_progress() { return; } if let Some(operator) = self.active_operator() { match operator { Operator::Literal { prefix } => { self.handle_literal_keystroke(keystroke_event, prefix.unwrap_or_default(), cx); } _ if !operator.is_waiting(self.mode) => { self.clear_operator(cx); self.stop_recording_immediately(Box::new(ClearOperators), cx) } _ => {} } } } fn handle_editor_event(&mut self, event: &EditorEvent, cx: &mut ViewContext<Self>) { match event { EditorEvent::Focused => self.focused(true, cx), EditorEvent::Blurred => self.blurred(cx), EditorEvent::SelectionsChanged { local: true } => { self.local_selections_changed(cx); } EditorEvent::InputIgnored { text } => { self.input_ignored(text.clone(), cx); Vim::globals(cx).observe_insertion(text, None) } EditorEvent::InputHandled { text, utf16_range_to_replace: range_to_replace, } => Vim::globals(cx).observe_insertion(text, range_to_replace.clone()), EditorEvent::TransactionBegun { transaction_id } => { self.transaction_begun(*transaction_id, cx) } EditorEvent::TransactionUndone { transaction_id } => { self.transaction_undone(transaction_id, cx) } EditorEvent::Edited { .. } => self.push_to_change_list(cx), EditorEvent::FocusedIn => self.sync_vim_settings(cx), EditorEvent::CursorShapeChanged => self.cursor_shape_changed(cx), _ => {} } } fn push_operator(&mut self, operator: Operator, cx: &mut ViewContext<Self>) { if matches!( operator, Operator::Change | Operator::Delete | Operator::Replace | Operator::Indent | Operator::Outdent | Operator::Lowercase | Operator::Uppercase | Operator::OppositeCase | Operator::ToggleComments ) { self.start_recording(cx) }; // Since these operations can only be entered with pre-operators, // we need to clear the previous operators when pushing, // so that the current stack is the most correct if matches!( operator, Operator::AddSurrounds { .. } | Operator::ChangeSurrounds { .. } | Operator::DeleteSurrounds ) { self.operator_stack.clear(); if let Operator::AddSurrounds { target: None } = operator { self.start_recording(cx); } }; self.operator_stack.push(operator); self.sync_vim_settings(cx); } pub fn switch_mode(&mut self, mode: Mode, leave_selections: bool, cx: &mut ViewContext<Self>) { if self.temp_mode && mode == Mode::Normal { self.temp_mode = false;Lines 1–500 of 1209. Load more
//! Vim support for Zed. #[cfg(test)] mod test; mod change_list; mod command; mod digraph; mod indent; mod insert; mod mode_indicator; mod motion; mod normal; mod object; mod replace; mod rewrap; mod state; mod surrounds; mod visual; use anyhow::Result; use collections::HashMap; use editor::{ movement::{self, FindRange}, Anchor, Bias, Editor, EditorEvent, EditorMode, ToPoint, }; use gpui::{ actions, impl_actions, Action, AppContext, Axis, Entity, EventEmitter, KeyContext, KeystrokeEvent, Render, Subscription, View, ViewContext, WeakView, }; use insert::{NormalBefore, TemporaryNormal}; use language::{CursorShape, Point, Selection, SelectionGoal, TransactionId}; pub use mode_indicator::ModeIndicator; use motion::Motion; use normal::search::SearchSubmit; use schemars::JsonSchema; use serde::Deserialize; use serde_derive::Serialize; use settings::{update_settings_file, Settings, SettingsSources, SettingsStore}; use state::{Mode, Operator, RecordedSelection, SearchState, VimGlobals}; use std::{mem, ops::Range, sync::Arc}; use surrounds::SurroundsType; use theme::ThemeSettings; use ui::{px, IntoElement, VisualContext}; use vim_mode_setting::VimModeSetting; use workspace::{self, Pane, ResizeIntent, Workspace}; use crate::state::ReplayableAction; /// Used to resize the current pane #[derive(Clone, Deserialize, PartialEq)] pub struct ResizePane(pub ResizeIntent); /// An Action to Switch between modes #[derive(Clone, Deserialize, PartialEq)] pub struct SwitchMode(pub Mode); /// PushOperator is used to put vim into a "minor" mode, /// where it's waiting for a specific next set of keystrokes. /// For example 'd' needs a motion to complete. #[derive(Clone, Deserialize, PartialEq)] pub struct PushOperator(pub Operator); /// Number is used to manage vim's count. Pushing a digit /// multiplis the current value by 10 and adds the digit. #[derive(Clone, Deserialize, PartialEq)] struct Number(usize); #[derive(Clone, Deserialize, PartialEq)] struct SelectRegister(String); actions!( vim, [ ClearOperators, Tab, Enter, Object, InnerObject, FindForward, FindBackward, OpenDefaultKeymap, MaximizePane, ResetPaneSizes, ] ); // in the workspace namespace so it's not filtered out when vim is disabled. actions!(workspace, [ToggleVimMode]); impl_actions!( vim, [ResizePane, SwitchMode, PushOperator, Number, SelectRegister] ); /// Initializes the `vim` crate. pub fn init(cx: &mut AppContext) { vim_mode_setting::init(cx); VimSettings::register(cx); VimGlobals::register(cx); cx.observe_new_views(|editor: &mut Editor, cx| Vim::register(editor, cx)) .detach(); cx.observe_new_views(|workspace: &mut Workspace, _| { workspace.register_action(|workspace, _: &ToggleVimMode, cx| { let fs = workspace.app_state().fs.clone(); let currently_enabled = Vim::enabled(cx); update_settings_file::<VimModeSetting>(fs, cx, move |setting, _| { *setting = Some(!currently_enabled) }) }); workspace.register_action(|_, _: &OpenDefaultKeymap, cx| { cx.emit(workspace::Event::OpenBundledFile { text: settings::vim_keymap(), title: "Default Vim Bindings", language: "JSON", }); }); workspace.register_action(|workspace, _: &ResetPaneSizes, cx| { workspace.reset_pane_sizes(cx); }); workspace.register_action(|workspace, _: &MaximizePane, cx| { let pane = workspace.active_pane(); let Some(size) = workspace.bounding_box_for_pane(&pane) else { return; }; let theme = ThemeSettings::get_global(cx); let height = theme.buffer_font_size(cx) * theme.buffer_line_height.value(); let desired_size = if let Some(count) = Vim::take_count(cx) { height * count } else { px(10000.) }; workspace.resize_pane(Axis::Vertical, desired_size - size.size.height, cx) }); workspace.register_action(|workspace, action: &ResizePane, cx| { let count = Vim::take_count(cx).unwrap_or(1) as f32; let theme = ThemeSettings::get_global(cx); let Ok(font_id) = cx.text_system().font_id(&theme.buffer_font) else { return; }; let Ok(width) = cx .text_system() .advance(font_id, theme.buffer_font_size(cx), 'm') else { return; }; let height = theme.buffer_font_size(cx) * theme.buffer_line_height.value(); let (axis, amount) = match action.0 { ResizeIntent::Lengthen => (Axis::Vertical, height), ResizeIntent::Shorten => (Axis::Vertical, height * -1.), ResizeIntent::Widen => (Axis::Horizontal, width.width), ResizeIntent::Narrow => (Axis::Horizontal, width.width * -1.), }; workspace.resize_pane(axis, amount * count, cx); }); workspace.register_action(|workspace, _: &SearchSubmit, cx| { let vim = workspace .focused_pane(cx) .read(cx) .active_item() .and_then(|item| item.act_as::<Editor>(cx)) .and_then(|editor| editor.read(cx).addon::<VimAddon>().cloned()); let Some(vim) = vim else { return }; vim.view .update(cx, |_, cx| cx.defer(|vim, cx| vim.search_submit(cx))) }); }) .detach(); } #[derive(Clone)] pub(crate) struct VimAddon { pub(crate) view: View<Vim>, } impl editor::Addon for VimAddon { fn extend_key_context(&self, key_context: &mut KeyContext, cx: &AppContext) { self.view.read(cx).extend_key_context(key_context, cx) } fn to_any(&self) -> &dyn std::any::Any { self } } /// The state pertaining to Vim mode. pub(crate) struct Vim { pub(crate) mode: Mode, pub last_mode: Mode, pub temp_mode: bool, pub exit_temporary_mode: bool, operator_stack: Vec<Operator>, pub(crate) replacements: Vec<(Range<editor::Anchor>, String)>, pub(crate) marks: HashMap<String, Vec<Anchor>>, pub(crate) stored_visual_mode: Option<(Mode, Vec<bool>)>, pub(crate) change_list: Vec<Vec<Anchor>>, pub(crate) change_list_position: Option<usize>, pub(crate) current_tx: Option<TransactionId>, pub(crate) current_anchor: Option<Selection<Anchor>>, pub(crate) undo_modes: HashMap<TransactionId, Mode>, selected_register: Option<char>, pub search: SearchState, editor: WeakView<Editor>, _subscriptions: Vec<Subscription>, } // Hack: Vim intercepts events dispatched to a window and updates the view in response. // This means it needs a VisualContext. The easiest way to satisfy that constraint is // to make Vim a "View" that is just never actually rendered. impl Render for Vim { fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement { gpui::Empty } } enum VimEvent { Focused, } impl EventEmitter<VimEvent> for Vim {} impl Vim { /// The namespace for Vim actions. const NAMESPACE: &'static str = "vim"; pub fn new(cx: &mut ViewContext<Editor>) -> View<Self> { let editor = cx.view().clone(); cx.new_view(|cx| Vim { mode: Mode::Normal, last_mode: Mode::Normal, temp_mode: false, exit_temporary_mode: false, operator_stack: Vec::new(), replacements: Vec::new(), marks: HashMap::default(), stored_visual_mode: None, change_list: Vec::new(), change_list_position: None, current_tx: None, current_anchor: None, undo_modes: HashMap::default(), selected_register: None, search: SearchState::default(), editor: editor.downgrade(), _subscriptions: vec![ cx.observe_keystrokes(Self::observe_keystrokes), cx.subscribe(&editor, |this, _, event, cx| { this.handle_editor_event(event, cx) }), ], }) } fn register(editor: &mut Editor, cx: &mut ViewContext<Editor>) { if !editor.use_modal_editing() { return; } let mut was_enabled = Vim::enabled(cx); let mut was_toggle = VimSettings::get_global(cx).toggle_relative_line_numbers; cx.observe_global::<SettingsStore>(move |editor, cx| { let enabled = Vim::enabled(cx); let toggle = VimSettings::get_global(cx).toggle_relative_line_numbers; if enabled && was_enabled && (toggle != was_toggle) { if toggle { let is_relative = editor .addon::<VimAddon>() .map(|vim| vim.view.read(cx).mode != Mode::Insert); editor.set_relative_line_number(is_relative, cx) } else { editor.set_relative_line_number(None, cx) } } was_toggle = VimSettings::get_global(cx).toggle_relative_line_numbers; if was_enabled == enabled { return; } was_enabled = enabled; if enabled { Self::activate(editor, cx) } else { Self::deactivate(editor, cx) } }) .detach(); if was_enabled { Self::activate(editor, cx) } } fn activate(editor: &mut Editor, cx: &mut ViewContext<Editor>) { let vim = Vim::new(cx); editor.register_addon(VimAddon { view: vim.clone() }); vim.update(cx, |_, cx| { Vim::action(editor, cx, |vim, action: &SwitchMode, cx| { vim.switch_mode(action.0, false, cx) }); Vim::action(editor, cx, |vim, action: &PushOperator, cx| { vim.push_operator(action.0.clone(), cx) }); Vim::action(editor, cx, |vim, _: &ClearOperators, cx| { vim.clear_operator(cx) }); Vim::action(editor, cx, |vim, n: &Number, cx| { vim.push_count_digit(n.0, cx); }); Vim::action(editor, cx, |vim, _: &Tab, cx| { vim.input_ignored(" ".into(), cx) }); Vim::action(editor, cx, |vim, _: &Enter, cx| { vim.input_ignored("\n".into(), cx) }); normal::register(editor, cx); insert::register(editor, cx); motion::register(editor, cx); command::register(editor, cx); replace::register(editor, cx); indent::register(editor, cx); rewrap::register(editor, cx); object::register(editor, cx); visual::register(editor, cx); change_list::register(editor, cx); digraph::register(editor, cx); cx.defer(|vim, cx| { vim.focused(false, cx); }) }) } fn deactivate(editor: &mut Editor, cx: &mut ViewContext<Editor>) { editor.set_cursor_shape(CursorShape::Bar, cx); editor.set_clip_at_line_ends(false, cx); editor.set_collapse_matches(false); editor.set_input_enabled(true); editor.set_autoindent(true); editor.selections.line_mode = false; editor.unregister_addon::<VimAddon>(); editor.set_relative_line_number(None, cx); if let Some(vim) = Vim::globals(cx).focused_vim() { if vim.entity_id() == cx.view().entity_id() { Vim::globals(cx).focused_vim = None; } } } /// Register an action on the editor. pub fn action<A: Action>( editor: &mut Editor, cx: &mut ViewContext<Vim>, f: impl Fn(&mut Vim, &A, &mut ViewContext<Vim>) + 'static, ) { let subscription = editor.register_action(cx.listener(f)); cx.on_release(|_, _, _| drop(subscription)).detach(); } pub fn editor(&self) -> Option<View<Editor>> { self.editor.upgrade() } pub fn workspace(&self, cx: &mut ViewContext<Self>) -> Option<View<Workspace>> { cx.window_handle() .downcast::<Workspace>() .and_then(|handle| handle.root(cx).ok()) } pub fn pane(&self, cx: &mut ViewContext<Self>) -> Option<View<Pane>> { self.workspace(cx) .map(|workspace| workspace.read(cx).focused_pane(cx)) } pub fn enabled(cx: &mut AppContext) -> bool { VimModeSetting::get_global(cx).0 } /// Called whenever an keystroke is typed so vim can observe all actions /// and keystrokes accordingly. fn observe_keystrokes(&mut self, keystroke_event: &KeystrokeEvent, cx: &mut ViewContext<Self>) { if self.exit_temporary_mode { self.exit_temporary_mode = false; // Don't switch to insert mode if the action is temporary_normal. if let Some(action) = keystroke_event.action.as_ref() { if action.as_any().downcast_ref::<TemporaryNormal>().is_some() { return; } } self.switch_mode(Mode::Insert, false, cx) } if let Some(action) = keystroke_event.action.as_ref() { // Keystroke is handled by the vim system, so continue forward if action.name().starts_with("vim::") { return; } } else if cx.has_pending_keystrokes() || keystroke_event.keystroke.is_ime_in_progress() { return; } if let Some(operator) = self.active_operator() { match operator { Operator::Literal { prefix } => { self.handle_literal_keystroke(keystroke_event, prefix.unwrap_or_default(), cx); } _ if !operator.is_waiting(self.mode) => { self.clear_operator(cx); self.stop_recording_immediately(Box::new(ClearOperators), cx) } _ => {} } } } fn handle_editor_event(&mut self, event: &EditorEvent, cx: &mut ViewContext<Self>) { match event { EditorEvent::Focused => self.focused(true, cx), EditorEvent::Blurred => self.blurred(cx), EditorEvent::SelectionsChanged { local: true } => { self.local_selections_changed(cx); } EditorEvent::InputIgnored { text } => { self.input_ignored(text.clone(), cx); Vim::globals(cx).observe_insertion(text, None) } EditorEvent::InputHandled { text, utf16_range_to_replace: range_to_replace, } => Vim::globals(cx).observe_insertion(text, range_to_replace.clone()), EditorEvent::TransactionBegun { transaction_id } => { self.transaction_begun(*transaction_id, cx) } EditorEvent::TransactionUndone { transaction_id } => { self.transaction_undone(transaction_id, cx) } EditorEvent::Edited { .. } => self.push_to_change_list(cx), EditorEvent::FocusedIn => self.sync_vim_settings(cx), EditorEvent::CursorShapeChanged => self.cursor_shape_changed(cx), _ => {} } } fn push_operator(&mut self, operator: Operator, cx: &mut ViewContext<Self>) { if matches!( operator, Operator::Change | Operator::Delete | Operator::Replace | Operator::Indent | Operator::Outdent | Operator::Lowercase | Operator::Uppercase | Operator::OppositeCase | Operator::ToggleComments ) { self.start_recording(cx) }; // Since these operations can only be entered with pre-operators, // we need to clear the previous operators when pushing, // so that the current stack is the most correct if matches!( operator, Operator::AddSurrounds { .. } | Operator::ChangeSurrounds { .. } | Operator::DeleteSurrounds ) { self.operator_stack.clear(); if let Operator::AddSurrounds { target: None } = operator { self.start_recording(cx); } }; self.operator_stack.push(operator); self.sync_vim_settings(cx); } pub fn switch_mode(&mut self, mode: Mode, leave_selections: bool, cx: &mut ViewContext<Self>) { if self.temp_mode && mode == Mode::Normal { self.temp_mode = false;