Early gui impl, basic window management

xmpd-gui/src/lib.rs

@@ -1,3 +1,51 @@
-pub fn test() {
-    println!("Hello, world!");
+#![feature(async_closure)]
+
+use std::{path::{Path, PathBuf}, sync::mpsc, thread::JoinHandle};
+use windows::WindowId;
+use xmpd_manifest::{store::JsonStore, Manifest};
+
+mod main_window;
+mod windows;
+
+
+const W_NAME: &str = "xmpd v2.0.0a";
+
+type Result<T> = anyhow::Result<T>;
+
+pub fn start(manifest_path: PathBuf) -> Result<()> {
+    let options = eframe::NativeOptions::default();
+    let mut state = GuiState::new(&manifest_path)?;
+    state.windows.toggle(&WindowId::Error, true);
+    
+    let res = eframe::run_simple_native(W_NAME, options, move |ctx, _frame| {
+        state.windows.clone().draw_all(ctx, &mut state);
+        egui::CentralPanel::default().show(ctx, |ui| main_window::draw(ui, &mut state));
+        ctx.request_repaint(); 
+    });
+    if let Err(e) = res { // dumb err value by eframe
+        anyhow::bail!(e.to_string());
+    }
+    Ok(())
 }
+
+
+pub enum Message {
+    
+}
+
+pub struct GuiState {
+    pub manifest: Manifest<JsonStore>,
+    pub windows: windows::Windows
+}
+
+impl GuiState {
+    pub fn new(manifest_path: &Path) -> Result<Self> {
+        Ok(Self {
+            manifest: Manifest::new(manifest_path)?,
+            windows: windows::Windows::new(),
+        })
+    }
+}
+
+
+

xmpd-gui/src/main_window.rs

@@ -0,0 +1,14 @@
+use egui::ViewportId;
+use xmpd_manifest::store::JsonStore;
+
+use crate::GuiState;
+
+
+
+pub fn draw(ui: &mut egui::Ui, state: &mut GuiState) -> crate::Result<()> {
+    ui.label("Hello! this is root of main window");
+    if ui.button("open iwndow").clicked() {
+        state.windows.toggle(&crate::windows::WindowId::Error, true);
+    }
+    Ok(())
+}

xmpd-gui/src/windows/error.rs

@@ -0,0 +1,14 @@
+use super::Window;
+
+
+#[derive(Debug, Default)]
+pub struct ErrorW {
+
+}
+
+impl Window for ErrorW {
+    fn draw(&self, ui: &mut egui::Ui, state: &mut crate::GuiState) -> crate::Result<()> {
+        ui.label("Hello from other window!");
+        Ok(()) 
+    }
+}

xmpd-gui/src/windows/mod.rs

@@ -0,0 +1,75 @@
+use std::{collections::{HashMap, HashSet}, ops::Deref, sync::{Arc, Mutex}};
+use egui::{ViewportBuilder, ViewportId};
+use crate::GuiState;
+
+mod error;
+
+lazy_static::lazy_static!(
+    static ref WINDOWS: Arc<Mutex<HashMap<WindowId, Box<dyn Window>>>> = Arc::new(Mutex::new(HashMap::new()));
+    static ref OPEN_WINDOWS: Arc<Mutex<HashSet<WindowId>>> = Arc::new(Mutex::new(HashSet::new()));
+
+);
+
+pub trait Window: std::fmt::Debug + Send {
+    fn draw(&self, ui: &mut egui::Ui, state: &mut GuiState) -> crate::Result<()>;
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, PartialOrd, Ord, Eq)]
+pub enum WindowId {
+    Error
+}
+
+#[derive(Debug, Clone)]
+pub struct Windows {
+    windows: HashMap<WindowId, (ViewportId, ViewportBuilder)>,
+}
+
+impl Windows {
+    pub fn new() -> Self {
+        let mut  s = Self {
+            windows: HashMap::new(),
+        };
+        s.add_all_windows();
+        s
+    }
+
+    pub fn add_all_windows(&mut self) {
+        self.add_new_window(WindowId::Error, "Error!", Box::<error::ErrorW>::default())
+    }
+
+    pub fn add_new_window(&mut self, id: WindowId, title: &str, cb: Box<dyn Window>) {
+        let builder = ViewportBuilder::default()
+            .with_title(title);
+        self.windows.insert(id.clone(), (ViewportId::from_hash_of(id.clone()), builder));
+        WINDOWS.lock().unwrap().insert(id, cb);
+    }
+
+    pub fn draw_all(&mut self, ctx: &egui::Context, state: &mut GuiState) {
+        for (win_id, (vp_id, builder)) in &self.windows {
+            if self.is_open(&win_id) {
+                ctx.show_viewport_immediate(vp_id.clone(), builder.clone(), |ctx, _vp_class| {        
+                    ctx.input(|inp| {
+                        // println!("CLose requested: {}",inp.viewport().close_requested() );
+                        self.toggle(win_id, !inp.viewport().close_requested());
+                    });
+                    egui::CentralPanel::default().show(ctx, |ui| {
+                        WINDOWS.lock().unwrap().get(&win_id).unwrap().draw(ui, state)
+                    }) 
+                });
+            }
+        }
+    }
+
+    pub fn toggle(&self, id: &WindowId, status: bool) {
+        if status {
+            OPEN_WINDOWS.lock().unwrap().insert(id.clone());
+        } else {
+            log::debug!("tried to kill");
+            OPEN_WINDOWS.lock().unwrap().remove(id);
+        }
+    }
+
+    pub fn is_open(&self, id: &WindowId) -> bool {
+        OPEN_WINDOWS.lock().unwrap().contains(&id)
+    }
+}