EpisodeView: Retain the scrollbar valignment.

hammond-gtk/src/stacks/episode.rs

@@ -5,11 +5,18 @@ use gtk::Cast;
 use failure::Error;
 use hammond_data::dbqueries::is_episodes_populated;
 use hammond_data::errors::DataError;
+use send_cell::SendCell;
 
 use app::Action;
 use views::{EmptyView, EpisodesView};
 
 use std::sync::mpsc::Sender;
+use std::sync::Mutex;
+
+lazy_static! {
+    pub static ref EPISODES_VIEW_VALIGNMENT: Mutex<Option<SendCell<gtk::Adjustment>>> =
+        Mutex::new(None);
+}
 
 #[derive(Debug, Clone)]
 pub struct EpisodeStack {
@@ -39,26 +46,18 @@ impl EpisodeStack {
             .map_err(|_| format_err!("Failed to downcast stack child to a Box."))?;
         debug!("Name: {:?}", WidgetExt::get_name(&old));
 
-        // let scrolled_window = old.get_children()
+        // Copy the vertical scrollbar adjustment from the old view.
-        //     .first()
+        save_alignment(&old)
-        //     .ok_or_else(|| format_err!("Box container has no childs."))?
+            .map_err(|err| error!("Failed to set episodes_view allignment: {}", err))
-        //     .clone()
+            .ok();
-        //     .downcast::<gtk::ScrolledWindow>()
-        //     .map_err(|_| format_err!("Failed to downcast stack child to a ScrolledWindow."))?;
-        // debug!("Name: {:?}", WidgetExt::get_name(&scrolled_window));
 
         let eps = EpisodesView::new(self.sender.clone())?;
-        // Copy the vertical scrollbar adjustment from the old view into the new one.
-        // scrolled_window
-        //     .get_vadjustment()
-        //     .map(|x| eps.set_vadjustment(&x));
 
         self.stack.remove(&old);
         self.stack.add_named(&eps.container, "episodes");
         set_stack_visible(&self.stack)?;
 
         old.destroy();
-
         Ok(())
     }
 
@@ -77,3 +76,25 @@ fn set_stack_visible(stack: &gtk::Stack) -> Result<(), DataError> {
 
     Ok(())
 }
+
+// ATTENTION: EXPECTS THE EPISODE_VIEW WIDGET CONTAINER
+fn save_alignment(old_widget: &gtk::Box) -> Result<(), Error> {
+    let scrolled_window = old_widget
+        .get_children()
+        .first()
+        .ok_or_else(|| format_err!("Box container has no childs."))?
+        .clone()
+        .downcast::<gtk::ScrolledWindow>()
+        .map_err(|_| format_err!("Failed to downcast stack child to a ScrolledWindow."))?;
+    debug!("Name: {:?}", WidgetExt::get_name(&scrolled_window));
+
+    if let Ok(mut guard) = EPISODES_VIEW_VALIGNMENT.lock() {
+        let adj = scrolled_window
+            .get_vadjustment()
+            .ok_or_else(|| format_err!("Could not get the adjustment"))?;
+        *guard = Some(SendCell::new(adj));
+        info!("Saved episodes_view alignment.");
+    }
+
+    Ok(())
+}

hammond-gtk/src/stacks/mod.rs

@@ -3,5 +3,5 @@ mod episode;
 mod show;
 
 pub use self::content::Content;
-pub use self::episode::EpisodeStack;
+pub use self::episode::{EpisodeStack, EPISODES_VIEW_VALIGNMENT};
 pub use self::show::ShowStack;

hammond-gtk/src/stacks/show.rs

@@ -16,17 +16,17 @@ use widgets::ShowWidget;
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
 
+lazy_static! {
+    static ref SHOW_WIDGET_VALIGNMENT: Mutex<Option<(i32, SendCell<gtk::Adjustment>)>> =
+        Mutex::new(None);
+}
+
 #[derive(Debug, Clone)]
 pub struct ShowStack {
     stack: gtk::Stack,
     sender: Sender<Action>,
 }
 
-lazy_static! {
-    static ref SHOW_WIDGET_VALIGNMENT: Mutex<Option<(i32, SendCell<gtk::Adjustment>)>> =
-        Mutex::new(None);
-}
-
 impl ShowStack {
     pub fn new(sender: Sender<Action>) -> Result<ShowStack, Error> {
         let stack = gtk::Stack::new();

hammond-gtk/src/views/episodes.rs

@@ -85,7 +85,7 @@ impl EpisodesView {
 
         let view = Rc::new(EpisodesView::default());
         let ignore = get_ignored_shows()?;
-        let episodes = dbqueries::get_episodes_widgets_filter_limit(&ignore, 200)?;
+        let episodes = dbqueries::get_episodes_widgets_filter_limit(&ignore, 100)?;
         let now_utc = Utc::now();
 
         let view_ = view.clone();
@@ -102,15 +102,36 @@ impl EpisodesView {
             }
         };
 
-        lazy_load_full(episodes, func, || {});
+        let view_ = view.clone();
+        let callback = move || {
+            view_
+                .set_vadjustment()
+                .map_err(|err| format!("{}", err))
+                .ok();
+        };
+
+        lazy_load_full(episodes, func, callback);
         view.container.show_all();
         Ok(view)
     }
 
     #[inline]
     /// Set scrolled window vertical adjustment.
-    pub fn set_vadjustment(&self, vadjustment: &gtk::Adjustment) {
+    fn set_vadjustment(&self) -> Result<(), Error> {
-        self.scrolled_window.set_vadjustment(vadjustment)
+        use stacks::EPISODES_VIEW_VALIGNMENT;
+
+        let guard = EPISODES_VIEW_VALIGNMENT
+            .lock()
+            .map_err(|err| format_err!("Failed to lock widget align mutex: {}", err))?;
+
+        if let Some(ref sendcell) = *guard {
+            // Copy the vertical scrollbar adjustment from the old view into the new one.
+            sendcell
+                .try_get()
+                .map(|x| self.scrolled_window.set_vadjustment(&x));
+        }
+
+        Ok(())
     }
 }