Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Show fold indicators (#3334)

Browse source 
Release Notes:

- N/A
This commit is contained in:
Antonio Scandurra 2023-11-15 20:10:24 +01:00 • committed by GitHub
commit 3978d4e872
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 622 additions and 638 deletions
Download patch file Download diff file Expand all files Collapse all files

6
crates/editor2/src/display_map.rs
View file

@ -31,7 +31,7 @@ pub use block_map::{
BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock, TransformBlock, BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock, TransformBlock,
}; };
pub use self::fold_map::FoldPoint; pub use self::fold_map::{Fold, FoldPoint};
pub use self::inlay_map::{Inlay, InlayOffset, InlayPoint}; pub use self::inlay_map::{Inlay, InlayOffset, InlayPoint};
#[derive(Copy, Clone, Debug, PartialEq, Eq)] #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@ -124,7 +124,7 @@ impl DisplayMap {
self.fold( self.fold(
other other
.folds_in_range(0..other.buffer_snapshot.len()) .folds_in_range(0..other.buffer_snapshot.len())
.map(|fold| fold.to_offset(&other.buffer_snapshot)), .map(|fold| fold.range.to_offset(&other.buffer_snapshot)),
cx, cx,
); );
} }
@ -723,7 +723,7 @@ impl DisplaySnapshot {
DisplayPoint(point) DisplayPoint(point)
} }
pub fn folds_in_range<T>(&self, range: Range<T>) -> impl Iterator<Item = &Range<Anchor>> pub fn folds_in_range<T>(&self, range: Range<T>) -> impl Iterator<Item = &Fold>
where where
T: ToOffset, T: ToOffset,
{ {

105
crates/editor2/src/display_map/fold_map.rs
View file

@ -3,15 +3,16 @@ use super::{
Highlights, Highlights,
}; };
use crate::{Anchor, AnchorRangeExt, MultiBufferSnapshot, ToOffset}; use crate::{Anchor, AnchorRangeExt, MultiBufferSnapshot, ToOffset};
use gpui::{HighlightStyle, Hsla}; use gpui::{ElementId, HighlightStyle, Hsla};
use language::{Chunk, Edit, Point, TextSummary}; use language::{Chunk, Edit, Point, TextSummary};
use std::{ use std::{
any::TypeId, any::TypeId,
cmp::{self, Ordering}, cmp::{self, Ordering},
iter, iter,
ops::{Add, AddAssign, Range, Sub}, ops::{Add, AddAssign, Deref, DerefMut, Range, Sub},
}; };
use sum_tree::{Bias, Cursor, FilterCursor, SumTree}; use sum_tree::{Bias, Cursor, FilterCursor, SumTree};
use util::post_inc;
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)] #[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
pub struct FoldPoint(pub Point); pub struct FoldPoint(pub Point);
@ -90,12 +91,16 @@ impl<'a> FoldMapWriter<'a> {
} }
// For now, ignore any ranges that span an excerpt boundary. // For now, ignore any ranges that span an excerpt boundary.
let fold = Fold(buffer.anchor_after(range.start)..buffer.anchor_before(range.end)); let fold_range =
if fold.0.start.excerpt_id != fold.0.end.excerpt_id { FoldRange(buffer.anchor_after(range.start)..buffer.anchor_before(range.end));
if fold_range.0.start.excerpt_id != fold_range.0.end.excerpt_id {
continue; continue;
} }
folds.push(fold); folds.push(Fold {
id: FoldId(post_inc(&mut self.0.next_fold_id.0)),
range: fold_range,
});
let inlay_range = let inlay_range =
snapshot.to_inlay_offset(range.start)..snapshot.to_inlay_offset(range.end); snapshot.to_inlay_offset(range.start)..snapshot.to_inlay_offset(range.end);
@ -106,13 +111,13 @@ impl<'a> FoldMapWriter<'a> {
} }
let buffer = &snapshot.buffer; let buffer = &snapshot.buffer;
folds.sort_unstable_by(|a, b| sum_tree::SeekTarget::cmp(a, b, buffer)); folds.sort_unstable_by(|a, b| sum_tree::SeekTarget::cmp(&a.range, &b.range, buffer));
self.0.snapshot.folds = { self.0.snapshot.folds = {
let mut new_tree = SumTree::new(); let mut new_tree = SumTree::new();
let mut cursor = self.0.snapshot.folds.cursor::<Fold>(); let mut cursor = self.0.snapshot.folds.cursor::<FoldRange>();
for fold in folds { for fold in folds {
new_tree.append(cursor.slice(&fold, Bias::Right, buffer), buffer); new_tree.append(cursor.slice(&fold.range, Bias::Right, buffer), buffer);
new_tree.push(fold, buffer); new_tree.push(fold, buffer);
} }
new_tree.append(cursor.suffix(buffer), buffer); new_tree.append(cursor.suffix(buffer), buffer);
@ -138,7 +143,8 @@ impl<'a> FoldMapWriter<'a> {
let mut folds_cursor = let mut folds_cursor =
intersecting_folds(&snapshot, &self.0.snapshot.folds, range, inclusive); intersecting_folds(&snapshot, &self.0.snapshot.folds, range, inclusive);
while let Some(fold) = folds_cursor.item() { while let Some(fold) = folds_cursor.item() {
let offset_range = fold.0.start.to_offset(buffer)..fold.0.end.to_offset(buffer); let offset_range =
fold.range.start.to_offset(buffer)..fold.range.end.to_offset(buffer);
if offset_range.end > offset_range.start { if offset_range.end > offset_range.start {
let inlay_range = snapshot.to_inlay_offset(offset_range.start) let inlay_range = snapshot.to_inlay_offset(offset_range.start)
..snapshot.to_inlay_offset(offset_range.end); ..snapshot.to_inlay_offset(offset_range.end);
@ -175,6 +181,7 @@ impl<'a> FoldMapWriter<'a> {
pub struct FoldMap { pub struct FoldMap {
snapshot: FoldSnapshot, snapshot: FoldSnapshot,
ellipses_color: Option<Hsla>, ellipses_color: Option<Hsla>,
next_fold_id: FoldId,
} }
impl FoldMap { impl FoldMap {
@ -197,6 +204,7 @@ impl FoldMap {
ellipses_color: None, ellipses_color: None,
}, },
ellipses_color: None, ellipses_color: None,
next_fold_id: FoldId::default(),
}; };
let snapshot = this.snapshot.clone(); let snapshot = this.snapshot.clone();
(this, snapshot) (this, snapshot)
@ -242,8 +250,8 @@ impl FoldMap {
while let Some(fold) = folds.next() { while let Some(fold) = folds.next() {
if let Some(next_fold) = folds.peek() { if let Some(next_fold) = folds.peek() {
let comparison = fold let comparison = fold
.0 .range
.cmp(&next_fold.0, &self.snapshot.inlay_snapshot.buffer); .cmp(&next_fold.range, &self.snapshot.inlay_snapshot.buffer);
assert!(comparison.is_le()); assert!(comparison.is_le());
} }
} }
@ -304,9 +312,9 @@ impl FoldMap {
let anchor = inlay_snapshot let anchor = inlay_snapshot
.buffer .buffer
.anchor_before(inlay_snapshot.to_buffer_offset(edit.new.start)); .anchor_before(inlay_snapshot.to_buffer_offset(edit.new.start));
let mut folds_cursor = self.snapshot.folds.cursor::<Fold>(); let mut folds_cursor = self.snapshot.folds.cursor::<FoldRange>();
folds_cursor.seek( folds_cursor.seek(
&Fold(anchor..Anchor::max()), &FoldRange(anchor..Anchor::max()),
Bias::Left, Bias::Left,
&inlay_snapshot.buffer, &inlay_snapshot.buffer,
); );
@ -315,8 +323,8 @@ impl FoldMap {
let inlay_snapshot = &inlay_snapshot; let inlay_snapshot = &inlay_snapshot;
move || { move || {
let item = folds_cursor.item().map(|f| { let item = folds_cursor.item().map(|f| {
let buffer_start = f.0.start.to_offset(&inlay_snapshot.buffer); let buffer_start = f.range.start.to_offset(&inlay_snapshot.buffer);
let buffer_end = f.0.end.to_offset(&inlay_snapshot.buffer); let buffer_end = f.range.end.to_offset(&inlay_snapshot.buffer);
inlay_snapshot.to_inlay_offset(buffer_start) inlay_snapshot.to_inlay_offset(buffer_start)
..inlay_snapshot.to_inlay_offset(buffer_end) ..inlay_snapshot.to_inlay_offset(buffer_end)
}); });
@ -596,13 +604,13 @@ impl FoldSnapshot {
self.transforms.summary().output.longest_row self.transforms.summary().output.longest_row
} }
pub fn folds_in_range<T>(&self, range: Range<T>) -> impl Iterator<Item = &Range<Anchor>> pub fn folds_in_range<T>(&self, range: Range<T>) -> impl Iterator<Item = &Fold>
where where
T: ToOffset, T: ToOffset,
{ {
let mut folds = intersecting_folds(&self.inlay_snapshot, &self.folds, range, false); let mut folds = intersecting_folds(&self.inlay_snapshot, &self.folds, range, false);
iter::from_fn(move || { iter::from_fn(move || {
let item = folds.item().map(|f| &f.0); let item = folds.item();
folds.next(&self.inlay_snapshot.buffer); folds.next(&self.inlay_snapshot.buffer);
item item
}) })
@ -830,10 +838,39 @@ impl sum_tree::Summary for TransformSummary {
} }
} }
#[derive(Clone, Debug)] #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
struct Fold(Range<Anchor>); pub struct FoldId(usize);
impl Default for Fold { impl Into<ElementId> for FoldId {
fn into(self) -> ElementId {
ElementId::Integer(self.0)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Fold {
pub id: FoldId,
pub range: FoldRange,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FoldRange(Range<Anchor>);
impl Deref for FoldRange {
type Target = Range<Anchor>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for FoldRange {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl Default for FoldRange {
fn default() -> Self { fn default() -> Self {
Self(Anchor::min()..Anchor::max()) Self(Anchor::min()..Anchor::max())
} }
@ -844,17 +881,17 @@ impl sum_tree::Item for Fold {
fn summary(&self) -> Self::Summary { fn summary(&self) -> Self::Summary {
FoldSummary { FoldSummary {
start: self.0.start.clone(), start: self.range.start.clone(),
end: self.0.end.clone(), end: self.range.end.clone(),
min_start: self.0.start.clone(), min_start: self.range.start.clone(),
max_end: self.0.end.clone(), max_end: self.range.end.clone(),
count: 1, count: 1,
} }
} }
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct FoldSummary { pub struct FoldSummary {
start: Anchor, start: Anchor,
end: Anchor, end: Anchor,
min_start: Anchor, min_start: Anchor,
@ -900,14 +937,14 @@ impl sum_tree::Summary for FoldSummary {
} }
} }
impl<'a> sum_tree::Dimension<'a, FoldSummary> for Fold { impl<'a> sum_tree::Dimension<'a, FoldSummary> for FoldRange {
fn add_summary(&mut self, summary: &'a FoldSummary, _: &MultiBufferSnapshot) { fn add_summary(&mut self, summary: &'a FoldSummary, _: &MultiBufferSnapshot) {
self.0.start = summary.start.clone(); self.0.start = summary.start.clone();
self.0.end = summary.end.clone(); self.0.end = summary.end.clone();
} }
} }
impl<'a> sum_tree::SeekTarget<'a, FoldSummary, Fold> for Fold { impl<'a> sum_tree::SeekTarget<'a, FoldSummary, FoldRange> for FoldRange {
fn cmp(&self, other: &Self, buffer: &MultiBufferSnapshot) -> Ordering { fn cmp(&self, other: &Self, buffer: &MultiBufferSnapshot) -> Ordering {
self.0.cmp(&other.0, buffer) self.0.cmp(&other.0, buffer)
} }
@ -1321,7 +1358,10 @@ mod tests {
let (snapshot, _) = map.read(inlay_snapshot.clone(), vec![]); let (snapshot, _) = map.read(inlay_snapshot.clone(), vec![]);
let fold_ranges = snapshot let fold_ranges = snapshot
.folds_in_range(Point::new(1, 0)..Point::new(1, 3)) .folds_in_range(Point::new(1, 0)..Point::new(1, 3))
.map(|fold| fold.start.to_point(&buffer_snapshot)..fold.end.to_point(&buffer_snapshot)) .map(|fold| {
fold.range.start.to_point(&buffer_snapshot)
..fold.range.end.to_point(&buffer_snapshot)
})
.collect::<Vec<_>>(); .collect::<Vec<_>>();
assert_eq!( assert_eq!(
fold_ranges, fold_ranges,
@ -1553,10 +1593,9 @@ mod tests {
.filter(|fold| { .filter(|fold| {
let start = buffer_snapshot.anchor_before(start); let start = buffer_snapshot.anchor_before(start);
let end = buffer_snapshot.anchor_after(end); let end = buffer_snapshot.anchor_after(end);
start.cmp(&fold.0.end, &buffer_snapshot) == Ordering::Less start.cmp(&fold.range.end, &buffer_snapshot) == Ordering::Less
&& end.cmp(&fold.0.start, &buffer_snapshot) == Ordering::Greater && end.cmp(&fold.range.start, &buffer_snapshot) == Ordering::Greater
}) })
.map(|fold| fold.0)
.collect::<Vec<_>>(); .collect::<Vec<_>>();
assert_eq!( assert_eq!(
@ -1639,10 +1678,10 @@ mod tests {
let buffer = &inlay_snapshot.buffer; let buffer = &inlay_snapshot.buffer;
let mut folds = self.snapshot.folds.items(buffer); let mut folds = self.snapshot.folds.items(buffer);
// Ensure sorting doesn't change how folds get merged and displayed. // Ensure sorting doesn't change how folds get merged and displayed.
folds.sort_by(|a, b| a.0.cmp(&b.0, buffer)); folds.sort_by(|a, b| a.range.cmp(&b.range, buffer));
let mut fold_ranges = folds let mut fold_ranges = folds
.iter() .iter()
.map(|fold| fold.0.start.to_offset(buffer)..fold.0.end.to_offset(buffer)) .map(|fold| fold.range.start.to_offset(buffer)..fold.range.end.to_offset(buffer))
.peekable(); .peekable();
let mut merged_ranges = Vec::new(); let mut merged_ranges = Vec::new();

148
crates/editor2/src/editor.rs
View file

@ -39,12 +39,12 @@ use futures::FutureExt;
use fuzzy::{StringMatch, StringMatchCandidate}; use fuzzy::{StringMatch, StringMatchCandidate};
use git::diff_hunk_to_display; use git::diff_hunk_to_display;
use gpui::{ use gpui::{
action, actions, div, point, prelude::*, px, relative, rems, render_view, size, uniform_list, action, actions, div, point, prelude::*, px, relative, rems, size, uniform_list, AnyElement,
AnyElement, AppContext, AsyncWindowContext, BackgroundExecutor, Bounds, ClipboardItem, AppContext, AsyncWindowContext, BackgroundExecutor, Bounds, ClipboardItem, Component, Context,
Component, Context, EventEmitter, FocusHandle, FontFeatures, FontStyle, FontWeight, EventEmitter, FocusHandle, FontFeatures, FontStyle, FontWeight, HighlightStyle, Hsla,
HighlightStyle, Hsla, InputHandler, KeyContext, Model, MouseButton, ParentComponent, Pixels, InputHandler, KeyContext, Model, MouseButton, ParentComponent, Pixels, Render, Styled,
Render, Styled, Subscription, Task, TextStyle, UniformListScrollHandle, View, ViewContext, Subscription, Task, TextStyle, UniformListScrollHandle, View, ViewContext, VisualContext,
VisualContext, WeakView, WindowContext, WeakView, WindowContext,
}; };
use highlight_matching_bracket::refresh_matching_bracket_highlights; use highlight_matching_bracket::refresh_matching_bracket_highlights;
use hover_popover::{hide_hover, HoverState}; use hover_popover::{hide_hover, HoverState};
@ -4372,69 +4372,42 @@ impl Editor {
} }
} }
// pub fn render_fold_indicators( pub fn render_fold_indicators(
// &self, &self,
// fold_data: Vec<Option<(FoldStatus, u32, bool)>>, fold_data: Vec<Option<(FoldStatus, u32, bool)>>,
// style: &EditorStyle, style: &EditorStyle,
// gutter_hovered: bool, gutter_hovered: bool,
// line_height: f32, line_height: Pixels,
// gutter_margin: f32, gutter_margin: Pixels,
// cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
// ) -> Vec<Option<AnyElement<Self>>> { ) -> Vec<Option<AnyElement<Self>>> {
// enum FoldIndicators {} fold_data
.iter()
// let style = style.folds.clone(); .enumerate()
.map(|(ix, fold_data)| {
// fold_data fold_data
// .iter() .map(|(fold_status, buffer_row, active)| {
// .enumerate() (active || gutter_hovered || fold_status == FoldStatus::Folded).then(|| {
// .map(|(ix, fold_data)| { let icon = match fold_status {
// fold_data FoldStatus::Folded => ui::Icon::ChevronRight,
// .map(|(fold_status, buffer_row, active)| { FoldStatus::Foldable => ui::Icon::ChevronDown,
// (active || gutter_hovered || fold_status == FoldStatus::Folded).then(|| { };
// MouseEventHandler::new::<FoldIndicators, _>( IconButton::new(ix as usize, icon)
// ix as usize, .on_click(move |editor: &mut Editor, cx| match fold_status {
// cx, FoldStatus::Folded => {
// |mouse_state, _| { editor.unfold_at(&UnfoldAt { buffer_row }, cx);
// Svg::new(match fold_status { }
// FoldStatus::Folded => style.folded_icon.clone(), FoldStatus::Foldable => {
// FoldStatus::Foldable => style.foldable_icon.clone(), editor.fold_at(&FoldAt { buffer_row }, cx);
// }) }
// .with_color( })
// style .render()
// .indicator })
// .in_state(fold_status == FoldStatus::Folded) })
// .style_for(mouse_state) .flatten()
// .color, })
// ) .collect()
// .constrained() }
// .with_width(gutter_margin * style.icon_margin_scale)
// .aligned()
// .constrained()
// .with_height(line_height)
// .with_width(gutter_margin)
// .aligned()
// },
// )
// .with_cursor_style(CursorStyle::PointingHand)
// .with_padding(Padding::uniform(3.))
// .on_click(MouseButton::Left, {
// move |_, editor, cx| match fold_status {
// FoldStatus::Folded => {
// editor.unfold_at(&UnfoldAt { buffer_row }, cx);
// }
// FoldStatus::Foldable => {
// editor.fold_at(&FoldAt { buffer_row }, cx);
// }
// }
// })
// .into_any()
// })
// })
// .flatten()
// })
// .collect()
// }
pub fn context_menu_visible(&self) -> bool { pub fn context_menu_visible(&self) -> bool {
self.context_menu self.context_menu
@ -5330,8 +5303,8 @@ impl Editor {
buffer.anchor_before(range_to_move.start) buffer.anchor_before(range_to_move.start)
..buffer.anchor_after(range_to_move.end), ..buffer.anchor_after(range_to_move.end),
) { ) {
let mut start = fold.start.to_point(&buffer); let mut start = fold.range.start.to_point(&buffer);
let mut end = fold.end.to_point(&buffer); let mut end = fold.range.end.to_point(&buffer);
start.row -= row_delta; start.row -= row_delta;
end.row -= row_delta; end.row -= row_delta;
refold_ranges.push(start..end); refold_ranges.push(start..end);
@ -5421,8 +5394,8 @@ impl Editor {
buffer.anchor_before(range_to_move.start) buffer.anchor_before(range_to_move.start)
..buffer.anchor_after(range_to_move.end), ..buffer.anchor_after(range_to_move.end),
) { ) {
let mut start = fold.start.to_point(&buffer); let mut start = fold.range.start.to_point(&buffer);
let mut end = fold.end.to_point(&buffer); let mut end = fold.range.end.to_point(&buffer);
start.row += row_delta; start.row += row_delta;
end.row += row_delta; end.row += row_delta;
refold_ranges.push(start..end); refold_ranges.push(start..end);
@ -7804,25 +7777,18 @@ impl Editor {
} }
div() div()
.pl(cx.anchor_x) .pl(cx.anchor_x)
.child(render_view( .child(rename_editor.render_with(EditorElement::new(
&rename_editor, &rename_editor,
EditorElement::new( EditorStyle {
&rename_editor, background: cx.theme().system().transparent,
EditorStyle { local_player: cx.editor_style.local_player,
background: cx.theme().system().transparent, text: text_style,
local_player: cx.editor_style.local_player, scrollbar_width: cx.editor_style.scrollbar_width,
text: text_style, syntax: cx.editor_style.syntax.clone(),
scrollbar_width: cx diagnostic_style:
.editor_style cx.editor_style.diagnostic_style.clone(),
.scrollbar_width, },
syntax: cx.editor_style.syntax.clone(), )))
diagnostic_style: cx
.editor_style
.diagnostic_style
.clone(),
},
),
))
.render() .render()
} }
}), }),

835
crates/editor2/src/element.rs
View file

File diff suppressed because it is too large Load diff

6
crates/editor2/src/git.rs
View file

@ -60,8 +60,8 @@ pub fn diff_hunk_to_display(hunk: DiffHunk<u32>, snapshot: &DisplaySnapshot) ->
let folds_end = Point::new(hunk.buffer_range.end + 2, 0); let folds_end = Point::new(hunk.buffer_range.end + 2, 0);
let folds_range = folds_start..folds_end; let folds_range = folds_start..folds_end;
let containing_fold = snapshot.folds_in_range(folds_range).find(|fold_range| { let containing_fold = snapshot.folds_in_range(folds_range).find(|fold| {
let fold_point_range = fold_range.to_point(&snapshot.buffer_snapshot); let fold_point_range = fold.range.to_point(&snapshot.buffer_snapshot);
let fold_point_range = fold_point_range.start..=fold_point_range.end; let fold_point_range = fold_point_range.start..=fold_point_range.end;
let folded_start = fold_point_range.contains(&hunk_start_point); let folded_start = fold_point_range.contains(&hunk_start_point);
@ -72,7 +72,7 @@ pub fn diff_hunk_to_display(hunk: DiffHunk<u32>, snapshot: &DisplaySnapshot) ->
}); });
if let Some(fold) = containing_fold { if let Some(fold) = containing_fold {
let row = fold.start.to_display_point(snapshot).row(); let row = fold.range.start.to_display_point(snapshot).row();
DisplayDiffHunk::Folded { display_row: row } DisplayDiffHunk::Folded { display_row: row }
} else { } else {
let start = hunk_start_point.to_display_point(snapshot).row(); let start = hunk_start_point.to_display_point(snapshot).row();

46
crates/gpui2/src/element.rs
View file

@ -3,7 +3,7 @@ use crate::{
}; };
use derive_more::{Deref, DerefMut}; use derive_more::{Deref, DerefMut};
pub(crate) use smallvec::SmallVec; pub(crate) use smallvec::SmallVec;
use std::{any::Any, mem}; use std::{any::Any, fmt::Debug, mem};
pub trait Element<V: 'static> { pub trait Element<V: 'static> {
type ElementState: 'static; type ElementState: 'static;
@ -33,6 +33,42 @@ pub trait Element<V: 'static> {
element_state: &mut Self::ElementState, element_state: &mut Self::ElementState,
cx: &mut ViewContext<V>, cx: &mut ViewContext<V>,
); );
fn draw<T, R>(
self,
origin: Point<Pixels>,
available_space: Size<T>,
view_state: &mut V,
cx: &mut ViewContext<V>,
f: impl FnOnce(&Self::ElementState, &mut ViewContext<V>) -> R,
) -> R
where
Self: Sized,
T: Clone + Default + Debug + Into<AvailableSpace>,
{
let mut element = RenderedElement {
element: self,
phase: ElementRenderPhase::Start,
};
element.draw(origin, available_space.map(Into::into), view_state, cx);
if let ElementRenderPhase::Painted { frame_state } = &element.phase {
if let Some(frame_state) = frame_state.as_ref() {
f(&frame_state, cx)
} else {
let element_id = element
.element
.element_id()
.expect("we either have some frame_state or some element_id");
cx.with_element_state(element_id, |element_state, cx| {
let element_state = element_state.unwrap();
let result = f(&element_state, cx);
(result, element_state)
})
}
} else {
unreachable!()
}
}
} }
#[derive(Deref, DerefMut, Default, Clone, Debug, Eq, PartialEq, Hash)] #[derive(Deref, DerefMut, Default, Clone, Debug, Eq, PartialEq, Hash)]
@ -99,7 +135,9 @@ enum ElementRenderPhase<V> {
available_space: Size<AvailableSpace>, available_space: Size<AvailableSpace>,
frame_state: Option<V>, frame_state: Option<V>,
}, },
Painted, Painted {
frame_state: Option<V>,
},
} }
/// Internal struct that wraps an element to store Layout and ElementState after the element is rendered. /// Internal struct that wraps an element to store Layout and ElementState after the element is rendered.
@ -157,7 +195,7 @@ where
ElementRenderPhase::Start => panic!("must call initialize before layout"), ElementRenderPhase::Start => panic!("must call initialize before layout"),
ElementRenderPhase::LayoutRequested { .. } ElementRenderPhase::LayoutRequested { .. }
| ElementRenderPhase::LayoutComputed { .. } | ElementRenderPhase::LayoutComputed { .. }
| ElementRenderPhase::Painted => { | ElementRenderPhase::Painted { .. } => {
panic!("element rendered twice") panic!("element rendered twice")
} }
}; };
@ -192,7 +230,7 @@ where
self.element self.element
.paint(bounds, view_state, frame_state.as_mut().unwrap(), cx); .paint(bounds, view_state, frame_state.as_mut().unwrap(), cx);
} }
ElementRenderPhase::Painted ElementRenderPhase::Painted { frame_state }
} }
_ => panic!("must call layout before paint"), _ => panic!("must call layout before paint"),

62
crates/gpui2/src/elements/div.rs
View file

@ -6,15 +6,15 @@ use crate::{
SharedString, Size, Style, StyleRefinement, Styled, Task, View, ViewContext, Visibility, SharedString, Size, Style, StyleRefinement, Styled, Task, View, ViewContext, Visibility,
}; };
use collections::HashMap; use collections::HashMap;
use parking_lot::Mutex;
use refineable::Refineable; use refineable::Refineable;
use smallvec::SmallVec; use smallvec::SmallVec;
use std::{ use std::{
any::{Any, TypeId}, any::{Any, TypeId},
cell::RefCell,
fmt::Debug, fmt::Debug,
marker::PhantomData, marker::PhantomData,
mem, mem,
sync::Arc, rc::Rc,
time::Duration, time::Duration,
}; };
use taffy::style::Overflow; use taffy::style::Overflow;
@ -420,7 +420,7 @@ pub trait StatefulInteractiveComponent<V: 'static, E: Element<V>>: InteractiveCo
self.interactivity().tooltip_builder.is_none(), self.interactivity().tooltip_builder.is_none(),
"calling tooltip more than once on the same element is not supported" "calling tooltip more than once on the same element is not supported"
); );
self.interactivity().tooltip_builder = Some(Arc::new(move |view_state, cx| { self.interactivity().tooltip_builder = Some(Rc::new(move |view_state, cx| {
build_tooltip(view_state, cx).into() build_tooltip(view_state, cx).into()
})); }));
@ -569,7 +569,7 @@ type DropListener<V> = dyn Fn(&mut V, AnyView, &mut ViewContext<V>) + 'static;
pub type HoverListener<V> = Box<dyn Fn(&mut V, bool, &mut ViewContext<V>) + 'static>; pub type HoverListener<V> = Box<dyn Fn(&mut V, bool, &mut ViewContext<V>) + 'static>;
pub type TooltipBuilder<V> = Arc<dyn Fn(&mut V, &mut ViewContext<V>) -> AnyView + 'static>; pub type TooltipBuilder<V> = Rc<dyn Fn(&mut V, &mut ViewContext<V>) -> AnyView + 'static>;
pub type KeyDownListener<V> = pub type KeyDownListener<V> =
Box<dyn Fn(&mut V, &KeyDownEvent, DispatchPhase, &mut ViewContext<V>) + 'static>; Box<dyn Fn(&mut V, &KeyDownEvent, DispatchPhase, &mut ViewContext<V>) + 'static>;
@ -725,6 +725,12 @@ pub struct DivState {
interactive_state: InteractiveElementState, interactive_state: InteractiveElementState,
} }
impl DivState {
pub fn is_active(&self) -> bool {
self.interactive_state.pending_mouse_down.borrow().is_some()
}
}
pub struct Interactivity<V> { pub struct Interactivity<V> {
pub element_id: Option<ElementId>, pub element_id: Option<ElementId>,
pub key_context: KeyContext, pub key_context: KeyContext,
@ -890,7 +896,7 @@ where
if !click_listeners.is_empty() || drag_listener.is_some() { if !click_listeners.is_empty() || drag_listener.is_some() {
let pending_mouse_down = element_state.pending_mouse_down.clone(); let pending_mouse_down = element_state.pending_mouse_down.clone();
let mouse_down = pending_mouse_down.lock().clone(); let mouse_down = pending_mouse_down.borrow().clone();
if let Some(mouse_down) = mouse_down { if let Some(mouse_down) = mouse_down {
if let Some(drag_listener) = drag_listener { if let Some(drag_listener) = drag_listener {
let active_state = element_state.clicked_state.clone(); let active_state = element_state.clicked_state.clone();
@ -904,7 +910,7 @@ where
&& bounds.contains_point(&event.position) && bounds.contains_point(&event.position)
&& (event.position - mouse_down.position).magnitude() > DRAG_THRESHOLD && (event.position - mouse_down.position).magnitude() > DRAG_THRESHOLD
{ {
*active_state.lock() = ElementClickedState::default(); *active_state.borrow_mut() = ElementClickedState::default();
let cursor_offset = event.position - bounds.origin; let cursor_offset = event.position - bounds.origin;
let drag = drag_listener(view_state, cursor_offset, cx); let drag = drag_listener(view_state, cursor_offset, cx);
cx.active_drag = Some(drag); cx.active_drag = Some(drag);
@ -924,13 +930,13 @@ where
listener(view_state, &mouse_click, cx); listener(view_state, &mouse_click, cx);
} }
} }
*pending_mouse_down.lock() = None; *pending_mouse_down.borrow_mut() = None;
cx.notify(); cx.notify();
}); });
} else { } else {
cx.on_mouse_event(move |_view_state, event: &MouseDownEvent, phase, cx| { cx.on_mouse_event(move |_view_state, event: &MouseDownEvent, phase, cx| {
if phase == DispatchPhase::Bubble && bounds.contains_point(&event.position) { if phase == DispatchPhase::Bubble && bounds.contains_point(&event.position) {
*pending_mouse_down.lock() = Some(event.clone()); *pending_mouse_down.borrow_mut() = Some(event.clone());
cx.notify(); cx.notify();
} }
}); });
@ -946,8 +952,8 @@ where
return; return;
} }
let is_hovered = let is_hovered =
bounds.contains_point(&event.position) && has_mouse_down.lock().is_none(); bounds.contains_point(&event.position) && has_mouse_down.borrow().is_none();
let mut was_hovered = was_hovered.lock(); let mut was_hovered = was_hovered.borrow_mut();
if is_hovered != was_hovered.clone() { if is_hovered != was_hovered.clone() {
*was_hovered = is_hovered; *was_hovered = is_hovered;
@ -968,13 +974,13 @@ where
} }
let is_hovered = let is_hovered =
bounds.contains_point(&event.position) && pending_mouse_down.lock().is_none(); bounds.contains_point(&event.position) && pending_mouse_down.borrow().is_none();
if !is_hovered { if !is_hovered {
active_tooltip.lock().take(); active_tooltip.borrow_mut().take();
return; return;
} }
if active_tooltip.lock().is_none() { if active_tooltip.borrow().is_none() {
let task = cx.spawn({ let task = cx.spawn({
let active_tooltip = active_tooltip.clone(); let active_tooltip = active_tooltip.clone();
let tooltip_builder = tooltip_builder.clone(); let tooltip_builder = tooltip_builder.clone();
@ -982,7 +988,7 @@ where
move |view, mut cx| async move { move |view, mut cx| async move {
cx.background_executor().timer(TOOLTIP_DELAY).await; cx.background_executor().timer(TOOLTIP_DELAY).await;
view.update(&mut cx, move |view_state, cx| { view.update(&mut cx, move |view_state, cx| {
active_tooltip.lock().replace(ActiveTooltip { active_tooltip.borrow_mut().replace(ActiveTooltip {
waiting: None, waiting: None,
tooltip: Some(AnyTooltip { tooltip: Some(AnyTooltip {
view: tooltip_builder(view_state, cx), view: tooltip_builder(view_state, cx),
@ -994,14 +1000,14 @@ where
.ok(); .ok();
} }
}); });
active_tooltip.lock().replace(ActiveTooltip { active_tooltip.borrow_mut().replace(ActiveTooltip {
waiting: Some(task), waiting: Some(task),
tooltip: None, tooltip: None,
}); });
} }
}); });
if let Some(active_tooltip) = element_state.active_tooltip.lock().as_ref() { if let Some(active_tooltip) = element_state.active_tooltip.borrow().as_ref() {
if active_tooltip.tooltip.is_some() { if active_tooltip.tooltip.is_some() {
cx.active_tooltip = active_tooltip.tooltip.clone() cx.active_tooltip = active_tooltip.tooltip.clone()
} }
@ -1009,10 +1015,10 @@ where
} }
let active_state = element_state.clicked_state.clone(); let active_state = element_state.clicked_state.clone();
if !active_state.lock().is_clicked() { if !active_state.borrow().is_clicked() {
cx.on_mouse_event(move |_, _: &MouseUpEvent, phase, cx| { cx.on_mouse_event(move |_, _: &MouseUpEvent, phase, cx| {
if phase == DispatchPhase::Capture { if phase == DispatchPhase::Capture {
*active_state.lock() = ElementClickedState::default(); *active_state.borrow_mut() = ElementClickedState::default();
cx.notify(); cx.notify();
} }
}); });
@ -1027,7 +1033,7 @@ where
.map_or(false, |bounds| bounds.contains_point(&down.position)); .map_or(false, |bounds| bounds.contains_point(&down.position));
let element = bounds.contains_point(&down.position); let element = bounds.contains_point(&down.position);
if group || element { if group || element {
*active_state.lock() = ElementClickedState { group, element }; *active_state.borrow_mut() = ElementClickedState { group, element };
cx.notify(); cx.notify();
} }
} }
@ -1038,14 +1044,14 @@ where
if overflow.x == Overflow::Scroll || overflow.y == Overflow::Scroll { if overflow.x == Overflow::Scroll || overflow.y == Overflow::Scroll {
let scroll_offset = element_state let scroll_offset = element_state
.scroll_offset .scroll_offset
.get_or_insert_with(Arc::default) .get_or_insert_with(Rc::default)
.clone(); .clone();
let line_height = cx.line_height(); let line_height = cx.line_height();
let scroll_max = (content_size - bounds.size).max(&Size::default()); let scroll_max = (content_size - bounds.size).max(&Size::default());
cx.on_mouse_event(move |_, event: &ScrollWheelEvent, phase, cx| { cx.on_mouse_event(move |_, event: &ScrollWheelEvent, phase, cx| {
if phase == DispatchPhase::Bubble && bounds.contains_point(&event.position) { if phase == DispatchPhase::Bubble && bounds.contains_point(&event.position) {
let mut scroll_offset = scroll_offset.lock(); let mut scroll_offset = scroll_offset.borrow_mut();
let old_scroll_offset = *scroll_offset; let old_scroll_offset = *scroll_offset;
let delta = event.delta.pixel_delta(line_height); let delta = event.delta.pixel_delta(line_height);
@ -1074,7 +1080,7 @@ where
let scroll_offset = element_state let scroll_offset = element_state
.scroll_offset .scroll_offset
.as_ref() .as_ref()
.map(|scroll_offset| *scroll_offset.lock()); .map(|scroll_offset| *scroll_offset.borrow());
cx.with_key_dispatch( cx.with_key_dispatch(
self.key_context.clone(), self.key_context.clone(),
@ -1173,7 +1179,7 @@ where
} }
} }
let clicked_state = element_state.clicked_state.lock(); let clicked_state = element_state.clicked_state.borrow();
if clicked_state.group { if clicked_state.group {
if let Some(group) = self.group_active_style.as_ref() { if let Some(group) = self.group_active_style.as_ref() {
style.refine(&group.style) style.refine(&group.style)
@ -1227,11 +1233,11 @@ impl<V: 'static> Default for Interactivity<V> {
#[derive(Default)] #[derive(Default)]
pub struct InteractiveElementState { pub struct InteractiveElementState {
pub focus_handle: Option<FocusHandle>, pub focus_handle: Option<FocusHandle>,
pub clicked_state: Arc<Mutex<ElementClickedState>>, pub clicked_state: Rc<RefCell<ElementClickedState>>,
pub hover_state: Arc<Mutex<bool>>, pub hover_state: Rc<RefCell<bool>>,
pub pending_mouse_down: Arc<Mutex<Option<MouseDownEvent>>>, pub pending_mouse_down: Rc<RefCell<Option<MouseDownEvent>>>,
pub scroll_offset: Option<Arc<Mutex<Point<Pixels>>>>, pub scroll_offset: Option<Rc<RefCell<Point<Pixels>>>>,
pub active_tooltip: Arc<Mutex<Option<ActiveTooltip>>>, pub active_tooltip: Rc<RefCell<Option<ActiveTooltip>>>,
} }
pub struct ActiveTooltip { pub struct ActiveTooltip {

17
crates/gpui2/src/elements/uniform_list.rs
View file

@ -3,9 +3,8 @@ use crate::{
ElementId, InteractiveComponent, InteractiveElementState, Interactivity, LayoutId, Pixels, ElementId, InteractiveComponent, InteractiveElementState, Interactivity, LayoutId, Pixels,
Point, Size, StyleRefinement, Styled, ViewContext, Point, Size, StyleRefinement, Styled, ViewContext,
}; };
use parking_lot::Mutex;
use smallvec::SmallVec; use smallvec::SmallVec;
use std::{cmp, mem, ops::Range, sync::Arc}; use std::{cell::RefCell, cmp, mem, ops::Range, rc::Rc};
use taffy::style::Overflow; use taffy::style::Overflow;
/// uniform_list provides lazy rendering for a set of items that are of uniform height. /// uniform_list provides lazy rendering for a set of items that are of uniform height.
@ -61,23 +60,23 @@ pub struct UniformList<V: 'static> {
} }
#[derive(Clone, Default)] #[derive(Clone, Default)]
pub struct UniformListScrollHandle(Arc<Mutex<Option<ScrollHandleState>>>); pub struct UniformListScrollHandle(Rc<RefCell<Option<ScrollHandleState>>>);
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct ScrollHandleState { struct ScrollHandleState {
item_height: Pixels, item_height: Pixels,
list_height: Pixels, list_height: Pixels,
scroll_offset: Arc<Mutex<Point<Pixels>>>, scroll_offset: Rc<RefCell<Point<Pixels>>>,
} }
impl UniformListScrollHandle { impl UniformListScrollHandle {
pub fn new() -> Self { pub fn new() -> Self {
Self(Arc::new(Mutex::new(None))) Self(Rc::new(RefCell::new(None)))
} }
pub fn scroll_to_item(&self, ix: usize) { pub fn scroll_to_item(&self, ix: usize) {
if let Some(state) = &*self.0.lock() { if let Some(state) = &*self.0.borrow() {
let mut scroll_offset = state.scroll_offset.lock(); let mut scroll_offset = state.scroll_offset.borrow_mut();
let item_top = state.item_height * ix; let item_top = state.item_height * ix;
let item_bottom = item_top + state.item_height; let item_bottom = item_top + state.item_height;
let scroll_top = -scroll_offset.y; let scroll_top = -scroll_offset.y;
@ -196,7 +195,7 @@ impl<V: 'static> Element<V> for UniformList<V> {
let shared_scroll_offset = element_state let shared_scroll_offset = element_state
.interactive .interactive
.scroll_offset .scroll_offset
.get_or_insert_with(Arc::default) .get_or_insert_with(Rc::default)
.clone(); .clone();
interactivity.paint( interactivity.paint(
@ -222,7 +221,7 @@ impl<V: 'static> Element<V> for UniformList<V> {
.measure_item(view_state, Some(padded_bounds.size.width), cx) .measure_item(view_state, Some(padded_bounds.size.width), cx)
.height; .height;
if let Some(scroll_handle) = self.scroll_handle.clone() { if let Some(scroll_handle) = self.scroll_handle.clone() {
scroll_handle.0.lock().replace(ScrollHandleState { scroll_handle.0.borrow_mut().replace(ScrollHandleState {
item_height, item_height,
list_height: padded_bounds.size.height, list_height: padded_bounds.size.height,
scroll_offset: shared_scroll_offset, scroll_offset: shared_scroll_offset,

27
crates/gpui2/src/view.rs
View file

@ -63,6 +63,16 @@ impl<V: 'static> View<V> {
pub fn read<'a>(&self, cx: &'a AppContext) -> &'a V { pub fn read<'a>(&self, cx: &'a AppContext) -> &'a V {
self.model.read(cx) self.model.read(cx)
} }
pub fn render_with<C>(&self, component: C) -> RenderViewWith<C, V>
where
C: 'static + Component<V>,
{
RenderViewWith {
view: self.clone(),
component: Some(component),
}
}
} }
impl<V> Clone for View<V> { impl<V> Clone for View<V> {
@ -281,12 +291,12 @@ where
} }
} }
pub struct RenderView<C, V> { pub struct RenderViewWith<C, V> {
view: View<V>, view: View<V>,
component: Option<C>, component: Option<C>,
} }
impl<C, ParentViewState, ViewState> Component<ParentViewState> for RenderView<C, ViewState> impl<C, ParentViewState, ViewState> Component<ParentViewState> for RenderViewWith<C, ViewState>
where where
C: 'static + Component<ViewState>, C: 'static + Component<ViewState>,
ParentViewState: 'static, ParentViewState: 'static,
@ -297,7 +307,7 @@ where
} }
} }
impl<C, ParentViewState, ViewState> Element<ParentViewState> for RenderView<C, ViewState> impl<C, ParentViewState, ViewState> Element<ParentViewState> for RenderViewWith<C, ViewState>
where where
C: 'static + Component<ViewState>, C: 'static + Component<ViewState>,
ParentViewState: 'static, ParentViewState: 'static,
@ -348,17 +358,6 @@ where
} }
} }
pub fn render_view<C, V>(view: &View<V>, component: C) -> RenderView<C, V>
where
C: 'static + Component<V>,
V: 'static,
{
RenderView {
view: view.clone(),
component: Some(component),
}
}
mod any_view { mod any_view {
use crate::{AnyElement, AnyView, BorrowWindow, LayoutId, Render, WindowContext}; use crate::{AnyElement, AnyView, BorrowWindow, LayoutId, Render, WindowContext};
use std::any::Any; use std::any::Any;

8
crates/gpui2/src/window.rs
View file

@ -216,7 +216,7 @@ pub struct Window {
// #[derive(Default)] // #[derive(Default)]
pub(crate) struct Frame { pub(crate) struct Frame {
element_states: HashMap<GlobalElementId, AnyBox>, pub(crate) element_states: HashMap<GlobalElementId, AnyBox>,
mouse_listeners: HashMap<TypeId, Vec<(StackingOrder, AnyMouseListener)>>, mouse_listeners: HashMap<TypeId, Vec<(StackingOrder, AnyMouseListener)>>,
pub(crate) dispatch_tree: DispatchTree, pub(crate) dispatch_tree: DispatchTree,
pub(crate) focus_listeners: Vec<AnyFocusListener>, pub(crate) focus_listeners: Vec<AnyFocusListener>,
@ -2471,7 +2471,7 @@ impl From<SmallVec<[u32; 16]>> for StackingOrder {
#[derive(Clone, Debug, Eq, PartialEq, Hash)] #[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub enum ElementId { pub enum ElementId {
View(EntityId), View(EntityId),
Number(usize), Integer(usize),
Name(SharedString), Name(SharedString),
FocusHandle(FocusId), FocusHandle(FocusId),
} }
@ -2484,13 +2484,13 @@ impl From<EntityId> for ElementId {
impl From<usize> for ElementId { impl From<usize> for ElementId {
fn from(id: usize) -> Self { fn from(id: usize) -> Self {
ElementId::Number(id) ElementId::Integer(id)
} }
} }
impl From<i32> for ElementId { impl From<i32> for ElementId {
fn from(id: i32) -> Self { fn from(id: i32) -> Self {
Self::Number(id as usize) Self::Integer(id as usize)
} }
} }