Home Reference Source

cables_dev/cables_electron/src_client/cmd_electron.js

  1. import pako from "pako";
  2. import cablesElectron from "./renderer.js";
  4. const CABLES_CMD_ELECTRON = {};
  5. const CABLES_CMD_ELECTRON_OVERRIDES = {};
  6. const CMD_ELECTRON_COMMANDS = [];
  8. function bytesArrToBase64(arr)
  9. {
  10.     const abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // base64 alphabet
  11.     const bin = (n) => { return n.toString(2).padStart(8, 0); }; // convert num to 8-bit binary string
  12.     const l = arr.length;
  13.     let result = "";
  15.     for (let i = 0; i <= (l - 1) / 3; i++)
  16.     {
  17.         let c1 = i * 3 + 1 >= l; // case when "=" is on end
  18.         let c2 = i * 3 + 2 >= l; // case when "=" is on end
  19.         let chunk = bin(arr[3 * i]) + bin(c1 ? 0 : arr[3 * i + 1]) + bin(c2 ? 0 : arr[3 * i + 2]);
  20.         let r = chunk.match(/.{1,6}/g).map((x, j) => { return (j == 3 && c2 ? "=" : (j == 2 && c1 ? "=" : abc[+("0b" + x)])); });
  21.         result += r.join("");
  22.     }
  24.     return result;
  25. }
  27. CABLES_CMD_ELECTRON.openOpDir = (opId = null, opName = null) =>
  28. {
  29.     const gui = cablesElectron.gui;
  30.     if (gui)
  31.     {
  32.         let options = { "opId": opId, "opName": opName };
  33.         if (!opId && !opName)
  34.         {
  35.             const ops = gui.patchView.getSelectedOps();
  36.             if (!ops.length) return;
  37.             options = {
  38.                 "opId": ops[0].opId,
  39.                 "opName": ops[0].name
  40.             };
  41.         }
  42.         cablesElectron.editor.api("openOpDir", options, (_err, r) => {});
  43.     }
  44. };
  46. CABLES_CMD_ELECTRON.openProjectDir = () =>
  47. {
  48.     cablesElectron.editor.api("openProjectDir", {}, (_err, r) => {});
  49. };
  51. CABLES_CMD_ELECTRON.openFileManager = (url = null) =>
  52. {
  53.     const data = {};
  54.     if (url) data.url = url;
  55.     cablesElectron.editor.api("openFileManager", data, (_err, r) => {});
  56. };
  58. CABLES_CMD_ELECTRON.collectAssets = () =>
  59. {
  60.     const loadingModal = cablesElectron.gui.startModalLoading("Copying assets...");
  61.     let closeTimeout = 2000;
  62.     cablesElectron.editor.api("collectAssets", {}, (_err, r) =>
  63.     {
  64.         if (!_err)
  65.         {
  66.             const ops = cablesElectron.gui.corePatch().ops;
  67.             const oldNew = r.data;
  68.             if (oldNew)
  69.             {
  70.                 const assetPorts = [];
  71.                 for (let i = 0; i < ops.length; i++)
  72.                 {
  73.                     for (let j = 0; j < ops[i].portsIn.length; j++)
  74.                     {
  75.                         if (ops[i].portsIn[j].uiAttribs && ops[i].portsIn[j].uiAttribs.display && ops[i].portsIn[j].uiAttribs.display === "file")
  76.                         {
  77.                             assetPorts.push(ops[i].portsIn[j]);
  78.                         }
  79.                     }
  80.                 }
  81.                 const oldNames = Object.keys(oldNew);
  82.                 if (oldNames.length > 0)
  83.                 {
  84.                     oldNames.forEach((srch) =>
  85.                     {
  86.                         const rplc = oldNew[srch];
  87.                         loadingModal.setTask("copied " + srch + " to " + rplc);
  88.                         assetPorts.forEach((assetPort) =>
  89.                         {
  90.                             let v = assetPort.get();
  91.                             if (v && v.startsWith(srch))
  92.                             {
  93.                                 v = rplc + v.substring(srch.length);
  94.                                 assetPort.set(v);
  95.                             }
  96.                         });
  97.                     });
  98.                     cablesElectron.gui.setStateUnsaved();
  99.                 }
  100.                 else
  101.                 {
  102.                     loadingModal.setTask("nothing to copy");
  103.                 }
  104.             }
  105.             else
  106.             {
  107.                 loadingModal.setTask("nothing to copy");
  108.             }
  109.         }
  110.         else
  111.         {
  112.             loadingModal.setTask("failed to copy assets");
  113.             loadingModal.setTask("---");
  114.             loadingModal.setTask(_err);
  115.             closeTimeout = 5000;
  116.         }
  117.         setTimeout(() => { cablesElectron.gui.endModalLoading(); }, closeTimeout);
  118.     });
  119. };
  121. CABLES_CMD_ELECTRON.collectOps = () =>
  122. {
  123.     const loadingModal = cablesElectron.gui.startModalLoading("Copying ops...");
  124.     let closeTimeout = 2000;
  125.     cablesElectron.editor.api("collectOps", { }, (_err, r) =>
  126.     {
  127.         if (!_err && r && r.data)
  128.         {
  129.             const oldNames = Object.keys(r.data);
  130.             if (r && oldNames.length > 0)
  131.             {
  132.                 oldNames.forEach((srch) =>
  133.                 {
  134.                     const rplc = r.data[srch];
  135.                     loadingModal.setTask("copied " + srch + " to " + rplc);
  136.                 });
  137.             }
  138.             else
  139.             {
  140.                 loadingModal.setTask("nothing to copy");
  141.             }
  142.             setTimeout(() => { cablesElectron.gui.endModalLoading(); }, closeTimeout);
  143.         }
  144.         else
  145.         {
  146.             loadingModal.setTask("failed to copy ops");
  147.             loadingModal.setTask("---");
  148.             loadingModal.setTask(_err);
  149.             closeTimeout = 5000;
  150.             setTimeout(() => { cablesElectron.gui.endModalLoading(); }, closeTimeout);
  151.         }
  152.     });
  153. };
  155. CABLES_CMD_ELECTRON.manageOpDirs = () =>
  156. {
  157.     cablesElectron.openOpDirsTab();
  158. };
  160. CABLES_CMD_ELECTRON.copyOpDirToClipboard = (opId = null) =>
  161. {
  162.     const gui = cablesElectron.gui;
  163.     if (gui)
  164.     {
  165.         if (!opId)
  166.         {
  167.             const ops = gui.patchView.getSelectedOps();
  168.             if (!ops.length) return;
  169.             opId = ops[0].opId;
  170.         }
  171.         const modulePath = window.ipcRenderer.sendSync("getOpDir", { "opId": opId });
  172.         if (modulePath)
  173.         {
  174.             navigator.clipboard.writeText(modulePath);
  175.             cablesElectron.editor.notify("Op path copied to clipboard");
  176.         }
  177.     }
  178. };
  180. CABLES_CMD_ELECTRON_OVERRIDES.PATCH = {};
  181. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.saveAs = () =>
  182. {
  183.     const gui = cablesElectron.gui;
  184.     let patchName = cablesElectron.gui.project() ? cablesElectron.gui.project().name : null;
  186.     let b64 = null;
  187.     if (gui)
  188.     {
  189.         const patch = cablesElectron.gui.patchView.store.makePatchSavable();
  190.         const patchstr = JSON.stringify(patch);
  191.         let uint8data = pako.deflate(patchstr);
  192.         b64 = bytesArrToBase64(uint8data);
  193.     }
  194.     cablesElectron.editor.api("saveProjectAs", {
  195.         "name": patchName,
  196.         "dataB64": b64
  197.     }, (err) =>
  198.     {
  199.         if (!err && gui)
  200.         {
  201.             gui.savedState.setSaved("save as end", 0);
  202.         }
  203.     });
  204. };
  205. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.uploadFileDialog = () =>
  206. {
  207.     cablesElectron.editor.api("selectFile", {}, (_err, filepath) =>
  208.     {
  209.         if (!_err && filepath)
  210.         {
  211.             const gui = cablesElectron.gui;
  212.             if (gui) gui.patchView.addAssetOpAuto(filepath);
  213.         }
  214.     });
  215. };
  216. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.newPatch = () =>
  217. {
  218.     cablesElectron.editor.api("newPatch", { }, (_err, r) => {});
  219. };
  221. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.renameOp = (opName = null) =>
  222. {
  223.     const gui = cablesElectron.gui;
  224.     if (gui)
  225.     {
  226.         if (!opName)
  227.         {
  228.             const ops = gui.patchView.getSelectedOps();
  229.             if (!ops.length) return;
  231.             const op = ops[0];
  232.             opName = op.objName;
  233.         }
  235.         gui.serverOps.renameDialog(opName);
  236.     }
  237. };
  239. CABLES_CMD_ELECTRON_OVERRIDES.RENDERER = {};
  240. CABLES_CMD_ELECTRON_OVERRIDES.RENDERER.fullscreen = () =>
  241. {
  242.     cablesElectron.editor.api("cycleFullscreen", { }, (_err, r) => {});
  243. };
  245. CABLES_CMD_ELECTRON_OVERRIDES.UI = {};
  246. CABLES_CMD_ELECTRON_OVERRIDES.UI.windowFullscreen = () =>
  247. {
  248.     cablesElectron.editor.api("cycleFullscreen", { }, (_err, r) => {});
  249. };
  251. const CABLES_CMD_COMMAND_OVERRIDES = [
  252.     {
  253.         "cmd": "save patch as...",
  254.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.saveAs
  255.     },
  256.     {
  257.         "cmd": "upload file dialog",
  258.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.uploadFileDialog
  259.     },
  260.     {
  261.         "cmd": "create new patch",
  262.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.newPatch
  263.     },
  264.     {
  265.         "cmd": "rename op",
  266.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.renameOp
  267.     },
  268.     {
  269.         "cmd": "Toggle window fullscreen",
  270.         "func": CABLES_CMD_ELECTRON_OVERRIDES.UI.windowFullscreen
  271.     }
  272. ];
  274. CMD_ELECTRON_COMMANDS.push(
  275.     {
  276.         "cmd": "collect assets into patch dir",
  277.         "category": "patch",
  278.         "func": CABLES_CMD_ELECTRON.collectAssets,
  279.         "icon": "file"
  280.     },
  281.     {
  282.         "cmd": "collect ops into patch dir",
  283.         "category": "ops",
  284.         "func": CABLES_CMD_ELECTRON.collectOps,
  285.         "icon": "op"
  286.     },
  287.     {
  288.         "cmd": "manage op directories",
  289.         "category": "ops",
  290.         "func": CABLES_CMD_ELECTRON.manageOpDirs,
  291.         "icon": "folder"
  292.     },
  293.     {
  294.         "cmd": "install ops from package.json",
  295.         "category": "ops",
  296.         "func": CABLES_CMD_ELECTRON.addOpPackage,
  297.         "icon": "op"
  298.     },
  299.     {
  300.         "cmd": "copy op dir to clipboard",
  301.         "category": "ops",
  302.         "func": CABLES_CMD_ELECTRON.copyOpDirToClipboard,
  303.         "icon": "op"
  304.     },
  305.     {
  306.         "cmd": "open op directory",
  307.         "category": "ops",
  308.         "func": CABLES_CMD_ELECTRON.openOpDir,
  309.         "icon": "folder"
  310.     },
  311.     {
  312.         "cmd": "open project directory",
  313.         "category": "patch",
  314.         "func": CABLES_CMD_ELECTRON.openProjectDir,
  315.         "icon": "folder"
  316.     },
  317.     {
  318.         "cmd": "open os file manager",
  319.         "category": "cables",
  320.         "func": CABLES_CMD_ELECTRON.openFileManager,
  321.         "icon": "folder"
  322.     }
  323. );
  325. export default {
  326.     "commands": CMD_ELECTRON_COMMANDS,
  327.     "functions": CABLES_CMD_ELECTRON,
  328.     "functionOverrides": CABLES_CMD_ELECTRON_OVERRIDES,
  329.     "commandOverrides": CABLES_CMD_COMMAND_OVERRIDES,
  330. };