DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 20 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1657 Commits
12 Branches
263MB
Tree: 3d44fb9d79
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3d44fb9d79'
${ noResults }
Cardinal/src/CardinalCommon.cpp

1139 lines
32KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021-2023 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 3 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the LICENSE file.

  16.  */

  17. 

  18. /**

  19.  * This file is partially based on VCVRack's patch.cpp

  20.  * Copyright (C) 2016-2021 VCV.

  21.  *

  22.  * This program is free software: you can redistribute it and/or

  23.  * modify it under the terms of the GNU General Public License as

  24.  * published by the Free Software Foundation; either version 3 of

  25.  * the License, or (at your option) any later version.

  26.  */

  27. 

  28. #include "CardinalCommon.hpp"

  29. 

  30. #include "AsyncDialog.hpp"

  31. #include "PluginContext.hpp"

  32. #include "DistrhoPluginUtils.hpp"

  33. 

  34. #include <asset.hpp>

  35. #include <context.hpp>

  36. #include <history.hpp>

  37. #include <patch.hpp>

  38. #include <settings.hpp>

  39. #include <string.hpp>

  40. #include <system.hpp>

  41. #include <app/Browser.hpp>

  42. #include <app/Scene.hpp>

  43. #include <engine/Engine.hpp>

  44. #include <window/Window.hpp>

  45. 

  46. #ifndef DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  47. # error wrong build

  48. #endif

  49. 

  50. #if (defined(STATIC_BUILD) && !defined(__MOD_DEVICES__)) || CARDINAL_VARIANT_MINI

  51. # undef CARDINAL_INIT_OSC_THREAD

  52. #endif

  53. 

  54. #ifdef NDEBUG

  55. # undef DEBUG

  56. #endif

  57. 

  58. // for finding special paths

  59. #ifdef ARCH_WIN

  60. # include <shlobj.h>

  61. #else

  62. # include <pwd.h>

  63. # include <unistd.h>

  64. #endif

  65. 

  66. #ifdef HAVE_LIBLO

  67. # include <lo/lo.h>

  68. #endif

  69. 

  70. #ifdef DISTRHO_OS_WASM

  71. # include <emscripten/emscripten.h>

  72. #endif

  73. 

  74. #if defined(CARDINAL_COMMON_DSP_ONLY) || defined(HEADLESS)

  75. # define HEADLESS_BEHAVIOUR

  76. #endif

  77. 

  78. #if CARDINAL_VARIANT_FX

  79. # define CARDINAL_VARIANT_NAME "fx"

  80. #elif CARDINAL_VARIANT_MINI

  81. # define CARDINAL_VARIANT_NAME "mini"

  82. #elif CARDINAL_VARIANT_NATIVE

  83. # define CARDINAL_VARIANT_NAME "native"

  84. #elif CARDINAL_VARIANT_SYNTH

  85. # define CARDINAL_VARIANT_NAME "synth"

  86. #else

  87. # define CARDINAL_VARIANT_NAME "main"

  88. #endif

  89. 

  90. #ifdef DISTRHO_OS_WASM

  91. # if CARDINAL_VARIANT_MINI

  92. #  define CARDINAL_WASM_WELCOME_TEMPLATE_FILENAME "welcome-wasm-mini"

  93. # else

  94. #  define CARDINAL_WASM_WELCOME_TEMPLATE_FILENAME "welcome-wasm"

  95. # endif

  96. #endif

  97. 

  98. namespace rack {

  99. namespace asset {

  100. std::string patchesPath();

  101. void destroy();

  102. }

  103. namespace plugin {

  104. void initStaticPlugins();

  105. void destroyStaticPlugins();

  106. }

  107. }

  108. 

  109. const std::string CARDINAL_VERSION = "23.07";

  110. 

  111. START_NAMESPACE_DISTRHO

  112. 

  113. // -----------------------------------------------------------------------------------------------------------

  114. 

  115. #ifndef HEADLESS

  116. void handleHostParameterDrag(const CardinalPluginContext* pcontext, uint index, bool started)

  117. {

  118.     DISTRHO_SAFE_ASSERT_RETURN(pcontext->ui != nullptr,);

  119. 

  120.    #ifndef CARDINAL_COMMON_DSP_ONLY

  121.     if (started)

  122.     {

  123.         pcontext->ui->editParameter(index, true);

  124.         pcontext->ui->setParameterValue(index, pcontext->parameters[index]);

  125.     }

  126.     else

  127.     {

  128.         pcontext->ui->editParameter(index, false);

  129.     }

  130.    #endif

  131. }

  132. #endif

  133. 

  134. // --------------------------------------------------------------------------------------------------------------------

  135. 

  136. #ifndef HEADLESS

  137. bool CardinalPluginContext::addIdleCallback(IdleCallback* const cb) const

  138. {

  139.    #ifndef CARDINAL_COMMON_DSP_ONLY

  140.     if (ui != nullptr)

  141.     {

  142.         ui->addIdleCallback(cb);

  143.         return true;

  144.     }

  145.    #else

  146.     // unused

  147.     (void)cb;

  148.    #endif

  149. 

  150.     return false;

  151. }

  152. 

  153. void CardinalPluginContext::removeIdleCallback(IdleCallback* const cb) const

  154. {

  155.    #ifndef CARDINAL_COMMON_DSP_ONLY

  156.     if (ui != nullptr)

  157.         ui->removeIdleCallback(cb);

  158.    #else

  159.     // unused

  160.     (void)cb;

  161.    #endif

  162. }

  163. #endif

  164. 

  165. void CardinalPluginContext::writeMidiMessage(const rack::midi::Message& message, const uint8_t channel)

  166. {

  167.     if (bypassed)

  168.         return;

  169. 

  170.     const size_t size = message.bytes.size();

  171.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  172.     DISTRHO_SAFE_ASSERT_RETURN(message.frame >= 0,);

  173. 

  174.     MidiEvent event;

  175.     event.frame = message.frame;

  176. 

  177.     switch (message.bytes[0] & 0xF0)

  178.     {

  179.     case 0x80:

  180.     case 0x90:

  181.     case 0xA0:

  182.     case 0xB0:

  183.     case 0xE0:

  184.         event.size = 3;

  185.         break;

  186.     case 0xC0:

  187.     case 0xD0:

  188.         event.size = 2;

  189.         break;

  190.     case 0xF0:

  191.         switch (message.bytes[0] & 0x0F)

  192.         {

  193.         case 0x0:

  194.         case 0x4:

  195.         case 0x5:

  196.         case 0x7:

  197.         case 0x9:

  198.         case 0xD:

  199.             // unsupported

  200.             return;

  201.         case 0x1:

  202.         case 0x2:

  203.         case 0x3:

  204.         case 0xE:

  205.             event.size = 3;

  206.             break;

  207.         case 0x6:

  208.         case 0x8:

  209.         case 0xA:

  210.         case 0xB:

  211.         case 0xC:

  212.         case 0xF:

  213.             event.size = 1;

  214.             break;

  215.         }

  216.         break;

  217.     default:

  218.         // invalid

  219.         return;

  220.     }

  221. 

  222.     DISTRHO_SAFE_ASSERT_RETURN(size >= event.size,);

  223. 

  224.     std::memcpy(event.data, message.bytes.data(), event.size);

  225. 

  226.     if (channel != 0 && event.data[0] < 0xF0)

  227.         event.data[0] |= channel & 0x0F;

  228. 

  229.     plugin->writeMidiEvent(event);

  230. }

  231. 

  232. // -----------------------------------------------------------------------------------------------------------

  233. 

  234. #ifdef HAVE_LIBLO

  235. static void osc_error_handler(int num, const char* msg, const char* path)

  236. {

  237.     d_stderr("Cardinal OSC Error: code: %i, msg: \"%s\", path: \"%s\")", num, msg, path);

  238. }

  239. 

  240. static int osc_fallback_handler(const char* const path, const char* const types, lo_arg**, int, lo_message, void*)

  241. {

  242.     d_stderr("Cardinal OSC unhandled message \"%s\" with types \"%s\"", path, types);

  243.     return 0;

  244. }

  245. 

  246. static int osc_hello_handler(const char*, const char*, lo_arg**, int, const lo_message m, void* const self)

  247. {

  248.     d_stdout("Hello received from OSC, saying hello back to them o/");

  249.     const lo_address source = lo_message_get_source(m);

  250.     const lo_server server = static_cast<Initializer*>(self)->oscServer;

  251.     lo_send_from(source, server, LO_TT_IMMEDIATE, "/resp", "ss", "hello", "ok");

  252.     return 0;

  253. }

  254. 

  255. static int osc_load_handler(const char*, const char* types, lo_arg** argv, int argc, const lo_message m, void* const self)

  256. {

  257.     d_debug("osc_load_handler()");

  258.     DISTRHO_SAFE_ASSERT_RETURN(argc == 1, 0);

  259.     DISTRHO_SAFE_ASSERT_RETURN(types != nullptr && types[0] == 'b', 0);

  260. 

  261.     const int32_t size = argv[0]->blob.size;

  262.     DISTRHO_SAFE_ASSERT_RETURN(size > 4, 0);

  263. 

  264.     const uint8_t* const blob = (uint8_t*)(&argv[0]->blob.data);

  265.     DISTRHO_SAFE_ASSERT_RETURN(blob != nullptr, 0);

  266. 

  267.     bool ok = false;

  268. 

  269.     if (CardinalBasePlugin* const plugin = static_cast<Initializer*>(self)->remotePluginInstance)

  270.     {

  271.         CardinalPluginContext* const context = plugin->context;

  272.         std::vector<uint8_t> data(size);

  273.         std::memcpy(data.data(), blob, size);

  274. 

  275.         rack::contextSet(context);

  276.         rack::system::removeRecursively(context->patch->autosavePath);

  277.         rack::system::createDirectories(context->patch->autosavePath);

  278.         try {

  279.             rack::system::unarchiveToDirectory(data, context->patch->autosavePath);

  280.             context->patch->loadAutosave();

  281.             ok = true;

  282.         }

  283.         catch (rack::Exception& e) {

  284.             WARN("%s", e.what());

  285.         }

  286.         rack::contextSet(nullptr);

  287.     }

  288. 

  289.     const lo_address source = lo_message_get_source(m);

  290.     const lo_server server = static_cast<Initializer*>(self)->oscServer;

  291.     lo_send_from(source, server, LO_TT_IMMEDIATE, "/resp", "ss", "load", ok ? "ok" : "fail");

  292.     return 0;

  293. }

  294. 

  295. static int osc_param_handler(const char*, const char* types, lo_arg** argv, int argc, const lo_message m, void* const self)

  296. {

  297.     d_debug("osc_param_handler()");

  298.     DISTRHO_SAFE_ASSERT_RETURN(argc == 3, 0);

  299.     DISTRHO_SAFE_ASSERT_RETURN(types != nullptr, 0);

  300.     DISTRHO_SAFE_ASSERT_RETURN(types[0] == 'h', 0);

  301.     DISTRHO_SAFE_ASSERT_RETURN(types[1] == 'i', 0);

  302.     DISTRHO_SAFE_ASSERT_RETURN(types[2] == 'f', 0);

  303. 

  304.     if (CardinalBasePlugin* const plugin = static_cast<Initializer*>(self)->remotePluginInstance)

  305.     {

  306.         CardinalPluginContext* const context = plugin->context;

  307. 

  308.         const int64_t moduleId = argv[0]->h;

  309.         const int paramId = argv[1]->i;

  310.         const float paramValue = argv[2]->f;

  311. 

  312.         rack::engine::Module* const module = context->engine->getModule(moduleId);

  313.         DISTRHO_SAFE_ASSERT_RETURN(module != nullptr, 0);

  314. 

  315.         context->engine->setParamValue(module, paramId, paramValue);

  316.     }

  317. 

  318.     return 0;

  319. }

  320. 

  321. static int osc_host_param_handler(const char*, const char* types, lo_arg** argv, int argc, const lo_message m, void* const self)

  322. {

  323.     d_debug("osc_host_param_handler()");

  324.     DISTRHO_SAFE_ASSERT_RETURN(argc == 2, 0);

  325.     DISTRHO_SAFE_ASSERT_RETURN(types != nullptr, 0);

  326.     DISTRHO_SAFE_ASSERT_RETURN(types[0] == 'i', 0);

  327.     DISTRHO_SAFE_ASSERT_RETURN(types[1] == 'f', 0);

  328. 

  329.     if (CardinalBasePlugin* const plugin = static_cast<Initializer*>(self)->remotePluginInstance)

  330.     {

  331.         CardinalPluginContext* const context = plugin->context;

  332. 

  333.         const int paramId = argv[0]->i;

  334.         DISTRHO_SAFE_ASSERT_RETURN(paramId >= 0, 0);

  335. 

  336.         const uint uparamId = static_cast<uint>(paramId);

  337.         DISTRHO_SAFE_ASSERT_UINT2_RETURN(uparamId < kModuleParameterCount, uparamId, kModuleParameterCount, 0);

  338. 

  339.         const float paramValue = argv[1]->f;

  340. 

  341.         context->parameters[uparamId] = paramValue;

  342.     }

  343. 

  344.     return 0;

  345. }

  346. 

  347. # ifdef CARDINAL_INIT_OSC_THREAD

  348. static int osc_screenshot_handler(const char*, const char* types, lo_arg** argv, int argc, const lo_message m, void* const self)

  349. {

  350.     d_debug("osc_screenshot_handler()");

  351.     DISTRHO_SAFE_ASSERT_RETURN(argc == 1, 0);

  352.     DISTRHO_SAFE_ASSERT_RETURN(types != nullptr && types[0] == 'b', 0);

  353. 

  354.     const int32_t size = argv[0]->blob.size;

  355.     DISTRHO_SAFE_ASSERT_RETURN(size > 4, 0);

  356. 

  357.     const uint8_t* const blob = (uint8_t*)(&argv[0]->blob.data);

  358.     DISTRHO_SAFE_ASSERT_RETURN(blob != nullptr, 0);

  359. 

  360.     bool ok = false;

  361. 

  362.     if (CardinalBasePlugin* const plugin = static_cast<Initializer*>(self)->remotePluginInstance)

  363.     {

  364.         if (char* const screenshot = String::asBase64(blob, size).getAndReleaseBuffer())

  365.         {

  366.             ok = plugin->updateStateValue("screenshot", screenshot);

  367.             std::free(screenshot);

  368.         }

  369.     }

  370. 

  371.     const lo_address source = lo_message_get_source(m);

  372.     const lo_server server = static_cast<Initializer*>(self)->oscServer;

  373.     lo_send_from(source, server, LO_TT_IMMEDIATE, "/resp", "ss", "screenshot", ok ? "ok" : "fail");

  374.     return 0;

  375. }

  376. # endif

  377. #endif

  378. 

  379. // -----------------------------------------------------------------------------------------------------------

  380. 

  381. #if defined(DISTRHO_OS_WASM) && !defined(CARDINAL_COMMON_UI_ONLY)

  382. static void WebBrowserDataLoaded(void* const data)

  383. {

  384.     static_cast<Initializer*>(data)->loadSettings(true);

  385. }

  386. #endif

  387. 

  388. // -----------------------------------------------------------------------------------------------------------

  389. 

  390. Initializer::Initializer(const CardinalBasePlugin* const plugin, const CardinalBaseUI* const ui)

  391. {

  392.     using namespace rack;

  393. 

  394.     // Cardinal default settings, potentially overriding VCV Rack ones

  395.     settings::allowCursorLock = false;

  396.     settings::tooltips = true;

  397.     settings::cableOpacity = 0.5f;

  398.     settings::cableTension = 0.75f;

  399.     settings::rackBrightness = 1.0f;

  400.     settings::haloBrightness = 0.25f;

  401.     settings::knobMode = settings::KNOB_MODE_LINEAR;

  402.     settings::knobScroll = false;

  403.     settings::knobScrollSensitivity = 0.001f;

  404.     settings::lockModules = false;

  405.     settings::browserSort = settings::BROWSER_SORT_UPDATED;

  406.     settings::browserZoom = -1.f;

  407.     settings::invertZoom = false;

  408.     settings::squeezeModules = true;

  409.     settings::darkMode = true;

  410.     settings::uiTheme = "dark";

  411. 

  412.     // runtime behaviour

  413.     settings::devMode = true;

  414.     settings::isPlugin = true;

  415.    #ifdef HEADLESS_BEHAVIOUR

  416.     settings::headless = true;

  417.    #endif

  418. 

  419.     // copied from https://community.vcvrack.com/t/16-colour-cable-palette/15951

  420.     settings::cableColors = {

  421.         color::fromHexString("#ff5252"),

  422.         color::fromHexString("#ff9352"),

  423.         color::fromHexString("#ffd452"),

  424.         color::fromHexString("#e8ff52"),

  425.         color::fromHexString("#a8ff52"),

  426.         color::fromHexString("#67ff52"),

  427.         color::fromHexString("#52ff7d"),

  428.         color::fromHexString("#52ffbe"),

  429.         color::fromHexString("#52ffff"),

  430.         color::fromHexString("#52beff"),

  431.         color::fromHexString("#527dff"),

  432.         color::fromHexString("#6752ff"),

  433.         color::fromHexString("#a852ff"),

  434.         color::fromHexString("#e952ff"),

  435.         color::fromHexString("#ff52d4"),

  436.         color::fromHexString("#ff5293"),

  437.     };

  438. 

  439.     system::init();

  440.     logger::init();

  441.     random::init();

  442.     ui::init();

  443. 

  444.    #ifdef CARDINAL_COMMON_UI_ONLY

  445.     constexpr const bool isRealInstance = true;

  446.    #else

  447.     const bool isRealInstance = !plugin->isDummyInstance();

  448.    #endif

  449. 

  450.     if (asset::systemDir.empty())

  451.     {

  452.         if (const char* const bundlePath = (plugin != nullptr ? plugin->getBundlePath() :

  453.                                            #if DISTRHO_PLUGIN_HAS_UI

  454.                                             ui != nullptr ? ui->getBundlePath() :

  455.                                            #endif

  456.                                             nullptr))

  457.         {

  458.             if (const char* const resourcePath = getResourcePath(bundlePath))

  459.             {

  460.                 asset::systemDir = resourcePath;

  461.                 asset::bundlePath = system::join(asset::systemDir, "PluginManifests");

  462.             }

  463.         }

  464. 

  465.         if (asset::systemDir.empty() || ! system::exists(asset::systemDir) || ! system::exists(asset::bundlePath))

  466.         {

  467.            #ifdef CARDINAL_PLUGIN_SOURCE_DIR

  468.             // Make system dir point to source code location as fallback

  469.             asset::systemDir = CARDINAL_PLUGIN_SOURCE_DIR DISTRHO_OS_SEP_STR "Rack";

  470.             asset::bundlePath.clear();

  471. 

  472.             // If source code dir does not exist use install target prefix as system dir

  473.             if (!system::exists(system::join(asset::systemDir, "res")))

  474.            #endif

  475.             {

  476.                #if defined(DISTRHO_OS_WASM)

  477.                 asset::systemDir = "/resources";

  478.                #elif defined(ARCH_MAC)

  479.                 asset::systemDir = "/Library/Application Support/Cardinal";

  480.                #elif defined(ARCH_WIN)

  481.                 asset::systemDir = system::join(getSpecialPath(kSpecialPathCommonProgramFiles), "Cardinal");

  482.                #else

  483.                 asset::systemDir = CARDINAL_PLUGIN_PREFIX "/share/cardinal";

  484.                #endif

  485.                 asset::bundlePath = system::join(asset::systemDir, "PluginManifests");

  486.             }

  487.         }

  488.     }

  489. 

  490.     if (asset::userDir.empty())

  491.     {

  492.        #if defined(DISTRHO_OS_WASM)

  493.         asset::userDir = "/userfiles";

  494.        #elif defined(ARCH_MAC)

  495.         asset::userDir = system::join(homeDir(), "Documents", "Cardinal");

  496.        #elif defined(ARCH_WIN)

  497.         asset::userDir = system::join(getSpecialPath(kSpecialPathMyDocuments), "Cardinal");

  498.        #else

  499.         if (const char* const xdgEnv = getenv("XDG_DOCUMENTS_DIR"))

  500.             asset::userDir = system::join(xdgEnv, "Cardinal");

  501.         else

  502.             asset::userDir = system::join(homeDir(), "Documents", "Cardinal");

  503.        #endif

  504. 

  505.         if (isRealInstance)

  506.         {

  507.             system::createDirectory(asset::userDir);

  508.            #if defined(DISTRHO_OS_WASM) && !defined(CARDINAL_COMMON_UI_ONLY)

  509.             EM_ASM({

  510.                 Module.FS.mount(Module.IDBFS, {}, '/userfiles');

  511.                 Module.FS.syncfs(true, function(err) { if (!err) { dynCall('vi', $0, [$1]) } });

  512.             }, WebBrowserDataLoaded, this);

  513.            #endif

  514.         }

  515.     }

  516. 

  517.    #ifndef CARDINAL_COMMON_DSP_ONLY

  518.     if (asset::configDir.empty())

  519.     {

  520.        #if defined(ARCH_MAC) || defined(ARCH_WIN) || defined(DISTRHO_OS_WASM)

  521.         asset::configDir = asset::userDir;

  522.        #else

  523.         if (const char* const xdgEnv = getenv("XDG_CONFIG_HOME"))

  524.             asset::configDir = system::join(xdgEnv, "Cardinal");

  525.         else

  526.             asset::configDir = system::join(homeDir(), ".config", "Cardinal");

  527. 

  528.         if (isRealInstance)

  529.             system::createDirectory(asset::configDir);

  530.        #endif

  531.     }

  532.    #endif

  533.    

  534.     if (settings::settingsPath.empty())

  535.         settings::settingsPath = asset::config(CARDINAL_VARIANT_NAME ".json");

  536. 

  537.     templatePath = asset::user("templates/" CARDINAL_VARIANT_NAME ".vcv");

  538.    #ifdef DISTRHO_OS_WASM

  539.     factoryTemplatePath = system::join(asset::patchesPath(), CARDINAL_WASM_WELCOME_TEMPLATE_FILENAME ".vcv");

  540.    #else

  541.     factoryTemplatePath = system::join(asset::patchesPath(), "templates/" CARDINAL_VARIANT_NAME ".vcv");

  542.    #endif

  543. 

  544.     // Log environment

  545.     INFO("%s %s %s, compatible with Rack version %s", APP_NAME.c_str(), APP_EDITION.c_str(), CARDINAL_VERSION.c_str(), APP_VERSION.c_str());

  546.     INFO("%s", system::getOperatingSystemInfo().c_str());

  547.     INFO("Binary filename: %s", getBinaryFilename());

  548.     if (plugin != nullptr) {

  549.         INFO("Bundle path: %s", plugin->getBundlePath());

  550.    #if DISTRHO_PLUGIN_HAS_UI

  551.     } else if (ui != nullptr) {

  552.         INFO("Bundle path: %s", ui->getBundlePath());

  553.    #endif

  554.     }

  555.     INFO("System directory: %s", asset::systemDir.c_str());

  556.     INFO("User directory: %s", asset::userDir.c_str());

  557.     INFO("Template patch: %s", templatePath.c_str());

  558.     INFO("System template patch: %s", factoryTemplatePath.c_str());

  559. 

  560.     // Report to user if something is wrong with the installation

  561.     if (asset::systemDir.empty())

  562.     {

  563.         d_stderr2("Failed to locate Cardinal plugin bundle.\n"

  564.                     "Install Cardinal with its bundle folder intact and try again.");

  565.     }

  566.     else if (! system::exists(asset::systemDir))

  567.     {

  568.         d_stderr2("System directory \"%s\" does not exist.\n"

  569.                     "Make sure Cardinal was downloaded and installed correctly.", asset::systemDir.c_str());

  570.     }

  571. 

  572.     INFO("Initializing plugins");

  573.     plugin::initStaticPlugins();

  574. 

  575.     INFO("Initializing plugin browser DB");

  576.     app::browserInit();

  577. 

  578.     loadSettings(isRealInstance);

  579. 

  580.    #if defined(CARDINAL_INIT_OSC_THREAD)

  581.     INFO("Initializing OSC Remote control");

  582.     const char* port;

  583.     if (const char* const portEnv = std::getenv("CARDINAL_REMOTE_HOST_PORT"))

  584.         port = portEnv;

  585.     else

  586.         port = CARDINAL_DEFAULT_REMOTE_PORT;

  587.     startRemoteServer(port);

  588.    #elif defined(HAVE_LIBLO)

  589.     if (isStandalone()) {

  590.         INFO("OSC Remote control is available on request");

  591.     } else {

  592.         INFO("OSC Remote control is not available on plugin variants");

  593.     }

  594.    #else

  595.     INFO("OSC Remote control is not enabled in this build");

  596.    #endif

  597. }

  598. 

  599. Initializer::~Initializer()

  600. {

  601.     using namespace rack;

  602. 

  603.    #ifdef HAVE_LIBLO

  604.     stopRemoteServer();

  605.    #endif

  606. 

  607.     if (shouldSaveSettings)

  608.     {

  609.         INFO("Save settings");

  610.         settings::save();

  611.     }

  612. 

  613.     INFO("Clearing asset paths");

  614.     asset::bundlePath.clear();

  615.     asset::systemDir.clear();

  616.     asset::userDir.clear();

  617. 

  618.     INFO("Destroying plugins");

  619.     plugin::destroyStaticPlugins();

  620. 

  621.     INFO("Destroying colourized assets");

  622.     asset::destroy();

  623. 

  624.     INFO("Destroying settings");

  625.     settings::destroy();

  626. 

  627.     INFO("Destroying logger");

  628.     logger::destroy();

  629. }

  630. 

  631. void Initializer::loadSettings(const bool isRealInstance)

  632. {

  633.     using namespace rack;

  634. 

  635.     if (isRealInstance)

  636.     {

  637.         INFO("Loading settings");

  638.         settings::load();

  639.         shouldSaveSettings = true;

  640.     }

  641. 

  642.     // enforce settings that do not make sense as anything else

  643.     settings::safeMode = false;

  644.     settings::token.clear();

  645.     settings::windowMaximized = false;

  646.     settings::windowPos = math::Vec(0, 0);

  647.     settings::pixelRatio = 0.0;

  648.     settings::sampleRate = 0;

  649.     settings::threadCount = 1;

  650.     settings::autosaveInterval = 0;

  651.     settings::skipLoadOnLaunch = true;

  652.     settings::autoCheckUpdates = false;

  653.     settings::showTipsOnLaunch = false;

  654.     settings::tipIndex = -1;

  655. 

  656.     if (settings::uiTheme != "dark" && settings::uiTheme != "light")

  657.     {

  658.         settings::uiTheme = "dark";

  659.         rack::ui::refreshTheme();

  660.     }

  661. 

  662.     // reload dark/light mode as necessary

  663.     switchDarkMode(settings::uiTheme == "dark");

  664. }

  665. 

  666. #ifdef HAVE_LIBLO

  667. bool Initializer::startRemoteServer(const char* const port)

  668. {

  669.    #ifdef CARDINAL_INIT_OSC_THREAD

  670.     if (oscServerThread != nullptr)

  671.         return true;

  672. 

  673.     if ((oscServerThread = lo_server_thread_new_with_proto(port, LO_UDP, osc_error_handler)) == nullptr)

  674.         return false;

  675. 

  676.     oscServer = lo_server_thread_get_server(oscServerThread);

  677. 

  678.     lo_server_thread_add_method(oscServerThread, "/hello", "", osc_hello_handler, this);

  679.     lo_server_thread_add_method(oscServerThread, "/host-param", "if", osc_host_param_handler, this);

  680.     lo_server_thread_add_method(oscServerThread, "/load", "b", osc_load_handler, this);

  681.     lo_server_thread_add_method(oscServerThread, "/param", "hif", osc_param_handler, this);

  682.     lo_server_thread_add_method(oscServerThread, "/screenshot", "b", osc_screenshot_handler, this);

  683.     lo_server_thread_add_method(oscServerThread, nullptr, nullptr, osc_fallback_handler, nullptr);

  684.     lo_server_thread_start(oscServerThread);

  685.    #else

  686.     if (oscServer != nullptr)

  687.         return true;

  688. 

  689.     if ((oscServer = lo_server_new_with_proto(port, LO_UDP, osc_error_handler)) == nullptr)

  690.         return false;

  691. 

  692.     lo_server_add_method(oscServer, "/hello", "", osc_hello_handler, this);

  693.     lo_server_add_method(oscServer, "/host-param", "if", osc_host_param_handler, this);

  694.     lo_server_add_method(oscServer, "/load", "b", osc_load_handler, this);

  695.     lo_server_add_method(oscServer, "/param", "hif", osc_param_handler, this);

  696.     lo_server_add_method(oscServer, nullptr, nullptr, osc_fallback_handler, nullptr);

  697.    #endif

  698. 

  699.     return true;

  700. }

  701. 

  702. void Initializer::stopRemoteServer()

  703. {

  704.     DISTRHO_SAFE_ASSERT(remotePluginInstance == nullptr);

  705. 

  706.    #ifdef CARDINAL_INIT_OSC_THREAD

  707.     if (oscServerThread != nullptr)

  708.     {

  709.         lo_server_thread_stop(oscServerThread);

  710.         lo_server_thread_del_method(oscServerThread, nullptr, nullptr);

  711.         lo_server_thread_free(oscServerThread);

  712.         oscServerThread = oscServer = nullptr;

  713.     }

  714.    #else

  715.     if (oscServer != nullptr)

  716.     {

  717.         lo_server_del_method(oscServer, nullptr, nullptr);

  718.         lo_server_free(oscServer);

  719.         oscServer = nullptr;

  720.     }

  721.    #endif

  722. }

  723. 

  724. void Initializer::stepRemoteServer()

  725. {

  726.     DISTRHO_SAFE_ASSERT_RETURN(oscServer != nullptr,);

  727.     DISTRHO_SAFE_ASSERT_RETURN(remotePluginInstance != nullptr,);

  728. 

  729.    #ifndef CARDINAL_INIT_OSC_THREAD

  730.     for (;;)

  731.     {

  732.         try {

  733.             if (lo_server_recv_noblock(oscServer, 0) == 0)

  734.                 break;

  735.         } DISTRHO_SAFE_EXCEPTION_CONTINUE("stepRemoteServer")

  736.     }

  737.    #endif

  738. }

  739. #endif // HAVE_LIBLO

  740. 

  741. // --------------------------------------------------------------------------------------------------------------------

  742. 

  743. END_NAMESPACE_DISTRHO

  744. 

  745. // --------------------------------------------------------------------------------------------------------------------

  746. 

  747. namespace rack {

  748. 

  749. bool isMini()

  750. {

  751. #if CARDINAL_VARIANT_MINI

  752.     return true;

  753. #else

  754.     return false;

  755. #endif

  756. }

  757. 

  758. bool isStandalone()

  759. {

  760.     static const bool standalone = std::strstr(getPluginFormatName(), "Standalone") != nullptr;

  761.     return standalone;

  762. }

  763. 

  764. #ifdef ARCH_WIN

  765. std::string getSpecialPath(const SpecialPath type)

  766. {

  767.     int csidl;

  768.     switch (type)

  769.     {

  770.     case kSpecialPathUserProfile:

  771.         csidl = CSIDL_PROFILE;

  772.         break;

  773.     case kSpecialPathCommonProgramFiles:

  774.         csidl = CSIDL_PROGRAM_FILES_COMMON;

  775.         break;

  776.     case kSpecialPathProgramFiles:

  777.         csidl = CSIDL_PROGRAM_FILES;

  778.         break;

  779.     case kSpecialPathAppData:

  780.         csidl = CSIDL_APPDATA;

  781.         break;

  782.     case kSpecialPathMyDocuments:

  783.         csidl = CSIDL_MYDOCUMENTS;

  784.     default:

  785.         return {};

  786.     }

  787. 

  788.     WCHAR path[MAX_PATH + 256];

  789. 

  790.     if (SHGetSpecialFolderPathW(nullptr, path, csidl, FALSE))

  791.         return string::UTF16toUTF8(path);

  792. 

  793.     return {};

  794. }

  795. #endif

  796. 

  797. #ifdef DISTRHO_OS_WASM

  798. char* patchFromURL = nullptr;

  799. char* patchRemoteURL = nullptr;

  800. char* patchStorageSlug = nullptr;

  801. 

  802. void syncfs()

  803. {

  804.     settings::save();

  805. 

  806.    #ifndef CARDINAL_COMMON_UI_ONLY

  807.     EM_ASM({

  808.         Module.FS.syncfs(false, function(){} );

  809.     });

  810.    #endif

  811. }

  812. #endif

  813. 

  814. std::string homeDir()

  815. {

  816.    #ifdef ARCH_WIN

  817.     return getSpecialPath(kSpecialPathUserProfile);

  818.    #else

  819.     if (const char* const home = getenv("HOME"))

  820.         return home;

  821.     if (struct passwd* const pwd = getpwuid(getuid()))

  822.         return pwd->pw_dir;

  823.    #endif

  824.     return {};

  825. }

  826. 

  827. } // namespace rack

  828. 

  829. // --------------------------------------------------------------------------------------------------------------------

  830. 

  831. namespace patchUtils

  832. {

  833. 

  834. using namespace rack;

  835. 

  836. #ifndef HEADLESS_BEHAVIOUR

  837. static void promptClear(const char* const message, const std::function<void()> action)

  838. {

  839.     if (APP->history->isSaved() || APP->scene->rack->hasModules())

  840.         return action();

  841. 

  842.     asyncDialog::create(message, action);

  843. }

  844. #endif

  845. 

  846. void loadDialog()

  847. {

  848. #ifndef HEADLESS_BEHAVIOUR

  849.     promptClear("The current patch is unsaved. Clear it and open a new patch?", []() {

  850.         std::string dir;

  851.         if (! APP->patch->path.empty())

  852.             dir = system::getDirectory(APP->patch->path);

  853.         else

  854.             dir = homeDir();

  855. 

  856.         CardinalPluginContext* const pcontext = static_cast<CardinalPluginContext*>(APP);

  857.         DISTRHO_SAFE_ASSERT_RETURN(pcontext != nullptr,);

  858. 

  859.         CardinalBaseUI* const ui = static_cast<CardinalBaseUI*>(pcontext->ui);

  860.         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);

  861. 

  862.         DISTRHO_NAMESPACE::FileBrowserOptions opts;

  863.         opts.saving = ui->saving = false;

  864.         opts.startDir = dir.c_str();

  865.         opts.title = "Open patch";

  866.         ui->openFileBrowser(opts);

  867.     });

  868. #endif

  869. }

  870. 

  871. void loadPathDialog(const std::string& path, const bool asTemplate)

  872. {

  873. #ifndef HEADLESS_BEHAVIOUR

  874.     promptClear("The current patch is unsaved. Clear it and open the new patch?", [path, asTemplate]() {

  875.         APP->patch->loadAction(path);

  876. 

  877.         if (asTemplate)

  878.         {

  879.             APP->patch->path = "";

  880.             APP->history->setSaved();

  881.         }

  882. 

  883.        #ifdef DISTRHO_OS_WASM

  884.         syncfs();

  885.        #endif

  886. 

  887.         if (remoteUtils::RemoteDetails* const remoteDetails = remoteUtils::getRemote())

  888.             if (remoteDetails->autoDeploy)

  889.                 remoteUtils::sendFullPatchToRemote(remoteDetails);

  890.     });

  891. #endif

  892. }

  893. 

  894. void loadSelectionDialog()

  895. {

  896.     app::RackWidget* const w = APP->scene->rack;

  897. 

  898.     std::string selectionDir = asset::user("selections");

  899.     system::createDirectories(selectionDir);

  900. 

  901.     async_dialog_filebrowser(false, nullptr, selectionDir.c_str(), "Import selection", [w](char* pathC) {

  902.         if (!pathC) {

  903.             // No path selected

  904.             return;

  905.         }

  906. 

  907.         try {

  908.             w->loadSelection(pathC);

  909.         }

  910.         catch (Exception& e) {

  911.             async_dialog_message(e.what());

  912.         }

  913. 

  914.         std::free(pathC);

  915. 

  916.        #ifdef DISTRHO_OS_WASM

  917.         syncfs();

  918.        #endif

  919. 

  920.         if (remoteUtils::RemoteDetails* const remoteDetails = remoteUtils::getRemote())

  921.             if (remoteDetails->autoDeploy)

  922.                 remoteUtils::sendFullPatchToRemote(remoteDetails);

  923.     });

  924. }

  925. 

  926. void loadTemplate(const bool factory)

  927. {

  928.     try {

  929.         APP->patch->load(factory ? APP->patch->factoryTemplatePath : APP->patch->templatePath);

  930.     }

  931.     catch (Exception& e) {

  932.         // if user template failed, try the factory one

  933.         if (!factory)

  934.             return loadTemplate(true);

  935. 

  936.         const std::string message = string::f("Could not load template patch, clearing rack: %s", e.what());

  937.         asyncDialog::create(message.c_str());

  938. 

  939.         APP->patch->clear();

  940.         APP->patch->clearAutosave();

  941.     }

  942. 

  943.     // load() sets the patch's original patch, but we don't want to use that.

  944.     APP->patch->path.clear();

  945.     APP->history->setSaved();

  946. 

  947.    #ifdef DISTRHO_OS_WASM

  948.     syncfs();

  949.    #endif

  950. 

  951.     if (remoteUtils::RemoteDetails* const remoteDetails = remoteUtils::getRemote())

  952.         if (remoteDetails->autoDeploy)

  953.             remoteUtils::sendFullPatchToRemote(remoteDetails);

  954. }

  955. 

  956. 

  957. void loadTemplateDialog(const bool factory)

  958. {

  959. #ifndef HEADLESS_BEHAVIOUR

  960.     promptClear("The current patch is unsaved. Clear it and start a new patch?", [factory]() {

  961.         loadTemplate(factory);

  962.     });

  963. #endif

  964. }

  965. 

  966. void revertDialog()

  967. {

  968. #ifndef HEADLESS_BEHAVIOUR

  969.     if (APP->patch->path.empty())

  970.         return;

  971.     promptClear("Revert patch to the last saved state?", []{

  972.         APP->patch->loadAction(APP->patch->path);

  973. 

  974.        #ifdef DISTRHO_OS_WASM

  975.         syncfs();

  976.        #endif

  977. 

  978.         if (remoteUtils::RemoteDetails* const remoteDetails = remoteUtils::getRemote())

  979.             if (remoteDetails->autoDeploy)

  980.                 remoteUtils::sendFullPatchToRemote(remoteDetails);

  981.     });

  982. #endif

  983. }

  984. 

  985. void saveDialog(const std::string& path)

  986. {

  987. #ifndef HEADLESS_BEHAVIOUR

  988.     if (path.empty()) {

  989.         return;

  990.     }

  991. 

  992.     // Note: If save() fails below, this should probably be reset. But we need it so toJson() doesn't set the "unsaved" property.

  993.     APP->history->setSaved();

  994. 

  995.     try {

  996.         APP->patch->save(path);

  997.     }

  998.     catch (Exception& e) {

  999.         asyncDialog::create(string::f("Could not save patch: %s", e.what()).c_str());

  1000.         return;

  1001.     }

  1002. 

  1003.     APP->patch->pushRecentPath(path);

  1004. 

  1005.    #ifdef DISTRHO_OS_WASM

  1006.     syncfs();

  1007.    #else

  1008.     rack::settings::save();

  1009.    #endif

  1010. #endif

  1011. }

  1012. 

  1013. #ifndef HEADLESS_BEHAVIOUR

  1014. static void saveAsDialog(const bool uncompressed)

  1015. {

  1016.     std::string dir;

  1017.     if (! APP->patch->path.empty())

  1018.     {

  1019.         dir = system::getDirectory(APP->patch->path);

  1020.     }

  1021.     else

  1022.     {

  1023.         dir = asset::user("patches");

  1024.         system::createDirectories(dir);

  1025.     }

  1026. 

  1027.     CardinalPluginContext* const pcontext = static_cast<CardinalPluginContext*>(APP);

  1028.     DISTRHO_SAFE_ASSERT_RETURN(pcontext != nullptr,);

  1029. 

  1030.     CardinalBaseUI* const ui = static_cast<CardinalBaseUI*>(pcontext->ui);

  1031.     DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);

  1032. 

  1033.     DISTRHO_NAMESPACE::FileBrowserOptions opts;

  1034.     opts.saving = ui->saving = true;

  1035.     opts.defaultName = "patch.vcv";

  1036.     opts.startDir = dir.c_str();

  1037.     opts.title = "Save patch";

  1038.     ui->savingUncompressed = uncompressed;

  1039.     ui->openFileBrowser(opts);

  1040. }

  1041. #endif

  1042. 

  1043. void saveAsDialog()

  1044. {

  1045. #ifndef HEADLESS_BEHAVIOUR

  1046.     saveAsDialog(false);

  1047. #endif

  1048. }

  1049. 

  1050. void saveAsDialogUncompressed()

  1051. {

  1052. #ifndef HEADLESS_BEHAVIOUR

  1053.     saveAsDialog(true);

  1054. #endif

  1055. }

  1056. 

  1057. void saveTemplateDialog()

  1058. {

  1059.     asyncDialog::create("Overwrite template patch?", []{

  1060.         rack::system::createDirectories(system::getDirectory(APP->patch->templatePath));

  1061. 

  1062.         try {

  1063.             APP->patch->save(APP->patch->templatePath);

  1064.         }

  1065.         catch (Exception& e) {

  1066.             asyncDialog::create(string::f("Could not save template patch: %s", e.what()).c_str());

  1067.             return;

  1068.         }

  1069. 

  1070.        #ifdef DISTRHO_OS_WASM

  1071.         syncfs();

  1072.        #endif

  1073.     });

  1074. }

  1075. 

  1076. void openBrowser(const std::string& url)

  1077. {

  1078. #ifdef DISTRHO_OS_WASM

  1079.     EM_ASM({

  1080.         window.open(UTF8ToString($0), '_blank');

  1081.     }, url.c_str());

  1082. #else

  1083.     system::openBrowser(url);

  1084. #endif

  1085. }

  1086. 

  1087. }

  1088. 

  1089. // --------------------------------------------------------------------------------------------------------------------

  1090. 

  1091. void async_dialog_filebrowser(const bool saving,

  1092.                               const char* const defaultName,

  1093.                               const char* const startDir,

  1094.                               const char* const title,

  1095.                               const std::function<void(char* path)> action)

  1096. {

  1097. #ifndef HEADLESS_BEHAVIOUR

  1098.     CardinalPluginContext* const pcontext = static_cast<CardinalPluginContext*>(APP);

  1099.     DISTRHO_SAFE_ASSERT_RETURN(pcontext != nullptr,);

  1100. 

  1101.     CardinalBaseUI* const ui = static_cast<CardinalBaseUI*>(pcontext->ui);

  1102.     DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);

  1103. 

  1104.     // only 1 dialog possible at a time

  1105.     DISTRHO_SAFE_ASSERT_RETURN(ui->filebrowserhandle == nullptr,);

  1106. 

  1107.     DISTRHO_NAMESPACE::FileBrowserOptions opts;

  1108.     opts.saving = saving;

  1109.     opts.defaultName = defaultName;

  1110.     opts.startDir = startDir;

  1111.     opts.title = title;

  1112. 

  1113.     ui->filebrowseraction = action;

  1114.     ui->filebrowserhandle = fileBrowserCreate(true, pcontext->nativeWindowId, pcontext->window->pixelRatio, opts);

  1115. #endif

  1116. }

  1117. 

  1118. void async_dialog_message(const char* const message)

  1119. {

  1120. #ifndef HEADLESS_BEHAVIOUR

  1121.     asyncDialog::create(message);

  1122. #endif

  1123. }

  1124. 

  1125. void async_dialog_message(const char* const message, const std::function<void()> action)

  1126. {

  1127. #ifndef HEADLESS_BEHAVIOUR

  1128.     asyncDialog::create(message, action);

  1129. #endif

  1130. }

  1131. 

  1132. void async_dialog_text_input(const char* const message, const char* const text,

  1133.                              const std::function<void(char* newText)> action)

  1134. {

  1135. #ifndef HEADLESS_BEHAVIOUR

  1136.     asyncDialog::textInput(message, text, action);

  1137. #endif

  1138. }