add auto loading

src-tauri/src/frontend_calls/load_previous_tabs.rs

···
+use std::collections::HashMap;
+
+use tauri::State;
+
+use crate::{ structs::nodes::Node, utils::config::Config };
+
+#[tauri::command]
+pub fn load_previous_tabs( conf: State<Config> ) -> HashMap<String, Vec<Node>> {
+  let config = conf.store.lock().unwrap();
+
+  let tabs = config.loaded_tabs.clone();
+  tabs
+}

src-tauri/src/frontend_calls/mod.rs

···
 pub mod get_addresses;
 pub mod save_graph;
-pub mod sync_tab;
+pub mod sync_tab;
+pub mod load_previous_tabs;

src-tauri/src/frontend_calls/sync_tab.rs

···
 
 use tauri::State;
 
-use crate::{ runtime::commands::RuntimeCommand, structs::nodes::Node };
+use crate::{ runtime::commands::RuntimeCommand, structs::nodes::Node, utils::config::Config };
 
 #[tauri::command]
-pub fn sync_tab( graph: Vec<Node>, id: String, cmd: State<Sender<RuntimeCommand>> ){
-  cmd.send(RuntimeCommand::AddTab(graph, id)).unwrap();
+pub fn sync_tab( graph: Vec<Node>, id: String, cmd: State<Sender<RuntimeCommand>>, conf: State<Config> ){
+  cmd.send(RuntimeCommand::AddTab(graph.clone(), id.clone())).unwrap();
+
+  let mut config = conf.store.lock().unwrap();
+  config.loaded_tabs.insert(id, graph);
+  drop(config);
+
+  conf.save();
 }
 
 #[tauri::command]
-pub fn discard_tab( id: String, cmd: State<Sender<RuntimeCommand>> ){
-  cmd.send(RuntimeCommand::RemoveTab(id)).unwrap();
+pub fn discard_tab( id: String, cmd: State<Sender<RuntimeCommand>>, conf: State<Config> ){
+  cmd.send(RuntimeCommand::RemoveTab(id.clone())).unwrap();
+
+  let mut config = conf.store.lock().unwrap();
+  config.loaded_tabs.remove(&id);
+  drop(config);
+
+  conf.save();
 }

src-tauri/src/lib.rs

···
 #[tokio::main]
 pub async fn run() {
   // TODO: Impl background running by default
-  // TODO: Auto loading last loaded tabs
+  // TODO: Delay close if unsaved tabs
 
   let container_folder = dirs::config_dir().unwrap().join("VRCMacros");
 
···
       get_addresses::get_addresses,
       save_graph::save_graph,
       sync_tab::sync_tab,
-      sync_tab::discard_tab
+      sync_tab::discard_tab,
+      load_previous_tabs::load_previous_tabs
     ])
     .manage(conf)
     .manage(&ADDRESSES)

src-tauri/src/setup.rs

···
 
 use flate2::read::GzDecoder;
 use serde_json::{ Map, Value };
-use tauri::{ App, Emitter, Listener, Manager };
+use tauri::{ App, Emitter, Listener, Manager, State };
 
-use crate::{ osc::{ self, OSCMessage }, runtime::{ commands::RuntimeCommand, nodes::RuntimeNodeTree, runtime, runtime_dry }, structs::parameter_types::ParameterType };
+use crate::{ osc::{ self, OSCMessage }, runtime::{ commands::RuntimeCommand, nodes::RuntimeNodeTree, runtime, runtime_dry }, structs::parameter_types::ParameterType, utils::config::Config };
 
 pub fn setup(
   app: &mut App,

src-tauri/src/structs/nodes.rs

···
 use serde::{ Deserialize, Serialize };
 use serde_json::Value;
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Node{
   pub id: String,
   pub name: String,
···
   pub type_id: String
 }
 
-impl Node{
-
-}
-
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct NodeStatic{
   pub name: String,
 
···
   pub value: Value
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct NodeOutput{
   pub name: String,
 
···
   pub connections: Vec<NodeOutputConnections>
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct NodeOutputConnections{
   pub name: String,
   pub node: String,

src-tauri/src/utils/config.rs

···
-use std::{
-  collections::HashMap,
-  fs::File,
-  io::{Read, Write},
-  path::PathBuf,
-  sync::Mutex,
-};
+use std::{ collections::HashMap, fs::File, io::{ Read, Write }, path::PathBuf, sync::Mutex };
 
-use flate2::{read::GzDecoder, write::GzEncoder, Compression};
-use serde_json::Value;
+use flate2::{ read::GzDecoder, write::GzEncoder, Compression };
+use serde::{ Deserialize, Serialize };
+
+use crate::structs::nodes::Node;
+
+#[derive(Clone, Serialize, Deserialize, Debug)]
+pub struct ConfigValues{
+  #[serde(default)]
+  pub loaded_tabs: HashMap<String, Vec<Node>>
+}
 
 pub struct Config {
-  store: Mutex<HashMap<String, Value>>,
+  pub store: Mutex<ConfigValues>,
   path: PathBuf,
 }
 
···
       "{}".into()
     };
 
-    let json: Value = serde_json::from_str(&json_string).unwrap();
-
-    let mut hashmap = HashMap::new();
-
-    let obj = json.as_object().unwrap();
-    for (key, val) in obj {
-      hashmap.insert(key.clone(), val.clone());
-    }
+    let json: ConfigValues = serde_json::from_str(&json_string).unwrap();
 
     Config {
-      store: Mutex::new(hashmap),
+      store: Mutex::new(json),
       path: path,
-    }
-  }
-
-  pub fn set(&self, key: &str, value: Value) {
-    self.store.lock().unwrap().insert(key.to_owned(), value);
-  }
-
-  pub fn get(&self, key: &str) -> Option<Value> {
-    let store = self.store.lock().unwrap();
-    let val = store.get(&key.to_owned());
-
-    if val.is_none() {
-      None
-    } else {
-      Some(val.unwrap().clone())
     }
   }
 

src/Mangers/NodeManager.tsx

···
     NodeManager.Instance = this;
 
     listen('load_new_tab', ( ev: any ) => {
-      this._loadFromConfig(ev.payload.path, ev.payload.graph);
-    })
+      this._loadFromConfig(ev.payload.path, null, ev.payload.graph);
+    });
+
+    invoke('load_previous_tabs').then(async ( tabs: any ) => {
+      let version = await getVersion();
+
+      for(let tab of Object.entries(tabs)){
+        console.log(tab);
+
+        await this._loadFromConfig(null, tab[0], JSON.stringify({
+          tab_name: 'test',
+          version,
+          graph: tab[1]
+        }));
+      };
+    });
   }
 
 
   private _tabUpdateHook: ( tabs: TabHashMap ) => void = () => {};
   private _tabChangeHook: () => void = () => {};
 
-  public async AddTab( name: string ): Promise<Tab>{
+  public async AddTab( name: string, id: string | null = null ): Promise<Tab>{
     let [ selected, setSelected ] = createSignal(false);
     let [ needsSave, setNeedsSave ] = createSignal(false);
 
     let tab: Tab = {
       name: name,
-      id: await NodeManager.Instance.GetNewNodeId(),
+      id: id || await NodeManager.Instance.GetNewNodeId(),
       nodes: [],
       saveLocation: null,
 
···
     if(needsSave)tab.setNeedsSave(true);
   }
 
-  private async _loadFromConfig( path: string, config: string ){
+  private async _loadFromConfig( path: string | null, id: string | null, config: string ){
     let json = JSON.parse(config);
 
     if(
···
       !json.graph
     )return;
 
-    let tab = await this.AddTab(json.tab_name);
+    let tab = await this.AddTab(json.tab_name, id);
     tab.refuseSync = true;
     tab.saveLocation = path;