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.toggleTransparentPopout = () =>
  28. // {
  29. //     const current = gui.userSettings.get("transparentpopout", true);
  30. //     gui.userSettings.set("transparentpopout", !current);
  31. //     cablesElectron.editor.notify("Transparent popout canvas: " + (!current ? "enabled" : "disabled"));
  32. // };
  34. CABLES_CMD_ELECTRON.openOpDir = (opId = null, opName = null) =>
  35. {
  36.     const gui = cablesElectron.gui;
  37.     if (gui)
  38.     {
  39.         let options = { "opId": opId, "opName": opName };
  40.         if (!opId && !opName)
  41.         {
  42.             const ops = gui.patchView.getSelectedOps();
  43.             if (!ops.length) return;
  44.             options = {
  45.                 "opId": ops[0].opId,
  46.                 "opName": ops[0].name
  47.             };
  48.         }
  49.         cablesElectron.editor.api("openOpDir", options, (_err, r) => {});
  50.     }
  51. };
  53. CABLES_CMD_ELECTRON.openProjectDir = () =>
  54. {
  55.     cablesElectron.editor.api("openProjectDir", {}, (_err, r) => {});
  56. };
  58. CABLES_CMD_ELECTRON.openFileManager = (url = null) =>
  59. {
  60.     const data = {};
  61.     if (url) data.url = url;
  62.     cablesElectron.editor.api("openFileManager", data, (_err, r) => {});
  63. };
  65. CABLES_CMD_ELECTRON.collectAssets = () =>
  66. {
  67.     const loadingModal = cablesElectron.gui.startModalLoading("Copying assets...");
  68.     let closeTimeout = 2000;
  69.     cablesElectron.editor.api("collectAssets", {}, (_err, r) =>
  70.     {
  71.         if (!_err)
  72.         {
  73.             const ops = cablesElectron.gui.corePatch().ops;
  74.             const oldNew = r.data;
  75.             if (oldNew)
  76.             {
  77.                 const assetPorts = [];
  78.                 for (let i = 0; i < ops.length; i++)
  79.                 {
  80.                     for (let j = 0; j < ops[i].portsIn.length; j++)
  81.                     {
  82.                         if (ops[i].portsIn[j].uiAttribs && ops[i].portsIn[j].uiAttribs.display && ops[i].portsIn[j].uiAttribs.display === "file")
  83.                         {
  84.                             assetPorts.push(ops[i].portsIn[j]);
  85.                         }
  86.                     }
  87.                 }
  88.                 const oldNames = Object.keys(oldNew);
  89.                 if (oldNames.length > 0)
  90.                 {
  91.                     oldNames.forEach((srch) =>
  92.                     {
  93.                         const rplc = oldNew[srch];
  94.                         loadingModal.setTask("copied " + srch + " to " + rplc);
  95.                         assetPorts.forEach((assetPort) =>
  96.                         {
  97.                             let v = assetPort.get();
  98.                             if (v && v.startsWith(srch))
  99.                             {
  100.                                 v = rplc + v.substring(srch.length);
  101.                                 assetPort.set(v);
  102.                             }
  103.                         });
  104.                     });
  105.                     cablesElectron.gui.setStateUnsaved();
  106.                 }
  107.                 else
  108.                 {
  109.                     loadingModal.setTask("nothing to copy");
  110.                 }
  111.             }
  112.             else
  113.             {
  114.                 loadingModal.setTask("nothing to copy");
  115.             }
  116.         }
  117.         else
  118.         {
  119.             loadingModal.setTask("failed to copy assets");
  120.             loadingModal.setTask("---");
  121.             loadingModal.setTask(_err);
  122.             closeTimeout = 5000;
  123.         }
  124.         setTimeout(() => { cablesElectron.gui.endModalLoading(); }, closeTimeout);
  125.     });
  126. };
  128. CABLES_CMD_ELECTRON.collectOps = () =>
  129. {
  130.     const loadingModal = cablesElectron.gui.startModalLoading("Copying ops...");
  131.     let closeTimeout = 2000;
  132.     cablesElectron.editor.api("collectOps", { }, (_err, r) =>
  133.     {
  134.         if (!_err && r && r.data)
  135.         {
  136.             const oldNames = Object.keys(r.data);
  137.             if (r && oldNames.length > 0)
  138.             {
  139.                 oldNames.forEach((srch) =>
  140.                 {
  141.                     const rplc = r.data[srch];
  142.                     loadingModal.setTask("copied " + srch + " to " + rplc);
  143.                 });
  144.             }
  145.             else
  146.             {
  147.                 loadingModal.setTask("nothing to copy");
  148.             }
  149.             setTimeout(() => { cablesElectron.gui.endModalLoading(); }, closeTimeout);
  150.         }
  151.         else
  152.         {
  153.             loadingModal.setTask("failed to copy ops");
  154.             loadingModal.setTask("---");
  155.             loadingModal.setTask(_err);
  156.             closeTimeout = 5000;
  157.             setTimeout(() => { cablesElectron.gui.endModalLoading(); }, closeTimeout);
  158.         }
  159.     });
  160. };
  162. CABLES_CMD_ELECTRON.manageOpDirs = () =>
  163. {
  164.     cablesElectron.openOpDirsTab();
  165. };
  167. CABLES_CMD_ELECTRON.copyOpDirToClipboard = (opId = null) =>
  168. {
  169.     const gui = cablesElectron.gui;
  170.     if (gui)
  171.     {
  172.         if (!opId)
  173.         {
  174.             const ops = gui.patchView.getSelectedOps();
  175.             if (!ops.length) return;
  176.             opId = ops[0].opId;
  177.         }
  178.         const modulePath = window.ipcRenderer.sendSync("getOpDir", { "opId": opId });
  179.         if (modulePath)
  180.         {
  181.             navigator.clipboard.writeText(modulePath);
  182.             cablesElectron.editor.notify("Op path copied to clipboard");
  183.         }
  184.     }
  185. };
  187. CABLES_CMD_ELECTRON_OVERRIDES.PATCH = {};
  188. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.saveAs = () =>
  189. {
  190.     const gui = cablesElectron.gui;
  191.     let patchName = cablesElectron.gui.project() ? cablesElectron.gui.project().name : null;
  193.     let b64 = null;
  194.     if (gui)
  195.     {
  196.         const patch = cablesElectron.gui.patchView.store.makePatchSavable();
  197.         const patchstr = JSON.stringify(patch);
  198.         let uint8data = pako.deflate(patchstr);
  199.         b64 = bytesArrToBase64(uint8data);
  200.     }
  201.     cablesElectron.editor.api("saveProjectAs", {
  202.         "name": patchName,
  203.         "dataB64": b64
  204.     }, (err) =>
  205.     {
  206.         if (!err && gui)
  207.         {
  208.             gui.savedState.setSaved("save as end", 0);
  209.         }
  210.     });
  211. };
  212. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.uploadFileDialog = () =>
  213. {
  214.     cablesElectron.editor.api("selectFile", {}, (_err, filepath) =>
  215.     {
  216.         if (!_err && filepath)
  217.         {
  218.             const gui = cablesElectron.gui;
  219.             if (gui) gui.patchView.addAssetOpAuto(filepath);
  220.         }
  221.     });
  222. };
  223. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.newPatch = () =>
  224. {
  225.     cablesElectron.editor.api("newPatch", { }, (_err, r) => {});
  226. };
  228. CABLES_CMD_ELECTRON_OVERRIDES.PATCH.renameOp = (opName = null) =>
  229. {
  230.     const gui = cablesElectron.gui;
  231.     if (gui)
  232.     {
  233.         if (!opName)
  234.         {
  235.             const ops = gui.patchView.getSelectedOps();
  236.             if (!ops.length) return;
  238.             const op = ops[0];
  239.             opName = op.objName;
  240.         }
  242.         gui.serverOps.renameDialog(opName);
  243.     }
  244. };
  246. CABLES_CMD_ELECTRON_OVERRIDES.RENDERER = {};
  247. CABLES_CMD_ELECTRON_OVERRIDES.RENDERER.fullscreen = () =>
  248. {
  249.     cablesElectron.editor.api("cycleFullscreen", { }, (_err, r) => {});
  250. };
  252. CABLES_CMD_ELECTRON_OVERRIDES.RENDERER.popoutCanvas = () =>
  253. {
  254.     const gui = cablesElectron.gui;
  255.     if (gui && gui.canvasManager)
  256.     {
  257.         gui.canvasManager.popOut();
  258.         if (gui.canvasManager.subWindow)
  259.         {
  260.             const transparent = gui.userSettings.get("transparentpopout", false);
  261.             if (transparent)
  262.             {
  263.                 const nDocument = gui.canvasManager.subWindow.document;
  264.                 const style = nDocument.createElement("style");
  265.                 style.innerHTML = "body { background-color: transparent !important; } .bgpatternDark, .bgPatternDark { background-image: none !important; background-color: transparent !important; }";
  266.                 nDocument.body.appendChild(style);
  267.             }
  268.         }
  269.     }
  270. };
  272. CABLES_CMD_ELECTRON_OVERRIDES.UI = {};
  273. CABLES_CMD_ELECTRON_OVERRIDES.UI.windowFullscreen = () =>
  274. {
  275.     cablesElectron.editor.api("cycleFullscreen", { }, (_err, r) => {});
  276. };
  278. const CABLES_CMD_COMMAND_OVERRIDES = [
  279.     {
  280.         "cmd": "save patch as...",
  281.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.saveAs
  282.     },
  283.     {
  284.         "cmd": "upload file dialog",
  285.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.uploadFileDialog
  286.     },
  287.     {
  288.         "cmd": "create new patch",
  289.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.newPatch
  290.     },
  291.     {
  292.         "cmd": "rename op",
  293.         "func": CABLES_CMD_ELECTRON_OVERRIDES.PATCH.renameOp
  294.     },
  295.     {
  296.         "cmd": "Toggle window fullscreen",
  297.         "func": CABLES_CMD_ELECTRON_OVERRIDES.UI.windowFullscreen
  298.     }
  299. ];
  301. CMD_ELECTRON_COMMANDS.push(
  302.     {
  303.         "cmd": "collect assets into patch dir",
  304.         "category": "patch",
  305.         "func": CABLES_CMD_ELECTRON.collectAssets,
  306.         "icon": "file"
  307.     },
  308.     {
  309.         "cmd": "collect ops into patch dir",
  310.         "category": "ops",
  311.         "func": CABLES_CMD_ELECTRON.collectOps,
  312.         "icon": "op"
  313.     },
  314.     {
  315.         "cmd": "manage op directories",
  316.         "category": "ops",
  317.         "func": CABLES_CMD_ELECTRON.manageOpDirs,
  318.         "icon": "folder"
  319.     },
  320.     // {
  321.     //     "cmd": "install ops from package.json",
  322.     //     "category": "ops",
  323.     //     "func": CABLES_CMD_ELECTRON.addOpPackage,
  324.     //     "icon": "op"
  325.     // },
  326.     {
  327.         "cmd": "copy op dir to clipboard",
  328.         "category": "ops",
  329.         "func": CABLES_CMD_ELECTRON.copyOpDirToClipboard,
  330.         "icon": "op"
  331.     },
  332.     {
  333.         "cmd": "open op directory",
  334.         "category": "ops",
  335.         "func": CABLES_CMD_ELECTRON.openOpDir,
  336.         "icon": "folder"
  337.     },
  338.     {
  339.         "cmd": "open project directory",
  340.         "category": "patch",
  341.         "func": CABLES_CMD_ELECTRON.openProjectDir,
  342.         "icon": "folder"
  343.     },
  344.     {
  345.         "cmd": "open os file manager",
  346.         "category": "cables",
  347.         "func": CABLES_CMD_ELECTRON.openFileManager,
  348.         "icon": "folder"
  349.     }
  350. );
  352. export default {
  353.     "commands": CMD_ELECTRON_COMMANDS,
  354.     "functions": CABLES_CMD_ELECTRON,
  355.     "functionOverrides": CABLES_CMD_ELECTRON_OVERRIDES,
  356.     "commandOverrides": CABLES_CMD_COMMAND_OVERRIDES,
  357. };