kifu/core/src/api.rs

@@ -1,17 +1,13 @@
 use crate::{
     database::Database,
-    types::{AppState, Config, ConfigOption, GameState, LibraryPath, Player, Rank},
+    types::{AppState, Config, ConfigOption, DatabasePath, GameState, Player, Rank},
-};
+    ui::{configuration, home, playing_field, ConfigurationView, HomeView, PlayingFieldView},
-use async_std::{
-    channel::{Receiver, Sender},
-    stream,
-    task::spawn,
 };
+use async_std::channel::{Receiver, Sender};
 use serde::{Deserialize, Serialize};
 use std::{
-    future::Future,
     path::PathBuf,
-    sync::{Arc, RwLock, RwLockReadGuard},
+    sync::{Arc, RwLock},
 };
 
 pub trait Observable<T> {
@@ -66,7 +62,6 @@ impl From<HotseatPlayerRequest> for Player {
     }
 }
 
-/*
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum CoreResponse {
     ConfigurationView(ConfigurationView),
@@ -74,55 +69,34 @@ pub enum CoreResponse {
     PlayingFieldView(PlayingFieldView),
     UpdatedConfigurationView(ConfigurationView),
 }
-*/
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum CoreNotification {
-    ConfigurationUpdated(Config),
     BoardUpdated,
 }
 
 #[derive(Clone, Debug)]
 pub struct Core {
-    config: Arc<RwLock<Config>>,
+    // config: Arc<RwLock<Config>>,
     // state: Arc<RwLock<AppState>>,
-    library: Arc<RwLock<Option<Database>>>,
+    database: Arc<RwLock<Option<Database>>>,
     subscribers: Arc<RwLock<Vec<Sender<CoreNotification>>>>,
 }
 
 impl Core {
-    pub fn new(config: Config) -> Self {
+    pub fn new(_config: Config) -> Self {
+        // let config = Config::from_path(config_path).expect("configuration to open");
+
+        // let state = Arc::new(RwLock::new(AppState::new(db_path)));
+
         Self {
-            config: Arc::new(RwLock::new(config)),
+            // config: Arc::new(RwLock::new(config)),
             // state,
-            library: Arc::new(RwLock::new(None)),
+            database: Arc::new(RwLock::new(None)),
             subscribers: Arc::new(RwLock::new(vec![])),
         }
     }
 
-    pub fn get_config(&self) -> Config {
-        self.config.read().unwrap().clone()
-    }
-
-    /// Change the configuration of the Core. This function will update any relevant core
-    /// functions, especially the contents of the library, and it will notify any subscribed objects
-    /// that the configuration has changed.
-    ///
-    /// It will not handle persisting the new configuration, as the backing store for the
-    /// configuration is not a decision for the core library.
-    pub async fn set_config(&self, config: Config) {
-        *self.config.write().unwrap() = config.clone();
-        let subscribers = self.subscribers.read().unwrap().clone();
-        for subscriber in subscribers {
-            let subscriber = subscriber.clone();
-            let _ = subscriber.send(CoreNotification::ConfigurationUpdated(config.clone())).await;
-        }
-    }
-
-    pub fn library<'a>(&'a self) -> RwLockReadGuard<'_, Option<Database>> {
-        self.library.read().unwrap()
-    }
-
     /*
     pub async fn dispatch(&self, request: CoreRequest) -> CoreResponse {
         match request {

kifu/core/src/lib.rs

@@ -1,7 +1,10 @@
 extern crate config_derive;
 
 mod api;
-pub use api::{Core, CoreNotification, Observable};
+pub use api::{
+    ChangeSettingRequest, Core, CoreNotification, CoreRequest, CoreResponse, CreateGameRequest,
+    HotseatPlayerRequest, Observable, PlayerInfoRequest,
+};
 
 mod board;
 pub use board::*;
@@ -9,5 +12,6 @@ pub use board::*;
 mod database;
 
 mod types;
-pub use types::{BoardError, Color, Config, ConfigOption, LibraryPath, Player, Rank, Size};
+pub use types::{BoardError, Color, Config, ConfigOption, DatabasePath, Player, Rank, Size};
 
+pub mod ui;

kifu/core/src/types.rs

@@ -10,21 +10,21 @@ use std::{path::PathBuf, time::Duration};
 use thiserror::Error;
 
 define_config! {
-    LibraryPath(LibraryPath),
+    DatabasePath(DatabasePath),
     Me(Me),
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, ConfigOption)]
-pub struct LibraryPath(pub PathBuf);
+pub struct DatabasePath(pub PathBuf);
 
-impl std::ops::Deref for LibraryPath {
+impl std::ops::Deref for DatabasePath {
     type Target = PathBuf;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl From<String> for LibraryPath {
+impl From<String> for DatabasePath {
     fn from(s: String) -> Self {
         Self(PathBuf::from(s))
     }
@@ -78,7 +78,7 @@ pub struct AppState {
 }
 
 impl AppState {
-    pub fn new(database_path: LibraryPath) -> Self {
+    pub fn new(database_path: DatabasePath) -> Self {
         Self {
             game: Some(GameState::default()),
             database: Database::open_path(database_path.to_path_buf()).unwrap(),

kifu/core/src/ui/configuration.rs

@@ -0,0 +1,22 @@
+use crate::{
+    types::{Config, DatabasePath},
+    ui::Field,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ConfigurationView {
+    pub library: Field<()>,
+}
+
+pub fn configuration(config: &Config) -> ConfigurationView {
+    let path: Option<DatabasePath> = config.get();
+    ConfigurationView {
+        library: Field {
+            id: "library-path-field".to_owned(),
+            label: "Library".to_owned(),
+            value: path.map(|path| path.to_string_lossy().into_owned()),
+            action: (),
+        },
+    }
+}

kifu/gtk/Cargo.toml

@@ -9,13 +9,13 @@ screenplay = []
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-adw             = { version = "0.5", package = "libadwaita", features = [ "v1_4" ] }
+adw             = { version = "0.5", package = "libadwaita", features = [ "v1_2" ] }
 async-channel   = { version = "2" }
 async-std       = { version = "1" }
 cairo-rs        = { version = "0.18" }
 gio             = { version = "0.18" }
 glib            = { version = "0.18" }
-gtk             = { version = "0.7", package = "gtk4", features = [ "v4_10" ] }
+gtk             = { version = "0.7", package = "gtk4", features = [ "v4_8" ] }
 image           = { version = "0.24" }
 kifu-core       = { path = "../core" }
 pango           = { version = "*" }

kifu/gtk/resources/com.luminescent-dreams.kifu.dev.gschema.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <schemalist>
     <schema id="com.luminescent-dreams.kifu-gtk.dev" path="/com/luminescent-dreams/kifu-gtk/dev/">
-        <key name="library-path" type="s">
+        <key name="database-path" type="s">
             <default>""</default>
             <summary>Path to the directory of games</summary>
         </key>

kifu/gtk/resources/com.luminescent-dreams.kifu.gschema.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <schemalist>
     <schema id="com.luminescent-dreams.kifu-gtk" path="/com/luminescent-dreams/kifu-gtk/">
-        <key name="library-path" type="s">
+        <key name="database-path" type="s">
             <default>""</default>
             <summary>Path to the directory of games</summary>
         </key>

kifu/gtk/resources/style.css

@@ -1,17 +1,3 @@
 .content {
     padding: 8px;
 }
-
-.settings-view {
-    margin: 8px;
-    padding: 4px;
-    background-color: @view_bg_color;
-}
-
-.settings-view {
-    padding: 8px;
-}
-
-.preference-item > suffixes {
-    margin: 4px;
-}

kifu/gtk/src/app_window.rs

@@ -1,175 +0,0 @@
-/*
-Copyright 2024, Savanni D'Gerinel <savanni@luminescent-dreams.com>
-
-This file is part of Kifu.
-
-Kifu is free software: you can redistribute it and/or modify it under the terms of the GNU
-General Public License as published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-Kifu is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with Kifu. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-use adw::prelude::*;
-/*
-use gio::resources_lookup_data;
-use glib::IsA;
-use gtk::STYLE_PROVIDER_PRIORITY_USER;
-*/
-use kifu_core::{Config, Core};
-use std::sync::{Arc, RwLock};
-
-use crate::{view_models::HomeViewModel, view_models::SettingsViewModel};
-
-#[derive(Clone)]
-enum AppView {
-    Settings(SettingsViewModel),
-    Home(HomeViewModel),
-}
-
-// An application window should generally contain
-// - an overlay widget
-// - the main content in a stack on the bottom panel of the overlay
-// - the settings and the about page in bins atop the overlay
-#[derive(Clone)]
-pub struct AppWindow {
-    pub window: adw::ApplicationWindow,
-    header: adw::HeaderBar,
-
-    // content is a stack which contains the view models for the application. These are the main
-    // elements that users want to interact with: the home page, the game library, a review, a game
-    // itself, perhaps also chat rooms and player lists on other networks. stack contains the
-    // widgets that need to be rendered. The two of these work together in order to ensure that
-    // we can maintain the state of previous views. Since the two of these work together, they are
-    // a candidate for extraction into a new widget or a new struct.
-    stack: adw::NavigationView,
-    content: Vec<AppView>,
-
-    // Overlays are for transient content, such as about and settings, which can be accessed from
-    // anywhere but shouldn't be part of the main application flow.
-    panel_overlay: gtk::Overlay,
-    core: Core,
-
-    // Not liking this, but I have to keep track of the settings view model separately from
-    // anything else. I'll have to look into this later.
-    settings_view_model: Arc<RwLock<Option<SettingsViewModel>>>,
-}
-
-impl AppWindow {
-    pub fn new(app: &adw::Application, core: Core) -> Self {
-        let window = Self::setup_window(app);
-        let header = Self::setup_header();
-        let panel_overlay = Self::setup_panel_overlay();
-        let (stack, content) = Self::setup_content(core.clone());
-
-        let layout = gtk::Box::builder()
-            .orientation(gtk::Orientation::Vertical)
-            .build();
-        layout.append(&header);
-        layout.append(&panel_overlay);
-        panel_overlay.set_child(Some(&stack));
-
-        window.set_content(Some(&layout));
-
-        Self {
-            window,
-            header,
-            stack,
-            content,
-            panel_overlay,
-            core,
-            settings_view_model: Default::default(),
-        }
-    }
-
-    pub fn open_settings(&self) {
-        let view_model = SettingsViewModel::new(&self.window, self.core.clone(), {
-            let s = self.clone();
-            move || {
-                s.close_overlay();
-            }
-        });
-        self.panel_overlay.add_overlay(&view_model.widget);
-        *self.settings_view_model.write().unwrap() = Some(view_model);
-    }
-
-    pub fn close_overlay(&self) {
-        let mut vm = self.settings_view_model.write().unwrap();
-        match *vm {
-            Some(ref mut view_model) => {
-                self.panel_overlay.remove_overlay(&view_model.widget);
-                *vm = None;
-            }
-            None => {}
-        }
-    }
-
-    fn setup_window(app: &adw::Application) -> adw::ApplicationWindow {
-        let window = adw::ApplicationWindow::builder()
-            .application(app)
-            .width_request(800)
-            .height_request(500)
-            .build();
-
-        window
-    }
-
-    fn setup_header() -> adw::HeaderBar {
-        let header = adw::HeaderBar::builder()
-            .title_widget(&gtk::Label::new(Some("Kifu")))
-            .build();
-
-        let app_menu = gio::Menu::new();
-        let menu_item = gio::MenuItem::new(Some("Configuration"), Some("app.show_settings"));
-        app_menu.append_item(&menu_item);
-
-        let hamburger = gtk::MenuButton::builder()
-            .icon_name("open-menu-symbolic")
-            .build();
-        hamburger.set_menu_model(Some(&app_menu));
-
-        header.pack_end(&hamburger);
-        header
-    }
-
-    fn setup_panel_overlay() -> gtk::Overlay {
-        gtk::Overlay::new()
-    }
-
-    fn setup_content(core: Core) -> (adw::NavigationView, Vec<AppView>) {
-        let stack = adw::NavigationView::new();
-        let mut content = Vec::new();
-
-        let nothing_page = adw::StatusPage::builder().title("Nothing here").build();
-        let _ = stack.push(
-            &adw::NavigationPage::builder()
-                .can_pop(false)
-                .title("Kifu")
-                .child(&nothing_page)
-                .build(),
-        );
-        content.push(AppView::Home(HomeViewModel::new(core.clone())));
-
-        /*
-        match *core.library() {
-            Some(_) =>  {
-            }
-            None => {
-                let settings_vm = SettingsViewModel::new(core.clone());
-                let _ = stack.push(&adw::NavigationPage::new(&settings_vm.widget, "Settings"));
-                content.push(AppView::Settings(settings_vm));
-            }
-        }
-        */
-
-        (stack, content)
-    }
-
-    // pub fn set_content(content: &impl IsA<gtk::Widget>) -> adw::ViewStack {
-    // self.content.set_child(Some(content));
-    // }
-}

kifu/gtk/src/lib.rs

@@ -1,29 +1,10 @@
-/*
-Copyright 2024, Savanni D'Gerinel <savanni@luminescent-dreams.com>
-
-This file is part of Kifu.
-
-Kifu is free software: you can redistribute it and/or modify it under the terms of the GNU
-General Public License as published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-Kifu is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with Kifu. If not, see <https://www.gnu.org/licenses/>.
-*/
-
 pub mod ui;
 
-mod app_window;
-pub use app_window::AppWindow;
-
 mod view_models;
 mod views;
 
 use async_std::task::yield_now;
-use kifu_core::{Core, Observable};
+use kifu_core::{Core, CoreRequest, CoreResponse, Observable};
 use std::{rc::Rc, sync::Arc};
 use tokio::runtime::Runtime;
 
@@ -34,7 +15,6 @@ pub struct CoreApi {
 }
 
 impl CoreApi {
-    /*
     pub fn dispatch(&self, request: CoreRequest) {
         /*
         spawn({
@@ -46,7 +26,6 @@ impl CoreApi {
         });
         */
     }
-*/
 }
 
 pub fn perftrace<F, A>(trace_name: &str, f: F) -> A

kifu/gtk/src/main.rs

@@ -1,12 +1,8 @@
 use adw::prelude::*;
-use async_std::channel::Receiver;
+use kifu_core::{Config, ConfigOption, Core, CoreRequest, CoreResponse, DatabasePath};
-use async_std::task::spawn;
-use gio::ActionEntry;
-use kifu_core::{Config, ConfigOption, Core, CoreNotification, LibraryPath, Observable};
 use kifu_gtk::{
     perftrace,
-    // ui::{ConfigurationPage, Home, PlayingField},
+    ui::{AppWindow, ConfigurationPage, Home, PlayingField},
-    AppWindow,
     CoreApi,
 };
 use std::sync::{Arc, RwLock};
@@ -16,30 +12,6 @@ const APP_ID_PROD: &str = "com.luminescent-dreams.kifu-gtk";
 
 const RESOURCE_BASE_PATH: &str = "/com/luminescent-dreams/kifu-gtk/";
 
-async fn handler(notifications: Receiver<CoreNotification>, app_id: String) {
-    loop {
-        let msg = notifications.recv().await;
-        match msg {
-            Ok(CoreNotification::ConfigurationUpdated(cfg)) => {
-                println!("commiting configuration");
-                let settings = gio::Settings::new(&app_id);
-                if let Some(LibraryPath(library_path)) = cfg.get() {
-                    let _ = settings.set_string(
-                        "library-path",
-                        &library_path.into_os_string().into_string().unwrap(),
-                    );
-                }
-            }
-            Ok(_) => println!("discarding message"),
-            Err(err) => {
-                println!("shutting down handler with error: {:?}", err);
-                return;
-            }
-        }
-    }
-}
-
-/*
 fn handle_response(api: CoreApi, app_window: &AppWindow, message: CoreResponse) {
     let playing_field = Arc::new(RwLock::new(None));
     match message {
@@ -76,26 +48,6 @@ fn handle_response(api: CoreApi, app_window: &AppWindow, message: CoreResponse)
         }),
     }
 }
-*/
-
-fn load_config(app_id: &str) -> Config {
-    let settings = gio::Settings::new(app_id);
-    let lib_path: String = settings.string("library-path").into();
-    let mut config = Config::new();
-    config.set(ConfigOption::LibraryPath(lib_path.into()));
-    config
-}
-
-fn setup_app_configuration_action(app: &adw::Application, app_window: AppWindow) {
-    println!("setup_app_configuration_action");
-    let action = ActionEntry::builder("show_settings")
-        .activate(move |_app: &adw::Application, _, _| {
-            app_window.open_settings();
-        })
-        .build();
-    app.add_action_entries([action]);
-    println!("setup_app_configuration_action complete");
-}
 
 fn main() {
     gio::resources_register_include!("com.luminescent-dreams.kifu-gtk.gresource")
@@ -107,7 +59,10 @@ fn main() {
         APP_ID_PROD
     };
 
-    let config = load_config(&app_id);
+    let settings = gio::Settings::new(app_id);
+    let db_path: String = settings.string("database-path").into();
+    let mut config = Config::new();
+    config.set(ConfigOption::DatabasePath(db_path.into()));
 
     let runtime = Arc::new(
         tokio::runtime::Builder::new_multi_thread()
@@ -132,12 +87,6 @@ fn main() {
 
     let core = Core::new(config);
 
-    spawn({
-        let notifier = core.subscribe();
-        let app_id = app_id.to_owned();
-        handler(notifier, app_id)
-    });
-
     /*
     let core_handle = runtime.spawn({
         let core = core.clone();
@@ -155,23 +104,13 @@ fn main() {
     app.connect_activate({
         let runtime = runtime.clone();
         move |app| {
-            let mut app_window = AppWindow::new(app, core.clone());
+            let app_window = AppWindow::new(app);
 
-            match *core.library() {
-                Some(_) => {}
-                None => app_window.open_settings(),
-            }
-
-            setup_app_configuration_action(app, app_window.clone());
-
-            /*
             let api = CoreApi {
                 rt: runtime.clone(),
                 core: core.clone(),
             };
-            */
 
-            /*
             let action_config = gio::SimpleAction::new("show-config", None);
             action_config.connect_activate({
                 let api = api.clone();
@@ -180,7 +119,6 @@ fn main() {
                 }
             });
             app.add_action(&action_config);
-            */
 
             app_window.window.present();
 
@@ -196,7 +134,7 @@ fn main() {
             });
              */
 
-            // api.dispatch(CoreRequest::Home);
+            api.dispatch(CoreRequest::Home);
         }
     });
 

kifu/gtk/src/ui/mod.rs

@@ -1,27 +1,100 @@
-// mod chat;
+use adw::prelude::*;
-// pub use chat::Chat;
+use gio::resources_lookup_data;
+use glib::IsA;
+use gtk::STYLE_PROVIDER_PRIORITY_USER;
 
-// mod config;
+mod chat;
-// pub use config::ConfigurationPage;
+pub use chat::Chat;
 
-// mod game_preview;
+mod config;
-// pub use game_preview::GamePreview;
+pub use config::ConfigurationPage;
 
-// mod library;
+mod game_preview;
-// pub use library::Library;
+pub use game_preview::GamePreview;
 
-// mod player_card;
+mod library;
-// pub use player_card::PlayerCard;
+pub use library::Library;
 
-// mod playing_field;
+mod player_card;
-// pub use playing_field::PlayingField;
+pub use player_card::PlayerCard;
 
-// mod home;
+mod playing_field;
-// pub use home::Home;
+pub use playing_field::PlayingField;
 
-// mod board;
+mod home;
-// pub use board::Board;
+pub use home::Home;
+
+mod board;
+pub use board::Board;
 
 #[cfg(feature = "screenplay")]
 pub use playing_field::playing_field_view;
 
+pub struct AppWindow {
+    pub window: adw::ApplicationWindow,
+    pub header: adw::HeaderBar,
+    pub content: adw::Bin,
+}
+
+impl AppWindow {
+    pub fn new(app: &adw::Application) -> Self {
+        let window = adw::ApplicationWindow::builder()
+            .application(app)
+            .width_request(800)
+            .height_request(500)
+            .build();
+
+        let stylesheet = String::from_utf8(
+            resources_lookup_data(
+                "/com/luminescent-dreams/kifu-gtk/style.css",
+                gio::ResourceLookupFlags::NONE,
+            )
+            .expect("stylesheet should just be available")
+            .to_vec(),
+        )
+        .expect("to parse stylesheet");
+
+        let provider = gtk::CssProvider::new();
+        provider.load_from_data(&stylesheet);
+        let context = window.style_context();
+        context.add_provider(&provider, STYLE_PROVIDER_PRIORITY_USER);
+
+        let header = adw::HeaderBar::builder()
+            .title_widget(&gtk::Label::new(Some("Kifu")))
+            .build();
+
+        let app_menu = gio::Menu::new();
+        let menu_item = gio::MenuItem::new(Some("Configuration"), Some("app.show-config"));
+        app_menu.append_item(&menu_item);
+
+        let hamburger = gtk::MenuButton::builder()
+            .icon_name("open-menu-symbolic")
+            .build();
+        hamburger.set_menu_model(Some(&app_menu));
+
+        header.pack_end(&hamburger);
+
+        let content = adw::Bin::builder().css_classes(vec!["content"]).build();
+        content.set_child(Some(
+            &adw::StatusPage::builder().title("Nothing here").build(),
+        ));
+
+        let layout = gtk::Box::builder()
+            .orientation(gtk::Orientation::Vertical)
+            .build();
+        layout.append(&header);
+        layout.append(&content);
+
+        window.set_content(Some(&layout));
+
+        Self {
+            window,
+            header,
+            content,
+        }
+    }
+
+    pub fn set_content(&self, content: &impl IsA<gtk::Widget>) {
+        self.content.set_child(Some(content));
+    }
+}

kifu/gtk/src/view_models/home_view_model.rs

@@ -16,25 +16,23 @@ You should have received a copy of the GNU General Public License along with Kif
 
 use crate::LocalObserver;
 use kifu_core::{Core, CoreNotification};
-use std::sync::Arc;
 
 /// Home controls the view that the user sees when starting the application if there are no games in progress. It provides a window into the database, showing a list of recently recorded games. It also provides the UI for starting a new game. This will render an empty database view if the user hasn't configured a database yet.
-#[derive(Clone)]
 pub struct HomeViewModel {
     core: Core,
-    notification_observer: Arc<LocalObserver<CoreNotification>>,
+    notification_observer: LocalObserver<CoreNotification>,
     widget: gtk::Box,
 }
 
 impl HomeViewModel {
-    pub fn new(core: Core) -> Self {
+    fn new(core: Core) -> Self {
         let notification_observer = LocalObserver::new(&core, |msg| {
-            println!("HomeViewModel handler called with message: {:?}", msg)
+            println!("DatabaseViewModelHandler called with message: {:?}", msg)
         });
 
         Self {
             core,
-            notification_observer: Arc::new(notification_observer),
+            notification_observer,
             widget: gtk::Box::new(gtk::Orientation::Horizontal, 0),
         }
     }

kifu/gtk/src/view_models/settings_view_model.rs

@@ -14,60 +14,25 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with Kifu. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::{views, views::SettingsView, LocalObserver};
+use crate::LocalObserver;
-use async_std::task::spawn;
+use kifu_core::{Core, CoreNotification};
-use gtk::prelude::*;
-use kifu_core::{Config, Core, CoreNotification};
-use std::{sync::Arc, rc::Rc};
 
-/// SettingsViewModel
-///
-/// Listens for messages from the core, and serves as intermediary between the Settings UI and the
-/// core. Because it needs to respond to events from the core, it owns the widget, which allows it
-/// to tell the widget to update after certain events.
-#[derive(Clone)]
 pub struct SettingsViewModel {
     core: Core,
-    // Technically, Settings doesn't care about any events from Core. We will keep this around for
+    notification_observer: LocalObserver<CoreNotification>,
-    // now as reference, until something which does care shows up.
+    widget: gtk::Box,
-    notification_observer: Arc<LocalObserver<CoreNotification>>,
-    pub widget: views::SettingsView,
 }
 
 impl SettingsViewModel {
-    pub fn new(parent: &impl IsA<gtk::Window>, core: Core, on_close: impl Fn() + 'static) -> Self {
+    fn new(core: Core) -> Self {
-        let on_close = Arc::new(on_close);
-
         let notification_observer = LocalObserver::new(&core, |msg| {
             println!("SettingsViewModel called with message: {:?}", msg)
         });
 
-        let config = core.get_config();
-
-        let widget = SettingsView::new(
-            parent,
-            config,
-            {
-                let core = core.clone();
-                let on_close = on_close.clone();
-                move |new_config| {
-                    spawn({
-                        let core = core.clone();
-                        on_close();
-                        async move {
-                            println!("running set_config in the background");
-                            core.set_config(new_config).await;
-                        }
-                    });
-                }
-            },
-            move || on_close(),
-        );
-
         Self {
-            core: core.clone(),
+            core,
-            notification_observer: Arc::new(notification_observer),
+            notification_observer,
-            widget,
+            widget: gtk::Box::new(gtk::Orientation::Horizontal, 0),
         }
     }
 }

kifu/gtk/src/views/mod.rs

@@ -1,2 +0,0 @@
-mod settings;
-pub use settings::SettingsView;

kifu/gtk/src/views/settings.rs

@@ -1,151 +0,0 @@
-/*
-Copyright 2024, Savanni D'Gerinel <savanni@luminescent-dreams.com>
-
-This file is part of Kifu.
-
-Kifu is free software: you can redistribute it and/or modify it under the terms of the GNU
-General Public License as published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-Kifu is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with Kifu. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-use std::{cell::RefCell, path::Path, rc::Rc, borrow::Cow};
-
-use adw::prelude::*;
-use glib::Object;
-use gtk::{prelude::*, subclass::prelude::*};
-use kifu_core::{Config, ConfigOption, LibraryPath};
-
-fn library_chooser_row(
-    parent: &impl IsA<gtk::Window>,
-    library_path: Option<LibraryPath>,
-    on_library_chosen: Rc<impl Fn(ConfigOption) + 'static>,
-) -> adw::ActionRow {
-    let dialog = gtk::FileDialog::builder().build();
-
-    let dialog_button = gtk::Button::builder()
-        .child(&gtk::Label::new(Some("Select Library")))
-        .valign(gtk::Align::Center)
-        .build();
-
-    let parent = parent.clone();
-
-    let library_row = adw::ActionRow::builder()
-        .title("Library Path")
-        .subtitle(library_path.map(|LibraryPath(path)| path.to_string_lossy().into_owned()).unwrap_or("No library set".to_owned()))
-        .css_classes(["preference-item"])
-        .build();
-
-    dialog_button.connect_clicked({
-        let library_row = library_row.clone();
-        move |_| {
-            let no_parent: Option<&gtk::Window> = None;
-            let not_cancellable: Option<&gio::Cancellable> = None;
-            let on_library_chosen = on_library_chosen.clone();
-            dialog.select_folder(no_parent, not_cancellable, {
-                let library_row = library_row.clone();
-                move |result| match result {
-                    Ok(path) => {
-                        let path_str: String =
-                            path.path().unwrap().into_os_string().into_string().unwrap();
-                        library_row.set_subtitle(&path_str);
-                        on_library_chosen(ConfigOption::LibraryPath(LibraryPath(
-                            path.path().unwrap(),
-                        )))
-                    }
-                    Err(err) => println!("Error choosing a library: {:?}", err),
-                }
-            });
-        }
-    });
-
-    library_row.add_suffix(&dialog_button);
-
-    library_row
-}
-
-pub struct SettingsPrivate {}
-
-#[glib::object_subclass]
-impl ObjectSubclass for SettingsPrivate {
-    const NAME: &'static str = "Settings";
-    type Type = SettingsView;
-    type ParentType = gtk::Frame;
-
-    fn new() -> Self {
-        Self {}
-    }
-}
-
-impl ObjectImpl for SettingsPrivate {}
-impl WidgetImpl for SettingsPrivate {}
-#[allow(deprecated)]
-impl FrameImpl for SettingsPrivate {}
-
-glib::wrapper! {
-    pub struct SettingsView(ObjectSubclass<SettingsPrivate>) @extends gtk::Frame, gtk::Widget, @implements gtk::Accessible, gtk::Orientable;
-}
-
-impl SettingsView {
-    pub fn new(
-        parent: &impl IsA<gtk::Window>,
-        config: Config,
-        on_save: impl Fn(Config) + 'static,
-        on_cancel: impl Fn() + 'static,
-    ) -> Self {
-        let s: Self = Object::builder().build();
-        let config = Rc::new(RefCell::new(config));
-
-        let group = adw::PreferencesGroup::builder().build();
-
-        let library_row = library_chooser_row(
-            parent,
-            config.borrow().get(),
-            Rc::new({
-                let config = config.clone();
-                move |library_path| {
-                    config.borrow_mut().set(library_path);
-                }
-            }),
-        );
-        group.add(&library_row);
-
-        let cancel_button = gtk::Button::builder().label("Cancel").build();
-        cancel_button.connect_clicked(move |_| on_cancel());
-        let save_button = gtk::Button::builder().label("Save").build();
-        save_button.connect_clicked({
-            let config = config.clone();
-            move |_| on_save(config.borrow().clone())
-        });
-
-        let action_row = gtk::Box::builder()
-            .orientation(gtk::Orientation::Horizontal)
-            .halign(gtk::Align::End)
-            .valign(gtk::Align::End)
-            .build();
-        action_row.append(&cancel_button);
-        action_row.append(&save_button);
-
-        let preferences_box = gtk::Box::builder()
-            .orientation(gtk::Orientation::Vertical)
-            .build();
-        preferences_box.append(&group);
-
-        let layout = gtk::Box::builder()
-            .orientation(gtk::Orientation::Vertical)
-            .spacing(8)
-            .build();
-        layout.append(&preferences_box);
-        layout.append(&action_row);
-
-        s.set_child(Some(&layout));
-        s.set_css_classes(&["settings-view"]);
-
-        s
-    }
-}