Antonio Scandurra
1d55872e7a
We still need to write a unit test for this, as well as add a keybinding.
674 lines
23 KiB
Rust
674 lines
23 KiB
Rust
use aho_corasick::AhoCorasickBuilder;
|
|
use anyhow::Result;
|
|
use collections::HashSet;
|
|
use editor::{char_kind, Anchor, Autoscroll, Editor, EditorSettings, MultiBufferSnapshot};
|
|
use gpui::{
|
|
action, elements::*, keymap::Binding, Entity, MutableAppContext, RenderContext, Subscription,
|
|
Task, View, ViewContext, ViewHandle, WeakViewHandle,
|
|
};
|
|
use postage::watch;
|
|
use regex::RegexBuilder;
|
|
use smol::future::yield_now;
|
|
use std::{
|
|
cmp::{self, Ordering},
|
|
ops::Range,
|
|
sync::Arc,
|
|
};
|
|
use workspace::{ItemViewHandle, Settings, Toolbar, Workspace};
|
|
|
|
action!(Deploy);
|
|
action!(Cancel);
|
|
action!(ToggleMode, SearchMode);
|
|
action!(GoToMatch, Direction);
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub enum Direction {
|
|
Prev,
|
|
Next,
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub enum SearchMode {
|
|
WholeWord,
|
|
CaseSensitive,
|
|
Regex,
|
|
}
|
|
|
|
pub fn init(cx: &mut MutableAppContext) {
|
|
cx.add_bindings([
|
|
Binding::new("cmd-f", Deploy, Some("Editor && mode == full")),
|
|
Binding::new("escape", Cancel, Some("FindBar")),
|
|
]);
|
|
cx.add_action(FindBar::deploy);
|
|
cx.add_action(FindBar::cancel);
|
|
cx.add_action(FindBar::toggle_mode);
|
|
cx.add_action(FindBar::go_to_match);
|
|
}
|
|
|
|
struct FindBar {
|
|
settings: watch::Receiver<Settings>,
|
|
query_editor: ViewHandle<Editor>,
|
|
active_editor: Option<ViewHandle<Editor>>,
|
|
active_match_index: Option<usize>,
|
|
active_editor_subscription: Option<Subscription>,
|
|
highlighted_editors: HashSet<WeakViewHandle<Editor>>,
|
|
pending_search: Option<Task<()>>,
|
|
case_sensitive_mode: bool,
|
|
whole_word_mode: bool,
|
|
regex_mode: bool,
|
|
query_contains_error: bool,
|
|
}
|
|
|
|
impl Entity for FindBar {
|
|
type Event = ();
|
|
}
|
|
|
|
impl View for FindBar {
|
|
fn ui_name() -> &'static str {
|
|
"FindBar"
|
|
}
|
|
|
|
fn on_focus(&mut self, cx: &mut ViewContext<Self>) {
|
|
cx.focus(&self.query_editor);
|
|
}
|
|
|
|
fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
|
|
let theme = &self.settings.borrow().theme.find;
|
|
let editor_container = if self.query_contains_error {
|
|
theme.invalid_editor
|
|
} else {
|
|
theme.editor.input.container
|
|
};
|
|
Flex::row()
|
|
.with_child(
|
|
ChildView::new(&self.query_editor)
|
|
.contained()
|
|
.with_style(editor_container)
|
|
.constrained()
|
|
.with_max_width(theme.editor.max_width)
|
|
.boxed(),
|
|
)
|
|
.with_child(
|
|
Flex::row()
|
|
.with_child(self.render_mode_button("Aa", SearchMode::CaseSensitive, theme, cx))
|
|
.with_child(self.render_mode_button("|ab|", SearchMode::WholeWord, theme, cx))
|
|
.with_child(self.render_mode_button(".*", SearchMode::Regex, theme, cx))
|
|
.contained()
|
|
.with_style(theme.mode_button_group)
|
|
.boxed(),
|
|
)
|
|
.with_child(
|
|
Flex::row()
|
|
.with_child(self.render_nav_button("<", Direction::Prev, theme, cx))
|
|
.with_child(self.render_nav_button(">", Direction::Next, theme, cx))
|
|
.boxed(),
|
|
)
|
|
.with_children(self.active_editor.as_ref().and_then(|editor| {
|
|
let (_, highlighted_ranges) =
|
|
editor.read(cx).highlighted_ranges_for_type::<Self>()?;
|
|
let match_ix = cmp::min(self.active_match_index? + 1, highlighted_ranges.len());
|
|
Some(
|
|
Label::new(
|
|
format!("{} of {}", match_ix, highlighted_ranges.len()),
|
|
theme.match_index.text.clone(),
|
|
)
|
|
.contained()
|
|
.with_style(theme.match_index.container)
|
|
.boxed(),
|
|
)
|
|
}))
|
|
.contained()
|
|
.with_style(theme.container)
|
|
.boxed()
|
|
}
|
|
}
|
|
|
|
impl Toolbar for FindBar {
|
|
fn active_item_changed(
|
|
&mut self,
|
|
item: Option<Box<dyn ItemViewHandle>>,
|
|
cx: &mut ViewContext<Self>,
|
|
) -> bool {
|
|
self.active_editor_subscription.take();
|
|
self.active_editor.take();
|
|
self.pending_search.take();
|
|
|
|
if let Some(editor) = item.and_then(|item| item.act_as::<Editor>(cx)) {
|
|
self.active_editor_subscription =
|
|
Some(cx.subscribe(&editor, Self::on_active_editor_event));
|
|
self.active_editor = Some(editor);
|
|
self.update_matches(cx);
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FindBar {
|
|
fn new(settings: watch::Receiver<Settings>, cx: &mut ViewContext<Self>) -> Self {
|
|
let query_editor = cx.add_view(|cx| {
|
|
Editor::auto_height(
|
|
2,
|
|
{
|
|
let settings = settings.clone();
|
|
Arc::new(move |_| {
|
|
let settings = settings.borrow();
|
|
EditorSettings {
|
|
style: settings.theme.find.editor.input.as_editor(),
|
|
tab_size: settings.tab_size,
|
|
soft_wrap: editor::SoftWrap::None,
|
|
}
|
|
})
|
|
},
|
|
cx,
|
|
)
|
|
});
|
|
cx.subscribe(&query_editor, Self::on_query_editor_event)
|
|
.detach();
|
|
|
|
Self {
|
|
query_editor,
|
|
active_editor: None,
|
|
active_editor_subscription: None,
|
|
active_match_index: None,
|
|
highlighted_editors: Default::default(),
|
|
case_sensitive_mode: false,
|
|
whole_word_mode: false,
|
|
regex_mode: false,
|
|
settings,
|
|
pending_search: None,
|
|
query_contains_error: false,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
fn set_query(&mut self, query: &str, cx: &mut ViewContext<Self>) {
|
|
self.query_editor.update(cx, |query_editor, cx| {
|
|
query_editor.buffer().update(cx, |query_buffer, cx| {
|
|
let len = query_buffer.read(cx).len();
|
|
query_buffer.edit([0..len], query, cx);
|
|
});
|
|
});
|
|
}
|
|
|
|
fn render_mode_button(
|
|
&self,
|
|
icon: &str,
|
|
mode: SearchMode,
|
|
theme: &theme::Find,
|
|
cx: &mut RenderContext<Self>,
|
|
) -> ElementBox {
|
|
let is_active = self.is_mode_enabled(mode);
|
|
MouseEventHandler::new::<Self, _, _, _>((cx.view_id(), mode as usize), cx, |state, _| {
|
|
let style = match (is_active, state.hovered) {
|
|
(false, false) => &theme.mode_button,
|
|
(false, true) => &theme.hovered_mode_button,
|
|
(true, false) => &theme.active_mode_button,
|
|
(true, true) => &theme.active_hovered_mode_button,
|
|
};
|
|
Label::new(icon.to_string(), style.text.clone())
|
|
.contained()
|
|
.with_style(style.container)
|
|
.boxed()
|
|
})
|
|
.on_click(move |cx| cx.dispatch_action(ToggleMode(mode)))
|
|
.boxed()
|
|
}
|
|
|
|
fn render_nav_button(
|
|
&self,
|
|
icon: &str,
|
|
direction: Direction,
|
|
theme: &theme::Find,
|
|
cx: &mut RenderContext<Self>,
|
|
) -> ElementBox {
|
|
MouseEventHandler::new::<Self, _, _, _>(
|
|
(cx.view_id(), 10 + direction as usize),
|
|
cx,
|
|
|state, _| {
|
|
let style = if state.hovered {
|
|
&theme.hovered_mode_button
|
|
} else {
|
|
&theme.mode_button
|
|
};
|
|
Label::new(icon.to_string(), style.text.clone())
|
|
.contained()
|
|
.with_style(style.container)
|
|
.boxed()
|
|
},
|
|
)
|
|
.on_click(move |cx| cx.dispatch_action(GoToMatch(direction)))
|
|
.boxed()
|
|
}
|
|
|
|
fn deploy(workspace: &mut Workspace, _: &Deploy, cx: &mut ViewContext<Workspace>) {
|
|
let settings = workspace.settings();
|
|
workspace.active_pane().update(cx, |pane, cx| {
|
|
pane.show_toolbar(cx, |cx| FindBar::new(settings, cx));
|
|
if let Some(toolbar) = pane.active_toolbar() {
|
|
cx.focus(toolbar);
|
|
}
|
|
});
|
|
}
|
|
|
|
fn cancel(workspace: &mut Workspace, _: &Cancel, cx: &mut ViewContext<Workspace>) {
|
|
workspace
|
|
.active_pane()
|
|
.update(cx, |pane, cx| pane.hide_toolbar(cx));
|
|
}
|
|
|
|
fn is_mode_enabled(&self, mode: SearchMode) -> bool {
|
|
match mode {
|
|
SearchMode::WholeWord => self.whole_word_mode,
|
|
SearchMode::CaseSensitive => self.case_sensitive_mode,
|
|
SearchMode::Regex => self.regex_mode,
|
|
}
|
|
}
|
|
|
|
fn toggle_mode(&mut self, ToggleMode(mode): &ToggleMode, cx: &mut ViewContext<Self>) {
|
|
let value = match mode {
|
|
SearchMode::WholeWord => &mut self.whole_word_mode,
|
|
SearchMode::CaseSensitive => &mut self.case_sensitive_mode,
|
|
SearchMode::Regex => &mut self.regex_mode,
|
|
};
|
|
*value = !*value;
|
|
self.update_matches(cx);
|
|
cx.notify();
|
|
}
|
|
|
|
fn go_to_match(&mut self, GoToMatch(direction): &GoToMatch, cx: &mut ViewContext<Self>) {
|
|
if let Some(mut index) = self.active_match_index {
|
|
if let Some(editor) = self.active_editor.as_ref() {
|
|
editor.update(cx, |editor, cx| {
|
|
if let Some((_, ranges)) = editor.highlighted_ranges_for_type::<Self>() {
|
|
match direction {
|
|
Direction::Prev => {
|
|
if index == 0 {
|
|
index = ranges.len() - 1;
|
|
} else {
|
|
index -= 1;
|
|
}
|
|
}
|
|
Direction::Next => {
|
|
if index == ranges.len() - 1 {
|
|
index = 0;
|
|
} else {
|
|
index += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
let range_to_select = ranges[index].clone();
|
|
editor.select_ranges([range_to_select], Some(Autoscroll::Fit), cx);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
fn on_query_editor_event(
|
|
&mut self,
|
|
_: ViewHandle<Editor>,
|
|
event: &editor::Event,
|
|
cx: &mut ViewContext<Self>,
|
|
) {
|
|
match event {
|
|
editor::Event::Edited => {
|
|
for editor in self.highlighted_editors.drain() {
|
|
if let Some(editor) = editor.upgrade(cx) {
|
|
if Some(&editor) != self.active_editor.as_ref() {
|
|
editor.update(cx, |editor, cx| {
|
|
editor.clear_highlighted_ranges::<Self>(cx)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
self.query_contains_error = false;
|
|
self.update_matches(cx);
|
|
cx.notify();
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
fn on_active_editor_event(
|
|
&mut self,
|
|
_: ViewHandle<Editor>,
|
|
event: &editor::Event,
|
|
cx: &mut ViewContext<Self>,
|
|
) {
|
|
match event {
|
|
editor::Event::Edited => self.update_matches(cx),
|
|
editor::Event::SelectionsChanged => self.update_match_index(cx),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
fn update_matches(&mut self, cx: &mut ViewContext<Self>) {
|
|
let query = self.query_editor.read(cx).text(cx);
|
|
self.pending_search.take();
|
|
if let Some(editor) = self.active_editor.as_ref() {
|
|
if query.is_empty() {
|
|
self.active_match_index.take();
|
|
editor.update(cx, |editor, cx| editor.clear_highlighted_ranges::<Self>(cx));
|
|
} else {
|
|
let buffer = editor.read(cx).buffer().read(cx).snapshot(cx);
|
|
let case_sensitive = self.case_sensitive_mode;
|
|
let whole_word = self.whole_word_mode;
|
|
let ranges = if self.regex_mode {
|
|
cx.background()
|
|
.spawn(regex_search(buffer, query, case_sensitive, whole_word))
|
|
} else {
|
|
cx.background().spawn(async move {
|
|
Ok(search(buffer, query, case_sensitive, whole_word).await)
|
|
})
|
|
};
|
|
|
|
let editor = editor.downgrade();
|
|
self.pending_search = Some(cx.spawn(|this, mut cx| async move {
|
|
match ranges.await {
|
|
Ok(ranges) => {
|
|
if let Some(editor) = cx.read(|cx| editor.upgrade(cx)) {
|
|
this.update(&mut cx, |this, cx| {
|
|
this.highlighted_editors.insert(editor.downgrade());
|
|
editor.update(cx, |editor, cx| {
|
|
let theme = &this.settings.borrow().theme.find;
|
|
editor.highlight_ranges::<Self>(
|
|
ranges,
|
|
theme.match_background,
|
|
cx,
|
|
)
|
|
});
|
|
this.update_match_index(cx);
|
|
});
|
|
}
|
|
}
|
|
Err(_) => {
|
|
this.update(&mut cx, |this, cx| {
|
|
this.query_contains_error = true;
|
|
cx.notify();
|
|
});
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_match_index(&mut self, cx: &mut ViewContext<Self>) {
|
|
self.active_match_index = self.active_match_index(cx);
|
|
cx.notify();
|
|
}
|
|
|
|
fn active_match_index(&mut self, cx: &mut ViewContext<Self>) -> Option<usize> {
|
|
let editor = self.active_editor.as_ref()?;
|
|
let editor = editor.read(cx);
|
|
let position = editor.newest_anchor_selection()?.head();
|
|
let ranges = editor.highlighted_ranges_for_type::<Self>()?.1;
|
|
let buffer = editor.buffer().read(cx).read(cx);
|
|
match ranges.binary_search_by(|probe| {
|
|
if probe.end.cmp(&position, &*buffer).unwrap().is_lt() {
|
|
Ordering::Less
|
|
} else if probe.start.cmp(&position, &*buffer).unwrap().is_gt() {
|
|
Ordering::Greater
|
|
} else {
|
|
Ordering::Equal
|
|
}
|
|
}) {
|
|
Ok(i) | Err(i) => Some(i),
|
|
}
|
|
}
|
|
}
|
|
|
|
const YIELD_INTERVAL: usize = 20000;
|
|
|
|
async fn search(
|
|
buffer: MultiBufferSnapshot,
|
|
query: String,
|
|
case_sensitive: bool,
|
|
whole_word: bool,
|
|
) -> Vec<Range<Anchor>> {
|
|
let mut ranges = Vec::new();
|
|
|
|
let search = AhoCorasickBuilder::new()
|
|
.auto_configure(&[&query])
|
|
.ascii_case_insensitive(!case_sensitive)
|
|
.build(&[&query]);
|
|
for (ix, mat) in search
|
|
.stream_find_iter(buffer.bytes_in_range(0..buffer.len()))
|
|
.enumerate()
|
|
{
|
|
if (ix + 1) % YIELD_INTERVAL == 0 {
|
|
yield_now().await;
|
|
}
|
|
|
|
let mat = mat.unwrap();
|
|
|
|
if whole_word {
|
|
let prev_kind = buffer.reversed_chars_at(mat.start()).next().map(char_kind);
|
|
let start_kind = char_kind(buffer.chars_at(mat.start()).next().unwrap());
|
|
let end_kind = char_kind(buffer.reversed_chars_at(mat.end()).next().unwrap());
|
|
let next_kind = buffer.chars_at(mat.end()).next().map(char_kind);
|
|
if Some(start_kind) == prev_kind || Some(end_kind) == next_kind {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
ranges.push(buffer.anchor_after(mat.start())..buffer.anchor_before(mat.end()));
|
|
}
|
|
|
|
ranges
|
|
}
|
|
|
|
async fn regex_search(
|
|
buffer: MultiBufferSnapshot,
|
|
mut query: String,
|
|
case_sensitive: bool,
|
|
whole_word: bool,
|
|
) -> Result<Vec<Range<Anchor>>> {
|
|
if whole_word {
|
|
let mut word_query = String::new();
|
|
word_query.push_str("\\b");
|
|
word_query.push_str(&query);
|
|
word_query.push_str("\\b");
|
|
query = word_query;
|
|
}
|
|
|
|
let mut ranges = Vec::new();
|
|
|
|
if query.contains("\n") || query.contains("\\n") {
|
|
let regex = RegexBuilder::new(&query)
|
|
.case_insensitive(!case_sensitive)
|
|
.multi_line(true)
|
|
.build()?;
|
|
for (ix, mat) in regex.find_iter(&buffer.text()).enumerate() {
|
|
if (ix + 1) % YIELD_INTERVAL == 0 {
|
|
yield_now().await;
|
|
}
|
|
|
|
ranges.push(buffer.anchor_after(mat.start())..buffer.anchor_before(mat.end()));
|
|
}
|
|
} else {
|
|
let regex = RegexBuilder::new(&query)
|
|
.case_insensitive(!case_sensitive)
|
|
.build()?;
|
|
|
|
let mut line = String::new();
|
|
let mut line_offset = 0;
|
|
for (chunk_ix, chunk) in buffer
|
|
.chunks(0..buffer.len(), None)
|
|
.map(|c| c.text)
|
|
.chain(["\n"])
|
|
.enumerate()
|
|
{
|
|
if (chunk_ix + 1) % YIELD_INTERVAL == 0 {
|
|
yield_now().await;
|
|
}
|
|
|
|
for (newline_ix, text) in chunk.split('\n').enumerate() {
|
|
if newline_ix > 0 {
|
|
for mat in regex.find_iter(&line) {
|
|
let start = line_offset + mat.start();
|
|
let end = line_offset + mat.end();
|
|
ranges.push(buffer.anchor_after(start)..buffer.anchor_before(end));
|
|
}
|
|
|
|
line_offset += line.len() + 1;
|
|
line.clear();
|
|
}
|
|
line.push_str(text);
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(ranges)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use editor::{DisplayPoint, Editor, EditorSettings, MultiBuffer};
|
|
use gpui::{color::Color, TestAppContext};
|
|
use std::sync::Arc;
|
|
use unindent::Unindent as _;
|
|
|
|
#[gpui::test]
|
|
async fn test_find_simple(mut cx: TestAppContext) {
|
|
let fonts = cx.font_cache();
|
|
let mut theme = gpui::fonts::with_font_cache(fonts.clone(), || theme::Theme::default());
|
|
theme.find.match_background = Color::red();
|
|
let settings = Settings::new("Courier", &fonts, Arc::new(theme)).unwrap();
|
|
|
|
let buffer = cx.update(|cx| {
|
|
MultiBuffer::build_simple(
|
|
&r#"
|
|
A regular expression (shortened as regex or regexp;[1] also referred to as
|
|
rational expression[2][3]) is a sequence of characters that specifies a search
|
|
pattern in text. Usually such patterns are used by string-searching algorithms
|
|
for "find" or "find and replace" operations on strings, or for input validation.
|
|
"#
|
|
.unindent(),
|
|
cx,
|
|
)
|
|
});
|
|
let editor = cx.add_view(Default::default(), |cx| {
|
|
Editor::new(buffer.clone(), Arc::new(EditorSettings::test), cx)
|
|
});
|
|
|
|
let find_bar = cx.add_view(Default::default(), |cx| {
|
|
let mut find_bar = FindBar::new(watch::channel_with(settings).1, cx);
|
|
find_bar.active_item_changed(Some(Box::new(editor.clone())), cx);
|
|
find_bar
|
|
});
|
|
|
|
// Search for a string that appears with different casing.
|
|
// By default, search is case-insensitive.
|
|
find_bar.update(&mut cx, |find_bar, cx| {
|
|
find_bar.set_query("us", cx);
|
|
});
|
|
editor.next_notification(&cx).await;
|
|
editor.update(&mut cx, |editor, cx| {
|
|
assert_eq!(
|
|
editor.all_highlighted_ranges(cx),
|
|
&[
|
|
(
|
|
DisplayPoint::new(2, 17)..DisplayPoint::new(2, 19),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(2, 43)..DisplayPoint::new(2, 45),
|
|
Color::red(),
|
|
),
|
|
]
|
|
);
|
|
});
|
|
|
|
// Switch to a case sensitive search.
|
|
find_bar.update(&mut cx, |find_bar, cx| {
|
|
find_bar.toggle_mode(&ToggleMode(SearchMode::CaseSensitive), cx);
|
|
});
|
|
editor.next_notification(&cx).await;
|
|
editor.update(&mut cx, |editor, cx| {
|
|
assert_eq!(
|
|
editor.all_highlighted_ranges(cx),
|
|
&[(
|
|
DisplayPoint::new(2, 43)..DisplayPoint::new(2, 45),
|
|
Color::red(),
|
|
)]
|
|
);
|
|
});
|
|
|
|
// Search for a string that appears both as a whole word and
|
|
// within other words. By default, all results are found.
|
|
find_bar.update(&mut cx, |find_bar, cx| {
|
|
find_bar.set_query("or", cx);
|
|
});
|
|
editor.next_notification(&cx).await;
|
|
editor.update(&mut cx, |editor, cx| {
|
|
assert_eq!(
|
|
editor.all_highlighted_ranges(cx),
|
|
&[
|
|
(
|
|
DisplayPoint::new(0, 24)..DisplayPoint::new(0, 26),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(0, 41)..DisplayPoint::new(0, 43),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(2, 71)..DisplayPoint::new(2, 73),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(3, 1)..DisplayPoint::new(3, 3),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(3, 11)..DisplayPoint::new(3, 13),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(3, 56)..DisplayPoint::new(3, 58),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(3, 60)..DisplayPoint::new(3, 62),
|
|
Color::red(),
|
|
),
|
|
]
|
|
);
|
|
});
|
|
|
|
// Switch to a whole word search.
|
|
find_bar.update(&mut cx, |find_bar, cx| {
|
|
find_bar.toggle_mode(&ToggleMode(SearchMode::WholeWord), cx);
|
|
});
|
|
editor.next_notification(&cx).await;
|
|
editor.update(&mut cx, |editor, cx| {
|
|
assert_eq!(
|
|
editor.all_highlighted_ranges(cx),
|
|
&[
|
|
(
|
|
DisplayPoint::new(0, 41)..DisplayPoint::new(0, 43),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(3, 11)..DisplayPoint::new(3, 13),
|
|
Color::red(),
|
|
),
|
|
(
|
|
DisplayPoint::new(3, 56)..DisplayPoint::new(3, 58),
|
|
Color::red(),
|
|
),
|
|
]
|
|
);
|
|
});
|
|
|
|
find_bar.update(&mut cx, |find_bar, cx| {
|
|
find_bar.go_to_match(&GoToMatch(Direction::Next), cx);
|
|
});
|
|
}
|
|
}
|