Detailed changes
@@ -18,11 +18,11 @@ use collections::{BTreeSet, HashMap, HashSet};
use editor::actions::ShowCompletions;
use editor::{
actions::{FoldAt, MoveToEndOfLine, Newline, UnfoldAt},
- display_map::{BlockDisposition, BlockId, BlockProperties, BlockStyle, Flap, ToDisplayPoint},
+ display_map::{BlockDisposition, BlockId, BlockProperties, BlockStyle, Crease, ToDisplayPoint},
scroll::{Autoscroll, AutoscrollStrategy},
Anchor, Editor, EditorEvent, RowExt, ToOffset as _, ToPoint,
};
-use editor::{display_map::FlapId, FoldPlaceholder};
+use editor::{display_map::CreaseId, FoldPlaceholder};
use file_icons::FileIcons;
use fs::Fs;
use futures::future::Shared;
@@ -2158,7 +2158,7 @@ pub struct ContextEditor {
editor: View<Editor>,
blocks: HashSet<BlockId>,
scroll_position: Option<ScrollPosition>,
- pending_slash_command_flaps: HashMap<Range<language::Anchor>, FlapId>,
+ pending_slash_command_creases: HashMap<Range<language::Anchor>, CreaseId>,
_subscriptions: Vec<Subscription>,
}
@@ -2230,7 +2230,7 @@ impl ContextEditor {
scroll_position: None,
fs,
workspace: workspace.downgrade(),
- pending_slash_command_flaps: HashMap::default(),
+ pending_slash_command_creases: HashMap::default(),
_subscriptions,
};
this.update_message_headers(cx);
@@ -2493,14 +2493,14 @@ impl ContextEditor {
let buffer = editor.buffer().read(cx).snapshot(cx);
let excerpt_id = *buffer.as_singleton().unwrap().0;
- editor.remove_flaps(
+ editor.remove_creases(
removed
.iter()
- .filter_map(|range| self.pending_slash_command_flaps.remove(range)),
+ .filter_map(|range| self.pending_slash_command_creases.remove(range)),
cx,
);
- let flap_ids = editor.insert_flaps(
+ let crease_ids = editor.insert_creases(
updated.iter().map(|command| {
let workspace = self.workspace.clone();
let confirm_command = Arc::new({
@@ -2546,16 +2546,16 @@ impl ContextEditor {
let end = buffer
.anchor_in_excerpt(excerpt_id, command.source_range.end)
.unwrap();
- Flap::new(start..end, placeholder, render_toggle, render_trailer)
+ Crease::new(start..end, placeholder, render_toggle, render_trailer)
}),
cx,
);
- self.pending_slash_command_flaps.extend(
+ self.pending_slash_command_creases.extend(
updated
.iter()
.map(|command| command.source_range.clone())
- .zip(flap_ids),
+ .zip(crease_ids),
);
})
}
@@ -2598,7 +2598,7 @@ impl ContextEditor {
let buffer = editor.buffer().read(cx).snapshot(cx);
let excerpt_id = *buffer.as_singleton().unwrap().0;
let mut buffer_rows_to_fold = BTreeSet::new();
- let mut flaps = Vec::new();
+ let mut creases = Vec::new();
for section in sections {
let start = buffer
.anchor_in_excerpt(excerpt_id, section.range.start)
@@ -2608,7 +2608,7 @@ impl ContextEditor {
.unwrap();
let buffer_row = MultiBufferRow(start.to_point(&buffer).row);
buffer_rows_to_fold.insert(buffer_row);
- flaps.push(Flap::new(
+ creases.push(Crease::new(
start..end,
FoldPlaceholder {
render: Arc::new({
@@ -2638,7 +2638,7 @@ impl ContextEditor {
));
}
- editor.insert_flaps(flaps, cx);
+ editor.insert_creases(creases, cx);
for buffer_row in buffer_rows_to_fold.into_iter().rev() {
editor.fold_at(&FoldAt { buffer_row }, cx);
@@ -18,7 +18,7 @@
//! [EditorElement]: crate::element::EditorElement
mod block_map;
-mod flap_map;
+mod crease_map;
mod fold_map;
mod inlay_map;
mod tab_map;
@@ -33,7 +33,7 @@ pub use block_map::{
};
use block_map::{BlockRow, BlockSnapshot};
use collections::{HashMap, HashSet};
-pub use flap_map::*;
+pub use crease_map::*;
pub use fold_map::{Fold, FoldId, FoldPlaceholder, FoldPoint};
use fold_map::{FoldMap, FoldSnapshot};
use gpui::{
@@ -106,7 +106,7 @@ pub struct DisplayMap {
/// Regions of inlays that should be highlighted.
inlay_highlights: InlayHighlights,
/// A container for explicitly foldable ranges, which supersede indentation based fold range suggestions.
- flap_map: FlapMap,
+ crease_map: CreaseMap,
fold_placeholder: FoldPlaceholder,
pub clip_at_line_ends: bool,
}
@@ -139,7 +139,7 @@ impl DisplayMap {
excerpt_header_height,
excerpt_footer_height,
);
- let flap_map = FlapMap::default();
+ let crease_map = CreaseMap::default();
cx.observe(&wrap_map, |_, _, cx| cx.notify()).detach();
@@ -151,7 +151,7 @@ impl DisplayMap {
tab_map,
wrap_map,
block_map,
- flap_map,
+ crease_map,
fold_placeholder,
text_highlights: Default::default(),
inlay_highlights: Default::default(),
@@ -178,7 +178,7 @@ impl DisplayMap {
tab_snapshot,
wrap_snapshot,
block_snapshot,
- flap_snapshot: self.flap_map.snapshot(),
+ crease_snapshot: self.crease_map.snapshot(),
text_highlights: self.text_highlights.clone(),
inlay_highlights: self.inlay_highlights.clone(),
clip_at_line_ends: self.clip_at_line_ends,
@@ -247,22 +247,22 @@ impl DisplayMap {
self.block_map.read(snapshot, edits);
}
- pub fn insert_flaps(
+ pub fn insert_creases(
&mut self,
- flaps: impl IntoIterator<Item = Flap>,
+ creases: impl IntoIterator<Item = Crease>,
cx: &mut ModelContext<Self>,
- ) -> Vec<FlapId> {
+ ) -> Vec<CreaseId> {
let snapshot = self.buffer.read(cx).snapshot(cx);
- self.flap_map.insert(flaps, &snapshot)
+ self.crease_map.insert(creases, &snapshot)
}
- pub fn remove_flaps(
+ pub fn remove_creases(
&mut self,
- flap_ids: impl IntoIterator<Item = FlapId>,
+ crease_ids: impl IntoIterator<Item = CreaseId>,
cx: &mut ModelContext<Self>,
) {
let snapshot = self.buffer.read(cx).snapshot(cx);
- self.flap_map.remove(flap_ids, &snapshot)
+ self.crease_map.remove(crease_ids, &snapshot)
}
pub fn insert_blocks(
@@ -472,7 +472,7 @@ pub struct HighlightedChunk<'a> {
pub struct DisplaySnapshot {
pub buffer_snapshot: MultiBufferSnapshot,
pub fold_snapshot: FoldSnapshot,
- pub flap_snapshot: FlapSnapshot,
+ pub crease_snapshot: CreaseSnapshot,
inlay_snapshot: InlaySnapshot,
tab_snapshot: TabSnapshot,
wrap_snapshot: WrapSnapshot,
@@ -955,13 +955,13 @@ impl DisplaySnapshot {
buffer_row: MultiBufferRow,
) -> Option<(Range<Point>, FoldPlaceholder)> {
let start = MultiBufferPoint::new(buffer_row.0, self.buffer_snapshot.line_len(buffer_row));
- if let Some(flap) = self
- .flap_snapshot
+ if let Some(crease) = self
+ .crease_snapshot
.query_row(buffer_row, &self.buffer_snapshot)
{
Some((
- flap.range.to_point(&self.buffer_snapshot),
- flap.placeholder.clone(),
+ crease.range.to_point(&self.buffer_snapshot),
+ crease.placeholder.clone(),
))
} else if self.starts_indent(MultiBufferRow(start.row))
&& !self.is_line_folded(MultiBufferRow(start.row))
@@ -1946,7 +1946,7 @@ pub mod tests {
}
#[gpui::test]
- fn test_flaps(cx: &mut gpui::AppContext) {
+ fn test_creases(cx: &mut gpui::AppContext) {
init_test(cx, |_| {});
let text = "aaa\nbbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\nkkk\nlll";
@@ -1969,8 +1969,8 @@ pub mod tests {
let range =
snapshot.anchor_before(Point::new(2, 0))..snapshot.anchor_after(Point::new(3, 3));
- map.flap_map.insert(
- [Flap::new(
+ map.crease_map.insert(
+ [Crease::new(
range,
FoldPlaceholder::test(),
|_row, _status, _toggle, _cx| div(),
@@ -9,36 +9,36 @@ use ui::WindowContext;
use crate::FoldPlaceholder;
#[derive(Copy, Clone, Default, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
-pub struct FlapId(usize);
+pub struct CreaseId(usize);
#[derive(Default)]
-pub struct FlapMap {
- snapshot: FlapSnapshot,
- next_id: FlapId,
- id_to_range: HashMap<FlapId, Range<Anchor>>,
+pub struct CreaseMap {
+ snapshot: CreaseSnapshot,
+ next_id: CreaseId,
+ id_to_range: HashMap<CreaseId, Range<Anchor>>,
}
#[derive(Clone, Default)]
-pub struct FlapSnapshot {
- flaps: SumTree<FlapItem>,
+pub struct CreaseSnapshot {
+ creases: SumTree<CreaseItem>,
}
-impl FlapSnapshot {
- /// Returns the first Flap starting on the specified buffer row.
+impl CreaseSnapshot {
+ /// Returns the first Crease starting on the specified buffer row.
pub fn query_row<'a>(
&'a self,
row: MultiBufferRow,
snapshot: &'a MultiBufferSnapshot,
- ) -> Option<&'a Flap> {
+ ) -> Option<&'a Crease> {
let start = snapshot.anchor_before(Point::new(row.0, 0));
- let mut cursor = self.flaps.cursor::<ItemSummary>();
+ let mut cursor = self.creases.cursor::<ItemSummary>();
cursor.seek(&start, Bias::Left, snapshot);
while let Some(item) = cursor.item() {
- match Ord::cmp(&item.flap.range.start.to_point(snapshot).row, &row.0) {
+ match Ord::cmp(&item.crease.range.start.to_point(snapshot).row, &row.0) {
Ordering::Less => cursor.next(snapshot),
Ordering::Equal => {
- if item.flap.range.start.is_valid(snapshot) {
- return Some(&item.flap);
+ if item.crease.range.start.is_valid(snapshot) {
+ return Some(&item.crease);
} else {
cursor.next(snapshot);
}
@@ -49,17 +49,17 @@ impl FlapSnapshot {
return None;
}
- pub fn flap_items_with_offsets(
+ pub fn crease_items_with_offsets(
&self,
snapshot: &MultiBufferSnapshot,
- ) -> Vec<(FlapId, Range<Point>)> {
- let mut cursor = self.flaps.cursor::<ItemSummary>();
+ ) -> Vec<(CreaseId, Range<Point>)> {
+ let mut cursor = self.creases.cursor::<ItemSummary>();
let mut results = Vec::new();
cursor.next(snapshot);
while let Some(item) = cursor.item() {
- let start_point = item.flap.range.start.to_point(snapshot);
- let end_point = item.flap.range.end.to_point(snapshot);
+ let start_point = item.crease.range.start.to_point(snapshot);
+ let end_point = item.crease.range.end.to_point(snapshot);
results.push((item.id, start_point..end_point));
cursor.next(snapshot);
}
@@ -82,14 +82,14 @@ type RenderTrailerFn =
Arc<dyn Send + Sync + Fn(MultiBufferRow, bool, &mut WindowContext) -> AnyElement>;
#[derive(Clone)]
-pub struct Flap {
+pub struct Crease {
pub range: Range<Anchor>,
pub placeholder: FoldPlaceholder,
pub render_toggle: RenderToggleFn,
pub render_trailer: RenderTrailerFn,
}
-impl Flap {
+impl Crease {
pub fn new<RenderToggle, ToggleElement, RenderTrailer, TrailerElement>(
range: Range<Anchor>,
placeholder: FoldPlaceholder,
@@ -115,7 +115,7 @@ impl Flap {
+ 'static,
TrailerElement: IntoElement,
{
- Flap {
+ Crease {
range,
placeholder,
render_toggle: Arc::new(move |row, folded, toggle, cx| {
@@ -128,50 +128,52 @@ impl Flap {
}
}
-impl std::fmt::Debug for Flap {
+impl std::fmt::Debug for Crease {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- f.debug_struct("Flap").field("range", &self.range).finish()
+ f.debug_struct("Crease")
+ .field("range", &self.range)
+ .finish()
}
}
#[derive(Clone, Debug)]
-struct FlapItem {
- id: FlapId,
- flap: Flap,
+struct CreaseItem {
+ id: CreaseId,
+ crease: Crease,
}
-impl FlapMap {
- pub fn snapshot(&self) -> FlapSnapshot {
+impl CreaseMap {
+ pub fn snapshot(&self) -> CreaseSnapshot {
self.snapshot.clone()
}
pub fn insert(
&mut self,
- flaps: impl IntoIterator<Item = Flap>,
+ creases: impl IntoIterator<Item = Crease>,
snapshot: &MultiBufferSnapshot,
- ) -> Vec<FlapId> {
+ ) -> Vec<CreaseId> {
let mut new_ids = Vec::new();
- self.snapshot.flaps = {
- let mut new_flaps = SumTree::new();
- let mut cursor = self.snapshot.flaps.cursor::<ItemSummary>();
- for flap in flaps {
- new_flaps.append(cursor.slice(&flap.range, Bias::Left, snapshot), snapshot);
+ self.snapshot.creases = {
+ let mut new_creases = SumTree::new();
+ let mut cursor = self.snapshot.creases.cursor::<ItemSummary>();
+ for crease in creases {
+ new_creases.append(cursor.slice(&crease.range, Bias::Left, snapshot), snapshot);
let id = self.next_id;
self.next_id.0 += 1;
- self.id_to_range.insert(id, flap.range.clone());
- new_flaps.push(FlapItem { flap, id }, snapshot);
+ self.id_to_range.insert(id, crease.range.clone());
+ new_creases.push(CreaseItem { crease, id }, snapshot);
new_ids.push(id);
}
- new_flaps.append(cursor.suffix(snapshot), snapshot);
- new_flaps
+ new_creases.append(cursor.suffix(snapshot), snapshot);
+ new_creases
};
new_ids
}
pub fn remove(
&mut self,
- ids: impl IntoIterator<Item = FlapId>,
+ ids: impl IntoIterator<Item = CreaseId>,
snapshot: &MultiBufferSnapshot,
) {
let mut removals = Vec::new();
@@ -184,24 +186,24 @@ impl FlapMap {
AnchorRangeExt::cmp(a_range, b_range, snapshot).then(b_id.cmp(&a_id))
});
- self.snapshot.flaps = {
- let mut new_flaps = SumTree::new();
- let mut cursor = self.snapshot.flaps.cursor::<ItemSummary>();
+ self.snapshot.creases = {
+ let mut new_creases = SumTree::new();
+ let mut cursor = self.snapshot.creases.cursor::<ItemSummary>();
for (id, range) in removals {
- new_flaps.append(cursor.slice(&range, Bias::Left, snapshot), snapshot);
+ new_creases.append(cursor.slice(&range, Bias::Left, snapshot), snapshot);
while let Some(item) = cursor.item() {
cursor.next(snapshot);
if item.id == id {
break;
} else {
- new_flaps.push(item.clone(), snapshot);
+ new_creases.push(item.clone(), snapshot);
}
}
}
- new_flaps.append(cursor.suffix(snapshot), snapshot);
- new_flaps
+ new_creases.append(cursor.suffix(snapshot), snapshot);
+ new_creases
};
}
}
@@ -227,17 +229,17 @@ impl sum_tree::Summary for ItemSummary {
}
}
-impl sum_tree::Item for FlapItem {
+impl sum_tree::Item for CreaseItem {
type Summary = ItemSummary;
fn summary(&self) -> Self::Summary {
ItemSummary {
- range: self.flap.range.clone(),
+ range: self.crease.range.clone(),
}
}
}
-/// Implements `SeekTarget` for `Range<Anchor>` to enable seeking within a `SumTree` of `FlapItem`s.
+/// Implements `SeekTarget` for `Range<Anchor>` to enable seeking within a `SumTree` of `CreaseItem`s.
impl SeekTarget<'_, ItemSummary, ItemSummary> for Range<Anchor> {
fn cmp(&self, cursor_location: &ItemSummary, snapshot: &MultiBufferSnapshot) -> Ordering {
AnchorRangeExt::cmp(self, &cursor_location.range, snapshot)
@@ -257,48 +259,48 @@ mod test {
use multi_buffer::MultiBuffer;
#[gpui::test]
- fn test_insert_and_remove_flaps(cx: &mut AppContext) {
+ fn test_insert_and_remove_creases(cx: &mut AppContext) {
let text = "line1\nline2\nline3\nline4\nline5";
let buffer = MultiBuffer::build_simple(text, cx);
let snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
- let mut flap_map = FlapMap::default();
+ let mut crease_map = CreaseMap::default();
- // Insert flaps
- let flaps = [
- Flap::new(
+ // Insert creases
+ let creases = [
+ Crease::new(
snapshot.anchor_before(Point::new(1, 0))..snapshot.anchor_after(Point::new(1, 5)),
FoldPlaceholder::test(),
|_row, _folded, _toggle, _cx| div(),
|_row, _folded, _cx| div(),
),
- Flap::new(
+ Crease::new(
snapshot.anchor_before(Point::new(3, 0))..snapshot.anchor_after(Point::new(3, 5)),
FoldPlaceholder::test(),
|_row, _folded, _toggle, _cx| div(),
|_row, _folded, _cx| div(),
),
];
- let flap_ids = flap_map.insert(flaps, &snapshot);
- assert_eq!(flap_ids.len(), 2);
+ let crease_ids = crease_map.insert(creases, &snapshot);
+ assert_eq!(crease_ids.len(), 2);
- // Verify flaps are inserted
- let flap_snapshot = flap_map.snapshot();
- assert!(flap_snapshot
+ // Verify creases are inserted
+ let crease_snapshot = crease_map.snapshot();
+ assert!(crease_snapshot
.query_row(MultiBufferRow(1), &snapshot)
.is_some());
- assert!(flap_snapshot
+ assert!(crease_snapshot
.query_row(MultiBufferRow(3), &snapshot)
.is_some());
- // Remove flaps
- flap_map.remove(flap_ids, &snapshot);
+ // Remove creases
+ crease_map.remove(crease_ids, &snapshot);
- // Verify flaps are removed
- let flap_snapshot = flap_map.snapshot();
- assert!(flap_snapshot
+ // Verify creases are removed
+ let crease_snapshot = crease_map.snapshot();
+ assert!(crease_snapshot
.query_row(MultiBufferRow(1), &snapshot)
.is_none());
- assert!(flap_snapshot
+ assert!(crease_snapshot
.query_row(MultiBufferRow(3), &snapshot)
.is_none());
}
@@ -9909,22 +9909,22 @@ impl Editor {
}
}
- pub fn insert_flaps(
+ pub fn insert_creases(
&mut self,
- flaps: impl IntoIterator<Item = Flap>,
+ creases: impl IntoIterator<Item = Crease>,
cx: &mut ViewContext<Self>,
- ) -> Vec<FlapId> {
+ ) -> Vec<CreaseId> {
self.display_map
- .update(cx, |map, cx| map.insert_flaps(flaps, cx))
+ .update(cx, |map, cx| map.insert_creases(creases, cx))
}
- pub fn remove_flaps(
+ pub fn remove_creases(
&mut self,
- ids: impl IntoIterator<Item = FlapId>,
+ ids: impl IntoIterator<Item = CreaseId>,
cx: &mut ViewContext<Self>,
) {
self.display_map
- .update(cx, |map, cx| map.remove_flaps(ids, cx));
+ .update(cx, |map, cx| map.remove_creases(ids, cx));
}
pub fn longest_row(&self, cx: &mut AppContext) -> DisplayRow {
@@ -11759,8 +11759,8 @@ impl EditorSnapshot {
) -> Option<AnyElement> {
let folded = self.is_line_folded(buffer_row);
- if let Some(flap) = self
- .flap_snapshot
+ if let Some(crease) = self
+ .crease_snapshot
.query_row(buffer_row, &self.buffer_snapshot)
{
let toggle_callback = Arc::new(move |folded, cx: &mut WindowContext| {
@@ -11775,7 +11775,7 @@ impl EditorSnapshot {
}
});
- Some((flap.render_toggle)(
+ Some((crease.render_toggle)(
buffer_row,
folded,
toggle_callback,
@@ -11801,16 +11801,16 @@ impl EditorSnapshot {
}
}
- pub fn render_flap_trailer(
+ pub fn render_crease_trailer(
&self,
buffer_row: MultiBufferRow,
cx: &mut WindowContext,
) -> Option<AnyElement> {
let folded = self.is_line_folded(buffer_row);
- let flap = self
- .flap_snapshot
+ let crease = self
+ .crease_snapshot
.query_row(buffer_row, &self.buffer_snapshot)?;
- Some((flap.render_trailer)(buffer_row, folded, cx))
+ Some((crease.render_trailer)(buffer_row, folded, cx))
}
}
@@ -12049,7 +12049,7 @@ async fn test_active_indent_guide_non_matching_indent(cx: &mut gpui::TestAppCont
}
#[gpui::test]
-fn test_flap_insertion_and_rendering(cx: &mut TestAppContext) {
+fn test_crease_insertion_and_rendering(cx: &mut TestAppContext) {
init_test(cx, |_| {});
let editor = cx.add_window(|cx| {
@@ -12070,7 +12070,7 @@ fn test_flap_insertion_and_rendering(cx: &mut TestAppContext) {
callback: Arc<dyn Fn(bool, &mut WindowContext) + Send + Sync>,
}
- let flap = Flap::new(
+ let crease = Crease::new(
range,
FoldPlaceholder::test(),
{
@@ -12087,7 +12087,7 @@ fn test_flap_insertion_and_rendering(cx: &mut TestAppContext) {
|_row, _folded, _cx| div(),
);
- editor.insert_flaps(Some(flap), cx);
+ editor.insert_creases(Some(crease), cx);
let snapshot = editor.snapshot(cx);
let _div = snapshot.render_fold_toggle(MultiBufferRow(1), false, cx.view().clone(), cx);
snapshot
@@ -1136,7 +1136,7 @@ impl EditorElement {
}
#[allow(clippy::too_many_arguments)]
- fn prepaint_flap_trailers(
+ fn prepaint_crease_trailers(
&self,
trailers: Vec<Option<AnyElement>>,
lines: &[LineWithInvisibles],
@@ -1145,7 +1145,7 @@ impl EditorElement {
scroll_pixel_position: gpui::Point<Pixels>,
em_width: Pixels,
cx: &mut WindowContext,
- ) -> Vec<Option<FlapTrailerLayout>> {
+ ) -> Vec<Option<CreaseTrailerLayout>> {
trailers
.into_iter()
.enumerate()
@@ -1170,7 +1170,7 @@ impl EditorElement {
let centering_offset = point(px(0.), (line_height - size.height) / 2.);
let origin = content_origin + position + centering_offset;
element.prepaint_as_root(origin, available_space, cx);
- Some(FlapTrailerLayout {
+ Some(CreaseTrailerLayout {
element,
bounds: Bounds::new(origin, size),
})
@@ -1266,7 +1266,7 @@ impl EditorElement {
display_row: DisplayRow,
display_snapshot: &DisplaySnapshot,
line_layout: &LineWithInvisibles,
- flap_trailer: Option<&FlapTrailerLayout>,
+ crease_trailer: Option<&CreaseTrailerLayout>,
em_width: Pixels,
content_origin: gpui::Point<Pixels>,
scroll_pixel_position: gpui::Point<Pixels>,
@@ -1306,8 +1306,8 @@ impl EditorElement {
let start_x = {
const INLINE_BLAME_PADDING_EM_WIDTHS: f32 = 6.;
- let line_end = if let Some(flap_trailer) = flap_trailer {
- flap_trailer.bounds.right()
+ let line_end = if let Some(crease_trailer) = crease_trailer {
+ crease_trailer.bounds.right()
} else {
content_origin.x - scroll_pixel_position.x + line_layout.width
};
@@ -1779,7 +1779,7 @@ impl EditorElement {
}
}
- fn layout_flap_trailers(
+ fn layout_crease_trailers(
&self,
buffer_rows: impl IntoIterator<Item = Option<MultiBufferRow>>,
snapshot: &EditorSnapshot,
@@ -1789,7 +1789,7 @@ impl EditorElement {
.into_iter()
.map(|row| {
if let Some(multibuffer_row) = row {
- snapshot.render_flap_trailer(multibuffer_row, cx)
+ snapshot.render_crease_trailer(multibuffer_row, cx)
} else {
None
}
@@ -3067,8 +3067,8 @@ impl EditorElement {
self.paint_redactions(layout, cx);
self.paint_cursors(layout, cx);
self.paint_inline_blame(layout, cx);
- cx.with_element_namespace("flap_trailers", |cx| {
- for trailer in layout.flap_trailers.iter_mut().flatten() {
+ cx.with_element_namespace("crease_trailers", |cx| {
+ for trailer in layout.crease_trailers.iter_mut().flatten() {
trailer.element.paint(cx);
}
});
@@ -4697,8 +4697,8 @@ impl Element for EditorElement {
cx,
)
});
- let flap_trailers = cx.with_element_namespace("flap_trailers", |cx| {
- self.layout_flap_trailers(buffer_rows.iter().copied(), &snapshot, cx)
+ let crease_trailers = cx.with_element_namespace("crease_trailers", |cx| {
+ self.layout_crease_trailers(buffer_rows.iter().copied(), &snapshot, cx)
});
let display_hunks = self.layout_git_gutters(
@@ -4759,9 +4759,9 @@ impl Element for EditorElement {
cx,
);
- let flap_trailers = cx.with_element_namespace("flap_trailers", |cx| {
- self.prepaint_flap_trailers(
- flap_trailers,
+ let crease_trailers = cx.with_element_namespace("crease_trailers", |cx| {
+ self.prepaint_crease_trailers(
+ crease_trailers,
&line_layouts,
line_height,
content_origin,
@@ -4777,12 +4777,12 @@ impl Element for EditorElement {
if (start_row..end_row).contains(&display_row) {
let line_ix = display_row.minus(start_row) as usize;
let line_layout = &line_layouts[line_ix];
- let flap_trailer_layout = flap_trailers[line_ix].as_ref();
+ let crease_trailer_layout = crease_trailers[line_ix].as_ref();
inline_blame = self.layout_inline_blame(
display_row,
&snapshot.display_snapshot,
line_layout,
- flap_trailer_layout,
+ crease_trailer_layout,
em_width,
content_origin,
scroll_pixel_position,
@@ -5037,7 +5037,7 @@ impl Element for EditorElement {
test_indicators,
code_actions_indicator,
gutter_fold_toggles,
- flap_trailers,
+ crease_trailers,
tab_invisible,
space_invisible,
}
@@ -5168,7 +5168,7 @@ pub struct EditorLayout {
code_actions_indicator: Option<AnyElement>,
test_indicators: Vec<AnyElement>,
gutter_fold_toggles: Vec<Option<AnyElement>>,
- flap_trailers: Vec<Option<FlapTrailerLayout>>,
+ crease_trailers: Vec<Option<CreaseTrailerLayout>>,
mouse_context_menu: Option<AnyElement>,
tab_invisible: ShapedLine,
space_invisible: ShapedLine,
@@ -5292,7 +5292,7 @@ impl ScrollbarLayout {
}
}
-struct FlapTrailerLayout {
+struct CreaseTrailerLayout {
element: AnyElement,
bounds: Bounds<Pixels>,
}