Integrate CC version list with UI

Author: Not-A-Normal-Robot

src/cold_clear.rs

@@ -1,12 +1,11 @@
-use std::ffi::{OsStr, OsString};
+use std::ffi::OsString;
 use std::io::Write;
-use std::fs::{self, File};
-use std::path::{PathBuf};
+use std::fs;
+use std::path::PathBuf;
 use std::collections::HashMap;
 use std::thread;
 use std::time::{Instant, Duration};
 use std::sync::{mpsc, Arc, Mutex};
-use reqwest::Url;
 use slint::SharedString;
 use slint::ComponentHandle;
 use tokio::runtime::Runtime;
@@ -498,6 +497,9 @@ pub fn unpack_cold_clear(version: &str) -> Result<(), Box<dyn std::error::Error>
 
     if let Err(_) = zip_archive {
         eprintln!("ColdClear zip archive at '{zip_path:#?}' seems to be invalid. Redownloading.");
+
+        fs::remove_file(zip_path)?;
+
         download_cold_clear(version)?;
 
         zip_archive = ZipArchive::new(&zip_file);
@@ -522,44 +524,50 @@ pub fn unpack_cold_clear(version: &str) -> Result<(), Box<dyn std::error::Error>
     return Ok(());
 }
 
-pub fn get_available_offline_versions() -> Result<Vec<String>, std::io::Error> {
-    let path = paths::get_cold_clear_download_path("")
-        .parent()?;
+pub fn get_available_offline_versions() -> Vec<String> {
+    let path = paths::get_cold_clear_download_path("");
+    let path = path
+        .parent();
+    if path.is_none() {
+        return vec![];
+    }
+    let path = path.unwrap();
 
-    let entries = fs::read_dir(path)?;
+    let entries = fs::read_dir(path);
+    if entries.is_err() {
+        return vec![];
+    }
+    let entries = entries.unwrap();
 
     let mut versions: Vec<String> = Vec::new();
 
     for entry in entries {
-        let entry = entry?;
-
+        if entry.is_err() { continue; }
+        let entry = entry.unwrap();
         let path = entry.path();
-        if !path.is_file() {
-            continue;
-        }
+        if !path.is_file() { continue; }
 
         let name = path.file_name();
-        if name.is_none() {
-            continue;
-        }
+        if name.is_none() { continue; }
         let name = name.unwrap()
-            .to_str()
-            .expect("Failed to get UTF-8 string from OsStr");
-
-        if !name.ends_with(".zip") {
-            continue;
-        }
+            .to_str();
+        if name.is_none() { continue; }
+        let name = name.unwrap();
+        if !name.ends_with(".zip") { continue; }
 
         let version = name
             .replace(".zip", "");
 
         versions.push(version);
     }
 
-    return Ok(versions);
+    return versions;
 }
 
-pub fn get_available_versions() -> Result<Vec<String>, Box<dyn std::error::Error>> {
+/// BLOCKING FUNCTION  
+/// This calls the GitHub API.  
+/// It shouldn't take *too* long, but you should wrap this in a separate thread if you can.
+pub fn get_available_online_versions() -> Result<Vec<String>, Box<dyn std::error::Error>> {
     let api_url = paths::COLD_CLEAR_RELEASES_API_URL;
 
     let response = reqwest::blocking::get(api_url)?;
@@ -585,4 +593,27 @@ pub fn get_available_versions() -> Result<Vec<String>, Box<dyn std::error::Error
     }
 
     return Ok(versions);
+}
+
+/// BLOCKING FUNCTION  
+/// This calls the GitHub API.  
+/// It shouldn't take *too* long, but you should wrap this in a separate thread if you can.
+pub fn get_available_versions() -> Vec<String> {
+    let mut versions = get_available_offline_versions();
+    let online_versions = get_available_online_versions();
+
+    if let Err(e) = online_versions {
+        eprintln!("Failed to get ColdClear online version list: {:#?}", e);
+        return versions;
+    }
+
+    let online_versions = online_versions.unwrap();
+
+    for online_version in online_versions {
+        if !versions.contains(&online_version) {
+            versions.push(online_version);
+        }
+    }
+
+    return versions;
 }

src/conf.rs

@@ -17,6 +17,7 @@ pub struct Config {
     pub game_repo_path: String,
     pub use_gui: bool,
     pub use_cold_clear: bool,
+    pub cold_clear_version: String,
 }
 
 /// [See definition for flags](crate::CliInstruction::Run::flags)
@@ -55,6 +56,7 @@ impl Config {
             game_repo_path: "".to_string(),
             use_gui: true,
             use_cold_clear: true,
+            cold_clear_version: "11.4.1".to_string(),
         }
     }
     pub fn load_from_file() -> Self {
@@ -151,6 +153,7 @@ impl From<Settings> for Config {
             game_repo_path: settings.game_repo_path.as_str().to_string(),
             use_gui: true,
             use_cold_clear: settings.use_cold_clear,
+            cold_clear_version: settings.cold_clear_version.as_str().to_string(),
         }
     }
 }
@@ -164,6 +167,7 @@ impl From<Config> for Settings {
             game_repo_path: cfg.game_repo_path.clone().into(),
             repo_initialized: cfg.repo_initialized,
             use_cold_clear: cfg.use_cold_clear,
+            cold_clear_version: cfg.cold_clear_version.clone().into(),
         }
     }
 }

src/main_window.rs

@@ -1,5 +1,6 @@
 use open as file_open;
 use copypasta::ClipboardProvider;
+use crate::cold_clear;
 use crate::dirs;
 use crate::conf::Config;
 use crate::game;
@@ -101,6 +102,16 @@ pub fn open(cfg: &Config) -> Result<MainWindow, slint::PlatformError> {
     main_window.set_versions(
         get_versions(&cfg.game_repo_path, false)
     );
+    main_window.set_cc_versions(
+        ModelRc::new(
+            VecModel::from(
+                cold_clear::get_available_offline_versions()
+                    .iter()
+                    .map(|s| SharedString::from(s))
+                    .collect::<Vec<SharedString>>()
+            )
+        )
+    );
     main_window.on_update_version_list(|include_commits| {
         get_versions(Config::load().game_repo_path.as_str(), include_commits)
     });
@@ -114,17 +125,28 @@ pub fn open(cfg: &Config) -> Result<MainWindow, slint::PlatformError> {
         return ModelRc::new(filtered);
     });
     main_window.on_apply_settings(|settings| {
-        let config = Config {
-            sandboxed: settings.sandboxed,
-            clear_temp_dir: settings.clear_temp_dir,
-            import_save_on_play: settings.import_save_on_play,
-            repo_initialized: settings.repo_initialized,
-            game_repo_path: settings.game_repo_path.as_str().to_string(),
-            use_gui: true,
-            use_cold_clear: settings.use_cold_clear,
-        };
+        let config: Config = settings.into();
         config.save();
     });
+
+    // Fetch for new CC version asynchronously
+    let main_window_weak = main_window.as_weak();
+    std::thread::spawn(move || {
+        main_window_weak.upgrade_in_event_loop(|window| {
+            window.set_cc_versions(
+                ModelRc::new(
+                    VecModel::from(
+                        cold_clear::get_available_versions()
+                            .iter()
+                            .map(|s| SharedString::from(s))
+                            .collect::<Vec<SharedString>>()
+                    )
+                )
+            )
+        })
+        .expect("Failed to upgrade weak ref in event loop while fetching CC versions");
+    });
+
     main_window.run()?;
 
     return Ok(main_window);

ui/main.slint

@@ -1,4 +1,4 @@
-import { TabWidget, Button, Switch, ScrollView, Palette, StandardButton, ProgressIndicator, LineEdit, ListView } from "std-widgets.slint";
+import { TabWidget, Button, Switch, ScrollView, Palette, StandardButton, ProgressIndicator, LineEdit, ListView, ComboBox } from "std-widgets.slint";
 import "fonts/JetBrainsMono-Bold.ttf";
 
 struct Settings {
@@ -8,6 +8,7 @@ struct Settings {
     repo_initialized: bool,
     game_repo_path: string,
     use_cold_clear: bool,
+    cold_clear_version: string,
 }
 
 component BoxedminoBanner {
@@ -52,9 +53,13 @@ export component MainWindow inherits Window {
         sandboxed: true,
         clear_temp_dir: true,
         import_save_on_play: false,
+        repo_initialized: true,
         game_repo_path: "",
+        use_cold_clear: true,
+        cold_clear_version: "11.4.1",
     };
     in property <bool> is_wayland_used: false;
+    in property <[string]> cc_versions: ["11.4.1", "11.4.2"];
     private property <[string]> matched_versions: versions;
     private property <string> selected_version: "";
     private property <string> searched_string: "";
@@ -286,25 +291,50 @@ export component MainWindow inherits Window {
                         }
                     }
                 }
-                HorizontalLayout {
-                    VerticalLayout {
-                        Text {
-                            text: "Cold Clear AI";
-                            font-size: 1.25rem;
+                VerticalLayout {
+                    spacing: 4px;
+                    HorizontalLayout {
+                        alignment: space-between;
+                        VerticalLayout {
+                            Text {
+                                text: "Cold Clear AI [WIP]";
+                                font-size: 1.25rem;
+                            }
+                            Text {
+                                text: "Import Techmino's AI library to the sandbox.";
+                                font-size: 0.96rem;
+                            }
                         }
-                        Text {
-                            text: "Import Techmino's AI library to the sandbox.";
-                            font-size: 0.96rem;
+                        Switch {
+                            checked: settings.use_cold_clear;
+                            toggled => {
+                                settings.use_cold_clear = self.checked;
+                                cc_ver_select.enabled = self.checked;
+                            }
                         }
                     }
-                    Switch {
-                        checked: settings.use_cold_clear;
-                        toggled => { settings.use_cold_clear = self.checked; }
+                    HorizontalLayout {
+                        alignment: stretch;
+                        spacing: 8px;
+                        Text {
+                            text: "Cold Clear version: ";
+                            vertical-alignment: center;
+                            font-size: 1.026rem;
+                        }
+                        cc_ver_select := ComboBox {
+                            enabled: settings.use_cold_clear;
+                            model: cc_versions;
+                            current-value: settings.cold_clear_version;
+                            selected(version) => {
+                                settings.cold_clear_version = version;
+                            }
+                        }
                     }
                 }
                 VerticalLayout {
                     padding-top: 8px;
                     Button {
+                        // TODO: Highlight Apply button when settings are changed
                         text: "Apply";
                         clicked => { apply_settings(settings); }
                     }