added assertion for saving room panel

Author: alanpoon

src/app.rs

@@ -371,14 +371,21 @@ impl AppMain for App {
         }
         if let Event::WindowClosed(_) | Event::Shutdown = event {
             if let Some(window_geom) = &self.app_state.window_geom {
-                if let Err(e) = save_window_state(window_geom) {
-                    log!("Bug! Failed to save window_state: {}", e);
-                }
+                let window_geom = window_geom.clone();
+                cx.spawn_thread(move || {
+                    if let Err(e) = save_window_state(window_geom) {
+                        error!("Bug! Failed to save window_state: {}", e);
+                    }
+                });
             }
             if let Some(user_id) = current_user_id(){
-                if let Err(e) = save_room_panel(&self.app_state.rooms_panel, &user_id) {
-                    log!("Bug! Failed to save room panel: {}", e);
-                }
+                let rooms_panel = self.app_state.rooms_panel.clone();
+                let user_id = user_id.clone();
+                cx.spawn_thread(move || {
+                    if let Err(e) = save_room_panel(rooms_panel, user_id) {
+                        error!("Bug! Failed to save room panel: {}", e);
+                    }
+                });
             }
         }
         // Forward events to the MatchEvent trait implementation.
@@ -491,11 +498,6 @@ pub enum RoomsPanelRestoreAction {
     /// and is now ready to be restored to the dock UI widget.
     /// This will be handled by the top-level App and by each RoomScreen in the dock.
     Restore(RoomsPanelState),
-    /// The given room has not yet been loaded from the homeserver
-    /// and is waiting to be known by our client so that it can be displayed.
-    /// Each RoomScreen widget will handle and update its own status
-    /// to be pending, and should thus display a loading spinner / notice.
-    Pending(OwnedRoomId),
     /// The given room was successfully loaded from the homeserver
     /// and is known to our client.
     /// The RoomScreen for this room can now fully display the room's timeline.

src/home/main_desktop_ui.rs

@@ -84,7 +84,6 @@ pub struct MainDesktopUI {
 
 impl Widget for MainDesktopUI {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
-
         let dock = self.view.dock(id!(dock));
         if let Event::Actions(actions) = event {
             for action in actions {
@@ -94,24 +93,23 @@ impl Widget for MainDesktopUI {
                         self.room_order = app_state.rooms_panel.room_order.clone();
                         self.most_recently_selected_room = app_state.rooms_panel.selected_room.clone();
                         self.open_rooms = HashMap::with_capacity(app_state.rooms_panel.open_rooms.len());
-                        for (k, v) in app_state.rooms_panel.open_rooms.iter() {
-                            self.open_rooms.insert(LiveId(*k), v.clone());
-                        }
                         if app_state.rooms_panel.dock_state.is_empty() {
                             return;
                         }
 
                         if let Some(mut dock) = dock.borrow_mut() {
                             dock.load_state(cx, app_state.rooms_panel.dock_state.clone());
-                            dock.items().iter().for_each(|(head_liveid, (_, widget))| {
+                            dock.items().iter().for_each(|(tab_id, (_, widget))| {
                                 if let Some(room) =
-                                    app_state.rooms_panel.open_rooms.get(&head_liveid.0)
+                                    app_state.rooms_panel.open_rooms.get(&tab_id.0)
                                 {
                                     widget.as_room_screen().set_displayed_room(
                                         cx,
                                         room.room_id.clone(),
                                         room.room_name.clone().unwrap_or_default(),
                                     );
+                                    // Open rooms should not contain rooms that are not in the dock.
+                                    self.open_rooms.insert(LiveId(tab_id.0), room.clone());
                                 }
                             });
                         } else {
@@ -337,11 +335,11 @@ impl MatchEvent for MainDesktopUI {
 /// or one of the RoomScreen widgets.
 #[derive(Clone, DefaultNone, Debug)]
 pub enum RoomsPanelAction {
+    None,
     /// Notifies that a room was focused.
     RoomFocused(SelectedRoom),
     /// Resets the focus to none, meaning that no room has focus.
     FocusNone,
-    None,
 }
 
 /// Actions related to saving/restoring the UI state of the dock widget.

src/home/room_screen.rs

@@ -1052,18 +1052,14 @@ impl Widget for RoomScreen {
 
             for action in actions {
                 // Handle actions related to restoring the previously-saved state of rooms.
-                match action.downcast_ref() {
-                    Some(RoomsPanelRestoreAction::Success(room_id)) => {
-                        if self.room_id.as_ref().is_some_and(|r| r == room_id) {                            
-                            // Reset room_id before displaying room.
-                            self.room_id = None;
-                            self.set_displayed_room(cx, room_id.clone(), self.room_name.clone());
-                            self.view
-                                .label(id!(restore_status_label)).set_text(cx, "");
-                            return;
-                        }
+                if let Some(RoomsPanelRestoreAction::Success(room_id)) = action.downcast_ref() {
+                    if self.room_id.as_ref().is_some_and(|r| r == room_id) {                            
+                        // Reset room_id before displaying room.
+                        self.room_id = None;
+                        self.set_displayed_room(cx, room_id.clone(), self.room_name.clone());
+                        self.view.label(id!(restore_status_label)).set_text(cx, "");
+                        return;
                     }
-                    _ => {}
                 }
                 // Handle the highlight animation.
                 let Some(tl) = self.tl_state.as_mut() else { continue };

src/home/rooms_list.rs

@@ -251,13 +251,18 @@ pub struct RoomsList {
 }
 
 impl RoomsList {
+
     /// Determines if all known rooms have been loaded.
     ///
-    /// Returns `true` if the number of rooms in `all_rooms` equals or exceeds
+    /// Returns `true` if the number of rooms in `all_joined_rooms` and `invited_rooms` equals or exceeds
     /// `max_known_rooms`, or `false` if `max_known_rooms` is `None`.
-
-    fn all_known_rooms_loaded(&self) -> bool {
-        self.max_known_rooms.map_or(false, |max_rooms| self.all_rooms.len() >= max_rooms as usize)
+    pub fn all_known_rooms_loaded(&self) -> bool {
+        self.max_known_rooms.is_some_and(|max_rooms| self.all_joined_rooms.len() + self.invited_rooms.len() >= max_rooms as usize)
+    }
+    /// Returns `true` if the given `room_id` is already in the `all_joined_rooms` and `invited_rooms` lists.
+    /// and `false` if it is not.
+    pub fn is_room_loaded(&self, room_id: &OwnedRoomId) -> bool {
+        self.all_joined_rooms.contains_key(room_id) || self.invited_rooms.contains_key(room_id)
     }
     /// Handle all pending updates to the list of all rooms.
     fn handle_rooms_list_updates(&mut self, cx: &mut Cx, _event: &Event, _scope: &mut Scope) {
@@ -662,57 +667,6 @@ impl Widget for RoomsList {
 
 }
 
-impl WidgetMatchEvent for RoomsList {
-    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, _scope: &mut Scope) {
-        for action in actions {
-            if let RoomsViewAction::Search(keywords) = action.as_widget_action().cast() {
-                let portal_list = self.view.portal_list(id!(list));
-                if keywords.is_empty() {
-                    // Reset the displayed rooms list to show all rooms.
-                    self.display_filter = RoomDisplayFilter::default();
-                    self.displayed_rooms = self.all_rooms.keys().cloned().collect();
-                    self.update_status_rooms_count();
-                    portal_list.set_first_id_and_scroll(0, 0.0);
-                    self.redraw(cx);
-                    return;
-                }
-
-                let (filter, sort_fn) = RoomDisplayFilterBuilder::new()
-                    .set_keywords(keywords.clone())
-                    .set_filter_criteria(RoomFilterCriteria::All)
-                    .build();
-                self.display_filter = filter;
-
-                let new_displayed_rooms = if let Some(sort_fn) = sort_fn {
-                    let mut filtered_rooms: Vec<_> = self.all_rooms
-                        .iter()
-                        .filter(|(_, room)| (self.display_filter)(room))
-                        .collect();
-
-                    filtered_rooms.sort_by(|(_, room_a), (_, room_b)| sort_fn(room_a, room_b));
-
-                    filtered_rooms
-                        .into_iter()
-                        .map(|(room_id, _)| room_id.clone())
-                        .collect()
-                } else {
-                    self.all_rooms
-                        .iter()
-                        .filter(|(_, room)| (self.display_filter)(room))
-                        .map(|(room_id, _)| room_id.clone())
-                        .collect()
-                };
-
-                // Update the displayed rooms list and redraw it.
-                self.displayed_rooms = new_displayed_rooms;
-                self.update_status_matching_rooms();
-                portal_list.set_first_id_and_scroll(0, 0.0);
-                self.redraw(cx);
-            }
-        }
-    }
-}
-
 impl RoomsListRef {
     /// See [`RoomsList::all_known_rooms_loaded()`].
     pub fn all_known_rooms_loaded(

src/persistent_state.rs

@@ -195,22 +195,25 @@ pub async fn save_session(
 
 /// Save the current display state of the room panel to persistent storage.
 pub fn save_room_panel(
-    rooms_panel_state: &RoomsPanelState,
-    user_id: &UserId,
+    rooms_panel_state: RoomsPanelState,
+    user_id: OwnedUserId,
 ) -> anyhow::Result<()> {
     std::fs::write(
-        persistent_state_dir(user_id).join(LATEST_DOCK_STATE_FILE_NAME),
+        persistent_state_dir(&user_id).join(LATEST_DOCK_STATE_FILE_NAME),
         rooms_panel_state.dock_state.serialize_ron(),
     )?;
+    for (tab_id, room) in &rooms_panel_state.open_rooms {
+        assert!(rooms_panel_state.dock_state.contains_key(&LiveId(*tab_id)), "Open room id: {} not found in dock state", &room.room_id);
+    }
     std::fs::write(
-        persistent_state_dir(user_id).join(ROOMS_PANEL_STATE_FILE_NAME),
+        persistent_state_dir(&user_id).join(ROOMS_PANEL_STATE_FILE_NAME),
         serde_json::to_string(&rooms_panel_state)?,
     )?;
     Ok(())
 }
 
 /// Save the current state of window geometry state to persistent storage.
-pub fn save_window_state(window_geom: &WindowGeom) -> anyhow::Result<()> {
+pub fn save_window_state(window_geom: WindowGeom) -> anyhow::Result<()> {
     let window_geom_state = WindowGeomState {
         window_is_fullscreen: window_geom.is_fullscreen,
         window_position: crate::utils::DVec2Wrapper(window_geom.position),

src/sliding_sync.rs

@@ -1796,6 +1796,11 @@ fn handle_ignore_user_list_subscriber(client: Client) {
     });
 }
 
+/// Asynchronously loads and restores the rooms panel state from persistent storage for the given user.
+/// 
+/// If the loaded state contains open rooms and dock state, it logs a message and posts an action
+/// to restore the rooms panel state in the UI. If loading fails, it enqueues a notification
+/// with the error message.
 fn handle_load_rooms_panel_state(user_id: OwnedUserId) {
     Handle::current().spawn(async move {
         match load_rooms_panel_state(&user_id).await {
@@ -1814,6 +1819,11 @@ fn handle_load_rooms_panel_state(user_id: OwnedUserId) {
     });
 }
 
+/// Asynchronously loads and restores the window geometry state from persistent storage.
+/// 
+/// If the loaded state is different from the default, it posts an action to restore
+/// the window's geometry in the UI. If loading fails, it enqueues a notification
+/// with the error message.
 fn handle_load_window_state() {
     Handle::current().spawn(async move {
         match load_window_state().await {