qol updates

src-tauri/Cargo.lock

···
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "chrono",
  "crossbeam-channel",
  "dirs",
  "enigo",
···
 checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 dependencies = [
  "iana-time-zone",
+ "js-sys",
  "num-traits",
  "serde",
+ "wasm-bindgen",
  "windows-link 0.2.1",
 ]
 

src-tauri/Cargo.toml

···
 
 # [target.'cfg(windows)'.dependencies]
 enigo = { version = "0.6.1" }
+chrono = "0.4.42"
 

src-tauri/src/frontend_calls/load_previous_tabs.rs

···
 pub fn load_previous_tabs(
   window: Window,
   conf: State<Config>,
-) -> HashMap<String, (Vec<Node>, String, Option<String>)> {
+) -> HashMap<String, (Vec<Node>, String, Option<String>, bool)> {
   let config = conf.store.lock().unwrap();
 
   if !config.hide_editor_on_start {

src-tauri/src/frontend_calls/sync_tab.rs

···
+use chrono::Utc;
 use crossbeam_channel::Sender;
 
 use tauri::State;
···
   graph: Vec<Node>,
   id: String,
   name: String,
+  save_state: bool,
   location: Option<String>,
   cmd: State<Sender<RuntimeCommand>>,
   conf: State<Config>,
···
     .unwrap();
 
   let mut config = conf.store.lock().unwrap();
-  config.loaded_tabs.insert(id, (graph, name, location)); // TODO: When loading a tab into config, store the save state of it too
+  config.loaded_tabs.insert(id, (graph, name, location, save_state)); // TODO: When loading a tab into config, store the save state of it too
+
+  // If we haven't updated the config in the last second, let's update it again.
+  if config.last_save + 1 < Utc::now().timestamp(){ conf.save_prelocked(config); }
 }
 
 #[tauri::command]

src-tauri/src/runtime.rs

···
   if node.is_none() { bail!("Cannot find node"); }
 
   let node = node.unwrap();
-
   let inputs = node.inputs();
-  dbg!(&inputs);
 
   let mut needed_input_nodes = HashMap::new();
 
···
       }
     }
   }
-
-  dbg!(&needed_input_nodes);
 
   for ( id, needed ) in needed_input_nodes{
     let (out_args, _) = runtime(id, tab, vec![]).unwrap();

src-tauri/src/runtime/nodes/shell.rs

···
-use std::process::Command;
+use std::{io::Stdin, process::{Command, Stdio}};
 
 use crate::{
   runtime::nodes::RuntimeNode,
···
 
   fn execute(&mut self, args: Vec<ParameterType>) -> Vec<ParameterType> {
     if let Ok(cmd) = args[1].as_string(){
-      dbg!(&cmd);
-
       if cmd != ""{
         let mut split_cmd = cmd.split(" ");
 
         let mut cmd = Command::new(split_cmd.nth(0).unwrap());
         if split_cmd.clone().count() > 0{ cmd.args(split_cmd); }
+
+        cmd.stdout(Stdio::piped());
+        cmd.stderr(Stdio::piped());
 
         let child = cmd.spawn().unwrap();
         let output = child.wait_with_output().unwrap();

src-tauri/src/setup.rs

···
   window.hide().unwrap();
 
   let win_handle = window.clone();
+
   window.on_window_event(move |event| match event {
     WindowEvent::CloseRequested { api, .. } => {
       api.prevent_close();
-
-      win_handle.hide().unwrap();
-      win_handle.emit("hide-window", ()).unwrap();
+      win_handle.emit("prompt_to_close", ()).unwrap();
+    }
+    WindowEvent::Resized(_) => {
+      let minimised = win_handle.is_minimized().unwrap();
+      if minimised{
+        win_handle.hide().unwrap();
+        win_handle.emit("hide-window", ()).unwrap();
+        win_handle.unminimize().unwrap();
+      }
     }
     _ => {}
   });

src-tauri/src/utils/config.rs

···
   fs::File,
   io::{Read, Write},
   path::PathBuf,
-  sync::Mutex,
+  sync::{Mutex, MutexGuard},
 };
 
+use chrono::Utc;
 use flate2::{read::GzDecoder, write::GzEncoder, Compression};
 use serde::{Deserialize, Serialize};
 
···
 #[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct ConfigValues {
   #[serde(default)]
-  pub loaded_tabs: HashMap<String, (Vec<Node>, String, Option<String>)>,
+  pub loaded_tabs: HashMap<String, (Vec<Node>, String, Option<String>, bool)>,
 
   #[serde(default)]
   pub hide_editor_on_start: bool,
+
+  #[serde(default)]
+  pub last_save: i64,
 }
 
 pub struct Config {
+
   pub store: Mutex<ConfigValues>,
   path: PathBuf,
 }
···
 
     let json: ConfigValues = serde_json::from_str(&json_string).unwrap();
 
-    dbg!(&json);
-
     Config {
       store: Mutex::new(json),
       path: path,
···
   }
 
   pub fn save(&self) {
-    let dat = serde_json::to_string(&self.store.lock().unwrap().clone()).unwrap();
-    dbg!(&dat);
+    let mut dat = self.store.lock().unwrap();
+    dat.last_save = Utc::now().timestamp();
+
+    let dat = serde_json::to_string(&*dat).unwrap();
+
+    let file = File::create(&self.path).unwrap();
+    let mut encoder = GzEncoder::new(file, Compression::default());
+
+    encoder.write_all(dat.as_bytes()).unwrap();
+    encoder.finish().unwrap();
+  }
+
+  pub fn save_prelocked(&self, mut dat: MutexGuard<'_, ConfigValues>) {
+    dat.last_save = Utc::now().timestamp();
+
+    let dat = serde_json::to_string(&*dat).unwrap();
 
     let file = File::create(&self.path).unwrap();
     let mut encoder = GzEncoder::new(file, Compression::default());

src-tauri/src/utils/setup_traymenu.rs

···
     .build(handle)
     .unwrap();
 
-  let hide = MenuItemBuilder::new("Hide / Show Editor")
-    .id("hide")
+  let show = MenuItemBuilder::new("Show Editor")
+    .id("show")
     .build(handle)
     .unwrap();
 
   let tray_menu = MenuBuilder::new(handle)
-    .items(&[&quit, &hide])
+    .items(&[&quit, &show])
     .build()
     .unwrap();
 
···
       "quit" => {
         app.emit("prompt_to_close", ()).unwrap();
       }
-      "hide" => {
+      "show" => {
         let window = app.get_webview_window("main").unwrap();
 
-        if window.is_visible().unwrap() {
-          window.hide().unwrap();
-
-          window.emit("hide-window", ()).unwrap();
-        } else {
-          window.show().unwrap();
-          window.set_focus().unwrap();
+        window.show().unwrap();
+        window.set_focus().unwrap();
 
-          window.emit("show-window", ()).unwrap();
-        }
+        window.emit("show-window", ()).unwrap();
       }
       _ => {}
     })

src/Mangers/NodeManager.tsx

···
     setInterval(() => {
       let tabs = Object.values(this._tabs).filter(x => x.needSync);
       for(let tab of tabs){
-        invoke('sync_tab', { graph: this._generateTabGraph(tab.id)[0], id: tab.id, name: tab.name, location: tab.saveLocation });
+        invoke('sync_tab', {
+          graph: this._generateTabGraph(tab.id)[0],
+          id: tab.id,
+          name: tab.name,
+          location: tab.saveLocation,
+          saveState: tab.needsSave()
+        });
+
         tab.needSync = false;
       }
     }, 1000);
···
       let version = await getVersion();
 
       for(let tab of Object.entries<any>(tabs)){
-        await this._loadFromConfig(tab[1][2], tab[0], JSON.stringify({
+        let loaded_tab = await this._loadFromConfig(tab[1][2], tab[0], JSON.stringify({
           tab_name: tab[1][1],
           version,
           graph: tab[1][0]
         }));
+
+        if(loaded_tab)
+          loaded_tab.setNeedsSave(tab[1][3]);
       };
 
       this.UpdateConfig();
···
 
     tab.needSync = false;
     if(!id)this.UpdateConfig(false);
+
+    return tab;
   }
 
   private _generateTabGraph( tabId: string | null ): [ any, Tab | null ]{

src/Nodes/Conditional/IfEqual.tsx

···
   typeId: 'ifequal',
 
   w: 220,
-  h: 150,
 
   statics: [{
     type: NodeType.Label,

src/Nodes/Conditional/IfFalse.tsx

···
   typeId: 'iffalse',
 
   w: 220,
-  h: 120,
 
   statics: [{
     type: NodeType.Label,

src/Nodes/Conditional/IfTrue.tsx

···
   typeId: 'iftrue',
 
   w: 220,
-  h: 120,
 
   statics: [{
     type: NodeType.Label,

src/Nodes/Debug.tsx

···
   typeId: 'debug',
 
   w: 200,
-  h: 110,
 
   statics: [
     {

src/Nodes/Nodes.tsx

···
   onStaticsUpdate?: ( node: Node ) => Promise<void>,
   // build?: ( pos: [ number, number ], onStaticsUpdate: ( node: Node ) => void ) => Promise<Node>,
   w?: number,
-  h?: number,
   statics?: NodeStatic[],
   inputs?: { name: string, type: NodeType }[],
   outputs?: { name: string, type: NodeType }[],
···
   [details: string] : NodeDefinition;
 }
 
-// TODO: (Node Additions) Pressing keyboard keys
+// TODO: (Node Additions) Pressing keyboard keys (like to do linux, but has extra steps)
 // TODO: (Node Additions) Getting media state from os
 // TODO: (Node Additions) Sending custom OSC messages
 // TODO: (Node Additions) Sending HTTP requests?

src/Nodes/OSCActions/Send Chatbox.tsx

···
   typeId: 'oscsendchatbox',
 
   w: 200,
-  h: 120,
 
   statics: [{
     type: NodeType.Label,

src/Nodes/OSCTrigger.tsx

···
   typeId: 'osctrigger',
 
   w: 200,
-  h: 50,
 
   statics: [
     {
···
       })
 
       node.outputs = tempOutputs;
-      node.h = 60 + (parameters.length + 1) * 30;
+      node.updateSize();
     }
 
     NodeManager.Instance.UpdateConfig();

src/Nodes/PressKey.tsx

···
   typeId: 'presskey',
 
   w: 200,
-  h: 80,
 
   statics: [
     {

src/Nodes/Shell.tsx

···
   typeId: 'shellcommand',
 
   w: 200,
-  h: 120,
 
   statics: [],
 

src/Nodes/Statics/Float.tsx

···
   typeId: 'staticfloat',
 
   w: 200,
-  h: 80,
 
   statics: [{
     type: NodeType.Float,

src/Nodes/Statics/Int.tsx

···
   typeId: 'staticint',
 
   w: 200,
-  h: 80,
 
   statics: [{
     type: NodeType.Int,

src/Nodes/Statics/String.tsx

···
   typeId: 'staticstring',
 
   w: 200,
-  h: 80,
 
   statics: [{
     type: NodeType.String,

src/structs/node.ts

···
     this.typeId = node.typeId!;
     this.x = pos[0];
     this.y = pos[1];
-    this.w = node.w!;
-    this.h = node.h!;
 
     this.inputs = node.inputs ? node.inputs.map(( x, indx ) => {
       return {
···
       }
     }) : [];
 
+    this.w = node.w || 200;
+    this.h = 50 + Math.max(this.outputs.length, this.inputs.length) * 30;
+
     this.selected = false;
     this.statics = node.statics!,
     this.onStaticsUpdate = node.onStaticsUpdate!;
+  }
+
+  updateSize(){
+    this.h = 50 + Math.max(this.outputs.length, this.inputs.length) * 30;
   }
 }