feat: refactor tables

Author: landaire

Cargo.lock

@@ -67,6 +67,7 @@ http-body-util = "0.1.2"
 toml = "0.8.19"
 tar = "0.4.43"
 scopeguard = "1.2.0"
+egui_table = "0.2.0"
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
@@ -95,7 +96,7 @@ debug = true
 
 [patch.crates-io]
 #serde-pickle = { path = "../serde-pickle" } #git = "https://github.com/landaire/serde-pickle.git" }
-wows_replays = { path = "../wows-replays/parser" }
+# wows_replays = { path = "../wows-replays/parser" }
 # wowsunpack = { path = "../wowsunpack" }
 
 # If you want to use the bleeding edge version of egui and eframe:

Cargo.toml

@@ -1,10 +1,12 @@
+use core::cell::RefCell;
 use std::{
     borrow::Borrow,
     collections::{HashMap, HashSet},
     env,
     error::Error,
     path::{Path, PathBuf},
     process::Command,
+    rc::Rc,
     sync::{
         atomic::{AtomicBool, Ordering},
         mpsc::{self, Receiver, Sender, TryRecvError},
@@ -329,6 +331,7 @@ pub enum NotifyFileEvent {
     TempArenaInfoCreated(PathBuf),
 }
 
+#[derive(Clone)]
 pub struct TimedMessage {
     pub message: String,
     pub expiration: Instant,
@@ -419,7 +422,7 @@ pub struct TabState {
     pub markdown_cache: CommonMarkCache,
 
     #[serde(default)]
-    pub replay_sort: std::sync::Mutex<replay_parser::SortOrder>,
+    pub replay_sort: Arc<parking_lot::Mutex<replay_parser::SortOrder>>,
 
     #[serde(skip)]
     pub game_constants: Arc<RwLock<serde_json::Value>>,
@@ -435,13 +438,16 @@ pub struct TabState {
     pub mod_action_receiver: Option<Receiver<ModInfo>>,
 
     #[serde(skip)]
-    pub mod_update_receiver: Option<Receiver<BackgroundTask>>,
+    pub background_task_receiver: Receiver<BackgroundTask>,
+    #[serde(skip)]
+    pub background_task_sender: Sender<BackgroundTask>,
 }
 
 impl Default for TabState {
     fn default() -> Self {
         let default_constants = serde_json::from_str(include_str!("../embedded_resources/constants.json")).expect("failed to parse constants JSON");
         let (mod_action_sender, mod_action_receiver) = mpsc::channel();
+        let (background_task_sender, background_task_receiver) = mpsc::channel();
         Self {
             world_of_warships_data: None,
             filter: Default::default(),
@@ -472,7 +478,8 @@ impl Default for TabState {
             mod_manager_info: Default::default(),
             mod_action_sender,
             mod_action_receiver: Some(mod_action_receiver),
-            mod_update_receiver: None,
+            background_task_receiver,
+            background_task_sender,
         }
     }
 }
@@ -502,7 +509,13 @@ impl TabState {
                                             if let Some(wows_data) = self.world_of_warships_data.as_ref() {
                                                 update_background_task!(
                                                     self.background_tasks,
-                                                    load_replay(Arc::clone(&self.game_constants), Arc::clone(wows_data), replay)
+                                                    load_replay(
+                                                        Arc::clone(&self.game_constants),
+                                                        Arc::clone(wows_data),
+                                                        replay,
+                                                        Arc::clone(&self.replay_sort),
+                                                        self.background_task_sender.clone()
+                                                    )
                                                 );
                                             }
                                         }
@@ -639,7 +652,7 @@ impl TabState {
         });
 
         BackgroundTask {
-            receiver: rx,
+            receiver: rx.into(),
             kind: BackgroundTaskKind::LoadingData,
         }
     }
@@ -755,7 +768,7 @@ impl WowsToolkitApp {
 
     pub fn build_bottom_panel(&mut self, ui: &mut Ui) {
         // Try to update mod update tasks
-        if let Some(new_task) = self.tab_state.mod_update_receiver.as_ref().and_then(|rx| rx.try_recv().ok()) {
+        if let Some(new_task) = self.tab_state.background_task_receiver.try_recv().ok() {
             self.tab_state.background_tasks.push(new_task);
         }
 
@@ -807,10 +820,19 @@ impl WowsToolkitApp {
                             BackgroundTaskKind::DownloadingMod { mod_info, rx, last_progress } => {
                                 // do nothing
                             }
+                            BackgroundTaskKind::UpdateTimedMessage(timed_message) => {
+                                self.tab_state.timed_message.write().replace(timed_message.clone());
+                            }
+                            BackgroundTaskKind::OpenFileViewer(plaintext_file_viewer) => {
+                                self.tab_state.file_viewer.lock().push(plaintext_file_viewer.clone());
+                            }
                         }
 
                         match result {
                             Ok(data) => match data {
+                                BackgroundTaskCompletion::NoReceiver => {
+                                    // do nothing
+                                }
                                 BackgroundTaskCompletion::DataLoaded { new_dir, wows_data, replays } => {
                                     let replays_dir = wows_data.replays_dir.clone();
                                     if let Some(old_wows_data) = &self.tab_state.world_of_warships_data {
@@ -819,11 +841,12 @@ impl WowsToolkitApp {
                                         let wows_data = Arc::new(RwLock::new(wows_data));
                                         self.tab_state.world_of_warships_data = Some(Arc::clone(&wows_data));
 
-                                        self.tab_state.mod_update_receiver = Some(task::start_mod_manager_thread(
+                                        task::start_mod_manager_thread(
                                             Arc::clone(&self.runtime),
                                             wows_data,
                                             self.tab_state.mod_action_receiver.take().unwrap(),
-                                        ));
+                                            self.tab_state.background_task_sender.clone(),
+                                        );
                                     }
                                     self.tab_state.update_wows_dir(&new_dir, &replays_dir);
                                     self.tab_state.replay_files = replays;
@@ -1089,7 +1112,9 @@ impl WowsToolkitApp {
                         parse_replay(
                             Arc::clone(&self.tab_state.game_constants),
                             Arc::clone(wows_data),
-                            self.tab_state.settings.current_replay_path.clone()
+                            self.tab_state.settings.current_replay_path.clone(),
+                            Arc::clone(&self.tab_state.replay_sort),
+                            self.tab_state.background_task_sender.clone(),
                         )
                     );
                 }

src/app.rs

@@ -10,6 +10,7 @@ pub enum FileType {
     Image { ext: String, contents: Vec<u8> },
 }
 
+#[derive(Clone)]
 pub struct PlaintextFileViewer {
     pub title: Arc<String>,
     pub file_info: Arc<Mutex<FileType>>,

src/plaintext_viewer.rs

@@ -38,9 +38,11 @@ use wowsunpack::{
 use zip::ZipArchive;
 
 use crate::{
+    app::TimedMessage,
     build_tracker,
     error::ToolkitError,
     game_params::load_game_params,
+    plaintext_viewer::PlaintextFileViewer,
     twitch::{self, Token, TwitchState, TwitchUpdate},
     ui::{
         mod_manager::{ModInfo, ModManagerIndex},
@@ -58,7 +60,7 @@ pub struct DownloadProgress {
 }
 
 pub struct BackgroundTask {
-    pub receiver: mpsc::Receiver<Result<BackgroundTaskCompletion, ToolkitError>>,
+    pub receiver: Option<mpsc::Receiver<Result<BackgroundTaskCompletion, ToolkitError>>>,
     pub kind: BackgroundTaskKind,
 }
 
@@ -87,12 +89,18 @@ pub enum BackgroundTaskKind {
         rx: mpsc::Receiver<DownloadProgress>,
         last_progress: Option<DownloadProgress>,
     },
+    UpdateTimedMessage(TimedMessage),
+    OpenFileViewer(PlaintextFileViewer),
 }
 
 impl BackgroundTask {
     /// TODO: has a bug currently where if multiple tasks are running at the same time, the message looks a bit wonky
     pub fn build_description(&mut self, ui: &mut egui::Ui) -> Option<Result<BackgroundTaskCompletion, ToolkitError>> {
-        match self.receiver.try_recv() {
+        if self.receiver.is_none() {
+            return Some(Ok(BackgroundTaskCompletion::NoReceiver));
+        }
+
+        match self.receiver.as_ref().unwrap().try_recv() {
             Ok(result) => Some(result),
             Err(TryRecvError::Empty) => {
                 match &mut self.kind {
@@ -166,6 +174,9 @@ impl BackgroundTask {
                             ui.add(egui::ProgressBar::new(progress.downloaded as f32 / progress.total as f32).text(format!("Uninstalling {}", mod_info.meta.name())));
                         }
                     }
+                    BackgroundTaskKind::UpdateTimedMessage(_) | BackgroundTaskKind::OpenFileViewer(_) => {
+                        // do nothing
+                    }
                 }
                 None
             }
@@ -190,6 +201,7 @@ pub enum BackgroundTaskCompletion {
     ModDownloaded(ModInfo),
     ModInstalled(ModInfo),
     ModUninstalled(ModInfo),
+    NoReceiver,
 }
 
 impl std::fmt::Debug for BackgroundTaskCompletion {
@@ -209,6 +221,7 @@ impl std::fmt::Debug for BackgroundTaskCompletion {
             Self::ModDownloaded(modi) => f.debug_struct("ModDownloaded").field("0", modi).finish(),
             Self::ModInstalled(modi) => f.debug_struct("ModInstalled").field("0", modi).finish(),
             Self::ModUninstalled(modi) => f.debug_struct("ModUninstalled").field("0", modi).finish(),
+            Self::NoReceiver => f.debug_struct("NoReceiver").finish(),
         }
     }
 }
@@ -466,7 +479,7 @@ pub fn start_download_update_task(runtime: &Runtime, release: &Asset) -> Backgro
     });
 
     BackgroundTask {
-        receiver: rx,
+        receiver: rx.into(),
         kind: BackgroundTaskKind::Updating {
             rx: progress_rx,
             last_progress: None,
@@ -783,7 +796,7 @@ pub fn start_populating_player_inspector(
     });
 
     BackgroundTask {
-        receiver: rx,
+        receiver: rx.into(),
         kind: BackgroundTaskKind::PopulatePlayerInspectorFromReplays,
     }
 }
@@ -805,30 +818,30 @@ pub fn load_constants(constants: Vec<u8>) -> BackgroundTask {
     std::thread::spawn(move || {
         let result = serde_json::from_slice(&constants)
             .context("failed to deserialize constants file")
-            .map(|constants| BackgroundTaskCompletion::ConstantsLoaded(constants))
+            .map(BackgroundTaskCompletion::ConstantsLoaded)
             .map_err(|err| err.into());
 
         tx.send(result);
     });
     BackgroundTask {
-        receiver: rx,
+        receiver: rx.into(),
         kind: BackgroundTaskKind::LoadingConstants,
     }
 }
 
 pub fn load_mods_db() -> BackgroundTask {
     let (tx, rx) = mpsc::channel();
     std::thread::spawn(move || {
-        let mods_db = std::fs::read_to_string("..\\mods.toml").unwrap();
+        let mods_db = std::fs::read_to_string("../mods.toml").unwrap();
         let result = toml::from_str::<ModManagerIndex>(&mods_db)
             .context("failed to deserialize mods db")
-            .map(|constants| BackgroundTaskCompletion::ModDatabaseLoaded(constants))
+            .map(BackgroundTaskCompletion::ModDatabaseLoaded)
             .map_err(|err| err.into());
 
         tx.send(result);
     });
     BackgroundTask {
-        receiver: rx,
+        receiver: rx.into(),
         kind: BackgroundTaskKind::LoadingModDatabase,
     }
 }
@@ -975,7 +988,7 @@ fn install_mod(runtime: Arc<Runtime>, wows_data: Arc<RwLock<WorldOfWarshipsData>
     let (download_task_tx, download_task_rx) = mpsc::channel();
     let (download_progress_tx, download_progress_rx) = mpsc::channel();
     let _ = tx.send(BackgroundTask {
-        receiver: download_task_rx,
+        receiver: download_task_rx.into(),
         kind: BackgroundTaskKind::DownloadingMod {
             mod_info: mod_info.clone(),
             rx: download_progress_rx,
@@ -993,7 +1006,7 @@ fn install_mod(runtime: Arc<Runtime>, wows_data: Arc<RwLock<WorldOfWarshipsData>
             let (install_task_tx, install_task_rx) = mpsc::channel();
             let (install_progress_tx, install_progress_rx) = mpsc::channel();
             let _ = tx.send(BackgroundTask {
-                receiver: install_task_rx,
+                receiver: install_task_rx.into(),
                 kind: if mod_info.enabled {
                     BackgroundTaskKind::InstallingMod {
                         mod_info: mod_info.clone(),
@@ -1025,7 +1038,7 @@ fn uninstall_mod(runtime: Arc<Runtime>, wows_data: Arc<RwLock<WorldOfWarshipsDat
     let (uninstall_task_tx, uninstall_task_rx) = mpsc::channel();
     let (uninstall_progress_tx, uninstall_progress_rx) = mpsc::channel();
     let _ = tx.send(BackgroundTask {
-        receiver: uninstall_task_rx,
+        receiver: uninstall_task_rx.into(),
         kind: BackgroundTaskKind::UninstallingMod {
             mod_info: mod_info.clone(),
             rx: uninstall_progress_rx,
@@ -1058,22 +1071,23 @@ fn uninstall_mod(runtime: Arc<Runtime>, wows_data: Arc<RwLock<WorldOfWarshipsDat
     Ok(())
 }
 
-pub fn start_mod_manager_thread(runtime: Arc<Runtime>, wows_data: Arc<RwLock<WorldOfWarshipsData>>, receiver: mpsc::Receiver<ModInfo>) -> mpsc::Receiver<BackgroundTask> {
-    let (tx, rx) = mpsc::channel();
-
+pub fn start_mod_manager_thread(
+    runtime: Arc<Runtime>,
+    wows_data: Arc<RwLock<WorldOfWarshipsData>>,
+    receiver: mpsc::Receiver<ModInfo>,
+    background_task_sender: mpsc::Sender<BackgroundTask>,
+) {
     std::thread::spawn(move || {
-        while let Some(mod_info) = receiver.recv().ok() {
+        while let Ok(mod_info) = receiver.recv() {
             eprintln!("mod was changed: {:?}", mod_info.meta.name());
 
             if mod_info.enabled {
                 eprintln!("installing mod: {:?}", mod_info.meta.name());
-                install_mod(runtime.clone(), wows_data.clone(), mod_info.clone(), tx.clone());
+                install_mod(runtime.clone(), wows_data.clone(), mod_info.clone(), background_task_sender.clone());
             } else {
                 eprintln!("uninstalling mod: {:?}", mod_info.meta.name());
-                uninstall_mod(runtime.clone(), wows_data.clone(), mod_info.clone(), tx.clone());
+                uninstall_mod(runtime.clone(), wows_data.clone(), mod_info.clone(), background_task_sender.clone());
             }
         }
     });
-
-    rx
 }