oak-team/oak-gpui
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP on rebuilding with extracted UI framework

Browse Source
This commit is contained in:
Nathan Sobo
2021-03-18 13:13:31 -06:00
parent 356bc41752
commit 23308e17a9
33 changed files with 2673 additions and 657 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zed/src/editor/buffer/mod.rs
+19 -20
View File
@@ -7,15 +7,14 @@ pub use point::*;
pub use text::*;
use crate::{
app::{self as app, AppContext, ModelContext},
operation_queue::{self, OperationQueue},
sum_tree::{self, Cursor, FilterCursor, SeekBias, SumTree},
time,
time::{self, ReplicaId},
util::RandomCharIter,
worktree::FileHandle,
ReplicaId,
};
use anyhow::{anyhow, Result};
use gpui::{AppContext, Entity, ModelContext};
use lazy_static::lazy_static;
use rand::prelude::*;
use std::{
@@ -423,11 +422,11 @@ impl Buffer {
}
pub fn simulate_typing<T: Rng>(&mut self, rng: &mut T) {
let end = rng.gen_range(0, self.len() + 1);
let start = rng.gen_range(0, end + 1);
let end = rng.gen_range(0..self.len() + 1);
let start = rng.gen_range(0..end + 1);
let mut range = start..end;
let new_text_len = rng.gen_range(0, 100);
let new_text_len = rng.gen_range(0..100);
let new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
for char in new_text.chars() {
@@ -452,11 +451,11 @@ impl Buffer {
if last_end > self.len() {
break;
}
let end = rng.gen_range(last_end, self.len() + 1);
let start = rng.gen_range(last_end, end + 1);
let end = rng.gen_range(last_end..self.len() + 1);
let start = rng.gen_range(last_end..end + 1);
old_ranges.push(start..end);
}
let new_text_len = rng.gen_range(0, 10);
let new_text_len = rng.gen_range(0..10);
let new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
let operations = self
@@ -1375,7 +1374,7 @@ pub enum Event {
Edited(Vec<Edit>),
}
impl app::Entity for Buffer {
impl Entity for Buffer {
type Event = Event;
}
@@ -1905,7 +1904,7 @@ mod tests {
#[test]
fn test_edit_events() {
use crate::app::App;
use gpui::App;
use std::{cell::RefCell, rc::Rc};
let mut app = App::new().unwrap();
@@ -1956,7 +1955,7 @@ mod tests {
println!("{:?}", seed);
let mut rng = &mut StdRng::seed_from_u64(seed);
let reference_string_len = rng.gen_range(0, 3);
let reference_string_len = rng.gen_range(0..3);
let mut reference_string = RandomCharIter::new(&mut rng)
.take(reference_string_len)
.collect::<String>();
@@ -1991,8 +1990,8 @@ mod tests {
}
for _ in 0..5 {
let end = rng.gen_range(0, buffer.len() + 1);
let start = rng.gen_range(0, end + 1);
let end = rng.gen_range(0..buffer.len() + 1);
let start = rng.gen_range(0..end + 1);
let line_lengths = line_lengths_in_range(&buffer, start..end);
let (longest_column, longest_rows) = line_lengths.iter().next_back().unwrap();
@@ -2236,7 +2235,7 @@ mod tests {
let mut ids = vec![FragmentId(Arc::from([0])), FragmentId(Arc::from([4]))];
for _i in 0..100 {
let index = rng.gen_range(1, ids.len());
let index = rng.gen_range(1..ids.len());
let left = ids[index - 1].clone();
let right = ids[index].clone();
@@ -2429,7 +2428,7 @@ mod tests {
#[test]
fn test_random_concurrent_edits() {
use crate::tests::Network;
use crate::test::Network;
const PEERS: usize = 3;
@@ -2437,7 +2436,7 @@ mod tests {
println!("{:?}", seed);
let mut rng = &mut StdRng::seed_from_u64(seed);
let base_text_len = rng.gen_range(0, 10);
let base_text_len = rng.gen_range(0..10);
let base_text = RandomCharIter::new(&mut rng)
.take(base_text_len)
.collect::<String>();
@@ -2453,7 +2452,7 @@ mod tests {
let mut mutation_count = 10;
loop {
let replica_index = rng.gen_range(0, PEERS);
let replica_index = rng.gen_range(0..PEERS);
let replica_id = replica_ids[replica_index];
let buffer = &mut buffers[replica_index];
if mutation_count > 0 && rng.gen() {
@@ -2510,9 +2509,9 @@ mod tests {
} else {
let mut ranges = Vec::new();
for _ in 0..5 {
let start = rng.gen_range(0, self.len() + 1);
let start = rng.gen_range(0..self.len() + 1);
let start_point = self.point_for_offset(start).unwrap();
let end = rng.gen_range(0, self.len() + 1);
let end = rng.gen_range(0..self.len() + 1);
let end_point = self.point_for_offset(end).unwrap();
ranges.push(start_point..end_point);
}
zed/src/editor/buffer/text.rs
+4 -4
View File
@@ -366,7 +366,7 @@ mod tests {
println!("buffer::text seed: {}", seed);
let rng = &mut StdRng::seed_from_u64(seed);
let len = rng.gen_range(0, 50);
let len = rng.gen_range(0..50);
let mut string = String::new();
for _ in 0..len {
if rng.gen_ratio(1, 5) {
@@ -378,8 +378,8 @@ mod tests {
let text = Text::from(string.clone());
for _ in 0..10 {
let start = rng.gen_range(0, text.len() + 1);
let end = rng.gen_range(start, text.len() + 2);
let start = rng.gen_range(0..text.len() + 1);
let end = rng.gen_range(start..text.len() + 2);
let string_slice = string
.chars()
@@ -414,7 +414,7 @@ mod tests {
assert!(rightmost_points.contains(&text_slice.rightmost_point()));
for _ in 0..10 {
let offset = rng.gen_range(0, string_slice.chars().count() + 1);
let offset = rng.gen_range(0..string_slice.chars().count() + 1);
let point = lines(&string_slice.chars().take(offset).collect::<String>());
assert_eq!(text_slice.point_for_offset(offset), point);
assert_eq!(text_slice.offset_for_point(point), offset);
zed/src/editor/buffer_element.rs
+212 -305
View File
@@ -1,24 +1,15 @@
use super::{BufferView, DisplayPoint, SelectAction};
use crate::{
app::{AppContext, MutableAppContext, ViewHandle},
fonts::FontCache,
text_layout::{self, LayoutCache},
ui::{
AfterLayoutContext, Bump, Element, Event, EventContext, LayoutContext, PaintContext,
SizeConstraint,
use gpui::{
geometry::{
rect::RectF,
vector::{vec2f, Vector2F},
},
text_layout::{self, TextLayoutCache},
AfterLayoutContext, AppContext, Element, Event, EventContext, FontCache, LayoutContext,
MutableAppContext, PaintContext, Scene, SizeConstraint, ViewHandle,
};
use pathfinder_canvas::{
ArcDirection, CanvasRenderingContext2D, ColorF, FillRule, FillStyle, Path2D,
};
use pathfinder_color::ColorU;
use pathfinder_geometry::{
rect::RectF,
vector::{vec2f, Vector2F},
};
use smallvec::SmallVec;
use std::{
cmp::{self, Ordering},
cmp::{self},
sync::Arc,
};
@@ -176,166 +167,165 @@ impl BufferElement {
}
fn paint_gutter(&mut self, rect: RectF, ctx: &mut PaintContext, app: &AppContext) {
if let Some(layout) = self.layout.as_ref() {
let view = self.view.as_ref(app);
let canvas = &mut ctx.canvas;
let font_cache = &ctx.font_cache;
let line_height = view.line_height(font_cache);
let scroll_top = view.scroll_position().y() * line_height;
// if let Some(layout) = self.layout.as_ref() {
// let view = self.view.as_ref(app);
// let scene = &mut ctx.scene;
// let font_cache = &ctx.font_cache;
// let line_height = view.line_height(font_cache);
// let scroll_top = view.scroll_position().y() * line_height;
canvas.save();
canvas.translate(rect.origin());
canvas.set_fill_style(FillStyle::Color(ColorU::white()));
// scene.save();
// scene.translate(rect.origin());
// scene.set_fill_style(FillStyle::Color(ColorU::white()));
let rect = RectF::new(Vector2F::zero(), rect.size());
let mut rect_path = Path2D::new();
rect_path.rect(rect);
canvas.clip_path(rect_path, FillRule::EvenOdd);
canvas.fill_rect(rect);
// let rect = RectF::new(Vector2F::zero(), rect.size());
// let mut rect_path = Path2D::new();
// rect_path.rect(rect);
// scene.clip_path(rect_path, FillRule::EvenOdd);
// scene.fill_rect(rect);
for (ix, line) in layout.line_number_layouts.iter().enumerate() {
let line_origin = vec2f(
rect.width() - line.width - layout.gutter_padding,
ix as f32 * line_height - (scroll_top % line_height),
);
line.paint(
line_origin,
rect,
&[(0..line.len, ColorU::black())],
canvas,
font_cache,
);
}
// for (ix, line) in layout.line_number_layouts.iter().enumerate() {
// let line_origin = vec2f(
// rect.width() - line.width - layout.gutter_padding,
// ix as f32 * line_height - (scroll_top % line_height),
// );
// line.paint(
// line_origin,
// rect,
// &[(0..line.len, ColorU::black())],
// scene,
// font_cache,
// );
// }
canvas.restore();
}
// scene.restore();
// }
}
fn paint_text(&mut self, rect: RectF, ctx: &mut PaintContext, app: &AppContext) {
if let Some(layout) = self.layout.as_ref() {
let canvas = &mut ctx.canvas;
let font_cache = &ctx.font_cache;
// if let Some(layout) = self.layout.as_ref() {
// let scene = &mut ctx.scene;
// let font_cache = &ctx.font_cache;
canvas.save();
canvas.translate(rect.origin());
canvas.set_fill_style(FillStyle::Color(ColorU::white()));
let rect = RectF::new(Vector2F::zero(), rect.size());
let mut rect_path = Path2D::new();
rect_path.rect(rect);
canvas.clip_path(rect_path, FillRule::EvenOdd);
canvas.fill_rect(rect);
// scene.save();
// scene.translate(rect.origin());
// scene.set_fill_style(FillStyle::Color(ColorU::white()));
// let rect = RectF::new(Vector2F::zero(), rect.size());
// let mut rect_path = Path2D::new();
// rect_path.rect(rect);
// scene.clip_path(rect_path, FillRule::EvenOdd);
// scene.fill_rect(rect);
let view = self.view.as_ref(app);
let line_height = view.line_height(font_cache);
let descent = view.font_descent(font_cache);
let start_row = view.scroll_position().y() as u32;
let scroll_top = view.scroll_position().y() * line_height;
let end_row = ((scroll_top + rect.height()) / line_height).ceil() as u32 + 1; // Add 1 to ensure selections bleed off screen
let max_glyph_width = view.em_width(font_cache);
let scroll_left = view.scroll_position().x() * max_glyph_width;
// let view = self.view.as_ref(app);
// let line_height = view.line_height(font_cache);
// let descent = view.font_descent(font_cache);
// let start_row = view.scroll_position().y() as u32;
// let scroll_top = view.scroll_position().y() * line_height;
// let end_row = ((scroll_top + rect.height()) / line_height).ceil() as u32 + 1; // Add 1 to ensure selections bleed off screen
// let max_glyph_width = view.em_width(font_cache);
// let scroll_left = view.scroll_position().x() * max_glyph_width;
// Draw selections
canvas.save();
let corner_radius = 2.5;
let mut cursors = SmallVec::<[Cursor; 32]>::new();
// // Draw selections
// scene.save();
// let corner_radius = 2.5;
// let mut cursors = SmallVec::<[Cursor; 32]>::new();
for selection in view.selections_in_range(
DisplayPoint::new(start_row, 0)..DisplayPoint::new(end_row, 0),
app,
) {
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)
} else {
cmp::max(range_start.row(), start_row)
..cmp::min(range_end.row() + 1, end_row)
};
// for selection in view.selections_in_range(
// DisplayPoint::new(start_row, 0)..DisplayPoint::new(end_row, 0),
// app,
// ) {
// 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)
// } else {
// cmp::max(range_start.row(), start_row)
// ..cmp::min(range_end.row() + 1, end_row)
// };
let selection = Selection {
line_height,
start_y: row_range.start as f32 * line_height - scroll_top,
lines: row_range
.into_iter()
.map(|row| {
let line_layout = &layout.line_layouts[(row - start_row) as usize];
SelectionLine {
start_x: if row == range_start.row() {
line_layout.x_for_index(range_start.column() as usize)
- scroll_left
- descent
} else {
-scroll_left
},
end_x: if row == range_end.row() {
line_layout.x_for_index(range_end.column() as usize)
- scroll_left
- descent
} else {
line_layout.width + corner_radius * 2.0
- scroll_left
- descent
},
}
})
.collect(),
};
// let selection = Selection {
// line_height,
// start_y: row_range.start as f32 * line_height - scroll_top,
// lines: row_range
// .into_iter()
// .map(|row| {
// let line_layout = &layout.line_layouts[(row - start_row) as usize];
// SelectionLine {
// start_x: if row == range_start.row() {
// line_layout.x_for_index(range_start.column() as usize)
// - scroll_left
// - descent
// } else {
// -scroll_left
// },
// end_x: if row == range_end.row() {
// line_layout.x_for_index(range_end.column() as usize)
// - scroll_left
// - descent
// } else {
// line_layout.width + corner_radius * 2.0
// - scroll_left
// - descent
// },
// }
// })
// .collect(),
// };
selection.paint(canvas);
}
// selection.paint(scene);
// }
if view.cursors_visible() {
let cursor_position = selection.end;
if (start_row..end_row).contains(&cursor_position.row()) {
let cursor_row_layout =
&layout.line_layouts[(selection.end.row() - start_row) as usize];
cursors.push(Cursor {
x: cursor_row_layout.x_for_index(selection.end.column() as usize)
- scroll_left
- descent,
y: selection.end.row() as f32 * line_height - scroll_top,
line_height,
});
}
}
}
canvas.restore();
// if view.cursors_visible() {
// let cursor_position = selection.end;
// if (start_row..end_row).contains(&cursor_position.row()) {
// let cursor_row_layout =
// &layout.line_layouts[(selection.end.row() - start_row) as usize];
// cursors.push(Cursor {
// x: cursor_row_layout.x_for_index(selection.end.column() as usize)
// - scroll_left
// - descent,
// y: selection.end.row() as f32 * line_height - scroll_top,
// line_height,
// });
// }
// }
// }
// scene.restore();
// Draw glyphs
// // Draw glyphs
canvas.set_fill_style(FillStyle::Color(ColorU::black()));
// scene.set_fill_style(FillStyle::Color(ColorU::black()));
for (ix, line) in layout.line_layouts.iter().enumerate() {
let row = start_row + ix as u32;
let line_origin = vec2f(
-scroll_left - descent,
row as f32 * line_height - scroll_top,
);
// for (ix, line) in layout.line_layouts.iter().enumerate() {
// let row = start_row + ix as u32;
// let line_origin = vec2f(
// -scroll_left - descent,
// row as f32 * line_height - scroll_top,
// );
line.paint(
line_origin,
rect,
&[(0..line.len, ColorU::black())],
canvas,
font_cache,
);
}
// line.paint(
// line_origin,
// rect,
// &[(0..line.len, ColorU::black())],
// scene,
// font_cache,
// );
// }
for cursor in cursors {
cursor.paint(canvas);
}
// for cursor in cursors {
// cursor.paint(scene);
// }
canvas.restore()
}
// scene.restore()
// }
}
}
impl<'a> Element<'a> for BufferElement {
impl Element for BufferElement {
fn layout(
&mut self,
constraint: SizeConstraint,
_: &'a Bump,
ctx: &mut LayoutContext,
app: &AppContext,
) -> Vector2F {
@@ -480,7 +470,7 @@ impl<'a> Element<'a> for BufferElement {
}
}
fn size(&self) -> Option<pathfinder_canvas::Vector2F> {
fn size(&self) -> Option<Vector2F> {
self.layout.as_ref().map(|layout| layout.size)
}
}
@@ -501,7 +491,7 @@ impl LayoutState {
&self,
view: &BufferView,
font_cache: &FontCache,
layout_cache: &LayoutCache,
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> f32 {
let row = view.rightmost_point(app).row();
@@ -516,7 +506,7 @@ impl LayoutState {
&self,
view: &BufferView,
font_cache: &FontCache,
layout_cache: &LayoutCache,
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> Vector2F {
vec2f(
@@ -569,12 +559,12 @@ struct Cursor {
}
impl Cursor {
fn paint(&self, canvas: &mut CanvasRenderingContext2D) {
canvas.set_fill_style(FillStyle::Color(ColorU::black()));
canvas.fill_rect(RectF::new(
vec2f(self.x, self.y),
vec2f(2.0, self.line_height),
));
fn paint(&self, scene: &mut Scene) {
// scene.set_fill_style(FillStyle::Color(ColorU::black()));
// scene.fill_rect(RectF::new(
// vec2f(self.x, self.y),
// vec2f(2.0, self.line_height),
// ));
}
}
@@ -592,167 +582,84 @@ struct SelectionLine {
}
impl Selection {
fn paint(&self, canvas: &mut CanvasRenderingContext2D) {
fn paint(&self, scene: &mut Scene) {
if self.lines.len() >= 2 && self.lines[0].start_x > self.lines[1].end_x {
self.paint_lines(self.start_y, &self.lines[0..1], canvas);
self.paint_lines(self.start_y + self.line_height, &self.lines[1..], canvas);
self.paint_lines(self.start_y, &self.lines[0..1], scene);
self.paint_lines(self.start_y + self.line_height, &self.lines[1..], scene);
} else {
self.paint_lines(self.start_y, &self.lines, canvas);
self.paint_lines(self.start_y, &self.lines, scene);
}
}
fn paint_lines(
&self,
start_y: f32,
lines: &[SelectionLine],
canvas: &mut CanvasRenderingContext2D,
) {
use Direction::*;
fn paint_lines(&self, start_y: f32, lines: &[SelectionLine], scene: &mut Scene) {
// use Direction::*;
if lines.is_empty() {
return;
}
// if lines.is_empty() {
// return;
// }
let mut path = Path2D::new();
let corner_radius = 0.08 * self.line_height;
// let mut path = Path2D::new();
// let corner_radius = 0.08 * self.line_height;
let first_line = lines.first().unwrap();
let last_line = lines.last().unwrap();
// let first_line = lines.first().unwrap();
// let last_line = lines.last().unwrap();
let corner = vec2f(first_line.end_x, start_y);
path.move_to(corner - vec2f(corner_radius, 0.0));
rounded_corner(&mut path, corner, corner_radius, Right, Down);
// let corner = vec2f(first_line.end_x, start_y);
// path.move_to(corner - vec2f(corner_radius, 0.0));
// rounded_corner(&mut path, corner, corner_radius, Right, Down);
let mut iter = lines.iter().enumerate().peekable();
while let Some((ix, line)) = iter.next() {
let corner = vec2f(line.end_x, start_y + (ix + 1) as f32 * self.line_height);
// let mut iter = lines.iter().enumerate().peekable();
// while let Some((ix, line)) = iter.next() {
// let corner = vec2f(line.end_x, start_y + (ix + 1) as f32 * self.line_height);
if let Some((_, next_line)) = iter.peek() {
let next_corner = vec2f(next_line.end_x, corner.y());
// if let Some((_, next_line)) = iter.peek() {
// let next_corner = vec2f(next_line.end_x, corner.y());
match next_corner.x().partial_cmp(&corner.x()).unwrap() {
Ordering::Equal => {
path.line_to(corner);
}
Ordering::Less => {
path.line_to(corner - vec2f(0.0, corner_radius));
rounded_corner(&mut path, corner, corner_radius, Down, Left);
path.line_to(next_corner + vec2f(corner_radius, 0.0));
rounded_corner(&mut path, next_corner, corner_radius, Left, Down);
}
Ordering::Greater => {
path.line_to(corner - vec2f(0.0, corner_radius));
rounded_corner(&mut path, corner, corner_radius, Down, Right);
path.line_to(next_corner - vec2f(corner_radius, 0.0));
rounded_corner(&mut path, next_corner, corner_radius, Right, Down);
}
}
} else {
path.line_to(corner - vec2f(0.0, corner_radius));
rounded_corner(&mut path, corner, corner_radius, Down, Left);
// match next_corner.x().partial_cmp(&corner.x()).unwrap() {
// Ordering::Equal => {
// path.line_to(corner);
// }
// Ordering::Less => {
// path.line_to(corner - vec2f(0.0, corner_radius));
// rounded_corner(&mut path, corner, corner_radius, Down, Left);
// path.line_to(next_corner + vec2f(corner_radius, 0.0));
// rounded_corner(&mut path, next_corner, corner_radius, Left, Down);
// }
// Ordering::Greater => {
// path.line_to(corner - vec2f(0.0, corner_radius));
// rounded_corner(&mut path, corner, corner_radius, Down, Right);
// path.line_to(next_corner - vec2f(corner_radius, 0.0));
// rounded_corner(&mut path, next_corner, corner_radius, Right, Down);
// }
// }
// } else {
// path.line_to(corner - vec2f(0.0, corner_radius));
// rounded_corner(&mut path, corner, corner_radius, Down, Left);
let corner = vec2f(line.start_x, corner.y());
path.line_to(corner + vec2f(corner_radius, 0.0));
rounded_corner(&mut path, corner, corner_radius, Left, Up);
}
}
// let corner = vec2f(line.start_x, corner.y());
// path.line_to(corner + vec2f(corner_radius, 0.0));
// rounded_corner(&mut path, corner, corner_radius, Left, Up);
// }
// }
if first_line.start_x > last_line.start_x {
let corner = vec2f(last_line.start_x, start_y + self.line_height);
path.line_to(corner + vec2f(0.0, corner_radius));
rounded_corner(&mut path, corner, corner_radius, Up, Right);
let corner = vec2f(first_line.start_x, corner.y());
path.line_to(corner - vec2f(corner_radius, 0.0));
rounded_corner(&mut path, corner, corner_radius, Right, Up);
}
// if first_line.start_x > last_line.start_x {
// let corner = vec2f(last_line.start_x, start_y + self.line_height);
// path.line_to(corner + vec2f(0.0, corner_radius));
// rounded_corner(&mut path, corner, corner_radius, Up, Right);
// let corner = vec2f(first_line.start_x, corner.y());
// path.line_to(corner - vec2f(corner_radius, 0.0));
// rounded_corner(&mut path, corner, corner_radius, Right, Up);
// }
let corner = vec2f(first_line.start_x, start_y);
path.line_to(corner + vec2f(0.0, corner_radius));
rounded_corner(&mut path, corner, corner_radius, Up, Right);
path.close_path();
// let corner = vec2f(first_line.start_x, start_y);
// path.line_to(corner + vec2f(0.0, corner_radius));
// rounded_corner(&mut path, corner, corner_radius, Up, Right);
// path.close_path();
canvas.set_fill_style(FillStyle::Color(
ColorF::new(0.639, 0.839, 1.0, 1.0).to_u8(),
));
canvas.fill_path(path, FillRule::Winding);
}
}
enum Direction {
Up,
Down,
Left,
Right,
}
fn rounded_corner(
path: &mut Path2D,
corner: Vector2F,
radius: f32,
incoming: Direction,
outgoing: Direction,
) {
use std::f32::consts::PI;
use Direction::*;
match (incoming, outgoing) {
(Down, Right) => path.arc(
corner + vec2f(radius, -radius),
radius,
1.0 * PI,
0.5 * PI,
ArcDirection::CCW,
),
(Down, Left) => path.arc(
corner + vec2f(-radius, -radius),
radius,
0.0,
0.5 * PI,
ArcDirection::CW,
),
(Up, Right) => path.arc(
corner + vec2f(radius, radius),
radius,
1.0 * PI,
1.5 * PI,
ArcDirection::CW,
),
(Up, Left) => path.arc(
corner + vec2f(-radius, radius),
radius,
0.0,
1.5 * PI,
ArcDirection::CCW,
),
(Right, Up) => path.arc(
corner + vec2f(-radius, -radius),
radius,
0.5 * PI,
0.0,
ArcDirection::CCW,
),
(Right, Down) => path.arc(
corner + vec2f(-radius, radius),
radius,
1.5 * PI,
2.0 * PI,
ArcDirection::CW,
),
(Left, Up) => path.arc(
corner + vec2f(radius, -radius),
radius,
0.5 * PI,
PI,
ArcDirection::CW,
),
(Left, Down) => path.arc(
corner + vec2f(radius, radius),
radius,
1.5 * PI,
PI,
ArcDirection::CCW,
),
_ => panic!("invalid incoming and outgoing directions for a corner"),
// scene.set_fill_style(FillStyle::Color(
// ColorF::new(0.639, 0.839, 1.0, 1.0).to_u8(),
// ));
// scene.fill_path(path, FillRule::Winding);
}
}
zed/src/editor/buffer_view.rs
+76 -87
View File
@@ -2,20 +2,16 @@ use super::{
buffer, movement, Anchor, Bias, Buffer, BufferElement, DisplayMap, DisplayPoint, Point,
ToOffset, ToPoint,
};
use crate::{
app::{self as app, App, AppContext, ModelHandle, ViewContext, WeakViewHandle},
fonts::FontCache,
keymap::Binding,
settings::Settings,
text_layout,
ui::elements::*,
watch, workspace,
};
use crate::{settings::Settings, watch};
use anyhow::Result;
use easy_parallel::Parallel;
use font_kit::properties::Properties as FontProperties;
use gpui::{
fonts::{FontCache, Properties as FontProperties},
keymap::Binding,
text_layout, App, AppContext, Element, Entity, ModelHandle, View, ViewContext, WeakViewHandle,
};
use gpui::{geometry::vector::Vector2F, TextLayoutCache};
use parking_lot::Mutex;
use pathfinder_geometry::vector::Vector2F;
use smallvec::SmallVec;
use smol::Timer;
use std::{
@@ -26,7 +22,6 @@ use std::{
sync::Arc,
time::Duration,
};
use text_layout::LayoutCache;
const CURSOR_BLINK_INTERVAL: Duration = Duration::from_millis(500);
@@ -88,17 +83,17 @@ pub enum SelectAction {
End,
}
impl workspace::Item for Buffer {
type View = BufferView;
// impl workspace::Item for Buffer {
// type View = BufferView;
fn build_view(
buffer: ModelHandle<Self>,
settings: watch::Receiver<Settings>,
ctx: &mut ViewContext<Self::View>,
) -> Self::View {
BufferView::for_buffer(buffer, settings, ctx)
}
}
// fn build_view(
// buffer: ModelHandle<Self>,
// settings: watch::Receiver<Settings>,
// ctx: &mut ViewContext<Self::View>,
// ) -> Self::View {
// BufferView::for_buffer(buffer, settings, ctx)
// }
// }
pub struct BufferView {
handle: WeakViewHandle<Self>,
@@ -348,7 +343,7 @@ impl BufferView {
if let Some(selection) = self.pending_selection.take() {
let ix = self.selection_insertion_index(&selection.start, ctx.app());
self.selections.insert(ix, selection);
self.merge_selections(ctx);
self.merge_selections(ctx.app());
ctx.notify();
} else {
log::error!("end_selection dispatched with no pending selection");
@@ -377,7 +372,7 @@ impl BufferView {
}
selections.sort_unstable_by(|a, b| a.start.cmp(&b.start, buffer).unwrap());
self.selections = selections;
self.merge_selections(ctx);
self.merge_selections(ctx.app());
ctx.notify();
Ok(())
}
@@ -609,13 +604,13 @@ impl BufferView {
}
pub fn changed_selections(&mut self, ctx: &mut ViewContext<Self>) {
self.merge_selections(ctx);
self.merge_selections(ctx.app());
self.pause_cursor_blinking(ctx);
*self.autoscroll_requested.lock() = true;
ctx.notify();
}
fn merge_selections<A: app::ModelAsRef>(&mut self, ctx: &A) {
fn merge_selections(&mut self, ctx: &AppContext) {
let buffer = self.buffer.as_ref(ctx);
let mut i = 1;
while i < self.selections.len() {
@@ -900,7 +895,7 @@ impl BufferView {
pub fn max_line_number_width(
&self,
font_cache: &FontCache,
layout_cache: &LayoutCache,
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> Result<f32> {
let settings = smol::block_on(self.settings.read());
@@ -926,7 +921,7 @@ impl BufferView {
&self,
viewport_height: f32,
font_cache: &FontCache,
layout_cache: &LayoutCache,
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> Result<Vec<Arc<text_layout::Line>>> {
let display_map = self.display_map.as_ref(app);
@@ -979,7 +974,7 @@ impl BufferView {
&self,
mut rows: Range<u32>,
font_cache: &FontCache,
layout_cache: &LayoutCache,
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> Result<Vec<Arc<text_layout::Line>>> {
let display_map = self.display_map.as_ref(app);
@@ -1000,13 +995,14 @@ impl BufferView {
let mut layouts = Vec::new();
layouts.resize_with(rows.len(), Default::default);
crossbeam::thread::scope(|s| {
for (ix, chunk) in layouts.chunks_mut(chunk_size as usize).enumerate() {
let font_cache = &font_cache;
let chunk_start = rows.start as usize + ix * chunk_size;
let chunk_end = cmp::min(chunk_start + chunk_size, rows.end as usize);
Parallel::new()
.each(
layouts.chunks_mut(chunk_size as usize).enumerate(),
|(ix, chunk)| {
let font_cache = &font_cache;
let chunk_start = rows.start as usize + ix * chunk_size;
let chunk_end = cmp::min(chunk_start + chunk_size, rows.end as usize);
s.spawn(move |_| {
let mut row = chunk_start;
let mut line = String::new();
let mut line_len = 0;
@@ -1032,10 +1028,9 @@ impl BufferView {
line.push(char);
}
}
});
}
})
.unwrap();
},
)
.run();
Ok(layouts)
}
@@ -1044,7 +1039,7 @@ impl BufferView {
&self,
row: u32,
font_cache: &FontCache,
layout_cache: &LayoutCache,
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> Result<Arc<text_layout::Line>> {
let settings = smol::block_on(self.settings.read());
@@ -1140,13 +1135,13 @@ pub enum Event {
Blurred,
}
impl app::Entity for BufferView {
impl Entity for BufferView {
type Event = Event;
}
impl app::View for BufferView {
fn render<'a>(&self, bump: &'a Bump, app: &AppContext) -> &'a mut dyn Element<'a> {
BufferElement::new(self.handle.upgrade(app).unwrap()).finish(bump)
impl View for BufferView {
fn render<'a>(&self, app: &AppContext) -> Box<dyn Element> {
BufferElement::new(self.handle.upgrade(app).unwrap()).boxed()
}
fn ui_name() -> &'static str {
@@ -1166,38 +1161,38 @@ impl app::View for BufferView {
}
}
impl workspace::ItemView for BufferView {
fn is_activate_event(event: &Self::Event) -> bool {
match event {
Event::Activate => true,
_ => false,
}
}
// impl workspace::ItemView for BufferView {
// fn is_activate_event(event: &Self::Event) -> bool {
// match event {
// Event::Activate => true,
// _ => false,
// }
// }
fn title(&self, app: &AppContext) -> std::string::String {
if let Some(path) = self.buffer.as_ref(app).path(app) {
path.file_name()
.expect("buffer's path is always to a file")
.to_string_lossy()
.into()
} else {
"untitled".into()
}
}
// fn title(&self, app: &AppContext) -> std::string::String {
// if let Some(path) = self.buffer.as_ref(app).path(app) {
// path.file_name()
// .expect("buffer's path is always to a file")
// .to_string_lossy()
// .into()
// } else {
// "untitled".into()
// }
// }
fn entry_id(&self, app: &AppContext) -> Option<(usize, usize)> {
self.buffer.as_ref(app).entry_id()
}
// fn entry_id(&self, app: &AppContext) -> Option<(usize, usize)> {
// self.buffer.as_ref(app).entry_id()
// }
fn clone_on_split(&self, ctx: &mut ViewContext<Self>) -> Option<Self>
where
Self: Sized,
{
let clone = BufferView::for_buffer(self.buffer.clone(), self.settings.clone(), ctx);
*clone.scroll_position.lock() = *self.scroll_position.lock();
Some(clone)
}
}
// fn clone_on_split(&self, ctx: &mut ViewContext<Self>) -> Option<Self>
// where
// Self: Sized,
// {
// let clone = BufferView::for_buffer(self.buffer.clone(), self.settings.clone(), ctx);
// *clone.scroll_position.lock() = *self.scroll_position.lock();
// Some(clone)
// }
// }
impl Selection {
fn head(&self) -> &Anchor {
@@ -1256,16 +1251,15 @@ impl Selection {
#[cfg(test)]
mod tests {
use super::*;
use crate::buffer::Point;
use crate::test_utils::*;
use crate::{editor::Point, settings, test::sample_text};
use anyhow::Error;
use unindent::Unindent;
#[test]
fn test_selection_with_mouse() {
App::run(|mut app| async move {
App::test(|mut app| async move {
let buffer = app.add_model(|_| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n"));
let settings = settings_rx(None);
let settings = settings::channel(&FontCache::new()).1;
let (_, buffer_view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
@@ -1362,16 +1356,15 @@ mod tests {
#[test]
fn test_layout_line_numbers() -> Result<()> {
use crate::fonts::FontCache;
use crate::text_layout::LayoutCache;
use gpui::{fonts::FontCache, text_layout::TextLayoutCache};
let font_cache = FontCache::new();
let layout_cache = LayoutCache::new();
let layout_cache = TextLayoutCache::new();
let mut app = App::new().unwrap();
let buffer = app.add_model(|_| Buffer::new(0, sample_text(6, 6)));
let settings = settings_rx(Some(&font_cache));
let settings = settings::channel(&font_cache).unwrap().1;
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
view.read(&app, |view, app| {
@@ -1385,8 +1378,6 @@ mod tests {
#[test]
fn test_fold() -> Result<()> {
init_logger();
let mut app = App::new().unwrap();
let buffer = app.add_model(|_| {
Buffer::new(
@@ -1402,8 +1393,6 @@ mod tests {
fn b() {
2
}
fn c() {
3
}
}
@@ -1411,7 +1400,7 @@ mod tests {
.unindent(),
)
});
let settings = settings_rx(None);
let settings = settings::channel(&FontCache::new()).unwrap().1;
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
view.update(&mut app, |view, ctx| {
@@ -1481,7 +1470,7 @@ mod tests {
fn test_move_cursor() -> Result<()> {
let mut app = App::new().unwrap();
let buffer = app.add_model(|_| Buffer::new(0, sample_text(6, 6)));
let settings = settings_rx(None);
let settings = settings::channel(&FontCache::new()).1;
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
buffer.update(&mut app, |buffer, ctx| {
zed/src/editor/display_map/fold_map.rs
+9 -9
View File
@@ -2,11 +2,11 @@ use super::{
buffer, Anchor, AnchorRangeExt, Buffer, DisplayPoint, Edit, Point, TextSummary, ToOffset,
};
use crate::{
app::{AppContext, ModelHandle},
sum_tree::{self, Cursor, SumTree},
util::find_insertion_index,
};
use anyhow::{anyhow, Result};
use gpui::{AppContext, ModelHandle};
use std::{
cmp::{self, Ordering},
iter::Take,
@@ -455,8 +455,8 @@ impl<'a> Dimension<'a, TransformSummary> for usize {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::App;
use crate::test_utils::sample_text;
use crate::test::sample_text;
use gpui::App;
#[test]
fn test_basic_folds() -> Result<()> {
@@ -565,7 +565,7 @@ mod tests {
#[test]
fn test_random_folds() -> Result<()> {
use crate::buffer::ToPoint;
use crate::editor::ToPoint;
use crate::util::RandomCharIter;
use rand::prelude::*;
@@ -575,7 +575,7 @@ mod tests {
let mut app = App::new()?;
let buffer = app.add_model(|_| {
let len = rng.gen_range(0, 10);
let len = rng.gen_range(0..10);
let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
Buffer::new(0, text)
});
@@ -584,11 +584,11 @@ mod tests {
app.read(|app| {
let buffer = buffer.as_ref(app);
let fold_count = rng.gen_range(0, 10);
let fold_count = rng.gen_range(0..10);
let mut fold_ranges: Vec<Range<usize>> = Vec::new();
for _ in 0..fold_count {
let end = rng.gen_range(0, buffer.len() + 1);
let start = rng.gen_range(0, end + 1);
let end = rng.gen_range(0..buffer.len() + 1);
let start = rng.gen_range(0..end + 1);
fold_ranges.push(start..end);
}
@@ -612,7 +612,7 @@ mod tests {
let edits = buffer.update(&mut app, |buffer, ctx| {
let start_version = buffer.version.clone();
let edit_count = rng.gen_range(1, 10);
let edit_count = rng.gen_range(1..10);
buffer.randomly_edit(&mut rng, edit_count, Some(ctx));
Ok::<_, anyhow::Error>(buffer.edits_since(start_version).collect::<Vec<_>>())
})?;
zed/src/editor/display_map/mod.rs
+4 -5
View File
@@ -1,11 +1,10 @@
mod fold_map;
use super::ToPoint;
use super::{buffer, Anchor, AnchorRangeExt, Buffer, Edit, Point, TextSummary, ToOffset};
use crate::app::{AppContext, Entity, ModelContext, ModelHandle};
use super::{buffer, Anchor, AnchorRangeExt, Buffer, Edit, Point, TextSummary, ToOffset, ToPoint};
use anyhow::Result;
pub use fold_map::BufferRows;
use fold_map::FoldMap;
use gpui::{AppContext, Entity, ModelContext, ModelHandle};
use std::ops::Range;
#[derive(Copy, Clone)]
@@ -291,9 +290,9 @@ pub fn collapse_tabs(
#[cfg(test)]
mod tests {
use super::*;
use crate::app::App;
use crate::test_utils::*;
use crate::test::*;
use anyhow::Error;
use gpui::App;
#[test]
fn test_chars_at() -> Result<()> {
zed/src/editor/movement.rs
+1 -1
View File
@@ -1,6 +1,6 @@
use super::{DisplayMap, DisplayPoint};
use crate::app::AppContext;
use anyhow::Result;
use gpui::AppContext;
use std::cmp;
pub fn left(map: &DisplayMap, mut point: DisplayPoint, app: &AppContext) -> Result<DisplayPoint> {