Merge thread scroll fix by kernel

kernelkind (5):
      TMP: use new egui-nav to fix scroll offset issues
      add `scroll_offset` to `NoteAction::Note`
      add `ThreadNote::set_scroll_offset`
      set scroll offset when routing to thread
      appease clippy

crates/notedeck/src/note/action.rs

@@ -24,7 +24,11 @@ pub enum NoteAction {
     Profile(Pubkey),
 
     /// User has clicked a note link
-    Note { note_id: NoteId, preview: bool },
+    Note {
+        note_id: NoteId,
+        preview: bool,
+        scroll_offset: f32,
+    },
 
     /// User has selected some context option
     Context(ContextSelection),
@@ -44,6 +48,7 @@ impl NoteAction {
         NoteAction::Note {
             note_id: id,
             preview: false,
+            scroll_offset: 0.0,
         }
     }
 }

crates/notedeck_columns/src/actionbar.rs

@@ -81,7 +81,11 @@ fn execute_note_action(
                 .open(ndb, note_cache, txn, pool, &kind)
                 .map(NotesOpenResult::Timeline);
         }
-        NoteAction::Note { note_id, preview } => 'ex: {
+        NoteAction::Note {
+            note_id,
+            preview,
+            scroll_offset,
+        } => 'ex: {
             let Ok(thread_selection) = ThreadSelection::from_note_id(ndb, note_cache, txn, note_id)
             else {
                 tracing::error!("No thread selection for {}?", hex::encode(note_id.bytes()));
@@ -89,7 +93,15 @@ fn execute_note_action(
             };
 
             timeline_res = threads
-                .open(ndb, txn, pool, &thread_selection, preview, col)
+                .open(
+                    ndb,
+                    txn,
+                    pool,
+                    &thread_selection,
+                    preview,
+                    col,
+                    scroll_offset,
+                )
                 .map(NotesOpenResult::Thread);
 
             let route = Route::Thread(thread_selection);

crates/notedeck_columns/src/timeline/thread.rs

@@ -23,6 +23,7 @@ pub struct ThreadNode {
     pub prev: ParentState,
     pub have_all_ancestors: bool,
     pub list: VirtualList,
+    pub set_scroll_offset: Option<f32>,
 }
 
 #[derive(Clone)]
@@ -132,8 +133,14 @@ impl ThreadNode {
             prev: parent,
             have_all_ancestors: false,
             list: VirtualList::new(),
+            set_scroll_offset: None,
         }
     }
+
+    pub fn with_offset(mut self, offset: f32) -> Self {
+        self.set_scroll_offset = Some(offset);
+        self
+    }
 }
 
 #[derive(Default)]
@@ -147,6 +154,7 @@ pub struct Threads {
 impl Threads {
     /// Opening a thread.
     /// Similar to [[super::cache::TimelineCache::open]]
+    #[allow(clippy::too_many_arguments)]
     pub fn open(
         &mut self,
         ndb: &mut Ndb,
@@ -155,6 +163,7 @@ impl Threads {
         thread: &ThreadSelection,
         new_scope: bool,
         col: usize,
+        scroll_offset: f32,
     ) -> Option<NewThreadNotes> {
         tracing::info!("Opening thread: {:?}", thread);
         let local_sub_filter = if let Some(selected) = &thread.selected_note {
@@ -184,7 +193,7 @@ impl Threads {
             RawEntryMut::Vacant(entry) => {
                 let id = NoteId::new(*selected_note_id);
 
-                let node = ThreadNode::new(ParentState::Unknown);
+                let node = ThreadNode::new(ParentState::Unknown).with_offset(scroll_offset);
                 entry.insert(id, node);
 
                 &local_sub_filter

crates/notedeck_columns/src/ui/thread.rs

@@ -52,17 +52,26 @@ impl<'a, 'd> ThreadView<'a, 'd> {
             .auto_shrink([false, false])
             .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysVisible);
 
-        let offset_id = scroll_id.with(("scroll_offset", self.selected_note_id));
-
-        if let Some(offset) = ui.data(|i| i.get_temp::<f32>(offset_id)) {
-            scroll_area = scroll_area.vertical_scroll_offset(offset);
+        if let Some(thread) = self.threads.threads.get_mut(&self.selected_note_id) {
+            if let Some(new_offset) = thread.set_scroll_offset.take() {
+                scroll_area = scroll_area.vertical_scroll_offset(new_offset);
+            }
         }
 
         let output = scroll_area.show(ui, |ui| self.notes(ui, &txn));
 
-        ui.data_mut(|d| d.insert_temp(offset_id, output.state.offset.y));
+        let mut resp = output.inner;
 
-        output.inner
+        if let Some(NoteAction::Note {
+            note_id: _,
+            preview: _,
+            scroll_offset,
+        }) = &mut resp
+        {
+            *scroll_offset = output.state.offset.y;
+        }
+
+        resp
     }
 
     fn notes(&mut self, ui: &mut egui::Ui, txn: &Transaction) -> Option<NoteAction> {
@@ -195,6 +204,7 @@ fn strip_note_action(action: NoteAction) -> Option<NoteAction> {
         NoteAction::Note {
             note_id: _,
             preview: false,
+            scroll_offset: _,
         }
     ) {
         return None;

crates/notedeck_ui/src/note/contents.rs

@@ -363,6 +363,7 @@ fn render_undecorated_note_contents<'a>(
                 NoteAction::Note { note_id, .. } => NoteAction::Note {
                     note_id,
                     preview: true,
+                    scroll_offset: 0.0,
                 },
                 other => other,
             })