1use crate::command::command_interceptor;
2use crate::motion::MotionKind;
3use crate::normal::repeat::Replayer;
4use crate::surrounds::SurroundsType;
5use crate::{ToggleMarksView, ToggleRegistersView, UseSystemClipboard, Vim, VimAddon, VimSettings};
6use crate::{motion::Motion, object::Object};
7use anyhow::Result;
8use collections::HashMap;
9use command_palette_hooks::{CommandPaletteFilter, CommandPaletteInterceptor};
10use db::{
11 sqlez::{domain::Domain, thread_safe_connection::ThreadSafeConnection},
12 sqlez_macros::sql,
13};
14use editor::display_map::{is_invisible, replacement};
15use editor::{Anchor, ClipboardSelection, Editor, MultiBuffer, ToPoint as EditorToPoint};
16use gpui::{
17 Action, App, AppContext, BorrowAppContext, ClipboardEntry, ClipboardItem, DismissEvent, Entity,
18 EntityId, Global, HighlightStyle, StyledText, Subscription, Task, TextStyle, WeakEntity,
19};
20use language::{Buffer, BufferEvent, BufferId, Chunk, Point};
21use multi_buffer::MultiBufferRow;
22use picker::{Picker, PickerDelegate};
23use project::{Project, ProjectItem, ProjectPath};
24use serde::{Deserialize, Serialize};
25use settings::{Settings, SettingsStore};
26use std::borrow::BorrowMut;
27use std::collections::HashSet;
28use std::path::Path;
29use std::{fmt::Display, ops::Range, sync::Arc};
30use text::{Bias, ToPoint};
31use theme::ThemeSettings;
32use ui::{
33 ActiveTheme, Context, Div, FluentBuilder, KeyBinding, ParentElement, SharedString, Styled,
34 StyledTypography, Window, h_flex, rems,
35};
36use util::ResultExt;
37use util::rel_path::RelPath;
38use workspace::searchable::Direction;
39use workspace::{Workspace, WorkspaceDb, WorkspaceId};
40
41#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
42pub enum Mode {
43 Normal,
44 Insert,
45 Replace,
46 Visual,
47 VisualLine,
48 VisualBlock,
49 HelixNormal,
50 HelixSelect,
51}
52
53impl Display for Mode {
54 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 match self {
56 Mode::Normal => write!(f, "NORMAL"),
57 Mode::Insert => write!(f, "INSERT"),
58 Mode::Replace => write!(f, "REPLACE"),
59 Mode::Visual => write!(f, "VISUAL"),
60 Mode::VisualLine => write!(f, "VISUAL LINE"),
61 Mode::VisualBlock => write!(f, "VISUAL BLOCK"),
62 Mode::HelixNormal => write!(f, "NORMAL"),
63 Mode::HelixSelect => write!(f, "SELECT"),
64 }
65 }
66}
67
68impl Mode {
69 pub fn is_visual(&self) -> bool {
70 match self {
71 Self::Visual | Self::VisualLine | Self::VisualBlock | Self::HelixSelect => true,
72 Self::Normal | Self::Insert | Self::Replace | Self::HelixNormal => false,
73 }
74 }
75}
76
77impl Default for Mode {
78 fn default() -> Self {
79 Self::Normal
80 }
81}
82
83#[derive(Clone, Debug, PartialEq)]
84pub enum Operator {
85 Change,
86 Delete,
87 Yank,
88 Replace,
89 Object {
90 around: bool,
91 },
92 FindForward {
93 before: bool,
94 multiline: bool,
95 },
96 FindBackward {
97 after: bool,
98 multiline: bool,
99 },
100 Sneak {
101 first_char: Option<char>,
102 },
103 SneakBackward {
104 first_char: Option<char>,
105 },
106 AddSurrounds {
107 // Typically no need to configure this as `SendKeystrokes` can be used - see #23088.
108 target: Option<SurroundsType>,
109 },
110 ChangeSurrounds {
111 target: Option<Object>,
112 is_opening: bool,
113 },
114 DeleteSurrounds,
115 Mark,
116 Jump {
117 line: bool,
118 },
119 Indent,
120 Outdent,
121 AutoIndent,
122 Rewrap,
123 ShellCommand,
124 Lowercase,
125 Uppercase,
126 OppositeCase,
127 Rot13,
128 Rot47,
129 Digraph {
130 first_char: Option<char>,
131 },
132 Literal {
133 prefix: Option<String>,
134 },
135 Register,
136 RecordRegister,
137 ReplayRegister,
138 ToggleComments,
139 ReplaceWithRegister,
140 Exchange,
141 HelixMatch,
142 HelixNext {
143 around: bool,
144 },
145 HelixPrevious {
146 around: bool,
147 },
148}
149
150#[derive(Default, Clone, Debug)]
151pub enum RecordedSelection {
152 #[default]
153 None,
154 Visual {
155 rows: u32,
156 cols: u32,
157 },
158 SingleLine {
159 cols: u32,
160 },
161 VisualBlock {
162 rows: u32,
163 cols: u32,
164 },
165 VisualLine {
166 rows: u32,
167 },
168}
169
170#[derive(Default, Clone, Debug)]
171pub struct Register {
172 pub(crate) text: SharedString,
173 pub(crate) clipboard_selections: Option<Vec<ClipboardSelection>>,
174}
175
176impl From<Register> for ClipboardItem {
177 fn from(register: Register) -> Self {
178 if let Some(clipboard_selections) = register.clipboard_selections {
179 ClipboardItem::new_string_with_json_metadata(register.text.into(), clipboard_selections)
180 } else {
181 ClipboardItem::new_string(register.text.into())
182 }
183 }
184}
185
186impl From<ClipboardItem> for Register {
187 fn from(item: ClipboardItem) -> Self {
188 // For now, we don't store metadata for multiple entries.
189 match item.entries().first() {
190 Some(ClipboardEntry::String(value)) if item.entries().len() == 1 => Register {
191 text: value.text().to_owned().into(),
192 clipboard_selections: value.metadata_json::<Vec<ClipboardSelection>>(),
193 },
194 // For now, registers can't store images. This could change in the future.
195 _ => Register::default(),
196 }
197 }
198}
199
200impl From<String> for Register {
201 fn from(text: String) -> Self {
202 Register {
203 text: text.into(),
204 clipboard_selections: None,
205 }
206 }
207}
208
209#[derive(Default)]
210pub struct VimGlobals {
211 pub last_find: Option<Motion>,
212
213 pub dot_recording: bool,
214 pub dot_replaying: bool,
215
216 /// pre_count is the number before an operator is specified (3 in 3d2d)
217 pub pre_count: Option<usize>,
218 /// post_count is the number after an operator is specified (2 in 3d2d)
219 pub post_count: Option<usize>,
220 pub forced_motion: bool,
221 pub stop_recording_after_next_action: bool,
222 pub ignore_current_insertion: bool,
223 pub recorded_count: Option<usize>,
224 pub recording_actions: Vec<ReplayableAction>,
225 pub recorded_actions: Vec<ReplayableAction>,
226 pub recorded_selection: RecordedSelection,
227
228 pub recording_register: Option<char>,
229 pub last_recorded_register: Option<char>,
230 pub last_replayed_register: Option<char>,
231 pub replayer: Option<Replayer>,
232
233 pub last_yank: Option<SharedString>,
234 pub registers: HashMap<char, Register>,
235 pub recordings: HashMap<char, Vec<ReplayableAction>>,
236
237 pub focused_vim: Option<WeakEntity<Vim>>,
238
239 pub marks: HashMap<EntityId, Entity<MarksState>>,
240}
241
242pub struct MarksState {
243 workspace: WeakEntity<Workspace>,
244
245 multibuffer_marks: HashMap<EntityId, HashMap<String, Vec<Anchor>>>,
246 buffer_marks: HashMap<BufferId, HashMap<String, Vec<text::Anchor>>>,
247 watched_buffers: HashMap<BufferId, (MarkLocation, Subscription, Subscription)>,
248
249 serialized_marks: HashMap<Arc<Path>, HashMap<String, Vec<Point>>>,
250 global_marks: HashMap<String, MarkLocation>,
251
252 _subscription: Subscription,
253}
254
255#[derive(Debug, PartialEq, Eq, Clone)]
256pub enum MarkLocation {
257 Buffer(EntityId),
258 Path(Arc<Path>),
259}
260
261pub enum Mark {
262 Local(Vec<Anchor>),
263 Buffer(EntityId, Vec<Anchor>),
264 Path(Arc<Path>, Vec<Point>),
265}
266
267impl MarksState {
268 pub fn new(workspace: &Workspace, cx: &mut App) -> Entity<MarksState> {
269 cx.new(|cx| {
270 let buffer_store = workspace.project().read(cx).buffer_store().clone();
271 let subscription = cx.subscribe(&buffer_store, move |this: &mut Self, _, event, cx| {
272 if let project::buffer_store::BufferStoreEvent::BufferAdded(buffer) = event {
273 this.on_buffer_loaded(buffer, cx);
274 }
275 });
276
277 let mut this = Self {
278 workspace: workspace.weak_handle(),
279 multibuffer_marks: HashMap::default(),
280 buffer_marks: HashMap::default(),
281 watched_buffers: HashMap::default(),
282 serialized_marks: HashMap::default(),
283 global_marks: HashMap::default(),
284 _subscription: subscription,
285 };
286
287 this.load(cx);
288 this
289 })
290 }
291
292 fn workspace_id(&self, cx: &App) -> Option<WorkspaceId> {
293 self.workspace
294 .read_with(cx, |workspace, _| workspace.database_id())
295 .ok()
296 .flatten()
297 }
298
299 fn project(&self, cx: &App) -> Option<Entity<Project>> {
300 self.workspace
301 .read_with(cx, |workspace, _| workspace.project().clone())
302 .ok()
303 }
304
305 fn load(&mut self, cx: &mut Context<Self>) {
306 cx.spawn(async move |this, cx| {
307 let Some(workspace_id) = this.update(cx, |this, cx| this.workspace_id(cx))? else {
308 return Ok(());
309 };
310 let (marks, paths) = cx
311 .background_spawn(async move {
312 let marks = DB.get_marks(workspace_id)?;
313 let paths = DB.get_global_marks_paths(workspace_id)?;
314 anyhow::Ok((marks, paths))
315 })
316 .await?;
317 this.update(cx, |this, cx| this.loaded(marks, paths, cx))
318 })
319 .detach_and_log_err(cx);
320 }
321
322 fn loaded(
323 &mut self,
324 marks: Vec<SerializedMark>,
325 global_mark_paths: Vec<(String, Arc<Path>)>,
326 cx: &mut Context<Self>,
327 ) {
328 let Some(project) = self.project(cx) else {
329 return;
330 };
331
332 for mark in marks {
333 self.serialized_marks
334 .entry(mark.path)
335 .or_default()
336 .insert(mark.name, mark.points);
337 }
338
339 for (name, path) in global_mark_paths {
340 self.global_marks
341 .insert(name, MarkLocation::Path(path.clone()));
342
343 let project_path = project
344 .read(cx)
345 .worktrees(cx)
346 .filter_map(|worktree| {
347 let relative = path.strip_prefix(worktree.read(cx).abs_path()).ok()?;
348 let path = RelPath::new(relative, worktree.read(cx).path_style()).log_err()?;
349 Some(ProjectPath {
350 worktree_id: worktree.read(cx).id(),
351 path: path.into_arc(),
352 })
353 })
354 .next();
355 if let Some(buffer) = project_path
356 .and_then(|project_path| project.read(cx).get_open_buffer(&project_path, cx))
357 {
358 self.on_buffer_loaded(&buffer, cx)
359 }
360 }
361 }
362
363 pub fn on_buffer_loaded(&mut self, buffer_handle: &Entity<Buffer>, cx: &mut Context<Self>) {
364 let Some(project) = self.project(cx) else {
365 return;
366 };
367 let Some(project_path) = buffer_handle.read(cx).project_path(cx) else {
368 return;
369 };
370 let Some(abs_path) = project.read(cx).absolute_path(&project_path, cx) else {
371 return;
372 };
373 let abs_path: Arc<Path> = abs_path.into();
374
375 let Some(serialized_marks) = self.serialized_marks.get(&abs_path) else {
376 return;
377 };
378
379 let mut loaded_marks = HashMap::default();
380 let buffer = buffer_handle.read(cx);
381 for (name, points) in serialized_marks.iter() {
382 loaded_marks.insert(
383 name.clone(),
384 points
385 .iter()
386 .map(|point| buffer.anchor_before(buffer.clip_point(*point, Bias::Left)))
387 .collect(),
388 );
389 }
390 self.buffer_marks.insert(buffer.remote_id(), loaded_marks);
391 self.watch_buffer(MarkLocation::Path(abs_path), buffer_handle, cx)
392 }
393
394 fn serialize_buffer_marks(
395 &mut self,
396 path: Arc<Path>,
397 buffer: &Entity<Buffer>,
398 cx: &mut Context<Self>,
399 ) {
400 let new_points: HashMap<String, Vec<Point>> =
401 if let Some(anchors) = self.buffer_marks.get(&buffer.read(cx).remote_id()) {
402 anchors
403 .iter()
404 .map(|(name, anchors)| {
405 (
406 name.clone(),
407 buffer
408 .read(cx)
409 .summaries_for_anchors::<Point, _>(anchors)
410 .collect(),
411 )
412 })
413 .collect()
414 } else {
415 HashMap::default()
416 };
417 let old_points = self.serialized_marks.get(&path);
418 if old_points == Some(&new_points) {
419 return;
420 }
421 let mut to_write = HashMap::default();
422
423 for (key, value) in &new_points {
424 if self.is_global_mark(key)
425 && self.global_marks.get(key) != Some(&MarkLocation::Path(path.clone()))
426 {
427 if let Some(workspace_id) = self.workspace_id(cx) {
428 let path = path.clone();
429 let key = key.clone();
430 cx.background_spawn(async move {
431 DB.set_global_mark_path(workspace_id, key, path).await
432 })
433 .detach_and_log_err(cx);
434 }
435
436 self.global_marks
437 .insert(key.clone(), MarkLocation::Path(path.clone()));
438 }
439 if old_points.and_then(|o| o.get(key)) != Some(value) {
440 to_write.insert(key.clone(), value.clone());
441 }
442 }
443
444 self.serialized_marks.insert(path.clone(), new_points);
445
446 if let Some(workspace_id) = self.workspace_id(cx) {
447 cx.background_spawn(async move {
448 DB.set_marks(workspace_id, path.clone(), to_write).await?;
449 anyhow::Ok(())
450 })
451 .detach_and_log_err(cx);
452 }
453 }
454
455 fn is_global_mark(&self, key: &str) -> bool {
456 key.chars()
457 .next()
458 .is_some_and(|c| c.is_uppercase() || c.is_digit(10))
459 }
460
461 fn rename_buffer(
462 &mut self,
463 old_path: MarkLocation,
464 new_path: Arc<Path>,
465 buffer: &Entity<Buffer>,
466 cx: &mut Context<Self>,
467 ) {
468 if let MarkLocation::Buffer(entity_id) = old_path
469 && let Some(old_marks) = self.multibuffer_marks.remove(&entity_id)
470 {
471 let buffer_marks = old_marks
472 .into_iter()
473 .map(|(k, v)| (k, v.into_iter().map(|anchor| anchor.text_anchor).collect()))
474 .collect();
475 self.buffer_marks
476 .insert(buffer.read(cx).remote_id(), buffer_marks);
477 }
478 self.watch_buffer(MarkLocation::Path(new_path.clone()), buffer, cx);
479 self.serialize_buffer_marks(new_path, buffer, cx);
480 }
481
482 fn path_for_buffer(&self, buffer: &Entity<Buffer>, cx: &App) -> Option<Arc<Path>> {
483 let project_path = buffer.read(cx).project_path(cx)?;
484 let project = self.project(cx)?;
485 let abs_path = project.read(cx).absolute_path(&project_path, cx)?;
486 Some(abs_path.into())
487 }
488
489 fn points_at(
490 &self,
491 location: &MarkLocation,
492 multi_buffer: &Entity<MultiBuffer>,
493 cx: &App,
494 ) -> bool {
495 match location {
496 MarkLocation::Buffer(entity_id) => entity_id == &multi_buffer.entity_id(),
497 MarkLocation::Path(path) => {
498 let Some(singleton) = multi_buffer.read(cx).as_singleton() else {
499 return false;
500 };
501 self.path_for_buffer(&singleton, cx).as_ref() == Some(path)
502 }
503 }
504 }
505
506 pub fn watch_buffer(
507 &mut self,
508 mark_location: MarkLocation,
509 buffer_handle: &Entity<Buffer>,
510 cx: &mut Context<Self>,
511 ) {
512 let on_change = cx.subscribe(buffer_handle, move |this, buffer, event, cx| match event {
513 BufferEvent::Edited => {
514 if let Some(path) = this.path_for_buffer(&buffer, cx) {
515 this.serialize_buffer_marks(path, &buffer, cx);
516 }
517 }
518 BufferEvent::FileHandleChanged => {
519 let buffer_id = buffer.read(cx).remote_id();
520 if let Some(old_path) = this
521 .watched_buffers
522 .get(&buffer_id.clone())
523 .map(|(path, _, _)| path.clone())
524 && let Some(new_path) = this.path_for_buffer(&buffer, cx)
525 {
526 this.rename_buffer(old_path, new_path, &buffer, cx)
527 }
528 }
529 _ => {}
530 });
531
532 let on_release = cx.observe_release(buffer_handle, |this, buffer, _| {
533 this.watched_buffers.remove(&buffer.remote_id());
534 this.buffer_marks.remove(&buffer.remote_id());
535 });
536
537 self.watched_buffers.insert(
538 buffer_handle.read(cx).remote_id(),
539 (mark_location, on_change, on_release),
540 );
541 }
542
543 pub fn set_mark(
544 &mut self,
545 name: String,
546 multibuffer: &Entity<MultiBuffer>,
547 anchors: Vec<Anchor>,
548 cx: &mut Context<Self>,
549 ) {
550 let buffer = multibuffer.read(cx).as_singleton();
551 let abs_path = buffer.as_ref().and_then(|b| self.path_for_buffer(b, cx));
552
553 let Some(abs_path) = abs_path else {
554 self.multibuffer_marks
555 .entry(multibuffer.entity_id())
556 .or_default()
557 .insert(name.clone(), anchors);
558 if self.is_global_mark(&name) {
559 self.global_marks
560 .insert(name, MarkLocation::Buffer(multibuffer.entity_id()));
561 }
562 if let Some(buffer) = buffer {
563 let buffer_id = buffer.read(cx).remote_id();
564 if !self.watched_buffers.contains_key(&buffer_id) {
565 self.watch_buffer(MarkLocation::Buffer(multibuffer.entity_id()), &buffer, cx)
566 }
567 }
568 return;
569 };
570 let Some(buffer) = buffer else {
571 return;
572 };
573
574 let buffer_id = buffer.read(cx).remote_id();
575 self.buffer_marks.entry(buffer_id).or_default().insert(
576 name,
577 anchors
578 .into_iter()
579 .map(|anchor| anchor.text_anchor)
580 .collect(),
581 );
582 if !self.watched_buffers.contains_key(&buffer_id) {
583 self.watch_buffer(MarkLocation::Path(abs_path.clone()), &buffer, cx)
584 }
585 self.serialize_buffer_marks(abs_path, &buffer, cx)
586 }
587
588 pub fn get_mark(
589 &self,
590 name: &str,
591 multi_buffer: &Entity<MultiBuffer>,
592 cx: &App,
593 ) -> Option<Mark> {
594 let target = self.global_marks.get(name);
595
596 if !self.is_global_mark(name) || target.is_some_and(|t| self.points_at(t, multi_buffer, cx))
597 {
598 if let Some(anchors) = self.multibuffer_marks.get(&multi_buffer.entity_id()) {
599 return Some(Mark::Local(anchors.get(name)?.clone()));
600 }
601
602 let singleton = multi_buffer.read(cx).as_singleton()?;
603 let excerpt_id = *multi_buffer.read(cx).excerpt_ids().first()?;
604 let buffer_id = singleton.read(cx).remote_id();
605 if let Some(anchors) = self.buffer_marks.get(&buffer_id) {
606 let text_anchors = anchors.get(name)?;
607 let anchors = text_anchors
608 .iter()
609 .map(|anchor| Anchor::in_buffer(excerpt_id, buffer_id, *anchor))
610 .collect();
611 return Some(Mark::Local(anchors));
612 }
613 }
614
615 match target? {
616 MarkLocation::Buffer(entity_id) => {
617 let anchors = self.multibuffer_marks.get(entity_id)?;
618 Some(Mark::Buffer(*entity_id, anchors.get(name)?.clone()))
619 }
620 MarkLocation::Path(path) => {
621 let points = self.serialized_marks.get(path)?;
622 Some(Mark::Path(path.clone(), points.get(name)?.clone()))
623 }
624 }
625 }
626 pub fn delete_mark(
627 &mut self,
628 mark_name: String,
629 multi_buffer: &Entity<MultiBuffer>,
630 cx: &mut Context<Self>,
631 ) {
632 let path = if let Some(target) = self.global_marks.get(&mark_name.clone()) {
633 let name = mark_name.clone();
634 if let Some(workspace_id) = self.workspace_id(cx) {
635 cx.background_spawn(async move {
636 DB.delete_global_marks_path(workspace_id, name).await
637 })
638 .detach_and_log_err(cx);
639 }
640 self.buffer_marks.iter_mut().for_each(|(_, m)| {
641 m.remove(&mark_name.clone());
642 });
643
644 match target {
645 MarkLocation::Buffer(entity_id) => {
646 self.multibuffer_marks
647 .get_mut(entity_id)
648 .map(|m| m.remove(&mark_name.clone()));
649 return;
650 }
651 MarkLocation::Path(path) => path.clone(),
652 }
653 } else {
654 self.multibuffer_marks
655 .get_mut(&multi_buffer.entity_id())
656 .map(|m| m.remove(&mark_name.clone()));
657
658 if let Some(singleton) = multi_buffer.read(cx).as_singleton() {
659 let buffer_id = singleton.read(cx).remote_id();
660 self.buffer_marks
661 .get_mut(&buffer_id)
662 .map(|m| m.remove(&mark_name.clone()));
663 let Some(path) = self.path_for_buffer(&singleton, cx) else {
664 return;
665 };
666 path
667 } else {
668 return;
669 }
670 };
671 self.global_marks.remove(&mark_name);
672 self.serialized_marks
673 .get_mut(&path)
674 .map(|m| m.remove(&mark_name.clone()));
675 if let Some(workspace_id) = self.workspace_id(cx) {
676 cx.background_spawn(async move { DB.delete_mark(workspace_id, path, mark_name).await })
677 .detach_and_log_err(cx);
678 }
679 }
680}
681
682impl Global for VimGlobals {}
683
684impl VimGlobals {
685 pub(crate) fn register(cx: &mut App) {
686 cx.set_global(VimGlobals::default());
687
688 cx.observe_keystrokes(|event, _, cx| {
689 let Some(action) = event.action.as_ref().map(|action| action.boxed_clone()) else {
690 return;
691 };
692 Vim::globals(cx).observe_action(action.boxed_clone())
693 })
694 .detach();
695
696 cx.observe_new(|workspace: &mut Workspace, window, _| {
697 RegistersView::register(workspace, window);
698 })
699 .detach();
700
701 cx.observe_new(move |workspace: &mut Workspace, window, _| {
702 MarksView::register(workspace, window);
703 })
704 .detach();
705
706 let mut was_enabled = None;
707
708 cx.observe_global::<SettingsStore>(move |cx| {
709 let is_enabled = Vim::enabled(cx);
710 if was_enabled == Some(is_enabled) {
711 return;
712 }
713 was_enabled = Some(is_enabled);
714 if is_enabled {
715 KeyBinding::set_vim_mode(cx, true);
716 CommandPaletteFilter::update_global(cx, |filter, _| {
717 filter.show_namespace(Vim::NAMESPACE);
718 });
719 CommandPaletteInterceptor::update_global(cx, |interceptor, _| {
720 interceptor.set(Box::new(command_interceptor));
721 });
722 for window in cx.windows() {
723 if let Some(workspace) = window.downcast::<Workspace>() {
724 workspace
725 .update(cx, |workspace, _, cx| {
726 Vim::update_globals(cx, |globals, cx| {
727 globals.register_workspace(workspace, cx)
728 });
729 })
730 .ok();
731 }
732 }
733 } else {
734 KeyBinding::set_vim_mode(cx, false);
735 *Vim::globals(cx) = VimGlobals::default();
736 CommandPaletteInterceptor::update_global(cx, |interceptor, _| {
737 interceptor.clear();
738 });
739 CommandPaletteFilter::update_global(cx, |filter, _| {
740 filter.hide_namespace(Vim::NAMESPACE);
741 });
742 }
743 })
744 .detach();
745 cx.observe_new(|workspace: &mut Workspace, _, cx| {
746 Vim::update_globals(cx, |globals, cx| globals.register_workspace(workspace, cx));
747 })
748 .detach()
749 }
750
751 fn register_workspace(&mut self, workspace: &Workspace, cx: &mut Context<Workspace>) {
752 let entity_id = cx.entity_id();
753 self.marks.insert(entity_id, MarksState::new(workspace, cx));
754 cx.observe_release(&cx.entity(), move |_, _, cx| {
755 Vim::update_globals(cx, |globals, _| {
756 globals.marks.remove(&entity_id);
757 })
758 })
759 .detach();
760 }
761
762 pub(crate) fn write_registers(
763 &mut self,
764 content: Register,
765 register: Option<char>,
766 is_yank: bool,
767 kind: MotionKind,
768 cx: &mut Context<Editor>,
769 ) {
770 if let Some(register) = register {
771 let lower = register.to_lowercase().next().unwrap_or(register);
772 if lower != register {
773 let current = self.registers.entry(lower).or_default();
774 current.text = (current.text.to_string() + &content.text).into();
775 // not clear how to support appending to registers with multiple cursors
776 current.clipboard_selections.take();
777 let yanked = current.clone();
778 self.registers.insert('"', yanked);
779 } else {
780 match lower {
781 '_' | ':' | '.' | '%' | '#' | '=' | '/' => {}
782 '+' => {
783 self.registers.insert('"', content.clone());
784 cx.write_to_clipboard(content.into());
785 }
786 '*' => {
787 self.registers.insert('"', content.clone());
788 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
789 cx.write_to_primary(content.into());
790 #[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
791 cx.write_to_clipboard(content.into());
792 }
793 '"' => {
794 self.registers.insert('"', content.clone());
795 self.registers.insert('0', content);
796 }
797 _ => {
798 self.registers.insert('"', content.clone());
799 self.registers.insert(lower, content);
800 }
801 }
802 }
803 } else {
804 let setting = VimSettings::get_global(cx).use_system_clipboard;
805 if setting == UseSystemClipboard::Always
806 || setting == UseSystemClipboard::OnYank && is_yank
807 {
808 self.last_yank.replace(content.text.clone());
809 cx.write_to_clipboard(content.clone().into());
810 } else {
811 if let Some(text) = cx.read_from_clipboard().and_then(|i| i.text()) {
812 self.last_yank.replace(text.into());
813 }
814 }
815 self.registers.insert('"', content.clone());
816 if is_yank {
817 self.registers.insert('0', content);
818 } else {
819 let contains_newline = content.text.contains('\n');
820 if !contains_newline {
821 self.registers.insert('-', content.clone());
822 }
823 if kind.linewise() || contains_newline {
824 let mut content = content;
825 for i in '1'..='9' {
826 if let Some(moved) = self.registers.insert(i, content) {
827 content = moved;
828 } else {
829 break;
830 }
831 }
832 }
833 }
834 }
835 }
836
837 pub(crate) fn read_register(
838 &self,
839 register: Option<char>,
840 editor: Option<&mut Editor>,
841 cx: &mut App,
842 ) -> Option<Register> {
843 let Some(register) = register.filter(|reg| *reg != '"') else {
844 let setting = VimSettings::get_global(cx).use_system_clipboard;
845 return match setting {
846 UseSystemClipboard::Always => cx.read_from_clipboard().map(|item| item.into()),
847 UseSystemClipboard::OnYank if self.system_clipboard_is_newer(cx) => {
848 cx.read_from_clipboard().map(|item| item.into())
849 }
850 _ => self.registers.get(&'"').cloned(),
851 };
852 };
853 let lower = register.to_lowercase().next().unwrap_or(register);
854 match lower {
855 '_' | ':' | '.' | '#' | '=' => None,
856 '+' => cx.read_from_clipboard().map(|item| item.into()),
857 '*' => {
858 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
859 {
860 cx.read_from_primary().map(|item| item.into())
861 }
862 #[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
863 {
864 cx.read_from_clipboard().map(|item| item.into())
865 }
866 }
867 '%' => editor.and_then(|editor| {
868 let selection = editor.selections.newest::<Point>(cx);
869 if let Some((_, buffer, _)) = editor
870 .buffer()
871 .read(cx)
872 .excerpt_containing(selection.head(), cx)
873 {
874 buffer
875 .read(cx)
876 .file()
877 .map(|file| file.path().display(file.path_style(cx)).into_owned().into())
878 } else {
879 None
880 }
881 }),
882 _ => self.registers.get(&lower).cloned(),
883 }
884 }
885
886 fn system_clipboard_is_newer(&self, cx: &App) -> bool {
887 cx.read_from_clipboard().is_some_and(|item| {
888 match (item.text().as_deref(), &self.last_yank) {
889 (Some(new), Some(last)) => last.as_ref() != new,
890 (Some(_), None) => true,
891 (None, _) => false,
892 }
893 })
894 }
895
896 pub fn observe_action(&mut self, action: Box<dyn Action>) {
897 if self.dot_recording {
898 self.recording_actions
899 .push(ReplayableAction::Action(action.boxed_clone()));
900
901 if self.stop_recording_after_next_action {
902 self.dot_recording = false;
903 self.recorded_actions = std::mem::take(&mut self.recording_actions);
904 self.stop_recording_after_next_action = false;
905 }
906 }
907 if self.replayer.is_none()
908 && let Some(recording_register) = self.recording_register
909 {
910 self.recordings
911 .entry(recording_register)
912 .or_default()
913 .push(ReplayableAction::Action(action));
914 }
915 }
916
917 pub fn observe_insertion(&mut self, text: &Arc<str>, range_to_replace: Option<Range<isize>>) {
918 if self.ignore_current_insertion {
919 self.ignore_current_insertion = false;
920 return;
921 }
922 if self.dot_recording {
923 self.recording_actions.push(ReplayableAction::Insertion {
924 text: text.clone(),
925 utf16_range_to_replace: range_to_replace.clone(),
926 });
927 if self.stop_recording_after_next_action {
928 self.dot_recording = false;
929 self.recorded_actions = std::mem::take(&mut self.recording_actions);
930 self.stop_recording_after_next_action = false;
931 }
932 }
933 if let Some(recording_register) = self.recording_register {
934 self.recordings.entry(recording_register).or_default().push(
935 ReplayableAction::Insertion {
936 text: text.clone(),
937 utf16_range_to_replace: range_to_replace,
938 },
939 );
940 }
941 }
942
943 pub fn focused_vim(&self) -> Option<Entity<Vim>> {
944 self.focused_vim.as_ref().and_then(|vim| vim.upgrade())
945 }
946}
947
948impl Vim {
949 pub fn globals(cx: &mut App) -> &mut VimGlobals {
950 cx.global_mut::<VimGlobals>()
951 }
952
953 pub fn update_globals<C, R>(cx: &mut C, f: impl FnOnce(&mut VimGlobals, &mut C) -> R) -> R
954 where
955 C: BorrowMut<App>,
956 {
957 cx.update_global(f)
958 }
959}
960
961#[derive(Debug)]
962pub enum ReplayableAction {
963 Action(Box<dyn Action>),
964 Insertion {
965 text: Arc<str>,
966 utf16_range_to_replace: Option<Range<isize>>,
967 },
968}
969
970impl Clone for ReplayableAction {
971 fn clone(&self) -> Self {
972 match self {
973 Self::Action(action) => Self::Action(action.boxed_clone()),
974 Self::Insertion {
975 text,
976 utf16_range_to_replace,
977 } => Self::Insertion {
978 text: text.clone(),
979 utf16_range_to_replace: utf16_range_to_replace.clone(),
980 },
981 }
982 }
983}
984
985#[derive(Clone, Default, Debug)]
986pub struct SearchState {
987 pub direction: Direction,
988 pub count: usize,
989
990 pub prior_selections: Vec<Range<Anchor>>,
991 pub prior_operator: Option<Operator>,
992 pub prior_mode: Mode,
993 pub helix_select: bool,
994}
995
996impl Operator {
997 pub fn id(&self) -> &'static str {
998 match self {
999 Operator::Object { around: false } => "i",
1000 Operator::Object { around: true } => "a",
1001 Operator::Change => "c",
1002 Operator::Delete => "d",
1003 Operator::Yank => "y",
1004 Operator::Replace => "r",
1005 Operator::Digraph { .. } => "^K",
1006 Operator::Literal { .. } => "^V",
1007 Operator::FindForward { before: false, .. } => "f",
1008 Operator::FindForward { before: true, .. } => "t",
1009 Operator::Sneak { .. } => "s",
1010 Operator::SneakBackward { .. } => "S",
1011 Operator::FindBackward { after: false, .. } => "F",
1012 Operator::FindBackward { after: true, .. } => "T",
1013 Operator::AddSurrounds { .. } => "ys",
1014 Operator::ChangeSurrounds { .. } => "cs",
1015 Operator::DeleteSurrounds => "ds",
1016 Operator::Mark => "m",
1017 Operator::Jump { line: true } => "'",
1018 Operator::Jump { line: false } => "`",
1019 Operator::Indent => ">",
1020 Operator::AutoIndent => "eq",
1021 Operator::ShellCommand => "sh",
1022 Operator::Rewrap => "gq",
1023 Operator::ReplaceWithRegister => "gR",
1024 Operator::Exchange => "cx",
1025 Operator::Outdent => "<",
1026 Operator::Uppercase => "gU",
1027 Operator::Lowercase => "gu",
1028 Operator::OppositeCase => "g~",
1029 Operator::Rot13 => "g?",
1030 Operator::Rot47 => "g?",
1031 Operator::Register => "\"",
1032 Operator::RecordRegister => "q",
1033 Operator::ReplayRegister => "@",
1034 Operator::ToggleComments => "gc",
1035 Operator::HelixMatch => "helix_m",
1036 Operator::HelixNext { .. } => "helix_next",
1037 Operator::HelixPrevious { .. } => "helix_previous",
1038 }
1039 }
1040
1041 pub fn status(&self) -> String {
1042 fn make_visible(c: &str) -> &str {
1043 match c {
1044 "\n" => "enter",
1045 "\t" => "tab",
1046 " " => "space",
1047 c => c,
1048 }
1049 }
1050 match self {
1051 Operator::Digraph {
1052 first_char: Some(first_char),
1053 } => format!("^K{}", make_visible(&first_char.to_string())),
1054 Operator::Literal {
1055 prefix: Some(prefix),
1056 } => format!("^V{}", make_visible(prefix)),
1057 Operator::AutoIndent => "=".to_string(),
1058 Operator::ShellCommand => "=".to_string(),
1059 Operator::HelixMatch => "m".to_string(),
1060 Operator::HelixNext { .. } => "]".to_string(),
1061 Operator::HelixPrevious { .. } => "[".to_string(),
1062 _ => self.id().to_string(),
1063 }
1064 }
1065
1066 pub fn is_waiting(&self, mode: Mode) -> bool {
1067 match self {
1068 Operator::AddSurrounds { target } => target.is_some() || mode.is_visual(),
1069 Operator::FindForward { .. }
1070 | Operator::Mark
1071 | Operator::Jump { .. }
1072 | Operator::FindBackward { .. }
1073 | Operator::Sneak { .. }
1074 | Operator::SneakBackward { .. }
1075 | Operator::Register
1076 | Operator::RecordRegister
1077 | Operator::ReplayRegister
1078 | Operator::Replace
1079 | Operator::Digraph { .. }
1080 | Operator::Literal { .. }
1081 | Operator::ChangeSurrounds { target: Some(_) }
1082 | Operator::DeleteSurrounds => true,
1083 Operator::Change
1084 | Operator::Delete
1085 | Operator::Yank
1086 | Operator::Rewrap
1087 | Operator::Indent
1088 | Operator::Outdent
1089 | Operator::AutoIndent
1090 | Operator::ShellCommand
1091 | Operator::Lowercase
1092 | Operator::Uppercase
1093 | Operator::Rot13
1094 | Operator::Rot47
1095 | Operator::ReplaceWithRegister
1096 | Operator::Exchange
1097 | Operator::Object { .. }
1098 | Operator::ChangeSurrounds { target: None }
1099 | Operator::OppositeCase
1100 | Operator::ToggleComments
1101 | Operator::HelixMatch
1102 | Operator::HelixNext { .. }
1103 | Operator::HelixPrevious { .. } => false,
1104 }
1105 }
1106
1107 pub fn starts_dot_recording(&self) -> bool {
1108 match self {
1109 Operator::Change
1110 | Operator::Delete
1111 | Operator::Replace
1112 | Operator::Indent
1113 | Operator::Outdent
1114 | Operator::AutoIndent
1115 | Operator::Lowercase
1116 | Operator::Uppercase
1117 | Operator::OppositeCase
1118 | Operator::Rot13
1119 | Operator::Rot47
1120 | Operator::ToggleComments
1121 | Operator::ReplaceWithRegister
1122 | Operator::Rewrap
1123 | Operator::ShellCommand
1124 | Operator::AddSurrounds { target: None }
1125 | Operator::ChangeSurrounds { target: None }
1126 | Operator::DeleteSurrounds
1127 | Operator::Exchange
1128 | Operator::HelixNext { .. }
1129 | Operator::HelixPrevious { .. } => true,
1130 Operator::Yank
1131 | Operator::Object { .. }
1132 | Operator::FindForward { .. }
1133 | Operator::FindBackward { .. }
1134 | Operator::Sneak { .. }
1135 | Operator::SneakBackward { .. }
1136 | Operator::Mark
1137 | Operator::Digraph { .. }
1138 | Operator::Literal { .. }
1139 | Operator::AddSurrounds { .. }
1140 | Operator::ChangeSurrounds { .. }
1141 | Operator::Jump { .. }
1142 | Operator::Register
1143 | Operator::RecordRegister
1144 | Operator::ReplayRegister
1145 | Operator::HelixMatch => false,
1146 }
1147 }
1148}
1149
1150struct RegisterMatch {
1151 name: char,
1152 contents: SharedString,
1153}
1154
1155pub struct RegistersViewDelegate {
1156 selected_index: usize,
1157 matches: Vec<RegisterMatch>,
1158}
1159
1160impl PickerDelegate for RegistersViewDelegate {
1161 type ListItem = Div;
1162
1163 fn match_count(&self) -> usize {
1164 self.matches.len()
1165 }
1166
1167 fn selected_index(&self) -> usize {
1168 self.selected_index
1169 }
1170
1171 fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
1172 self.selected_index = ix;
1173 cx.notify();
1174 }
1175
1176 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
1177 Arc::default()
1178 }
1179
1180 fn update_matches(
1181 &mut self,
1182 _: String,
1183 _: &mut Window,
1184 _: &mut Context<Picker<Self>>,
1185 ) -> gpui::Task<()> {
1186 Task::ready(())
1187 }
1188
1189 fn confirm(&mut self, _: bool, _: &mut Window, _: &mut Context<Picker<Self>>) {}
1190
1191 fn dismissed(&mut self, _: &mut Window, _: &mut Context<Picker<Self>>) {}
1192
1193 fn render_match(
1194 &self,
1195 ix: usize,
1196 selected: bool,
1197 _: &mut Window,
1198 cx: &mut Context<Picker<Self>>,
1199 ) -> Option<Self::ListItem> {
1200 let register_match = self.matches.get(ix)?;
1201
1202 let mut output = String::new();
1203 let mut runs = Vec::new();
1204 output.push('"');
1205 output.push(register_match.name);
1206 runs.push((
1207 0..output.len(),
1208 HighlightStyle::color(cx.theme().colors().text_accent),
1209 ));
1210 output.push(' ');
1211 output.push(' ');
1212 let mut base = output.len();
1213 for (ix, c) in register_match.contents.char_indices() {
1214 if ix > 100 {
1215 break;
1216 }
1217 let replace = match c {
1218 '\t' => Some("\\t".to_string()),
1219 '\n' => Some("\\n".to_string()),
1220 '\r' => Some("\\r".to_string()),
1221 c if is_invisible(c) => {
1222 if c <= '\x1f' {
1223 replacement(c).map(|s| s.to_string())
1224 } else {
1225 Some(format!("\\u{:04X}", c as u32))
1226 }
1227 }
1228 _ => None,
1229 };
1230 let Some(replace) = replace else {
1231 output.push(c);
1232 continue;
1233 };
1234 output.push_str(&replace);
1235 runs.push((
1236 base + ix..base + ix + replace.len(),
1237 HighlightStyle::color(cx.theme().colors().text_muted),
1238 ));
1239 base += replace.len() - c.len_utf8();
1240 }
1241
1242 let theme = ThemeSettings::get_global(cx);
1243 let text_style = TextStyle {
1244 color: cx.theme().colors().editor_foreground,
1245 font_family: theme.buffer_font.family.clone(),
1246 font_features: theme.buffer_font.features.clone(),
1247 font_fallbacks: theme.buffer_font.fallbacks.clone(),
1248 font_size: theme.buffer_font_size(cx).into(),
1249 line_height: (theme.line_height() * theme.buffer_font_size(cx)).into(),
1250 font_weight: theme.buffer_font.weight,
1251 font_style: theme.buffer_font.style,
1252 ..Default::default()
1253 };
1254
1255 Some(
1256 h_flex()
1257 .when(selected, |el| el.bg(cx.theme().colors().element_selected))
1258 .font_buffer(cx)
1259 .text_buffer(cx)
1260 .h(theme.buffer_font_size(cx) * theme.line_height())
1261 .px_2()
1262 .gap_1()
1263 .child(StyledText::new(output).with_default_highlights(&text_style, runs)),
1264 )
1265 }
1266}
1267
1268pub struct RegistersView {}
1269
1270impl RegistersView {
1271 fn register(workspace: &mut Workspace, _window: Option<&mut Window>) {
1272 workspace.register_action(|workspace, _: &ToggleRegistersView, window, cx| {
1273 Self::toggle(workspace, window, cx);
1274 });
1275 }
1276
1277 pub fn toggle(workspace: &mut Workspace, window: &mut Window, cx: &mut Context<Workspace>) {
1278 let editor = workspace
1279 .active_item(cx)
1280 .and_then(|item| item.act_as::<Editor>(cx));
1281 workspace.toggle_modal(window, cx, move |window, cx| {
1282 RegistersView::new(editor, window, cx)
1283 });
1284 }
1285
1286 fn new(
1287 editor: Option<Entity<Editor>>,
1288 window: &mut Window,
1289 cx: &mut Context<Picker<RegistersViewDelegate>>,
1290 ) -> Picker<RegistersViewDelegate> {
1291 let mut matches = Vec::default();
1292 cx.update_global(|globals: &mut VimGlobals, cx| {
1293 for name in ['"', '+', '*'] {
1294 if let Some(register) = globals.read_register(Some(name), None, cx) {
1295 matches.push(RegisterMatch {
1296 name,
1297 contents: register.text.clone(),
1298 })
1299 }
1300 }
1301 if let Some(editor) = editor {
1302 let register = editor.update(cx, |editor, cx| {
1303 globals.read_register(Some('%'), Some(editor), cx)
1304 });
1305 if let Some(register) = register {
1306 matches.push(RegisterMatch {
1307 name: '%',
1308 contents: register.text,
1309 })
1310 }
1311 }
1312 for (name, register) in globals.registers.iter() {
1313 if ['"', '+', '*', '%'].contains(name) {
1314 continue;
1315 };
1316 matches.push(RegisterMatch {
1317 name: *name,
1318 contents: register.text.clone(),
1319 })
1320 }
1321 });
1322 matches.sort_by(|a, b| a.name.cmp(&b.name));
1323 let delegate = RegistersViewDelegate {
1324 selected_index: 0,
1325 matches,
1326 };
1327
1328 Picker::nonsearchable_uniform_list(delegate, window, cx)
1329 .width(rems(36.))
1330 .modal(true)
1331 }
1332}
1333
1334enum MarksMatchInfo {
1335 Path(Arc<Path>),
1336 Title(String),
1337 Content {
1338 line: String,
1339 highlights: Vec<(Range<usize>, HighlightStyle)>,
1340 },
1341}
1342
1343impl MarksMatchInfo {
1344 fn from_chunks<'a>(chunks: impl Iterator<Item = Chunk<'a>>, cx: &App) -> Self {
1345 let mut line = String::new();
1346 let mut highlights = Vec::new();
1347 let mut offset = 0;
1348 for chunk in chunks {
1349 line.push_str(chunk.text);
1350 if let Some(highlight_style) = chunk.syntax_highlight_id
1351 && let Some(highlight) = highlight_style.style(cx.theme().syntax())
1352 {
1353 highlights.push((offset..offset + chunk.text.len(), highlight))
1354 }
1355 offset += chunk.text.len();
1356 }
1357 MarksMatchInfo::Content { line, highlights }
1358 }
1359}
1360
1361struct MarksMatch {
1362 name: String,
1363 position: Point,
1364 info: MarksMatchInfo,
1365}
1366
1367pub struct MarksViewDelegate {
1368 selected_index: usize,
1369 matches: Vec<MarksMatch>,
1370 point_column_width: usize,
1371 workspace: WeakEntity<Workspace>,
1372}
1373
1374impl PickerDelegate for MarksViewDelegate {
1375 type ListItem = Div;
1376
1377 fn match_count(&self) -> usize {
1378 self.matches.len()
1379 }
1380
1381 fn selected_index(&self) -> usize {
1382 self.selected_index
1383 }
1384
1385 fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
1386 self.selected_index = ix;
1387 cx.notify();
1388 }
1389
1390 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
1391 Arc::default()
1392 }
1393
1394 fn update_matches(
1395 &mut self,
1396 _: String,
1397 _: &mut Window,
1398 cx: &mut Context<Picker<Self>>,
1399 ) -> gpui::Task<()> {
1400 let Some(workspace) = self.workspace.upgrade() else {
1401 return Task::ready(());
1402 };
1403 cx.spawn(async move |picker, cx| {
1404 let mut matches = Vec::new();
1405 let _ = workspace.update(cx, |workspace, cx| {
1406 let entity_id = cx.entity_id();
1407 let Some(editor) = workspace
1408 .active_item(cx)
1409 .and_then(|item| item.act_as::<Editor>(cx))
1410 else {
1411 return;
1412 };
1413 let editor = editor.read(cx);
1414 let mut has_seen = HashSet::new();
1415 let Some(marks_state) = cx.global::<VimGlobals>().marks.get(&entity_id) else {
1416 return;
1417 };
1418 let marks_state = marks_state.read(cx);
1419
1420 if let Some(map) = marks_state
1421 .multibuffer_marks
1422 .get(&editor.buffer().entity_id())
1423 {
1424 for (name, anchors) in map {
1425 if has_seen.contains(name) {
1426 continue;
1427 }
1428 has_seen.insert(name.clone());
1429 let Some(anchor) = anchors.first() else {
1430 continue;
1431 };
1432
1433 let snapshot = editor.buffer().read(cx).snapshot(cx);
1434 let position = anchor.to_point(&snapshot);
1435
1436 let chunks = snapshot.chunks(
1437 Point::new(position.row, 0)
1438 ..Point::new(
1439 position.row,
1440 snapshot.line_len(MultiBufferRow(position.row)),
1441 ),
1442 true,
1443 );
1444 matches.push(MarksMatch {
1445 name: name.clone(),
1446 position,
1447 info: MarksMatchInfo::from_chunks(chunks, cx),
1448 })
1449 }
1450 }
1451
1452 if let Some(buffer) = editor.buffer().read(cx).as_singleton() {
1453 let buffer = buffer.read(cx);
1454 if let Some(map) = marks_state.buffer_marks.get(&buffer.remote_id()) {
1455 for (name, anchors) in map {
1456 if has_seen.contains(name) {
1457 continue;
1458 }
1459 has_seen.insert(name.clone());
1460 let Some(anchor) = anchors.first() else {
1461 continue;
1462 };
1463 let snapshot = buffer.snapshot();
1464 let position = anchor.to_point(&snapshot);
1465 let chunks = snapshot.chunks(
1466 Point::new(position.row, 0)
1467 ..Point::new(position.row, snapshot.line_len(position.row)),
1468 true,
1469 );
1470
1471 matches.push(MarksMatch {
1472 name: name.clone(),
1473 position,
1474 info: MarksMatchInfo::from_chunks(chunks, cx),
1475 })
1476 }
1477 }
1478 }
1479
1480 for (name, mark_location) in marks_state.global_marks.iter() {
1481 if has_seen.contains(name) {
1482 continue;
1483 }
1484 has_seen.insert(name.clone());
1485
1486 match mark_location {
1487 MarkLocation::Buffer(entity_id) => {
1488 if let Some(&anchor) = marks_state
1489 .multibuffer_marks
1490 .get(entity_id)
1491 .and_then(|map| map.get(name))
1492 .and_then(|anchors| anchors.first())
1493 {
1494 let Some((info, snapshot)) = workspace
1495 .items(cx)
1496 .filter_map(|item| item.act_as::<Editor>(cx))
1497 .map(|entity| entity.read(cx).buffer())
1498 .find(|buffer| buffer.entity_id().eq(entity_id))
1499 .map(|buffer| {
1500 (
1501 MarksMatchInfo::Title(
1502 buffer.read(cx).title(cx).to_string(),
1503 ),
1504 buffer.read(cx).snapshot(cx),
1505 )
1506 })
1507 else {
1508 continue;
1509 };
1510 matches.push(MarksMatch {
1511 name: name.clone(),
1512 position: anchor.to_point(&snapshot),
1513 info,
1514 });
1515 }
1516 }
1517 MarkLocation::Path(path) => {
1518 if let Some(&position) = marks_state
1519 .serialized_marks
1520 .get(path.as_ref())
1521 .and_then(|map| map.get(name))
1522 .and_then(|points| points.first())
1523 {
1524 let info = MarksMatchInfo::Path(path.clone());
1525 matches.push(MarksMatch {
1526 name: name.clone(),
1527 position,
1528 info,
1529 });
1530 }
1531 }
1532 }
1533 }
1534 });
1535 let _ = picker.update(cx, |picker, cx| {
1536 matches.sort_by_key(|a| {
1537 (
1538 a.name.chars().next().map(|c| c.is_ascii_uppercase()),
1539 a.name.clone(),
1540 )
1541 });
1542 let digits = matches
1543 .iter()
1544 .map(|m| (m.position.row + 1).ilog10() + (m.position.column + 1).ilog10())
1545 .max()
1546 .unwrap_or_default();
1547 picker.delegate.matches = matches;
1548 picker.delegate.point_column_width = (digits + 4) as usize;
1549 cx.notify();
1550 });
1551 })
1552 }
1553
1554 fn confirm(&mut self, _: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
1555 let Some(vim) = self
1556 .workspace
1557 .upgrade()
1558 .map(|w| w.read(cx))
1559 .and_then(|w| w.focused_pane(window, cx).read(cx).active_item())
1560 .and_then(|item| item.act_as::<Editor>(cx))
1561 .and_then(|editor| editor.read(cx).addon::<VimAddon>().cloned())
1562 .map(|addon| addon.entity)
1563 else {
1564 return;
1565 };
1566 let Some(text): Option<Arc<str>> = self
1567 .matches
1568 .get(self.selected_index)
1569 .map(|m| Arc::from(m.name.to_string().into_boxed_str()))
1570 else {
1571 return;
1572 };
1573 vim.update(cx, |vim, cx| {
1574 vim.jump(text, false, false, window, cx);
1575 });
1576
1577 cx.emit(DismissEvent);
1578 }
1579
1580 fn dismissed(&mut self, _: &mut Window, _: &mut Context<Picker<Self>>) {}
1581
1582 fn render_match(
1583 &self,
1584 ix: usize,
1585 selected: bool,
1586 _: &mut Window,
1587 cx: &mut Context<Picker<Self>>,
1588 ) -> Option<Self::ListItem> {
1589 let mark_match = self.matches.get(ix)?;
1590
1591 let mut left_output = String::new();
1592 let mut left_runs = Vec::new();
1593 left_output.push('`');
1594 left_output.push_str(&mark_match.name);
1595 left_runs.push((
1596 0..left_output.len(),
1597 HighlightStyle::color(cx.theme().colors().text_accent),
1598 ));
1599 left_output.push(' ');
1600 left_output.push(' ');
1601 let point_column = format!(
1602 "{},{}",
1603 mark_match.position.row + 1,
1604 mark_match.position.column + 1
1605 );
1606 left_output.push_str(&point_column);
1607 if let Some(padding) = self.point_column_width.checked_sub(point_column.len()) {
1608 left_output.push_str(&" ".repeat(padding));
1609 }
1610
1611 let (right_output, right_runs): (String, Vec<_>) = match &mark_match.info {
1612 MarksMatchInfo::Path(path) => {
1613 let s = path.to_string_lossy().into_owned();
1614 (
1615 s.clone(),
1616 vec![(0..s.len(), HighlightStyle::color(cx.theme().colors().text))],
1617 )
1618 }
1619 MarksMatchInfo::Title(title) => (
1620 title.clone(),
1621 vec![(
1622 0..title.len(),
1623 HighlightStyle::color(cx.theme().colors().text),
1624 )],
1625 ),
1626 MarksMatchInfo::Content { line, highlights } => (line.clone(), highlights.clone()),
1627 };
1628
1629 let theme = ThemeSettings::get_global(cx);
1630 let text_style = TextStyle {
1631 color: cx.theme().colors().editor_foreground,
1632 font_family: theme.buffer_font.family.clone(),
1633 font_features: theme.buffer_font.features.clone(),
1634 font_fallbacks: theme.buffer_font.fallbacks.clone(),
1635 font_size: theme.buffer_font_size(cx).into(),
1636 line_height: (theme.line_height() * theme.buffer_font_size(cx)).into(),
1637 font_weight: theme.buffer_font.weight,
1638 font_style: theme.buffer_font.style,
1639 ..Default::default()
1640 };
1641
1642 Some(
1643 h_flex()
1644 .when(selected, |el| el.bg(cx.theme().colors().element_selected))
1645 .font_buffer(cx)
1646 .text_buffer(cx)
1647 .h(theme.buffer_font_size(cx) * theme.line_height())
1648 .px_2()
1649 .child(StyledText::new(left_output).with_default_highlights(&text_style, left_runs))
1650 .child(
1651 StyledText::new(right_output).with_default_highlights(&text_style, right_runs),
1652 ),
1653 )
1654 }
1655}
1656
1657pub struct MarksView {}
1658
1659impl MarksView {
1660 fn register(workspace: &mut Workspace, _window: Option<&mut Window>) {
1661 workspace.register_action(|workspace, _: &ToggleMarksView, window, cx| {
1662 Self::toggle(workspace, window, cx);
1663 });
1664 }
1665
1666 pub fn toggle(workspace: &mut Workspace, window: &mut Window, cx: &mut Context<Workspace>) {
1667 let handle = cx.weak_entity();
1668 workspace.toggle_modal(window, cx, move |window, cx| {
1669 MarksView::new(handle, window, cx)
1670 });
1671 }
1672
1673 fn new(
1674 workspace: WeakEntity<Workspace>,
1675 window: &mut Window,
1676 cx: &mut Context<Picker<MarksViewDelegate>>,
1677 ) -> Picker<MarksViewDelegate> {
1678 let matches = Vec::default();
1679 let delegate = MarksViewDelegate {
1680 selected_index: 0,
1681 point_column_width: 0,
1682 matches,
1683 workspace,
1684 };
1685 Picker::nonsearchable_uniform_list(delegate, window, cx)
1686 .width(rems(36.))
1687 .modal(true)
1688 }
1689}
1690
1691pub struct VimDb(ThreadSafeConnection);
1692
1693impl Domain for VimDb {
1694 const NAME: &str = stringify!(VimDb);
1695
1696 const MIGRATIONS: &[&str] = &[
1697 sql! (
1698 CREATE TABLE vim_marks (
1699 workspace_id INTEGER,
1700 mark_name TEXT,
1701 path BLOB,
1702 value TEXT
1703 );
1704 CREATE UNIQUE INDEX idx_vim_marks ON vim_marks (workspace_id, mark_name, path);
1705 ),
1706 sql! (
1707 CREATE TABLE vim_global_marks_paths(
1708 workspace_id INTEGER,
1709 mark_name TEXT,
1710 path BLOB
1711 );
1712 CREATE UNIQUE INDEX idx_vim_global_marks_paths
1713 ON vim_global_marks_paths(workspace_id, mark_name);
1714 ),
1715 ];
1716}
1717
1718db::static_connection!(DB, VimDb, [WorkspaceDb]);
1719
1720struct SerializedMark {
1721 path: Arc<Path>,
1722 name: String,
1723 points: Vec<Point>,
1724}
1725
1726impl VimDb {
1727 pub(crate) async fn set_marks(
1728 &self,
1729 workspace_id: WorkspaceId,
1730 path: Arc<Path>,
1731 marks: HashMap<String, Vec<Point>>,
1732 ) -> Result<()> {
1733 log::debug!("Setting path {path:?} for {} marks", marks.len());
1734
1735 self.write(move |conn| {
1736 let mut query = conn.exec_bound(sql!(
1737 INSERT OR REPLACE INTO vim_marks
1738 (workspace_id, mark_name, path, value)
1739 VALUES
1740 (?, ?, ?, ?)
1741 ))?;
1742 for (mark_name, value) in marks {
1743 let pairs: Vec<(u32, u32)> = value
1744 .into_iter()
1745 .map(|point| (point.row, point.column))
1746 .collect();
1747 let serialized = serde_json::to_string(&pairs)?;
1748 query((workspace_id, mark_name, path.clone(), serialized))?;
1749 }
1750 Ok(())
1751 })
1752 .await
1753 }
1754
1755 fn get_marks(&self, workspace_id: WorkspaceId) -> Result<Vec<SerializedMark>> {
1756 let result: Vec<(Arc<Path>, String, String)> = self.select_bound(sql!(
1757 SELECT path, mark_name, value FROM vim_marks
1758 WHERE workspace_id = ?
1759 ))?(workspace_id)?;
1760
1761 Ok(result
1762 .into_iter()
1763 .filter_map(|(path, name, value)| {
1764 let pairs: Vec<(u32, u32)> = serde_json::from_str(&value).log_err()?;
1765 Some(SerializedMark {
1766 path,
1767 name,
1768 points: pairs
1769 .into_iter()
1770 .map(|(row, column)| Point { row, column })
1771 .collect(),
1772 })
1773 })
1774 .collect())
1775 }
1776
1777 pub(crate) async fn delete_mark(
1778 &self,
1779 workspace_id: WorkspaceId,
1780 path: Arc<Path>,
1781 mark_name: String,
1782 ) -> Result<()> {
1783 self.write(move |conn| {
1784 conn.exec_bound(sql!(
1785 DELETE FROM vim_marks
1786 WHERE workspace_id = ? AND mark_name = ? AND path = ?
1787 ))?((workspace_id, mark_name, path))
1788 })
1789 .await
1790 }
1791
1792 pub(crate) async fn set_global_mark_path(
1793 &self,
1794 workspace_id: WorkspaceId,
1795 mark_name: String,
1796 path: Arc<Path>,
1797 ) -> Result<()> {
1798 log::debug!("Setting global mark path {path:?} for {mark_name}");
1799 self.write(move |conn| {
1800 conn.exec_bound(sql!(
1801 INSERT OR REPLACE INTO vim_global_marks_paths
1802 (workspace_id, mark_name, path)
1803 VALUES
1804 (?, ?, ?)
1805 ))?((workspace_id, mark_name, path))
1806 })
1807 .await
1808 }
1809
1810 pub fn get_global_marks_paths(
1811 &self,
1812 workspace_id: WorkspaceId,
1813 ) -> Result<Vec<(String, Arc<Path>)>> {
1814 self.select_bound(sql!(
1815 SELECT mark_name, path FROM vim_global_marks_paths
1816 WHERE workspace_id = ?
1817 ))?(workspace_id)
1818 }
1819
1820 pub(crate) async fn delete_global_marks_path(
1821 &self,
1822 workspace_id: WorkspaceId,
1823 mark_name: String,
1824 ) -> Result<()> {
1825 self.write(move |conn| {
1826 conn.exec_bound(sql!(
1827 DELETE FROM vim_global_marks_paths
1828 WHERE workspace_id = ? AND mark_name = ?
1829 ))?((workspace_id, mark_name))
1830 })
1831 .await
1832 }
1833}