WIP

crates/assistant/src/assistant_panel.rs

@@ -1446,8 +1446,8 @@ struct ScrollPosition {
 }
 
 struct PatchViewState {
-    footer_block_id: CustomBlockId,
-    crease_id: CreaseId,
+    block_id: CustomBlockId,
+    // crease_id: CreaseId,
     editor: Option<PatchEditorState>,
     update_task: Option<Task<()>>,
 }
@@ -2173,8 +2173,8 @@ impl ContextEditor {
         for range in removed {
             if let Some(state) = self.patches.remove(range) {
                 editors_to_close.extend(state.editor.and_then(|state| state.editor.upgrade()));
-                removed_block_ids.insert(state.footer_block_id);
-                removed_crease_ids.push(state.crease_id);
+                removed_block_ids.insert(state.block_id);
+                // removed_crease_ids.push(state.crease_id);
             }
         }
 
@@ -2203,12 +2203,14 @@ impl ContextEditor {
                         let max_width = cx.max_width;
                         let gutter_width = cx.gutter_dimensions.full_width();
                         let block_id = cx.block_id;
+                        let selected = cx.selected;
                         this.update(&mut **cx, |this, cx| {
-                            this.render_patch_footer(
+                            this.render_patch(
                                 patch_range.clone(),
                                 max_width,
                                 gutter_width,
                                 block_id,
+                                selected,
                                 cx,
                             )
                         })
@@ -2218,26 +2220,9 @@ impl ContextEditor {
                     }
                 });
 
-                let header_placeholder = FoldPlaceholder {
-                    render: {
-                        let this = this.clone();
-                        let patch_range = range.clone();
-                        Arc::new(move |fold_id, _range, cx| {
-                            this.update(cx, |this, cx| {
-                                this.render_patch_header(patch_range.clone(), fold_id, cx)
-                            })
-                            .ok()
-                            .flatten()
-                            .unwrap_or_else(|| Empty.into_any())
-                        })
-                    },
-                    constrain_width: false,
-                    merge_adjacent: false,
-                };
-
                 let should_refold;
                 if let Some(state) = self.patches.get_mut(&range) {
-                    replaced_blocks.insert(state.footer_block_id, render_block);
+                    replaced_blocks.insert(state.block_id, render_block);
                     if let Some(editor_state) = &state.editor {
                         if editor_state.opened_patch != patch {
                             state.update_task = Some({
@@ -2257,30 +2242,30 @@ impl ContextEditor {
                     let block_ids = editor.insert_blocks(
                         [BlockProperties {
                             height: path_count as u32 + 1,
-                            style: BlockStyle::Flex,
+                            style: BlockStyle::Fixed,
                             render: render_block,
-                            placement: BlockPlacement::Below(patch_start),
+                            placement: BlockPlacement::Replace(patch_start..patch_end),
                             priority: 0,
                         }],
                         None,
                         cx,
                     );
 
-                    let new_crease_ids = editor.insert_creases(
-                        [Crease::new(
-                            patch_start..patch_end,
-                            header_placeholder.clone(),
-                            fold_toggle("patch-header"),
-                            |_, _, _| Empty.into_any_element(),
-                        )],
-                        cx,
-                    );
+                    // let new_crease_ids = editor.insert_creases(
+                    //     [Crease::new(
+                    //         patch_start..patch_end,
+                    //         header_placeholder.clone(),
+                    //         fold_toggle("patch-header"),
+                    //         |_, _, _| Empty.into_any_element(),
+                    //     )],
+                    //     cx,
+                    // );
 
                     self.patches.insert(
                         range.clone(),
                         PatchViewState {
-                            footer_block_id: block_ids[0],
-                            crease_id: new_crease_ids[0],
+                            block_id: block_ids[0],
+                            // crease_id: new_crease_ids[0],
                             editor: None,
                             update_task: None,
                         },
@@ -2290,8 +2275,8 @@ impl ContextEditor {
                 }
 
                 if should_refold {
-                    editor.unfold_ranges([patch_start..patch_end], true, false, cx);
-                    editor.fold_ranges([(patch_start..patch_end, header_placeholder)], false, cx);
+                    // editor.unfold_ranges([patch_start..patch_end], true, false, cx);
+                    // editor.fold_ranges([(patch_start..patch_end, header_placeholder)], false, cx);
                 }
             }
 
@@ -3449,33 +3434,13 @@ impl ContextEditor {
             .unwrap_or_else(|| Cow::Borrowed(DEFAULT_TAB_TITLE))
     }
 
-    fn render_patch_header(
-        &self,
-        range: Range<text::Anchor>,
-        _id: FoldId,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<AnyElement> {
-        let patch = self.context.read(cx).patch_for_range(&range, cx)?;
-        let theme = cx.theme().clone();
-        Some(
-            h_flex()
-                .px_1()
-                .py_0p5()
-                .border_b_1()
-                .border_color(theme.status().info_border)
-                .gap_1()
-                .child(Icon::new(IconName::Diff).size(IconSize::Small))
-                .child(Label::new(patch.title.clone()).size(LabelSize::Small))
-                .into_any(),
-        )
-    }
-
-    fn render_patch_footer(
+    fn render_patch(
         &mut self,
         range: Range<text::Anchor>,
         max_width: Pixels,
         gutter_width: Pixels,
         id: BlockId,
+        selected: bool,
         cx: &mut ViewContext<Self>,
     ) -> Option<AnyElement> {
         let snapshot = self.editor.update(cx, |editor, cx| editor.snapshot(cx));
@@ -3486,10 +3451,6 @@ impl ContextEditor {
             .anchor_in_excerpt(excerpt_id, range.start)
             .unwrap();
 
-        if !snapshot.intersects_fold(anchor) {
-            return None;
-        }
-
         let patch = self.context.read(cx).patch_for_range(&range, cx)?;
         let paths = patch
             .paths()
@@ -3498,10 +3459,18 @@ impl ContextEditor {
 
         Some(
             v_flex()
+                .bg(cx.theme().colors().editor_background)
+                .border_1()
+                .border_color(if selected {
+                    cx.theme().colors().border_focused
+                } else {
+                    cx.theme().colors().border
+                })
                 .id(id)
-                .pl(gutter_width)
-                .w(max_width)
-                .py_2()
+                .ml(gutter_width)
+                .p_2()
+                .rounded_md()
+                .min_h(cx.line_height() * 3.)
                 .cursor(CursorStyle::PointingHand)
                 .on_click(cx.listener(move |this, _, cx| {
                     this.editor.update(cx, |editor, cx| {
@@ -3511,6 +3480,7 @@ impl ContextEditor {
                     });
                     this.focus_active_patch(cx);
                 }))
+                .child(Label::new(patch.title.clone()))
                 .children(paths.into_iter().map(|path| {
                     h_flex()
                         .pl_1()

crates/diagnostics/src/diagnostics_tests.rs

@@ -986,6 +986,7 @@ fn editor_blocks(
                                     em_width: px(0.),
                                     max_width: px(0.),
                                     block_id,
+                                    selected: false,
                                     editor_style: &editor::EditorStyle::default(),
                                 });
                                 let element = element.downcast_mut::<Stateful<Div>>().unwrap();

crates/editor/src/display_map.rs

@@ -942,6 +942,14 @@ impl DisplaySnapshot {
         DisplayPoint(clipped)
     }
 
+    pub fn clip_point_2(&self, point: DisplayPoint, bias: Bias, skip_blocks: bool) -> DisplayPoint {
+        let mut clipped = self.block_snapshot.clip_point_2(point.0, bias, skip_blocks);
+        if self.clip_at_line_ends {
+            clipped = self.clip_at_line_end(DisplayPoint(clipped)).0
+        }
+        DisplayPoint(clipped)
+    }
+
     pub fn clip_ignoring_line_ends(&self, point: DisplayPoint, bias: Bias) -> DisplayPoint {
         DisplayPoint(self.block_snapshot.clip_point(point.0, bias))
     }

crates/editor/src/display_map/block_map.rs

@@ -265,6 +265,7 @@ pub struct BlockContext<'a, 'b> {
     pub em_width: Pixels,
     pub line_height: Pixels,
     pub block_id: BlockId,
+    pub selected: bool,
     pub editor_style: &'b EditorStyle,
 }
 
@@ -1297,6 +1298,68 @@ impl BlockSnapshot {
         cursor.item().map_or(false, |t| t.block.is_some())
     }
 
+    pub fn clip_point_2(&self, point: BlockPoint, bias: Bias, skip_blocks: bool) -> BlockPoint {
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
+        cursor.seek(&BlockRow(point.row), Bias::Right, &());
+
+        let max_input_row = WrapRow(self.transforms.summary().input_rows);
+        let mut search_left =
+            (bias == Bias::Left && cursor.start().1 .0 > 0) || cursor.end(&()).1 == max_input_row;
+        let mut reversed = false;
+
+        loop {
+            if let Some(transform) = cursor.item() {
+                let (output_start_row, input_start_row) = cursor.start();
+                let (output_end_row, input_end_row) = cursor.end(&());
+                let output_start = Point::new(output_start_row.0, 0);
+                let output_end = Point::new(output_end_row.0, 0);
+                let input_start = Point::new(input_start_row.0, 0);
+                let input_end = Point::new(input_end_row.0, 0);
+
+                match transform.block.as_ref() {
+                    Some(Block::Custom(block))
+                        if matches!(block.placement, BlockPlacement::Replace(_)) =>
+                    {
+                        if bias == Bias::Left {
+                            return BlockPoint(output_start);
+                        } else {
+                            return BlockPoint(Point::new(output_end.row - 1, 0));
+                        }
+                    }
+                    None => {
+                        let input_point = if point.row >= output_end_row.0 {
+                            let line_len = self.wrap_snapshot.line_len(input_end_row.0 - 1);
+                            self.wrap_snapshot
+                                .clip_point(WrapPoint::new(input_end_row.0 - 1, line_len), bias)
+                        } else {
+                            let output_overshoot = point.0.saturating_sub(output_start);
+                            self.wrap_snapshot
+                                .clip_point(WrapPoint(input_start + output_overshoot), bias)
+                        };
+
+                        if (input_start..input_end).contains(&input_point.0) {
+                            let input_overshoot = input_point.0.saturating_sub(input_start);
+                            return BlockPoint(output_start + input_overshoot);
+                        }
+                    }
+                    _ => {}
+                }
+
+                if search_left {
+                    cursor.prev(&());
+                } else {
+                    cursor.next(&());
+                }
+            } else if reversed {
+                return self.max_point();
+            } else {
+                reversed = true;
+                search_left = !search_left;
+                cursor.seek(&BlockRow(point.row), Bias::Right, &());
+            }
+        }
+    }
+
     pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
         let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&BlockRow(point.row), Bias::Right, &());

crates/editor/src/editor.rs

@@ -7463,11 +7463,12 @@ impl Editor {
                 if !selection.is_empty() && !line_mode {
                     selection.goal = SelectionGoal::None;
                 }
-                let (cursor, goal) = movement::up(
+                let (cursor, goal) = movement::up2(
                     map,
                     selection.start,
                     selection.goal,
                     false,
+                    false,
                     text_layout_details,
                 );
                 selection.collapse_to(cursor, goal);
@@ -7628,8 +7629,16 @@ impl Editor {
     pub fn select_up(&mut self, _: &SelectUp, cx: &mut ViewContext<Self>) {
         let text_layout_details = &self.text_layout_details(cx);
         self.change_selections(Some(Autoscroll::fit()), cx, |s| {
-            s.move_heads_with(|map, head, goal| {
-                movement::up(map, head, goal, false, text_layout_details)
+            s.move_with(|map, selection| {
+                let (head, goal) = movement::up2(
+                    map,
+                    selection.head(),
+                    selection.goal,
+                    false,
+                    !selection.reversed,
+                    text_layout_details,
+                );
+                selection.set_head(head, goal);
             })
         })
     }

crates/editor/src/element.rs

@@ -2068,6 +2068,7 @@ impl EditorElement {
         editor_width: Pixels,
         scroll_width: &mut Pixels,
         resized_blocks: &mut HashMap<CustomBlockId, u32>,
+        active_rows: &BTreeMap<DisplayRow, bool>,
         cx: &mut WindowContext,
     ) -> (AnyElement, Size<Pixels>) {
         let mut element = match block {
@@ -2094,6 +2095,7 @@ impl EditorElement {
                         line_height,
                         em_width,
                         block_id,
+                        selected: active_rows.contains_key(&block_row_start),
                         max_width: text_hitbox.size.width.max(*scroll_width),
                         editor_style: &self.style,
                     }))
@@ -2431,6 +2433,7 @@ impl EditorElement {
         text_x: Pixels,
         line_height: Pixels,
         line_layouts: &[LineWithInvisibles],
+        active_rows: &BTreeMap<DisplayRow, bool>,
         cx: &mut WindowContext,
     ) -> Result<Vec<BlockLayout>, HashMap<CustomBlockId, u32>> {
         let (fixed_blocks, non_fixed_blocks) = snapshot
@@ -2467,6 +2470,7 @@ impl EditorElement {
                 editor_width,
                 scroll_width,
                 &mut resized_blocks,
+                active_rows,
                 cx,
             );
             fixed_block_max_width = fixed_block_max_width.max(element_size.width + em_width);
@@ -2511,6 +2515,7 @@ impl EditorElement {
                 editor_width,
                 scroll_width,
                 &mut resized_blocks,
+                active_rows,
                 cx,
             );
 
@@ -2556,6 +2561,7 @@ impl EditorElement {
                             editor_width,
                             scroll_width,
                             &mut resized_blocks,
+                            active_rows,
                             cx,
                         );
 
@@ -5176,6 +5182,7 @@ impl Element for EditorElement {
                             gutter_dimensions.full_width(),
                             line_height,
                             &line_layouts,
+                            &active_rows,
                             cx,
                         )
                     });

crates/editor/src/movement.rs

@@ -76,6 +76,26 @@ pub fn saturating_right(map: &DisplaySnapshot, mut point: DisplayPoint) -> Displ
     map.clip_point(point, Bias::Right)
 }
 
+/// Returns a display point for the preceding displayed line (which might be a soft-wrapped line).
+pub fn up2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    goal: SelectionGoal,
+    preserve_column_at_start: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    up_by_rows2(
+        map,
+        start,
+        1,
+        goal,
+        preserve_column_at_start,
+        skip_replace_blocks,
+        text_layout_details,
+    )
+}
+
 /// Returns a display point for the preceding displayed line (which might be a soft-wrapped line).
 pub fn up(
     map: &DisplaySnapshot,
@@ -112,6 +132,26 @@ pub fn down(
     )
 }
 
+/// Returns a display point for the next displayed line (which might be a soft-wrapped line).
+pub fn down2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    goal: SelectionGoal,
+    preserve_column_at_end: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    down_by_rows2(
+        map,
+        start,
+        1,
+        goal,
+        preserve_column_at_end,
+        skip_replace_blocks,
+        text_layout_details,
+    )
+}
+
 pub(crate) fn up_by_rows(
     map: &DisplaySnapshot,
     start: DisplayPoint,
@@ -151,6 +191,46 @@ pub(crate) fn up_by_rows(
     )
 }
 
+pub(crate) fn up_by_rows2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    row_count: u32,
+    goal: SelectionGoal,
+    preserve_column_at_start: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    let mut goal_x = match goal {
+        SelectionGoal::HorizontalPosition(x) => x.into(),
+        SelectionGoal::WrappedHorizontalPosition((_, x)) => x.into(),
+        SelectionGoal::HorizontalRange { end, .. } => end.into(),
+        _ => map.x_for_display_point(start, text_layout_details),
+    };
+
+    let prev_row = DisplayRow(start.row().0.saturating_sub(row_count));
+    let mut point = map.clip_point(
+        DisplayPoint::new(prev_row, map.line_len(prev_row)),
+        Bias::Left,
+    );
+    if point.row() < start.row() {
+        *point.column_mut() = map.display_column_for_x(point.row(), goal_x, text_layout_details)
+    } else if preserve_column_at_start {
+        return (start, goal);
+    } else {
+        point = DisplayPoint::new(DisplayRow(0), 0);
+        goal_x = px(0.);
+    }
+
+    let mut clipped_point = map.clip_point_2(point, Bias::Left, skip_replace_blocks);
+    if clipped_point.row() < point.row() {
+        clipped_point = map.clip_point_2(point, Bias::Right, skip_replace_blocks);
+    }
+    (
+        clipped_point,
+        SelectionGoal::HorizontalPosition(goal_x.into()),
+    )
+}
+
 pub(crate) fn down_by_rows(
     map: &DisplaySnapshot,
     start: DisplayPoint,
@@ -187,6 +267,43 @@ pub(crate) fn down_by_rows(
     )
 }
 
+pub(crate) fn down_by_rows2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    row_count: u32,
+    goal: SelectionGoal,
+    preserve_column_at_end: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    let mut goal_x = match goal {
+        SelectionGoal::HorizontalPosition(x) => x.into(),
+        SelectionGoal::WrappedHorizontalPosition((_, x)) => x.into(),
+        SelectionGoal::HorizontalRange { end, .. } => end.into(),
+        _ => map.x_for_display_point(start, text_layout_details),
+    };
+
+    let new_row = DisplayRow(start.row().0 + row_count);
+    let mut point = map.clip_point(DisplayPoint::new(new_row, 0), Bias::Right);
+    if point.row() > start.row() {
+        *point.column_mut() = map.display_column_for_x(point.row(), goal_x, text_layout_details)
+    } else if preserve_column_at_end {
+        return (start, goal);
+    } else {
+        point = map.max_point();
+        goal_x = map.x_for_display_point(point, text_layout_details)
+    }
+
+    let mut clipped_point = map.clip_point_2(point, Bias::Right, skip_replace_blocks);
+    if clipped_point.row() > point.row() {
+        clipped_point = map.clip_point_2(point, Bias::Left, skip_replace_blocks);
+    }
+    (
+        clipped_point,
+        SelectionGoal::HorizontalPosition(goal_x.into()),
+    )
+}
+
 /// Returns a position of the start of line.
 /// If `stop_at_soft_boundaries` is true, the returned position is that of the
 /// displayed line (e.g. it could actually be in the middle of a text line if that line is soft-wrapped).