Cargo.lock 🔗
@@ -1521,6 +1521,7 @@ dependencies = [
name = "editor"
version = "0.1.0"
dependencies = [
+ "aho-corasick",
"anyhow",
"buffer",
"clock",
Merge pull request #256 from zed-industries/select-next
Nathan Sobo created
Implement select next (cmd-d) and replace selection with next (cmd-k cmd-d)Change summary
Cargo.lock | 1
crates/buffer/src/anchor.rs | 89 ++++++--
crates/buffer/src/lib.rs | 84 ++++---
crates/buffer/src/rope.rs | 75 ++++++
crates/buffer/src/selection.rs | 23 ++
crates/editor/Cargo.toml | 1
crates/editor/src/display_map.rs | 6
crates/editor/src/element.rs | 61 ++---
crates/editor/src/lib.rs | 350 +++++++++++++++++++++++----------
crates/language/src/proto.rs | 17 +
10 files changed, 495 insertions(+), 212 deletions(-)
Detailed changes
crates/buffer/src/anchor.rs 🔗
@@ -29,7 +29,9 @@ pub struct AnchorSet(pub(crate) AnchorMap<()>);
#[derive(Clone)]
pub struct AnchorRangeMap<T> {
pub(crate) version: clock::Global,
- pub(crate) entries: Vec<(Range<(FullOffset, Bias)>, T)>,
+ pub(crate) entries: Vec<(Range<FullOffset>, T)>,
+ pub(crate) start_bias: Bias,
+ pub(crate) end_bias: Bias,
}
#[derive(Clone)]
@@ -140,8 +142,12 @@ impl<T> AnchorMap<T> {
{
let content = content.into();
content
- .summaries_for_anchors(self)
- .map(move |(sum, value)| (sum, value))
+ .summaries_for_anchors(
+ self.version.clone(),
+ self.bias,
+ self.entries.iter().map(|e| &e.0),
+ )
+ .zip(self.entries.iter().map(|e| &e.1))
}
}
@@ -174,9 +180,16 @@ impl<T> AnchorRangeMap<T> {
pub fn from_full_offset_ranges(
version: clock::Global,
- entries: Vec<(Range<(FullOffset, Bias)>, T)>,
+ start_bias: Bias,
+ end_bias: Bias,
+ entries: Vec<(Range<FullOffset>, T)>,
) -> Self {
- Self { version, entries }
+ Self {
+ version,
+ start_bias,
+ end_bias,
+ entries,
+ }
}
pub fn ranges<'a, D>(
@@ -187,13 +200,53 @@ impl<T> AnchorRangeMap<T> {
D: 'a + TextDimension<'a>,
{
let content = content.into();
- content.summaries_for_anchor_ranges(self)
+ content
+ .summaries_for_anchor_ranges(
+ self.version.clone(),
+ self.start_bias,
+ self.end_bias,
+ self.entries.iter().map(|e| &e.0),
+ )
+ .zip(self.entries.iter().map(|e| &e.1))
}
- pub fn full_offset_ranges(&self) -> impl Iterator<Item = (Range<FullOffset>, &T)> {
- self.entries
- .iter()
- .map(|(range, value)| (range.start.0..range.end.0, value))
+ pub fn intersecting_ranges<'a, D, I>(
+ &'a self,
+ range: Range<(I, Bias)>,
+ content: impl Into<Content<'a>> + 'a,
+ ) -> impl Iterator<Item = (Range<D>, &'a T)> + 'a
+ where
+ D: 'a + TextDimension<'a>,
+ I: ToOffset,
+ {
+ let content = content.into();
+ let range = content.anchor_at(range.start.0, range.start.1)
+ ..content.anchor_at(range.end.0, range.end.1);
+
+ let mut probe_anchor = Anchor {
+ full_offset: Default::default(),
+ bias: self.start_bias,
+ version: self.version.clone(),
+ };
+ let start_ix = self.entries.binary_search_by(|probe| {
+ probe_anchor.full_offset = probe.0.end;
+ probe_anchor.cmp(&range.start, &content).unwrap()
+ });
+
+ match start_ix {
+ Ok(start_ix) | Err(start_ix) => content
+ .summaries_for_anchor_ranges(
+ self.version.clone(),
+ self.start_bias,
+ self.end_bias,
+ self.entries[start_ix..].iter().map(|e| &e.0),
+ )
+ .zip(self.entries.iter().map(|e| &e.1)),
+ }
+ }
+
+ pub fn full_offset_ranges(&self) -> impl Iterator<Item = &(Range<FullOffset>, T)> {
+ self.entries.iter()
}
pub fn min_by_key<'a, C, D, F, K>(
@@ -232,25 +285,19 @@ impl<T> AnchorRangeMap<T> {
.map(|(range, value)| (self.resolve_range(range, &content), value))
}
- fn resolve_range<'a, D>(
- &self,
- range: &Range<(FullOffset, Bias)>,
- content: &Content<'a>,
- ) -> Range<D>
+ fn resolve_range<'a, D>(&self, range: &Range<FullOffset>, content: &Content<'a>) -> Range<D>
where
D: 'a + TextDimension<'a>,
{
- let (start, start_bias) = range.start;
let mut anchor = Anchor {
- full_offset: start,
- bias: start_bias,
+ full_offset: range.start,
+ bias: self.start_bias,
version: self.version.clone(),
};
let start = content.summary_for_anchor(&anchor);
- let (end, end_bias) = range.end;
- anchor.full_offset = end;
- anchor.bias = end_bias;
+ anchor.full_offset = range.end;
+ anchor.bias = self.end_bias;
let end = content.summary_for_anchor(&anchor);
start..end
crates/buffer/src/lib.rs 🔗
@@ -606,9 +606,8 @@ impl Buffer {
self.text_for_range(range).flat_map(str::chars)
}
- pub fn bytes_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = u8> + '_ {
- let offset = position.to_offset(self);
- self.visible_text.bytes_at(offset)
+ pub fn bytes_in_range<T: ToOffset>(&self, range: Range<T>) -> rope::Bytes {
+ self.content().bytes_in_range(range)
}
pub fn contains_str_at<T>(&self, position: T, needle: &str) -> bool
@@ -618,7 +617,9 @@ impl Buffer {
let position = position.to_offset(self);
position == self.clip_offset(position, Bias::Left)
&& self
- .bytes_at(position)
+ .bytes_in_range(position..self.len())
+ .flatten()
+ .copied()
.take(needle.len())
.eq(needle.bytes())
}
@@ -1581,6 +1582,10 @@ impl Snapshot {
self.visible_text.max_point()
}
+ pub fn bytes_in_range<T: ToOffset>(&self, range: Range<T>) -> rope::Bytes {
+ self.content().bytes_in_range(range)
+ }
+
pub fn text_for_range<T: ToOffset>(&self, range: Range<T>) -> Chunks {
self.content().text_for_range(range)
}
@@ -1716,6 +1721,12 @@ impl<'a> Content<'a> {
self.visible_text.reversed_chars_at(offset)
}
+ pub fn bytes_in_range<T: ToOffset>(&self, range: Range<T>) -> rope::Bytes<'a> {
+ let start = range.start.to_offset(self);
+ let end = range.end.to_offset(self);
+ self.visible_text.bytes_in_range(start..end)
+ }
+
pub fn text_for_range<T: ToOffset>(&self, range: Range<T>) -> Chunks<'a> {
let start = range.start.to_offset(self);
let end = range.end.to_offset(self);
@@ -1775,66 +1786,67 @@ impl<'a> Content<'a> {
self.visible_text.cursor(range.start).summary(range.end)
}
- fn summaries_for_anchors<D, T>(&self, map: &'a AnchorMap<T>) -> impl Iterator<Item = (D, &'a T)>
+ fn summaries_for_anchors<D, I>(
+ &self,
+ version: clock::Global,
+ bias: Bias,
+ ranges: I,
+ ) -> impl 'a + Iterator<Item = D>
where
- D: TextDimension<'a>,
+ D: 'a + TextDimension<'a>,
+ I: 'a + IntoIterator<Item = &'a FullOffset>,
{
- let cx = Some(map.version.clone());
+ let cx = Some(version.clone());
let mut summary = D::default();
let mut rope_cursor = self.visible_text.cursor(0);
let mut cursor = self.fragments.cursor::<(VersionedFullOffset, usize)>();
- map.entries.iter().map(move |(offset, value)| {
- cursor.seek_forward(&VersionedFullOffset::Offset(*offset), map.bias, &cx);
+ ranges.into_iter().map(move |offset| {
+ cursor.seek_forward(&VersionedFullOffset::Offset(*offset), bias, &cx);
let overshoot = if cursor.item().map_or(false, |fragment| fragment.visible) {
*offset - cursor.start().0.full_offset()
} else {
0
};
summary.add_assign(&rope_cursor.summary(cursor.start().1 + overshoot));
- (summary.clone(), value)
+ summary.clone()
})
}
- fn summaries_for_anchor_ranges<D, T>(
+ fn summaries_for_anchor_ranges<D, I>(
&self,
- map: &'a AnchorRangeMap<T>,
- ) -> impl Iterator<Item = (Range<D>, &'a T)>
+ version: clock::Global,
+ start_bias: Bias,
+ end_bias: Bias,
+ ranges: I,
+ ) -> impl 'a + Iterator<Item = Range<D>>
where
- D: TextDimension<'a>,
+ D: 'a + TextDimension<'a>,
+ I: 'a + IntoIterator<Item = &'a Range<FullOffset>>,
{
- let cx = Some(map.version.clone());
+ let cx = Some(version);
let mut summary = D::default();
let mut rope_cursor = self.visible_text.cursor(0);
let mut cursor = self.fragments.cursor::<(VersionedFullOffset, usize)>();
- map.entries.iter().map(move |(range, value)| {
- let Range {
- start: (start_offset, start_bias),
- end: (end_offset, end_bias),
- } = range;
-
- cursor.seek_forward(
- &VersionedFullOffset::Offset(*start_offset),
- *start_bias,
- &cx,
- );
+ ranges.into_iter().map(move |range| {
+ cursor.seek_forward(&VersionedFullOffset::Offset(range.start), start_bias, &cx);
let overshoot = if cursor.item().map_or(false, |fragment| fragment.visible) {
- *start_offset - cursor.start().0.full_offset()
+ range.start - cursor.start().0.full_offset()
} else {
0
};
summary.add_assign(&rope_cursor.summary::<D>(cursor.start().1 + overshoot));
let start_summary = summary.clone();
- cursor.seek_forward(&VersionedFullOffset::Offset(*end_offset), *end_bias, &cx);
+ cursor.seek_forward(&VersionedFullOffset::Offset(range.end), end_bias, &cx);
let overshoot = if cursor.item().map_or(false, |fragment| fragment.visible) {
- *end_offset - cursor.start().0.full_offset()
+ range.end - cursor.start().0.full_offset()
} else {
0
};
summary.add_assign(&rope_cursor.summary::<D>(cursor.start().1 + overshoot));
let end_summary = summary.clone();
- (start_summary..end_summary, value)
+ start_summary..end_summary
})
}
@@ -1890,14 +1902,16 @@ impl<'a> Content<'a> {
let full_start_offset = FullOffset(cursor.start().deleted + start_offset);
cursor.seek_forward(&end_offset, end_bias, &None);
let full_end_offset = FullOffset(cursor.start().deleted + end_offset);
- (
- (full_start_offset, start_bias)..(full_end_offset, end_bias),
- value,
- )
+ (full_start_offset..full_end_offset, value)
})
.collect();
- AnchorRangeMap { version, entries }
+ AnchorRangeMap {
+ version,
+ start_bias,
+ end_bias,
+ entries,
+ }
}
pub fn anchor_set<E>(&self, bias: Bias, entries: E) -> AnchorSet
crates/buffer/src/rope.rs 🔗
@@ -3,7 +3,7 @@ use crate::PointUtf16;
use super::Point;
use arrayvec::ArrayString;
use smallvec::SmallVec;
-use std::{cmp, fmt, mem, ops::Range, str};
+use std::{cmp, fmt, io, mem, ops::Range, str};
use sum_tree::{Bias, Dimension, SumTree};
#[cfg(test)]
@@ -137,8 +137,8 @@ impl Rope {
.flat_map(|chunk| chunk.chars().rev())
}
- pub fn bytes_at(&self, start: usize) -> impl Iterator<Item = u8> + '_ {
- self.chunks_in_range(start..self.len()).flat_map(str::bytes)
+ pub fn bytes_in_range(&self, range: Range<usize>) -> Bytes {
+ Bytes::new(self, range)
}
pub fn chunks<'a>(&'a self) -> Chunks<'a> {
@@ -444,6 +444,59 @@ impl<'a> Iterator for Chunks<'a> {
}
}
+pub struct Bytes<'a> {
+ chunks: sum_tree::Cursor<'a, Chunk, usize>,
+ range: Range<usize>,
+}
+
+impl<'a> Bytes<'a> {
+ pub fn new(rope: &'a Rope, range: Range<usize>) -> Self {
+ let mut chunks = rope.chunks.cursor();
+ chunks.seek(&range.start, Bias::Right, &());
+ Self { chunks, range }
+ }
+
+ pub fn peek(&self) -> Option<&'a [u8]> {
+ let chunk = self.chunks.item()?;
+ let chunk_start = *self.chunks.start();
+ if self.range.end <= chunk_start {
+ return None;
+ }
+
+ let start = self.range.start.saturating_sub(chunk_start);
+ let end = self.range.end - chunk_start;
+ Some(&chunk.0.as_bytes()[start..chunk.0.len().min(end)])
+ }
+}
+
+impl<'a> Iterator for Bytes<'a> {
+ type Item = &'a [u8];
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let result = self.peek();
+ if result.is_some() {
+ self.chunks.next(&());
+ }
+ result
+ }
+}
+
+impl<'a> io::Read for Bytes<'a> {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ if let Some(chunk) = self.peek() {
+ let len = cmp::min(buf.len(), chunk.len());
+ buf[..len].copy_from_slice(&chunk[..len]);
+ self.range.start += len;
+ if len == chunk.len() {
+ self.chunks.next(&());
+ }
+ Ok(len)
+ } else {
+ Ok(0)
+ }
+ }
+}
+
#[derive(Clone, Debug, Default)]
struct Chunk(ArrayString<{ 2 * CHUNK_BASE }>);
@@ -767,7 +820,7 @@ mod tests {
use super::*;
use crate::random_char_iter::RandomCharIter;
use rand::prelude::*;
- use std::{cmp::Ordering, env};
+ use std::{cmp::Ordering, env, io::Read};
use Bias::{Left, Right};
#[test]
@@ -843,10 +896,16 @@ mod tests {
for _ in 0..5 {
let end_ix = clip_offset(&expected, rng.gen_range(0..=expected.len()), Right);
let start_ix = clip_offset(&expected, rng.gen_range(0..=end_ix), Left);
- assert_eq!(
- actual.chunks_in_range(start_ix..end_ix).collect::<String>(),
- &expected[start_ix..end_ix]
- );
+
+ let actual_text = actual.chunks_in_range(start_ix..end_ix).collect::<String>();
+ assert_eq!(actual_text, &expected[start_ix..end_ix]);
+
+ let mut actual_text = String::new();
+ actual
+ .bytes_in_range(start_ix..end_ix)
+ .read_to_string(&mut actual_text)
+ .unwrap();
+ assert_eq!(actual_text, &expected[start_ix..end_ix]);
assert_eq!(
actual
crates/buffer/src/selection.rs 🔗
@@ -1,3 +1,5 @@
+use sum_tree::Bias;
+
use crate::rope::TextDimension;
use super::{AnchorRangeMap, Buffer, Content, Point, ToOffset, ToPoint};
@@ -117,6 +119,27 @@ impl SelectionSet {
})
}
+ pub fn intersecting_selections<'a, D, I, C>(
+ &'a self,
+ range: Range<(I, Bias)>,
+ content: C,
+ ) -> impl 'a + Iterator<Item = Selection<D>>
+ where
+ D: 'a + TextDimension<'a>,
+ I: 'a + ToOffset,
+ C: 'a + Into<Content<'a>>,
+ {
+ self.selections
+ .intersecting_ranges(range, content)
+ .map(|(range, state)| Selection {
+ id: state.id,
+ start: range.start,
+ end: range.end,
+ reversed: state.reversed,
+ goal: state.goal,
+ })
+ }
+
pub fn oldest_selection<'a, D, C>(&'a self, content: C) -> Option<Selection<D>>
where
D: 'a + TextDimension<'a>,
crates/editor/Cargo.toml 🔗
@@ -20,6 +20,7 @@ sum_tree = { path = "../sum_tree" }
theme = { path = "../theme" }
util = { path = "../util" }
workspace = { path = "../workspace" }
+aho-corasick = "0.7"
anyhow = "1.0"
lazy_static = "1.4"
log = "0.4"
crates/editor/src/display_map.rs 🔗
@@ -418,6 +418,12 @@ impl DisplayPoint {
}
}
+impl ToDisplayPoint for usize {
+ fn to_display_point(&self, map: &DisplayMapSnapshot) -> DisplayPoint {
+ map.point_to_display_point(self.to_point(&map.buffer_snapshot), Bias::Left)
+ }
+}
+
impl ToDisplayPoint for Point {
fn to_display_point(&self, map: &DisplayMapSnapshot) -> DisplayPoint {
map.point_to_display_point(*self, Bias::Left)
crates/editor/src/element.rs 🔗
@@ -380,13 +380,12 @@ impl EditorElement {
for selection in selections {
if selection.start != selection.end {
- let range_start = cmp::min(selection.start, selection.end);
- let range_end = cmp::max(selection.start, selection.end);
- let row_range = if range_end.column() == 0 {
- cmp::max(range_start.row(), start_row)..cmp::min(range_end.row(), end_row)
+ let row_range = if selection.end.column() == 0 {
+ cmp::max(selection.start.row(), start_row)
+ ..cmp::min(selection.end.row(), end_row)
} else {
- cmp::max(range_start.row(), start_row)
- ..cmp::min(range_end.row() + 1, end_row)
+ cmp::max(selection.start.row(), start_row)
+ ..cmp::min(selection.end.row() + 1, end_row)
};
let selection = Selection {
@@ -399,16 +398,18 @@ impl EditorElement {
.map(|row| {
let line_layout = &layout.line_layouts[(row - start_row) as usize];
SelectionLine {
- start_x: if row == range_start.row() {
+ start_x: if row == selection.start.row() {
content_origin.x()
- + line_layout.x_for_index(range_start.column() as usize)
+ + line_layout
+ .x_for_index(selection.start.column() as usize)
- scroll_left
} else {
content_origin.x() - scroll_left
},
- end_x: if row == range_end.row() {
+ end_x: if row == selection.end.row() {
content_origin.x()
- + line_layout.x_for_index(range_end.column() as usize)
+ + line_layout
+ .x_for_index(selection.end.column() as usize)
- scroll_left
} else {
content_origin.x()
@@ -425,13 +426,13 @@ impl EditorElement {
}
if view.show_local_cursors() || *replica_id != local_replica_id {
- let cursor_position = selection.end;
+ let cursor_position = selection.head();
if (start_row..end_row).contains(&cursor_position.row()) {
let cursor_row_layout =
- &layout.line_layouts[(selection.end.row() - start_row) as usize];
- let x = cursor_row_layout.x_for_index(selection.end.column() as usize)
+ &layout.line_layouts[(cursor_position.row() - start_row) as usize];
+ let x = cursor_row_layout.x_for_index(cursor_position.column() as usize)
- scroll_left;
- let y = selection.end.row() as f32 * layout.line_height - scroll_top;
+ let y = cursor_position.row() as f32 * layout.line_height - scroll_top;
cursors.push(Cursor {
color: style.cursor,
origin: content_origin + vec2f(x, y),
@@ -747,26 +748,18 @@ impl Element for EditorElement {
self.update_view(cx.app, |view, cx| {
highlighted_row = view.highlighted_row();
for selection_set_id in view.active_selection_sets(cx).collect::<Vec<_>>() {
- let mut set = Vec::new();
- for selection in view.selections_in_range(
- selection_set_id,
- DisplayPoint::new(start_row, 0)..DisplayPoint::new(end_row, 0),
- cx,
- ) {
- set.push(selection.clone());
+ let replica_selections = view
+ .intersecting_selections(
+ selection_set_id,
+ DisplayPoint::new(start_row, 0)..DisplayPoint::new(end_row, 0),
+ cx,
+ )
+ .collect::<Vec<_>>();
+ for selection in &replica_selections {
if selection_set_id == view.selection_set_id {
let is_empty = selection.start == selection.end;
- let mut selection_start;
- let mut selection_end;
- if selection.start < selection.end {
- selection_start = selection.start;
- selection_end = selection.end;
- } else {
- selection_start = selection.end;
- selection_end = selection.start;
- };
- selection_start = snapshot.prev_row_boundary(selection_start).0;
- selection_end = snapshot.next_row_boundary(selection_end).0;
+ let selection_start = snapshot.prev_row_boundary(selection.start).0;
+ let selection_end = snapshot.next_row_boundary(selection.end).0;
for row in cmp::max(selection_start.row(), start_row)
..=cmp::min(selection_end.row(), end_row)
{
@@ -777,7 +770,7 @@ impl Element for EditorElement {
}
}
- selections.insert(selection_set_id.replica_id, set);
+ selections.insert(selection_set_id.replica_id, replica_selections);
}
});
@@ -939,7 +932,7 @@ pub struct LayoutState {
line_height: f32,
em_width: f32,
em_advance: f32,
- selections: HashMap<ReplicaId, Vec<Range<DisplayPoint>>>,
+ selections: HashMap<ReplicaId, Vec<buffer::Selection<DisplayPoint>>>,
overscroll: Vector2F,
text_offset: Vector2F,
max_visible_line_width: f32,
crates/editor/src/lib.rs 🔗
@@ -6,6 +6,7 @@ pub mod movement;
#[cfg(test)]
mod test;
+use aho_corasick::AhoCorasick;
use buffer::rope::TextDimension;
use clock::ReplicaId;
use display_map::*;
@@ -87,6 +88,7 @@ action!(SelectLine);
action!(SplitSelectionIntoLines);
action!(AddSelectionAbove);
action!(AddSelectionBelow);
+action!(SelectNext, bool);
action!(ToggleComments);
action!(SelectLargerSyntaxNode);
action!(SelectSmallerSyntaxNode);
@@ -191,6 +193,8 @@ pub fn init(cx: &mut MutableAppContext, entry_openers: &mut Vec<Box<dyn EntryOpe
Binding::new("cmd-ctrl-p", AddSelectionAbove, Some("Editor")),
Binding::new("cmd-alt-down", AddSelectionBelow, Some("Editor")),
Binding::new("cmd-ctrl-n", AddSelectionBelow, Some("Editor")),
+ Binding::new("cmd-d", SelectNext(false), Some("Editor")),
+ Binding::new("cmd-k cmd-d", SelectNext(true), Some("Editor")),
Binding::new("cmd-/", ToggleComments, Some("Editor")),
Binding::new("alt-up", SelectLargerSyntaxNode, Some("Editor")),
Binding::new("ctrl-w", SelectLargerSyntaxNode, Some("Editor")),
@@ -254,6 +258,7 @@ pub fn init(cx: &mut MutableAppContext, entry_openers: &mut Vec<Box<dyn EntryOpe
cx.add_action(Editor::split_selection_into_lines);
cx.add_action(Editor::add_selection_above);
cx.add_action(Editor::add_selection_below);
+ cx.add_action(Editor::select_next);
cx.add_action(Editor::toggle_comments);
cx.add_action(Editor::select_larger_syntax_node);
cx.add_action(Editor::select_smaller_syntax_node);
@@ -311,9 +316,11 @@ enum SelectMode {
All,
}
+#[derive(PartialEq, Eq)]
pub enum Autoscroll {
- Closest,
+ Fit,
Center,
+ Newest,
}
#[derive(Copy, Clone, PartialEq, Eq)]
@@ -338,6 +345,7 @@ pub struct Editor {
columnar_selection_tail: Option<Anchor>,
next_selection_id: usize,
add_selections_state: Option<AddSelectionsState>,
+ select_next_state: Option<SelectNextState>,
autoclose_stack: Vec<BracketPairState>,
select_larger_syntax_node_stack: Vec<Box<[Selection<usize>]>>,
active_diagnostics: Option<ActiveDiagnosticGroup>,
@@ -373,6 +381,12 @@ struct AddSelectionsState {
stack: Vec<usize>,
}
+struct SelectNextState {
+ query: AhoCorasick,
+ wordwise: bool,
+ done: bool,
+}
+
#[derive(Debug)]
struct BracketPairState {
ranges: AnchorRangeSet,
@@ -473,6 +487,7 @@ impl Editor {
columnar_selection_tail: None,
next_selection_id,
add_selections_state: None,
+ select_next_state: None,
autoclose_stack: Default::default(),
select_larger_syntax_node_stack: Vec::new(),
active_diagnostics: None,
@@ -595,20 +610,29 @@ impl Editor {
return false;
};
- let mut selections = self.selections::<Point>(cx).peekable();
- let first_cursor_top = selections
- .peek()
- .unwrap()
- .head()
- .to_display_point(&display_map)
- .row() as f32;
- let last_cursor_bottom = selections
- .last()
- .unwrap()
- .head()
- .to_display_point(&display_map)
- .row() as f32
- + 1.0;
+ let first_cursor_top;
+ let last_cursor_bottom;
+ if autoscroll == Autoscroll::Newest {
+ let newest_selection = self.newest_selection::<Point>(cx);
+ first_cursor_top = newest_selection.head().to_display_point(&display_map).row() as f32;
+ last_cursor_bottom = first_cursor_top + 1.;
+ } else {
+ let mut selections = self.selections::<Point>(cx).peekable();
+ first_cursor_top = selections
+ .peek()
+ .unwrap()
+ .head()
+ .to_display_point(&display_map)
+ .row() as f32;
+ last_cursor_bottom = selections
+ .last()
+ .unwrap()
+ .head()
+ .to_display_point(&display_map)
+ .row() as f32
+ + 1.0;
+ }
+
let margin = if matches!(self.mode, EditorMode::AutoHeight { .. }) {
0.
} else {
@@ -619,7 +643,7 @@ impl Editor {
}
match autoscroll {
- Autoscroll::Closest => {
+ Autoscroll::Fit | Autoscroll::Newest => {
let margin = margin.min(3.0);
let target_top = (first_cursor_top - margin).max(0.0);
let target_bottom = last_cursor_bottom + margin;
@@ -658,14 +682,17 @@ impl Editor {
let mut target_right = 0.0_f32;
for selection in selections {
let head = selection.head().to_display_point(&display_map);
- let start_column = head.column().saturating_sub(3);
- let end_column = cmp::min(display_map.line_len(head.row()), head.column() + 3);
- target_left = target_left
- .min(layouts[(head.row() - start_row) as usize].x_for_index(start_column as usize));
- target_right = target_right.max(
- layouts[(head.row() - start_row) as usize].x_for_index(end_column as usize)
- + max_glyph_width,
- );
+ if head.row() >= start_row && head.row() < start_row + layouts.len() as u32 {
+ let start_column = head.column().saturating_sub(3);
+ let end_column = cmp::min(display_map.line_len(head.row()), head.column() + 3);
+ target_left = target_left.min(
+ layouts[(head.row() - start_row) as usize].x_for_index(start_column as usize),
+ );
+ target_right = target_right.max(
+ layouts[(head.row() - start_row) as usize].x_for_index(end_column as usize)
+ + max_glyph_width,
+ );
+ }
}
target_right = target_right.min(scroll_width);
@@ -1000,7 +1027,7 @@ impl Editor {
goal: selection.goal,
};
if self.selections::<Point>(cx).next().is_none() {
- self.update_selections(vec![selection], Some(Autoscroll::Closest), cx);
+ self.update_selections(vec![selection], Some(Autoscroll::Fit), cx);
}
} else {
let mut oldest_selection = self.oldest_selection::<usize>(cx);
@@ -1008,7 +1035,7 @@ impl Editor {
oldest_selection.start = oldest_selection.head().clone();
oldest_selection.end = oldest_selection.head().clone();
}
- self.update_selections(vec![oldest_selection], Some(Autoscroll::Closest), cx);
+ self.update_selections(vec![oldest_selection], Some(Autoscroll::Fit), cx);
}
}
@@ -1201,7 +1228,7 @@ impl Editor {
))
});
- self.update_selections(new_selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(new_selections, Some(Autoscroll::Fit), cx);
self.end_transaction(cx);
#[derive(Default)]
@@ -1241,7 +1268,7 @@ impl Editor {
.collect();
});
- self.update_selections(new_selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(new_selections, Some(Autoscroll::Fit), cx);
self.end_transaction(cx);
}
@@ -1341,7 +1368,7 @@ impl Editor {
})
.collect();
self.autoclose_stack.pop();
- self.update_selections(new_selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(new_selections, Some(Autoscroll::Fit), cx);
true
} else {
false
@@ -1369,7 +1396,7 @@ impl Editor {
selection.goal = SelectionGoal::None;
}
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
self.insert("", cx);
self.end_transaction(cx);
}
@@ -1388,7 +1415,7 @@ impl Editor {
selection.goal = SelectionGoal::None;
}
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
self.insert(&"", cx);
self.end_transaction(cx);
}
@@ -1459,7 +1486,7 @@ impl Editor {
}
});
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
self.end_transaction(cx);
}
@@ -1505,7 +1532,7 @@ impl Editor {
self.update_selections(
self.selections::<usize>(cx).collect(),
- Some(Autoscroll::Closest),
+ Some(Autoscroll::Fit),
cx,
);
self.end_transaction(cx);
@@ -1576,7 +1603,7 @@ impl Editor {
.collect();
self.buffer
.update(cx, |buffer, cx| buffer.edit(edit_ranges, "", cx));
- self.update_selections(new_selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(new_selections, Some(Autoscroll::Fit), cx);
self.end_transaction(cx);
}
@@ -1634,7 +1661,7 @@ impl Editor {
}
});
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
self.end_transaction(cx);
}
@@ -1723,7 +1750,7 @@ impl Editor {
}
});
self.fold_ranges(new_folds, cx);
- self.select_ranges(new_selection_ranges, Some(Autoscroll::Closest), cx);
+ self.select_ranges(new_selection_ranges, Some(Autoscroll::Fit), cx);
self.end_transaction(cx);
}
@@ -1810,7 +1837,7 @@ impl Editor {
}
});
self.fold_ranges(new_folds, cx);
- self.select_ranges(new_selection_ranges, Some(Autoscroll::Closest), cx);
+ self.select_ranges(new_selection_ranges, Some(Autoscroll::Fit), cx);
self.end_transaction(cx);
}
@@ -1840,7 +1867,7 @@ impl Editor {
});
}
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
self.insert("", cx);
self.end_transaction(cx);
@@ -1925,7 +1952,7 @@ impl Editor {
selection.end = selection.start;
});
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
} else {
self.insert(clipboard_text, cx);
}
@@ -1934,12 +1961,12 @@ impl Editor {
pub fn undo(&mut self, _: &Undo, cx: &mut ViewContext<Self>) {
self.buffer.update(cx, |buffer, cx| buffer.undo(cx));
- self.request_autoscroll(Autoscroll::Closest, cx);
+ self.request_autoscroll(Autoscroll::Fit, cx);
}
pub fn redo(&mut self, _: &Redo, cx: &mut ViewContext<Self>) {
self.buffer.update(cx, |buffer, cx| buffer.redo(cx));
- self.request_autoscroll(Autoscroll::Closest, cx);
+ self.request_autoscroll(Autoscroll::Fit, cx);
}
pub fn move_left(&mut self, _: &MoveLeft, cx: &mut ViewContext<Self>) {
@@ -1961,7 +1988,7 @@ impl Editor {
selection.reversed = false;
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_left(&mut self, _: &SelectLeft, cx: &mut ViewContext<Self>) {
@@ -1975,7 +2002,7 @@ impl Editor {
selection.set_head(cursor);
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn move_right(&mut self, _: &MoveRight, cx: &mut ViewContext<Self>) {
@@ -1997,7 +2024,7 @@ impl Editor {
selection.reversed = false;
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_right(&mut self, _: &SelectRight, cx: &mut ViewContext<Self>) {
@@ -2011,7 +2038,7 @@ impl Editor {
selection.set_head(cursor);
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn move_up(&mut self, _: &MoveUp, cx: &mut ViewContext<Self>) {
@@ -2036,7 +2063,7 @@ impl Editor {
selection.goal = goal;
selection.reversed = false;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_up(&mut self, _: &SelectUp, cx: &mut ViewContext<Self>) {
@@ -2049,7 +2076,7 @@ impl Editor {
selection.set_head(cursor);
selection.goal = goal;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn move_down(&mut self, _: &MoveDown, cx: &mut ViewContext<Self>) {
@@ -2074,7 +2101,7 @@ impl Editor {
selection.goal = goal;
selection.reversed = false;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_down(&mut self, _: &SelectDown, cx: &mut ViewContext<Self>) {
@@ -2087,7 +2114,7 @@ impl Editor {
selection.set_head(cursor);
selection.goal = goal;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn move_to_previous_word_boundary(
@@ -2105,7 +2132,7 @@ impl Editor {
selection.reversed = false;
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_to_previous_word_boundary(
@@ -2121,7 +2148,7 @@ impl Editor {
selection.set_head(cursor);
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn delete_to_previous_word_boundary(
@@ -2141,7 +2168,7 @@ impl Editor {
selection.goal = SelectionGoal::None;
}
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
self.insert("", cx);
self.end_transaction(cx);
}
@@ -2161,7 +2188,7 @@ impl Editor {
selection.reversed = false;
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_to_next_word_boundary(
@@ -2177,7 +2204,7 @@ impl Editor {
selection.set_head(cursor);
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn delete_to_next_word_boundary(
@@ -2197,7 +2224,7 @@ impl Editor {
selection.goal = SelectionGoal::None;
}
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
self.insert("", cx);
self.end_transaction(cx);
}
@@ -2218,7 +2245,7 @@ impl Editor {
selection.reversed = false;
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_to_beginning_of_line(
@@ -2234,7 +2261,7 @@ impl Editor {
selection.set_head(new_head.to_point(&display_map));
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn delete_to_beginning_of_line(
@@ -2262,7 +2289,7 @@ impl Editor {
selection.goal = SelectionGoal::None;
}
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn select_to_end_of_line(&mut self, _: &SelectToEndOfLine, cx: &mut ViewContext<Self>) {
@@ -2274,7 +2301,7 @@ impl Editor {
selection.set_head(new_head.to_point(&display_map));
selection.goal = SelectionGoal::None;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn delete_to_end_of_line(&mut self, _: &DeleteToEndOfLine, cx: &mut ViewContext<Self>) {
@@ -2299,13 +2326,13 @@ impl Editor {
reversed: false,
goal: SelectionGoal::None,
};
- self.update_selections(vec![selection], Some(Autoscroll::Closest), cx);
+ self.update_selections(vec![selection], Some(Autoscroll::Fit), cx);
}
pub fn select_to_beginning(&mut self, _: &SelectToBeginning, cx: &mut ViewContext<Self>) {
let mut selection = self.selections::<Point>(cx).last().unwrap().clone();
selection.set_head(Point::zero());
- self.update_selections(vec![selection], Some(Autoscroll::Closest), cx);
+ self.update_selections(vec![selection], Some(Autoscroll::Fit), cx);
}
pub fn move_to_end(&mut self, _: &MoveToEnd, cx: &mut ViewContext<Self>) {
@@ -2318,13 +2345,13 @@ impl Editor {
reversed: false,
goal: SelectionGoal::None,
};
- self.update_selections(vec![selection], Some(Autoscroll::Closest), cx);
+ self.update_selections(vec![selection], Some(Autoscroll::Fit), cx);
}
pub fn select_to_end(&mut self, _: &SelectToEnd, cx: &mut ViewContext<Self>) {
let mut selection = self.selections::<usize>(cx).last().unwrap().clone();
selection.set_head(self.buffer.read(cx).len());
- self.update_selections(vec![selection], Some(Autoscroll::Closest), cx);
+ self.update_selections(vec![selection], Some(Autoscroll::Fit), cx);
}
pub fn select_all(&mut self, _: &SelectAll, cx: &mut ViewContext<Self>) {
@@ -2349,7 +2376,7 @@ impl Editor {
selection.end = cmp::min(max_point, Point::new(rows.end, 0));
selection.reversed = false;
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn split_selection_into_lines(
@@ -2383,7 +2410,7 @@ impl Editor {
to_unfold.push(selection.start..selection.end);
}
self.unfold_ranges(to_unfold, cx);
- self.update_selections(new_selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(new_selections, Some(Autoscroll::Fit), cx);
}
pub fn add_selection_above(&mut self, _: &AddSelectionAbove, cx: &mut ViewContext<Self>) {
@@ -2481,12 +2508,110 @@ impl Editor {
state.stack.pop();
}
- self.update_selections(new_selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(new_selections, Some(Autoscroll::Fit), cx);
if state.stack.len() > 1 {
self.add_selections_state = Some(state);
}
}
+ pub fn select_next(&mut self, action: &SelectNext, cx: &mut ViewContext<Self>) {
+ let replace_newest = action.0;
+ let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+ let buffer = &display_map.buffer_snapshot;
+ let mut selections = self.selections::<usize>(cx).collect::<Vec<_>>();
+ if let Some(mut select_next_state) = self.select_next_state.take() {
+ let query = &select_next_state.query;
+ if !select_next_state.done {
+ let first_selection = selections.iter().min_by_key(|s| s.id).unwrap();
+ let last_selection = selections.iter().max_by_key(|s| s.id).unwrap();
+ let mut next_selected_range = None;
+
+ let bytes_after_last_selection =
+ buffer.bytes_in_range(last_selection.end..buffer.len());
+ let bytes_before_first_selection = buffer.bytes_in_range(0..first_selection.start);
+ let query_matches = query
+ .stream_find_iter(bytes_after_last_selection)
+ .map(|result| (last_selection.end, result))
+ .chain(
+ query
+ .stream_find_iter(bytes_before_first_selection)
+ .map(|result| (0, result)),
+ );
+ for (start_offset, query_match) in query_matches {
+ let query_match = query_match.unwrap(); // can only fail due to I/O
+ let offset_range =
+ start_offset + query_match.start()..start_offset + query_match.end();
+ let display_range = offset_range.start.to_display_point(&display_map)
+ ..offset_range.end.to_display_point(&display_map);
+
+ if !select_next_state.wordwise
+ || (!movement::is_inside_word(&display_map, display_range.start)
+ && !movement::is_inside_word(&display_map, display_range.end))
+ {
+ next_selected_range = Some(offset_range);
+ break;
+ }
+ }
+
+ if let Some(next_selected_range) = next_selected_range {
+ if replace_newest {
+ if let Some(newest_id) =
+ selections.iter().max_by_key(|s| s.id).map(|s| s.id)
+ {
+ selections.retain(|s| s.id != newest_id);
+ }
+ }
+ selections.push(Selection {
+ id: post_inc(&mut self.next_selection_id),
+ start: next_selected_range.start,
+ end: next_selected_range.end,
+ reversed: false,
+ goal: SelectionGoal::None,
+ });
+ selections.sort_unstable_by_key(|s| s.start);
+ self.update_selections(selections, Some(Autoscroll::Newest), cx);
+ } else {
+ select_next_state.done = true;
+ }
+ }
+
+ self.select_next_state = Some(select_next_state);
+ } else if selections.len() == 1 {
+ let selection = selections.last_mut().unwrap();
+ if selection.start == selection.end {
+ let word_range = movement::surrounding_word(
+ &display_map,
+ selection.start.to_display_point(&display_map),
+ );
+ selection.start = word_range.start.to_offset(&display_map, Bias::Left);
+ selection.end = word_range.end.to_offset(&display_map, Bias::Left);
+ selection.goal = SelectionGoal::None;
+ selection.reversed = false;
+
+ let query = buffer
+ .text_for_range(selection.start..selection.end)
+ .collect::<String>();
+ let select_state = SelectNextState {
+ query: AhoCorasick::new_auto_configured(&[query]),
+ wordwise: true,
+ done: false,
+ };
+ self.update_selections(selections, Some(Autoscroll::Newest), cx);
+ self.select_next_state = Some(select_state);
+ } else {
+ let query = buffer
+ .text_for_range(selection.start..selection.end)
+ .collect::<String>();
+ self.select_next_state = Some(SelectNextState {
+ query: AhoCorasick::new_auto_configured(&[query]),
+ wordwise: false,
+ done: false,
+ });
+ self.select_next(action, cx);
+ }
+ }
+ }
+
pub fn toggle_comments(&mut self, _: &ToggleComments, cx: &mut ViewContext<Self>) {
// Get the line comment prefix. Split its trailing whitespace into a separate string,
// as that portion won't be used for detecting if a line is a comment.
@@ -2529,7 +2654,10 @@ impl Editor {
}
let start = Point::new(row, buffer.indent_column_for_line(row));
- let mut line_bytes = buffer.bytes_at(start);
+ let mut line_bytes = buffer
+ .bytes_in_range(start..buffer.max_point())
+ .flatten()
+ .copied();
// If this line currently begins with the line comment prefix, then record
// the range containing the prefix.
@@ -2575,7 +2703,7 @@ impl Editor {
self.update_selections(
self.selections::<usize>(cx).collect(),
- Some(Autoscroll::Closest),
+ Some(Autoscroll::Fit),
cx,
);
self.end_transaction(cx);
@@ -2622,7 +2750,7 @@ impl Editor {
if selected_larger_node {
stack.push(old_selections);
new_selections.sort_unstable_by_key(|selection| selection.start);
- self.update_selections(new_selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(new_selections, Some(Autoscroll::Fit), cx);
}
self.select_larger_syntax_node_stack = stack;
}
@@ -2634,7 +2762,7 @@ impl Editor {
) {
let mut stack = mem::take(&mut self.select_larger_syntax_node_stack);
if let Some(selections) = stack.pop() {
- self.update_selections(selections.to_vec(), Some(Autoscroll::Closest), cx);
+ self.update_selections(selections.to_vec(), Some(Autoscroll::Fit), cx);
}
self.select_larger_syntax_node_stack = stack;
}
@@ -2663,7 +2791,7 @@ impl Editor {
}
}
- self.update_selections(selections, Some(Autoscroll::Closest), cx);
+ self.update_selections(selections, Some(Autoscroll::Fit), cx);
}
pub fn show_next_diagnostic(&mut self, _: &ShowNextDiagnostic, cx: &mut ViewContext<Self>) {
@@ -2898,32 +3026,27 @@ impl Editor {
.map(|(set_id, _)| *set_id)
}
- pub fn selections_in_range<'a>(
+ pub fn intersecting_selections<'a>(
&'a self,
set_id: SelectionSetId,
range: Range<DisplayPoint>,
cx: &'a mut MutableAppContext,
- ) -> impl 'a + Iterator<Item = Range<DisplayPoint>> {
+ ) -> impl 'a + Iterator<Item = Selection<DisplayPoint>> {
let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
let buffer = self.buffer.read(cx);
- let selections = self
- .buffer
- .read(cx)
- .selection_set(set_id)
- .unwrap()
- .selections::<Point, _>(buffer)
- .collect::<Vec<_>>();
- let start = range.start.to_point(&display_map);
- let start_index = self.selection_insertion_index(&selections, start);
+
let pending_selection = if set_id == self.selection_set_id {
self.pending_selection.as_ref().and_then(|pending| {
- let mut selection_start = pending.selection.start.to_display_point(&display_map);
- let mut selection_end = pending.selection.end.to_display_point(&display_map);
- if pending.selection.reversed {
- mem::swap(&mut selection_start, &mut selection_end);
- }
+ let selection_start = pending.selection.start.to_display_point(&display_map);
+ let selection_end = pending.selection.end.to_display_point(&display_map);
if selection_start <= range.end || selection_end <= range.end {
- Some(selection_start..selection_end)
+ Some(Selection {
+ id: pending.selection.id,
+ start: selection_start,
+ end: selection_end,
+ reversed: pending.selection.reversed,
+ goal: pending.selection.goal,
+ })
} else {
None
}
@@ -2931,27 +3054,27 @@ impl Editor {
} else {
None
};
+
+ let range = (range.start.to_offset(&display_map, Bias::Left), Bias::Left)
+ ..(range.end.to_offset(&display_map, Bias::Left), Bias::Right);
+ let selections = self
+ .buffer
+ .read(cx)
+ .selection_set(set_id)
+ .unwrap()
+ .intersecting_selections::<Point, _, _>(range, buffer);
+
selections
- .into_iter()
- .skip(start_index)
- .map(move |s| s.display_range(&display_map))
- .take_while(move |r| r.start <= range.end || r.end <= range.end)
+ .map(move |s| Selection {
+ id: s.id,
+ start: s.start.to_display_point(&display_map),
+ end: s.end.to_display_point(&display_map),
+ reversed: s.reversed,
+ goal: s.goal,
+ })
.chain(pending_selection)
}
- fn selection_insertion_index(&self, selections: &[Selection<Point>], start: Point) -> usize {
- match selections.binary_search_by_key(&start, |probe| probe.start) {
- Ok(index) => index,
- Err(index) => {
- if index > 0 && selections[index - 1].end > start {
- index - 1
- } else {
- index
- }
- }
- }
- }
-
pub fn selections<'a, D>(&self, cx: &'a AppContext) -> impl 'a + Iterator<Item = Selection<D>>
where
D: 'a + TextDimension<'a> + Ord,
@@ -3061,6 +3184,7 @@ impl Editor {
self.pending_selection = None;
self.add_selections_state = None;
+ self.select_next_state = None;
self.select_larger_syntax_node_stack.clear();
while let Some(autoclose_pair_state) = self.autoclose_stack.last() {
let all_selections_inside_autoclose_ranges =
@@ -3219,7 +3343,7 @@ impl Editor {
fn fold_ranges<T: ToOffset>(&mut self, ranges: Vec<Range<T>>, cx: &mut ViewContext<Self>) {
if !ranges.is_empty() {
self.display_map.update(cx, |map, cx| map.fold(ranges, cx));
- self.request_autoscroll(Autoscroll::Closest, cx);
+ self.request_autoscroll(Autoscroll::Fit, cx);
cx.notify();
}
}
@@ -3228,7 +3352,7 @@ impl Editor {
if !ranges.is_empty() {
self.display_map
.update(cx, |map, cx| map.unfold(ranges, cx));
- self.request_autoscroll(Autoscroll::Closest, cx);
+ self.request_autoscroll(Autoscroll::Fit, cx);
cx.notify();
}
}
@@ -5564,12 +5688,20 @@ mod tests {
impl Editor {
fn selection_ranges(&self, cx: &mut MutableAppContext) -> Vec<Range<DisplayPoint>> {
- self.selections_in_range(
+ self.intersecting_selections(
self.selection_set_id,
DisplayPoint::zero()..self.max_point(cx),
cx,
)
- .collect::<Vec<_>>()
+ .into_iter()
+ .map(|s| {
+ if s.reversed {
+ s.end..s.start
+ } else {
+ s.start..s.end
+ }
+ })
+ .collect()
}
}
crates/language/src/proto.rs 🔗
@@ -194,8 +194,8 @@ pub fn deserialize_operation(message: proto::Operation) -> Result<Operation> {
.selections
.iter()
.map(|selection| {
- let range = (FullOffset(selection.start as usize), Bias::Left)
- ..(FullOffset(selection.end as usize), Bias::Right);
+ let range = FullOffset(selection.start as usize)
+ ..FullOffset(selection.end as usize);
let state = SelectionState {
id: selection.id as usize,
reversed: selection.reversed,
@@ -204,7 +204,12 @@ pub fn deserialize_operation(message: proto::Operation) -> Result<Operation> {
(range, state)
})
.collect();
- let selections = AnchorRangeMap::from_full_offset_ranges(version, entries);
+ let selections = AnchorRangeMap::from_full_offset_ranges(
+ version,
+ Bias::Left,
+ Bias::Left,
+ entries,
+ );
Operation::Buffer(buffer::Operation::UpdateSelections {
set_id: clock::Lamport {
@@ -276,11 +281,13 @@ pub fn deserialize_selection_set(set: proto::SelectionSet) -> SelectionSet {
active: set.is_active,
selections: Arc::new(AnchorRangeMap::from_full_offset_ranges(
set.version.into(),
+ Bias::Left,
+ Bias::Left,
set.selections
.into_iter()
.map(|selection| {
- let range = (FullOffset(selection.start as usize), Bias::Left)
- ..(FullOffset(selection.end as usize), Bias::Left);
+ let range =
+ FullOffset(selection.start as usize)..FullOffset(selection.end as usize);
let state = SelectionState {
id: selection.id as usize,
reversed: selection.reversed,