Preserve scroll position when toggling markdown Rendered/Raw views

Toggling a markdown file between Rendered and Raw replaces the entire
pane (FileNotebookView <-> CodeView), so the new pane always started at
the top of the document. Capture the outgoing pane's vertical scroll as
a fraction of its scrollable range, carry it on the pane-replacement
events, and re-apply it after the new pane's content is laid out.

A fraction is used instead of a char-offset snapshot because the two
modes render different documents. Application is deferred through the
render model's element-update cycle (version- and viewport-gated),
since a freshly created pane has no laid-out content yet and applying
immediately would clamp the scroll to the top.

Fixes the scroll-preservation half of #7897; search/replace is out of
scope.

Author: slash9494

app/src/code/editor/scroll.rs

@@ -27,6 +27,10 @@ impl ScrollWheelBehavior {
 pub enum ScrollPosition {
     LineAndColumn(LineAndColumnArg),
     FocusedDiffHunk,
+    /// Scroll to a fraction of the scrollable range, in `0..=1`. Used to restore scroll position
+    /// across a markdown raw<->rendered toggle, where the documents differ and a line/column can't
+    /// map between them.
+    Fraction(f32),
 }
 
 /// We don't want to scroll to the provided line number until the content has

app/src/code/editor/view.rs

@@ -1319,6 +1319,9 @@ impl CodeEditorView {
                         ScrollPosition::FocusedDiffHunk => {
                             self.navigate_current_diff_hunk(ctx);
                         }
+                        ScrollPosition::Fraction(fraction) => {
+                            self.scroll_to_fraction(fraction, ctx);
+                        }
                     }
                 }
                 ctx.emit(CodeEditorEvent::ViewportUpdated);
@@ -1600,6 +1603,23 @@ impl CodeEditorView {
         self.model.as_ref(ctx).render_state().as_ref(ctx).height()
     }
 
+    /// The current vertical scroll position as a fraction of the scrollable range, in `0..=1`.
+    pub fn scroll_fraction(&self, ctx: &AppContext) -> f32 {
+        self.model
+            .as_ref(ctx)
+            .render_state()
+            .as_ref(ctx)
+            .scroll_fraction()
+    }
+
+    fn scroll_to_fraction(&self, fraction: f32, ctx: &mut ViewContext<Self>) {
+        self.model.update(ctx, |model, ctx| {
+            model.render_state().update(ctx, |render_state, _ctx| {
+                render_state.scroll_to_fraction(fraction);
+            });
+        });
+    }
+
     pub fn interaction_state(&self, ctx: &AppContext) -> InteractionState {
         self.model.as_ref(ctx).interaction_state()
     }

app/src/code/local_code_editor.rs

@@ -1918,6 +1918,11 @@ impl LocalCodeEditorView {
         &self.editor
     }
 
+    /// The current vertical scroll position as a fraction of the scrollable range, in `0..=1`.
+    pub fn scroll_fraction(&self, ctx: &AppContext) -> f32 {
+        self.editor.as_ref(ctx).scroll_fraction(ctx)
+    }
+
     /// Accept the diff that is currently in the editor. For local files, this can only be called after the file contents
     /// have been loaded into the editor.
     /// If it is a local file, the diff content will be retrieved and the pending diff will be marked as completed.

app/src/code/view.rs

@@ -265,11 +265,18 @@ impl CodeView {
     pub fn new(
         source: CodeSource,
         line_col: Option<LineAndColumnArg>,
+        scroll_fraction: Option<f32>,
         ctx: &mut ViewContext<Self>,
     ) -> Self {
         let location = source.location();
         let mut view = Self::new_internal(source, ctx);
         view.open_or_focus_existing(location, line_col, ctx);
+        // Restore scroll captured before a markdown rendered->raw toggle, overriding the default
+        // top-of-file scroll. The rendered and raw documents differ, so a fraction is used rather
+        // than a line/column.
+        if let Some(fraction) = scroll_fraction {
+            view.set_pending_scroll_fraction(fraction, ctx);
+        }
         #[cfg(feature = "local_fs")]
         {
             view.update_markdown_mode_segmented_control(ctx);
@@ -781,6 +788,22 @@ impl CodeView {
         });
     }
 
+    fn set_pending_scroll_fraction(&self, fraction: f32, ctx: &mut ViewContext<Self>) {
+        let Some(tab) = self.tab_group.get(self.active_tab_index) else {
+            return;
+        };
+        tab.editor_view.update(ctx, |editor, ctx| {
+            editor.set_pending_scroll(ScrollPosition::Fraction(fraction), ctx);
+        });
+    }
+
+    /// The current vertical scroll fraction of the active tab's editor, in `0..=1`.
+    #[cfg(feature = "local_fs")]
+    fn scroll_fraction(&self, ctx: &AppContext) -> Option<f32> {
+        let tab = self.tab_group.get(self.active_tab_index)?;
+        Some(tab.editor_view.as_ref(ctx).scroll_fraction(ctx))
+    }
+
     fn open_new_tab(
         &mut self,
         location: Option<LocalOrRemotePath>,
@@ -1296,7 +1319,7 @@ impl CodeView {
                 range_end: None,
             };
             self.remove_tab_data_index(index, ctx);
-            CodePane::new(source, None, ctx)
+            CodePane::new(source, None, None, ctx)
         })
     }
 
@@ -2345,6 +2368,8 @@ impl TypedActionView for CodeView {
 
                 if let Some(lor_path) = lor_path {
                     let source = self.source.clone();
+                    let scroll_fraction =
+                        self.scroll_fraction(ctx).map(ordered_float::OrderedFloat);
                     if self.active_tab_has_unsaved_changes(ctx) {
                         self.save_local(
                             self.active_tab_index,
@@ -2353,6 +2378,7 @@ impl TypedActionView for CodeView {
                                     ctx.emit(CodeViewEvent::Pane(PaneEvent::ReplaceWithFilePane {
                                         path: lor_path.clone(),
                                         source: Some(source.clone()),
+                                        scroll_fraction,
                                     }));
                                 }
                             })),
@@ -2362,6 +2388,7 @@ impl TypedActionView for CodeView {
                         ctx.emit(CodeViewEvent::Pane(PaneEvent::ReplaceWithFilePane {
                             path: lor_path,
                             source: Some(source),
+                            scroll_fraction,
                         }));
                     }
                 }

app/src/notebooks/file/mod.rs

@@ -103,6 +103,9 @@ pub struct FileNotebookView {
     code_source: Option<CodeSource>,
     /// Persistent hover state for the header title tooltip.
     header_title_mouse_state: MouseStateHandle,
+    /// Vertical scroll fraction (`0..=1`) to restore once the file content is first loaded,
+    /// captured before a markdown raw->rendered toggle. Consumed on the first `set_content`.
+    pending_scroll_fraction: Option<f32>,
 }
 
 #[derive(Debug, Clone)]
@@ -304,6 +307,7 @@ impl FileNotebookView {
             #[cfg(feature = "local_fs")]
             code_source: None,
             header_title_mouse_state: Default::default(),
+            pending_scroll_fraction: None,
         }
     }
 
@@ -314,6 +318,26 @@ impl FileNotebookView {
         self.code_source = source;
     }
 
+    /// Set the scroll fraction to restore once the file content is first loaded. Used to preserve
+    /// scroll position when toggling markdown from raw to rendered.
+    pub fn set_pending_scroll_fraction(&mut self, scroll_fraction: Option<f32>) {
+        self.pending_scroll_fraction = scroll_fraction;
+    }
+
+    /// The current vertical scroll fraction of the rendered editor, in `0..=1`.
+    #[cfg(feature = "local_fs")]
+    fn scroll_fraction(&self, ctx: &AppContext) -> Option<f32> {
+        Some(
+            self.editor
+                .as_ref(ctx)
+                .model()
+                .as_ref(ctx)
+                .render_state()
+                .as_ref(ctx)
+                .scroll_fraction(),
+        )
+    }
+
     pub fn title(&self) -> String {
         // Prefer the location name that's been resolved against a Session, but if that's not
         // available yet, fall back to the raw file path.
@@ -339,15 +363,23 @@ impl FileNotebookView {
         let doc_path = self.file_state.local_path().map(|p| p.to_path_buf());
         let render_as_ipynb =
             FeatureFlag::JupyterNotebookRendering.is_enabled() && self.is_jupyter_notebook_file();
+        let scroll_fraction = self.pending_scroll_fraction.take();
         self.editor.update(ctx, |editor, ctx| {
             if render_as_ipynb {
                 editor.reset_with_ipynb(content, ctx);
             } else {
                 editor.reset_with_markdown(content, ctx);
             }
-            // Set the document path for resolving relative image paths
             editor.model().update(ctx, |model, ctx| {
+                // Set the document path for resolving relative image paths
                 model.set_document_path(doc_path, ctx);
+                // Restore scroll captured before a raw->rendered toggle. Deferred through the
+                // layout pipeline so it applies after the new content is laid out.
+                if let Some(fraction) = scroll_fraction {
+                    model.render_state().update(ctx, |render_state, _ctx| {
+                        render_state.scroll_to_fraction(fraction);
+                    });
+                }
             });
         });
     }
@@ -687,10 +719,12 @@ impl FileNotebookView {
     #[cfg(feature = "local_fs")]
     fn open_as_code(&mut self, ctx: &mut ViewContext<Self>) {
         if let Some(path) = self.file_state.path().cloned() {
+            let scroll_fraction = self.scroll_fraction(ctx).map(ordered_float::OrderedFloat);
             // Emit an event to the pane group to handle the replacement
             ctx.emit(FileNotebookEvent::Pane(PaneEvent::ReplaceWithCodePane {
                 path,
                 source: self.code_source.clone(),
+                scroll_fraction,
             }));
         }
     }
@@ -1067,9 +1101,12 @@ impl TypedActionView for FileNotebookView {
                     });
                 } else if let Some(path) = self.file_state.path().cloned() {
                     // For remote files, open as a code editor pane.
+                    let scroll_fraction =
+                        self.scroll_fraction(ctx).map(ordered_float::OrderedFloat);
                     ctx.emit(FileNotebookEvent::Pane(PaneEvent::ReplaceWithCodePane {
                         path,
                         source: None,
+                        scroll_fraction,
                     }));
                 }
             }
@@ -1099,9 +1136,12 @@ impl TypedActionView for FileNotebookView {
                         #[cfg(feature = "local_fs")]
                         {
                             if let Some(path) = self.file_state.path().cloned() {
+                                let scroll_fraction =
+                                    self.scroll_fraction(ctx).map(ordered_float::OrderedFloat);
                                 ctx.emit(FileNotebookEvent::Pane(PaneEvent::ReplaceWithCodePane {
                                     path,
                                     source: self.code_source.clone(),
+                                    scroll_fraction,
                                 }));
                             }
                         }

app/src/pane_group/mod.rs

@@ -1755,6 +1755,7 @@ impl PaneGroup {
                         None,
                         #[cfg(feature = "local_fs")]
                         None,
+                        None,
                         ctx,
                     )),
                 };
@@ -5004,6 +5005,7 @@ impl PaneGroup {
         file_pane_id: PaneId,
         path: LocalOrRemotePath,
         source: Option<crate::code::editor_management::CodeSource>,
+        scroll_fraction: Option<f32>,
         ctx: &mut ViewContext<Self>,
     ) {
         use crate::code::editor_management::CodeSource;
@@ -5012,7 +5014,7 @@ impl PaneGroup {
         // Use the provided source if available, or construct from the path.
         let source = source.unwrap_or(CodeSource::FileTree { location: path });
 
-        let code_pane = CodePane::new(source, None, ctx);
+        let code_pane = CodePane::new(source, None, scroll_fraction, ctx);
         let success = self.replace_pane(file_pane_id, code_pane, false, ctx);
 
         if !success {
@@ -5029,6 +5031,7 @@ impl PaneGroup {
         code_pane_id: PaneId,
         path: LocalOrRemotePath,
         source: Option<crate::code::editor_management::CodeSource>,
+        scroll_fraction: Option<f32>,
         ctx: &mut ViewContext<Self>,
     ) {
         // Get the active session to pass to the FilePane, if any
@@ -5044,7 +5047,7 @@ impl PaneGroup {
             }
         });
 
-        let file_pane = FilePane::new(Some(path), session, source, ctx);
+        let file_pane = FilePane::new(Some(path), session, source, scroll_fraction, ctx);
         let success = self.replace_pane(code_pane_id, file_pane, false, ctx);
 
         if !success {
@@ -5099,12 +5102,32 @@ impl PaneGroup {
             }
             PaneEvent::ClearHoveredTabIndex => ctx.emit(Event::ClearHoveredTabIndex),
             #[cfg(feature = "local_fs")]
-            PaneEvent::ReplaceWithCodePane { path, source } => {
-                self.replace_file_pane_with_code_pane(pane_id, path.clone(), source.clone(), ctx);
+            PaneEvent::ReplaceWithCodePane {
+                path,
+                source,
+                scroll_fraction,
+            } => {
+                self.replace_file_pane_with_code_pane(
+                    pane_id,
+                    path.clone(),
+                    source.clone(),
+                    (*scroll_fraction).map(|f| f.into_inner()),
+                    ctx,
+                );
             }
             #[cfg(feature = "local_fs")]
-            PaneEvent::ReplaceWithFilePane { path, source } => {
-                self.replace_code_pane_with_file_pane(pane_id, path.clone(), source.clone(), ctx);
+            PaneEvent::ReplaceWithFilePane {
+                path,
+                source,
+                scroll_fraction,
+            } => {
+                self.replace_code_pane_with_file_pane(
+                    pane_id,
+                    path.clone(),
+                    source.clone(),
+                    (*scroll_fraction).map(|f| f.into_inner()),
+                    ctx,
+                );
             }
             PaneEvent::RepoChanged => {
                 ctx.emit(Event::RepoChanged);

app/src/pane_group/pane/code_pane.rs

@@ -33,9 +33,12 @@ impl CodePane {
     pub fn new<V: View>(
         source: CodeSource,
         line_col: Option<LineAndColumnArg>,
+        scroll_fraction: Option<f32>,
         ctx: &mut ViewContext<V>,
     ) -> Self {
-        let view = ctx.add_typed_action_view(move |ctx| CodeView::new(source, line_col, ctx));
+        let view = ctx.add_typed_action_view(move |ctx| {
+            CodeView::new(source, line_col, scroll_fraction, ctx)
+        });
         Self::from_view(view, ctx)
     }
 

app/src/pane_group/pane/file_pane.rs

@@ -44,12 +44,14 @@ impl FilePane {
         path: Option<LocalOrRemotePath>,
         target_session: Option<Arc<Session>>,
         #[cfg(feature = "local_fs")] code_source: Option<CodeSource>,
+        scroll_fraction: Option<f32>,
         ctx: &mut ViewContext<V>,
     ) -> Self {
         let view = ctx.add_typed_action_view(move |ctx| {
             let mut view = FileNotebookView::new(ctx);
             #[cfg(feature = "local_fs")]
             view.set_code_source(code_source);
+            view.set_pending_scroll_fraction(scroll_fraction);
 
             if let Some(path) = path {
                 view.open(path, target_session, ctx);

app/src/pane_group/pane/mod.rs

@@ -1128,10 +1128,18 @@ pub enum PaneEvent {
     ReplaceWithCodePane {
         path: LocalOrRemotePath,
         source: Option<crate::code::editor_management::CodeSource>,
+        /// Vertical scroll fraction (`0..=1`) captured from the outgoing pane, to restore on the
+        /// new pane. `None` scrolls to the top. Wrapped in `OrderedFloat` so `PaneEvent` can
+        /// still derive `Eq`.
+        scroll_fraction: Option<ordered_float::OrderedFloat<f32>>,
     },
     #[cfg(feature = "local_fs")]
     ReplaceWithFilePane {
         path: LocalOrRemotePath,
         source: Option<crate::code::editor_management::CodeSource>,
+        /// Vertical scroll fraction (`0..=1`) captured from the outgoing pane, to restore on the
+        /// new pane. `None` scrolls to the top. Wrapped in `OrderedFloat` so `PaneEvent` can
+        /// still derive `Eq`.
+        scroll_fraction: Option<ordered_float::OrderedFloat<f32>>,
     },
 }

app/src/workspace/home.rs

@@ -25,6 +25,7 @@ pub fn create_home_pane(ctx: &mut ViewContext<Workspace>) -> Box<dyn AnyPaneCont
         None,
         #[cfg(feature = "local_fs")]
         None,
+        None,
         ctx,
     );
     pane.file_view(ctx).update(ctx, |pane, ctx| {