some more keybinds, and syncing doesn't shit itself anymore

src-tauri/src/frontend_calls/sync_tab.rs

···
 
   let mut config = conf.store.lock().unwrap();
   config.loaded_tabs.remove(&id);
-  drop(config);
-
-  conf.save();
 }

src/App.tsx

···
 import { TabMenu } from "./components/TabMenu";
 import { ConfirmationPopup } from "./components/ConfirmationPopup";
 
-let App = () => {
-  // TODO: Keybind system
-  // TODO: Delete selected node when delete key is pressed
-  // TODO: Copy / paste
-  // TODO: Add undo / redo -ing
-  // TODO: Multi-select
+import * as keybinds from './keybinds';
 
+let App = () => {
   let [ selectedNode, setSelectedNode ] = createSignal<Node | null>(null);
 
   let canvas!: HTMLCanvasElement;
···
       isDrawing = false;
       isMouseDown = false;
     }
+
+    keybinds.load(selectedNode);
 
     requestAnimationFrame(update);
   });

src/Mangers/NodeManager.tsx

···
 import { NodesByID } from "../Nodes/Nodes";
 import { save } from "@tauri-apps/plugin-dialog";
 import { ConfirmationManager } from "./ConfirmationManager";
-import { getCurrentWindow } from "@tauri-apps/api/window";
 
 export interface TabHashMap {
   [details: string] : Tab;
···
 
   constructor(){
     NodeManager.Instance = this;
+
+    setInterval(() => {
+      let tabs = Object.values(this._tabs).filter(x => x.needSync);
+      console.log('Syncing ' + tabs.length + ' tabs');
+      for(let tab of tabs){
+        invoke('sync_tab', { graph: this._generateTabGraph(tab.id)[0], id: tab.id, name: tab.name, location: tab.saveLocation });
+        tab.needSync = false;
+      }
+    }, 1000);
 
     listen('load_new_tab', ( ev: any ) => {
       this._loadFromConfig(ev.payload.path, null, ev.payload.graph);
···
   private _tabUpdateHook: ( tabs: TabHashMap ) => void = () => {};
   private _tabChangeHook: () => void = () => {};
 
+  public CurrentTab(): Tab | null{
+    if(!this._selectedTab)return null
+    return this._tabs[this._selectedTab] || null;
+  }
+
   public async AddTab( name: string, id: string | null = null ): Promise<Tab>{
     let [ selected, setSelected ] = createSignal(false);
     let [ needsSave, setNeedsSave ] = createSignal(false);
···
       needsSave,
       setNeedsSave,
 
-      refuseSync: false
+      needSync: false
     };
 
     this._tabs[tab.id] = tab;
···
     }
   }
 
-  public async SaveTab( tab: Tab ){
+  public async SaveTab( tab: Tab, ignoreSaveLocation: boolean = false ){
     let path =
-      tab.saveLocation ||
+      tab.saveLocation && !ignoreSaveLocation ?
+      tab.saveLocation :
       await save({ defaultPath: tab.name + '.macro', filters: [ { name: 'Macro Files', extensions: [ 'macro' ] } ] });
 
     if(!path)throw new Error("Cannot save");
···
     let tab = this._tabs[this._selectedTab];
     if(!tab)return;
 
-    if(tab.refuseSync)return;
-    invoke('sync_tab', { graph: this._generateTabGraph(tab.id)[0], id: tab.id, name: tab.name, location: tab.saveLocation });
+    tab.nodes = this._nodes;
+    tab.needSync = true;
 
     if(needsSave)tab.setNeedsSave(true);
   }
···
     )return;
 
     let tab = await this.AddTab(json.tab_name, id);
-    tab.refuseSync = true;
+    tab.needSync = false;
     tab.saveLocation = path;
 
     this._nodes = [];
···
           let input = output.connections[k];
           let node = this._nodes.find(x => x.id === input.node)!;
 
+          if(!node)continue;
+
           let realInput = node.inputs.find(x => x.index === input.index);
           let realOutput = outputParentNode.outputs[j];
 
···
     tab.setNeedsSave(false);
     tab.nodes = this._nodes;
 
-    tab.refuseSync = false;
+    tab.needSync = false;
     if(!id)this.UpdateConfig(false);
   }
 

src/keybinds.ts

···
+import { Accessor } from "solid-js";
+import { NodeManager } from "./Mangers/NodeManager";
+import { Node } from "./structs/node";
+
+let isKeyDown: any = {};
+
+export let load = ( selectedNode: Accessor<Node | null> ) => {
+  // TODO: Keybind system
+  // TODO: Delete selected node when delete key is pressed
+  // TODO: Copy / paste
+  // TODO: Add undo / redo -ing
+
+  window.onkeydown = ( e ) => {
+    isKeyDown[e.key] = true;
+
+    console.log(e.key);
+
+    switch(e.key){
+      case 'Delete':
+        let node = selectedNode();
+        if(!node)return;
+
+        node.inputs.map(input => {
+          input.connections.map(partner => {
+            partner.connections = partner.connections.filter(x => x != input);
+          })
+        })
+
+        node.outputs.map(output => {
+          output.connections.map(partner => {
+            partner.connections = partner.connections.filter(x => x != output);
+          })
+        })
+
+        // TODO: If node is currently selected, deselect it.
+        NodeManager.Instance.RemoveNode(node);
+        break;
+      case 's':
+        if(e.ctrlKey){
+          let currentTab = NodeManager.Instance.CurrentTab();
+          if(!currentTab)return;
+
+          // Save
+          NodeManager.Instance.SaveTab(currentTab);
+        }
+        break;
+      case 'S':
+        if(e.ctrlKey){
+          let currentTab = NodeManager.Instance.CurrentTab();
+          if(!currentTab)return;
+
+          // Save
+          NodeManager.Instance.SaveTab(currentTab, true);
+        }
+        break;
+    }
+  }
+
+  window.onkeyup = ( e ) => {
+    isKeyDown[e.key] = false;
+  }
+}

src/structs/Tab.ts

···
   needsSave: Accessor<boolean>,
   setNeedsSave: Setter<boolean>,
 
-  refuseSync: boolean
+  needSync: boolean
 }