use std::sync::Arc; use collections::HashMap;use editor::{    display_map::{DisplaySnapshot, ToDisplayPoint},    movement,    scroll::Autoscroll,    Bias, DisplayPoint, Editor, ToOffset,};use gpui::{actions, ViewContext};use language::{Point, Selection, SelectionGoal};use multi_buffer::MultiBufferRow;use search::BufferSearchBar;use util::ResultExt;use workspace::searchable::Direction; use crate::{    motion::{first_non_whitespace, next_line_end, start_of_line, Motion},    object::Object,    state::{Mode, Operator},    Vim,}; actions!(    vim,    [        ToggleVisual,        ToggleVisualLine,        ToggleVisualBlock,        VisualDelete,        VisualDeleteLine,        VisualYank,        VisualYankLine,        OtherEnd,        SelectNext,        SelectPrevious,        SelectNextMatch,        SelectPreviousMatch,        RestoreVisualSelection,        VisualInsertEndOfLine,        VisualInsertFirstNonWhiteSpace,    ]); pub fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {    Vim::action(editor, cx, |vim, _: &ToggleVisual, cx| {        vim.toggle_mode(Mode::Visual, cx)    });    Vim::action(editor, cx, |vim, _: &ToggleVisualLine, cx| {        vim.toggle_mode(Mode::VisualLine, cx)    });    Vim::action(editor, cx, |vim, _: &ToggleVisualBlock, cx| {        vim.toggle_mode(Mode::VisualBlock, cx)    });    Vim::action(editor, cx, Vim::other_end);    Vim::action(editor, cx, Vim::visual_insert_end_of_line);    Vim::action(editor, cx, Vim::visual_insert_first_non_white_space);    Vim::action(editor, cx, |vim, _: &VisualDelete, cx| {        vim.record_current_action(cx);        vim.visual_delete(false, cx);    });    Vim::action(editor, cx, |vim, _: &VisualDeleteLine, cx| {        vim.record_current_action(cx);        vim.visual_delete(true, cx);    });    Vim::action(editor, cx, |vim, _: &VisualYank, cx| {        vim.visual_yank(false, cx)    });    Vim::action(editor, cx, |vim, _: &VisualYankLine, cx| {        vim.visual_yank(true, cx)    });     Vim::action(editor, cx, Vim::select_next);    Vim::action(editor, cx, Vim::select_previous);    Vim::action(editor, cx, |vim, _: &SelectNextMatch, cx| {        vim.select_match(Direction::Next, cx);    });    Vim::action(editor, cx, |vim, _: &SelectPreviousMatch, cx| {        vim.select_match(Direction::Prev, cx);    });     Vim::action(editor, cx, |vim, _: &RestoreVisualSelection, cx| {        let Some((stored_mode, reversed)) = vim.stored_visual_mode.take() else {            return;        };        let Some((start, end)) = vim.marks.get("<").zip(vim.marks.get(">")) else {            return;        };        let ranges = start            .iter()            .zip(end)            .zip(reversed)            .map(|((start, end), reversed)| (*start, *end, reversed))            .collect::<Vec<_>>();         if vim.mode.is_visual() {            vim.create_visual_marks(vim.mode, cx);        }         vim.update_editor(cx, |_, editor, cx| {            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                let map = s.display_map();                let ranges = ranges                    .into_iter()                    .map(|(start, end, reversed)| {                        let new_end = movement::saturating_right(&map, end.to_display_point(&map));                        Selection {                            id: s.new_selection_id(),                            start: start.to_offset(&map.buffer_snapshot),                            end: new_end.to_offset(&map, Bias::Left),                            reversed,                            goal: SelectionGoal::None,                        }                    })                    .collect();                s.select(ranges);            })        });        vim.switch_mode(stored_mode, true, cx)    });} impl Vim {    pub fn visual_motion(        &mut self,        motion: Motion,        times: Option<usize>,        cx: &mut ViewContext<Self>,    ) {        self.update_editor(cx, |vim, editor, cx| {            let text_layout_details = editor.text_layout_details(cx);            if vim.mode == Mode::VisualBlock                && !matches!(                    motion,                    Motion::EndOfLine {                        display_lines: false                    }                )            {                let is_up_or_down = matches!(motion, Motion::Up { .. } | Motion::Down { .. });                vim.visual_block_motion(is_up_or_down, editor, cx, |map, point, goal| {                    motion.move_point(map, point, goal, times, &text_layout_details)                })            } else {                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                    s.move_with(|map, selection| {                        let was_reversed = selection.reversed;                        let mut current_head = selection.head();                         // our motions assume the current character is after the cursor,                        // but in (forward) visual mode the current character is just                        // before the end of the selection.                         // If the file ends with a newline (which is common) we don't do this.                        // so that if you go to the end of such a file you can use "up" to go                        // to the previous line and have it work somewhat as expected.                        #[allow(clippy::nonminimal_bool)]                        if !selection.reversed                            && !selection.is_empty()                            && !(selection.end.column() == 0 && selection.end == map.max_point())                        {                            current_head = movement::left(map, selection.end)                        }                         let Some((new_head, goal)) = motion.move_point(                            map,                            current_head,                            selection.goal,                            times,                            &text_layout_details,                        ) else {                            return;                        };                         selection.set_head(new_head, goal);                         // ensure the current character is included in the selection.                        if !selection.reversed {                            let next_point = if vim.mode == Mode::VisualBlock {                                movement::saturating_right(map, selection.end)                            } else {                                movement::right(map, selection.end)                            };                             if !(next_point.column() == 0 && next_point == map.max_point()) {                                selection.end = next_point;                            }                        }                         // vim always ensures the anchor character stays selected.                        // if our selection has reversed, we need to move the opposite end                        // to ensure the anchor is still selected.                        if was_reversed && !selection.reversed {                            selection.start = movement::left(map, selection.start);                        } else if !was_reversed && selection.reversed {                            selection.end = movement::right(map, selection.end);                        }                    })                });            }        });    }     pub fn visual_block_motion(        &mut self,        preserve_goal: bool,        editor: &mut Editor,        cx: &mut ViewContext<Editor>,        mut move_selection: impl FnMut(            &DisplaySnapshot,            DisplayPoint,            SelectionGoal,        ) -> Option<(DisplayPoint, SelectionGoal)>,    ) {        let text_layout_details = editor.text_layout_details(cx);        editor.change_selections(Some(Autoscroll::fit()), cx, |s| {            let map = &s.display_map();            let mut head = s.newest_anchor().head().to_display_point(map);            let mut tail = s.oldest_anchor().tail().to_display_point(map);             let mut head_x = map.x_for_display_point(head, &text_layout_details);            let mut tail_x = map.x_for_display_point(tail, &text_layout_details);             let (start, end) = match s.newest_anchor().goal {                SelectionGoal::HorizontalRange { start, end } if preserve_goal => (start, end),                SelectionGoal::HorizontalPosition(start) if preserve_goal => (start, start),                _ => (tail_x.0, head_x.0),            };            let mut goal = SelectionGoal::HorizontalRange { start, end };             let was_reversed = tail_x > head_x;            if !was_reversed && !preserve_goal {                head = movement::saturating_left(map, head);            }             let Some((new_head, _)) = move_selection(map, head, goal) else {                return;            };            head = new_head;            head_x = map.x_for_display_point(head, &text_layout_details);             let is_reversed = tail_x > head_x;            if was_reversed && !is_reversed {                tail = movement::saturating_left(map, tail);                tail_x = map.x_for_display_point(tail, &text_layout_details);            } else if !was_reversed && is_reversed {                tail = movement::saturating_right(map, tail);                tail_x = map.x_for_display_point(tail, &text_layout_details);            }            if !is_reversed && !preserve_goal {                head = movement::saturating_right(map, head);                head_x = map.x_for_display_point(head, &text_layout_details);            }             let positions = if is_reversed {                head_x..tail_x            } else {                tail_x..head_x            };             if !preserve_goal {                goal = SelectionGoal::HorizontalRange {                    start: positions.start.0,                    end: positions.end.0,                };            }             let mut selections = Vec::new();            let mut row = tail.row();             loop {                let laid_out_line = map.layout_row(row, &text_layout_details);                let start = DisplayPoint::new(                    row,                    laid_out_line.closest_index_for_x(positions.start) as u32,                );                let mut end =                    DisplayPoint::new(row, laid_out_line.closest_index_for_x(positions.end) as u32);                if end <= start {                    if start.column() == map.line_len(start.row()) {                        end = start;                    } else {                        end = movement::saturating_right(map, start);                    }                }                 if positions.start <= laid_out_line.width {                    let selection = Selection {                        id: s.new_selection_id(),                        start: start.to_point(map),                        end: end.to_point(map),                        reversed: is_reversed,                        goal,                    };                     selections.push(selection);                }                if row == head.row() {                    break;                }                if tail.row() > head.row() {                    row.0 -= 1                } else {                    row.0 += 1                }            }             s.select(selections);        })    }     pub fn visual_object(&mut self, object: Object, cx: &mut ViewContext<Vim>) {        if let Some(Operator::Object { around }) = self.active_operator() {            self.pop_operator(cx);            let current_mode = self.mode;            let target_mode = object.target_visual_mode(current_mode);            if target_mode != current_mode {                self.switch_mode(target_mode, true, cx);            }             self.update_editor(cx, |_, editor, cx| {                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                    s.move_with(|map, selection| {                        let mut mut_selection = selection.clone();                         // all our motions assume that the current character is                        // after the cursor; however in the case of a visual selection                        // the current character is before the cursor.                        // But this will affect the judgment of the html tag                        // so the html tag needs to skip this logic.                        if !selection.reversed && object != Object::Tag {                            mut_selection.set_head(                                movement::left(map, mut_selection.head()),                                mut_selection.goal,                            );                        }                         if let Some(range) = object.range(map, mut_selection, around) {                            if !range.is_empty() {                                let expand_both_ways = object.always_expands_both_ways()                                    || selection.is_empty()                                    || movement::right(map, selection.start) == selection.end;                                 if expand_both_ways {                                    selection.start = range.start;                                    selection.end = range.end;                                } else if selection.reversed {                                    selection.start = range.start;                                } else {                                    selection.end = range.end;                                }                            }                             // In the visual selection result of a paragraph object, the cursor is                            // placed at the start of the last line. And in the visual mode, the                            // selection end is located after the end character. So, adjustment of                            // selection end is needed.                            //                            // We don't do this adjustment for a one-line blank paragraph since the                            // trailing newline is included in its selection from the beginning.                            if object == Object::Paragraph && range.start != range.end {                                let row_of_selection_end_line = selection.end.to_point(map).row;                                let new_selection_end = if map                                    .buffer_snapshot                                    .line_len(MultiBufferRow(row_of_selection_end_line))                                    == 0                                {                                    Point::new(row_of_selection_end_line + 1, 0)                                } else {                                    Point::new(row_of_selection_end_line, 1)                                };                                selection.end = new_selection_end.to_display_point(map);                            }                        }                    });                });            });        }    }     fn visual_insert_end_of_line(&mut self, _: &VisualInsertEndOfLine, cx: &mut ViewContext<Self>) {        self.update_editor(cx, |_, editor, cx| {            editor.split_selection_into_lines(&Default::default(), cx);            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                s.move_cursors_with(|map, cursor, _| {                    (next_line_end(map, cursor, 1), SelectionGoal::None)                });            });        });         self.switch_mode(Mode::Insert, false, cx);    }     fn visual_insert_first_non_white_space(        &mut self,        _: &VisualInsertFirstNonWhiteSpace,        cx: &mut ViewContext<Self>,    ) {        self.update_editor(cx, |_, editor, cx| {            editor.split_selection_into_lines(&Default::default(), cx);            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                s.move_cursors_with(|map, cursor, _| {                    (                        first_non_whitespace(map, false, cursor),                        SelectionGoal::None,                    )                });            });        });         self.switch_mode(Mode::Insert, false, cx);    }     fn toggle_mode(&mut self, mode: Mode, cx: &mut ViewContext<Self>) {        if self.mode == mode {            self.switch_mode(Mode::Normal, false, cx);        } else {            self.switch_mode(mode, false, cx);        }    }     pub fn other_end(&mut self, _: &OtherEnd, cx: &mut ViewContext<Self>) {        self.update_editor(cx, |_, editor, cx| {            editor.change_selections(None, cx, |s| {                s.move_with(|_, selection| {                    selection.reversed = !selection.reversed;                })            })        });    }     pub fn visual_delete(&mut self, line_mode: bool, cx: &mut ViewContext<Self>) {        self.store_visual_marks(cx);        self.update_editor(cx, |vim, editor, cx| {            let mut original_columns: HashMap<_, _> = Default::default();            let line_mode = line_mode || editor.selections.line_mode;             editor.transact(cx, |editor, cx| {                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                    s.move_with(|map, selection| {                        if line_mode {                            let mut position = selection.head();                            if !selection.reversed {                                position = movement::left(map, position);                            }                            original_columns.insert(selection.id, position.to_point(map).column);                            if vim.mode == Mode::VisualBlock {                                *selection.end.column_mut() = map.line_len(selection.end.row())                            } else if vim.mode != Mode::VisualLine {                                selection.start = DisplayPoint::new(selection.start.row(), 0);                                if selection.end.row() == map.max_point().row() {                                    selection.end = map.max_point()                                } else {                                    *selection.end.row_mut() += 1;                                    *selection.end.column_mut() = 0;                                }                            }                        }                        selection.goal = SelectionGoal::None;                    });                });                vim.copy_selections_content(editor, line_mode, cx);                editor.insert("", cx);                 // Fixup cursor position after the deletion                editor.set_clip_at_line_ends(true, cx);                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                    s.move_with(|map, selection| {                        let mut cursor = selection.head().to_point(map);                         if let Some(column) = original_columns.get(&selection.id) {                            cursor.column = *column                        }                        let cursor = map.clip_point(cursor.to_display_point(map), Bias::Left);                        selection.collapse_to(cursor, selection.goal)                    });                    if vim.mode == Mode::VisualBlock {                        s.select_anchors(vec![s.first_anchor()])                    }                });            })        });        self.switch_mode(Mode::Normal, true, cx);    }     pub fn visual_yank(&mut self, line_mode: bool, cx: &mut ViewContext<Self>) {        self.store_visual_marks(cx);        self.update_editor(cx, |vim, editor, cx| {            let line_mode = line_mode || editor.selections.line_mode;            editor.selections.line_mode = line_mode;            vim.yank_selections_content(editor, line_mode, cx);            editor.change_selections(None, cx, |s| {                s.move_with(|map, selection| {                    if line_mode {                        selection.start = start_of_line(map, false, selection.start);                    };                    selection.collapse_to(selection.start, SelectionGoal::None)                });                if vim.mode == Mode::VisualBlock {                    s.select_anchors(vec![s.first_anchor()])

Lines 1–500 of 1437. Load more