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.
1810 Commits
12 Branches
263MB
Tree: b1bedc8956
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b1bedc8956'
${ noResults }
Cardinal/src/CardinalCommon.cpp

1287 lines
36KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

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

  4.  * SPDX-License-Identifier: GPL-3.0-or-later

  5.  */

  6. 

  7. /**

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

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

  10.  *

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

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

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

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

  15.  */

  16. 

  17. #include "CardinalCommon.hpp"

  18. 

  19. #include "AsyncDialog.hpp"

  20. #include "CardinalPluginContext.hpp"

  21. #include "DistrhoPluginUtils.hpp"

  22. 

  23. #include <asset.hpp>

  24. #include <context.hpp>

  25. #include <history.hpp>

  26. #include <patch.hpp>

  27. #include <settings.hpp>

  28. #include <string.hpp>

  29. #include <system.hpp>

  30. #include <app/Browser.hpp>

  31. #include <app/Scene.hpp>

  32. #include <engine/Engine.hpp>

  33. #include <window/Window.hpp>

  34. 

  35. #ifndef DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  36. # error wrong build

  37. #endif

  38. 

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

  40. # undef CARDINAL_INIT_OSC_THREAD

  41. #endif

  42. 

  43. #ifdef NDEBUG

  44. # undef DEBUG

  45. #endif

  46. 

  47. // for finding special paths

  48. #ifdef ARCH_WIN

  49. # include <shlobj.h>

  50. #else

  51. # include <pwd.h>

  52. # include <unistd.h>

  53. #endif

  54. 

  55. #ifdef ARCH_LIN

  56. # include <fstream>

  57. #endif

  58. 

  59. #ifdef HAVE_LIBLO

  60. # include <lo/lo.h>

  61. #endif

  62. 

  63. #ifdef DISTRHO_OS_WASM

  64. # include <emscripten/emscripten.h>

  65. #endif

  66. 

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

  68. # define HEADLESS_BEHAVIOUR

  69. #endif

  70. 

  71. #if CARDINAL_VARIANT_FX

  72. # define CARDINAL_VARIANT_NAME "fx"

  73. #elif CARDINAL_VARIANT_MINI

  74. # define CARDINAL_VARIANT_NAME "mini"

  75. #elif CARDINAL_VARIANT_NATIVE

  76. # define CARDINAL_VARIANT_NAME "native"

  77. #elif CARDINAL_VARIANT_SYNTH

  78. # define CARDINAL_VARIANT_NAME "synth"

  79. #else

  80. # define CARDINAL_VARIANT_NAME "main"

  81. #endif

  82. 

  83. #ifdef DISTRHO_OS_WASM

  84. # if CARDINAL_VARIANT_MINI

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

  86. # else

  87. #  define CARDINAL_WASM_WELCOME_TEMPLATE_FILENAME "welcome-wasm"

  88. # endif

  89. #endif

  90. 

  91. namespace rack {

  92. namespace asset {

  93. std::string patchesPath();

  94. void destroy();

  95. }

  96. namespace plugin {

  97. void initStaticPlugins();

  98. void destroyStaticPlugins();

  99. }

  100. }

  101. 

  102. const std::string CARDINAL_VERSION = "24.04";

  103. 

  104. // -----------------------------------------------------------------------------------------------------------

  105. 

  106. #ifndef HEADLESS

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

  108. {

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

  110. 

  111.    #ifndef CARDINAL_COMMON_DSP_ONLY

  112.     if (started)

  113.     {

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

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

  116.     }

  117.     else

  118.     {

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

  120.     }

  121.    #endif

  122. }

  123. #endif

  124. 

  125. // --------------------------------------------------------------------------------------------------------------------

  126. 

  127. CardinalPluginContext::CardinalPluginContext(Plugin* const p)

  128.     : bufferSize(p != nullptr ? p->getBufferSize() : 0),

  129.       processCounter(0),

  130.       sampleRate(p != nullptr ? p->getSampleRate() : 0.0),

  131.      #if CARDINAL_VARIANT_MAIN

  132.       variant(kCardinalVariantMain),

  133.      #elif CARDINAL_VARIANT_MINI

  134.       variant(kCardinalVariantMini),

  135.      #elif CARDINAL_VARIANT_FX

  136.       variant(kCardinalVariantFX),

  137.      #elif CARDINAL_VARIANT_NATIVE

  138.       variant(kCardinalVariantNative),

  139.      #elif CARDINAL_VARIANT_SYNTH

  140.       variant(kCardinalVariantSynth),

  141.      #else

  142.       #error cardinal variant not set

  143.      #endif

  144.       bypassed(false),

  145.       playing(false),

  146.       reset(false),

  147.       bbtValid(false),

  148.       bar(1),

  149.       beat(1),

  150.       beatsPerBar(4),

  151.       beatType(4),

  152.       frame(0),

  153.       barStartTick(0.0),

  154.       beatsPerMinute(120.0),

  155.       tick(0.0),

  156.       tickClock(0.0),

  157.       ticksPerBeat(0.0),

  158.       ticksPerClock(0.0),

  159.       ticksPerFrame(0.0),

  160.       nativeWindowId(0),

  161.       dataIns(nullptr),

  162.       dataOuts(nullptr),

  163.       midiEvents(nullptr),

  164.       midiEventCount(0),

  165.       plugin(p)

  166.    #ifndef HEADLESS

  167.     , tlw(nullptr)

  168.     , ui(nullptr)

  169.    #endif

  170. {

  171.     std::memset(parameters, 0, sizeof(parameters));

  172. }

  173. 

  174. #ifndef HEADLESS

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

  176. {

  177.    #ifndef CARDINAL_COMMON_DSP_ONLY

  178.     if (ui != nullptr)

  179.     {

  180.         ui->addIdleCallback(cb);

  181.         return true;

  182.     }

  183.    #else

  184.     // unused

  185.     (void)cb;

  186.    #endif

  187. 

  188.     return false;

  189. }

  190. 

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

  192. {

  193.    #ifndef CARDINAL_COMMON_DSP_ONLY

  194.     if (ui != nullptr)

  195.         ui->removeIdleCallback(cb);

  196.    #else

  197.     // unused

  198.     (void)cb;

  199.    #endif

  200. }

  201. #endif

  202. 

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

  204. {

  205.     if (bypassed)

  206.         return;

  207. 

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

  209.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

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

  211. 

  212.     MidiEvent event;

  213.     event.frame = message.frame;

  214. 

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

  216.     {

  217.     case 0x80:

  218.     case 0x90:

  219.     case 0xA0:

  220.     case 0xB0:

  221.     case 0xE0:

  222.         event.size = 3;

  223.         break;

  224.     case 0xC0:

  225.     case 0xD0:

  226.         event.size = 2;

  227.         break;

  228.     case 0xF0:

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

  230.         {

  231.         case 0x0:

  232.         case 0x4:

  233.         case 0x5:

  234.         case 0x7:

  235.         case 0x9:

  236.         case 0xD:

  237.             // unsupported

  238.             return;

  239.         case 0x1:

  240.         case 0x2:

  241.         case 0x3:

  242.         case 0xE:

  243.             event.size = 3;

  244.             break;

  245.         case 0x6:

  246.         case 0x8:

  247.         case 0xA:

  248.         case 0xB:

  249.         case 0xC:

  250.         case 0xF:

  251.             event.size = 1;

  252.             break;

  253.         }

  254.         break;

  255.     default:

  256.         // invalid

  257.         return;

  258.     }

  259. 

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

  261. 

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

  263. 

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

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

  266. 

  267.     plugin->writeMidiEvent(event);

  268. }

  269. 

  270. // -----------------------------------------------------------------------------------------------------------

  271. 

  272. namespace rack {

  273. namespace midi {

  274. 

  275. struct InputQueue::Internal {

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

  277.     const CardinalDISTRHO::MidiEvent* midiEvents = nullptr;

  278.     uint32_t midiEventsLeft = 0;

  279.     uint32_t lastProcessCounter = 0;

  280.     int64_t lastBlockFrame = 0;

  281. };

  282. 

  283. InputQueue::InputQueue() {

  284.     internal = new Internal;

  285. }

  286. 

  287. InputQueue::~InputQueue() {

  288.     delete internal;

  289. }

  290. 

  291. bool InputQueue::tryPop(Message* const messageOut, int64_t maxFrame)

  292. {

  293.     const uint32_t processCounter = internal->pcontext->processCounter;

  294.     const bool processCounterChanged = internal->lastProcessCounter != processCounter;

  295. 

  296.     if (processCounterChanged)

  297.     {

  298.         internal->lastBlockFrame = internal->pcontext->engine->getBlockFrame();

  299.         internal->lastProcessCounter = processCounter;

  300. 

  301.         internal->midiEvents = internal->pcontext->midiEvents;

  302.         internal->midiEventsLeft = internal->pcontext->midiEventCount;

  303.     }

  304. 

  305.     if (internal->midiEventsLeft == 0 || maxFrame < internal->lastBlockFrame)

  306.         return false;

  307. 

  308.     const uint32_t frame = maxFrame - internal->lastBlockFrame;

  309. 

  310.     if (frame > internal->midiEvents->frame)

  311.         return false;

  312. 

  313.     const CardinalDISTRHO::MidiEvent& midiEvent(*internal->midiEvents);

  314. 

  315.     const uint8_t* data;

  316.     if (midiEvent.size > CardinalDISTRHO::MidiEvent::kDataSize)

  317.     {

  318.         data = midiEvent.dataExt;

  319.         messageOut->bytes.resize(midiEvent.size);

  320.     }

  321.     else

  322.     {

  323.         data = midiEvent.data;

  324.     }

  325. 

  326.     messageOut->frame = frame;

  327.     std::memcpy(messageOut->bytes.data(), data, midiEvent.size);

  328. 

  329.     ++internal->midiEvents;

  330.     --internal->midiEventsLeft;

  331.     return true;

  332. }

  333. 

  334. json_t* InputQueue::toJson() const

  335. {

  336.     return nullptr;

  337. }

  338. 

  339. void InputQueue::fromJson(json_t* rootJ)

  340. {

  341. }

  342. 

  343. }

  344. }

  345. 

  346. // -----------------------------------------------------------------------------------------------------------

  347. 

  348. START_NAMESPACE_DISTRHO

  349. 

  350. // -----------------------------------------------------------------------------------------------------------

  351. 

  352. #ifdef HAVE_LIBLO

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

  354. {

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

  356. }

  357. 

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

  359. {

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

  361.     return 0;

  362. }

  363. 

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

  365. {

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

  367.     const lo_address source = lo_message_get_source(m);

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

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

  370.     return 0;

  371. }

  372. 

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

  374. {

  375.     d_debug("osc_load_handler()");

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

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

  378. 

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

  380.     DISTRHO_SAFE_ASSERT_RETURN(size > 4, 0);

  381. 

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

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

  384. 

  385.     bool ok = false;

  386. 

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

  388.     {

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

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

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

  392. 

  393.         rack::contextSet(context);

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

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

  396.         try {

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

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

  399.             ok = true;

  400.         }

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

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

  403.         }

  404.         rack::contextSet(nullptr);

  405.     }

  406. 

  407.     const lo_address source = lo_message_get_source(m);

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

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

  410.     return 0;

  411. }

  412. 

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

  414. {

  415.     d_debug("osc_param_handler()");

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

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

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

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

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

  421. 

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

  423.     {

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

  425. 

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

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

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

  429. 

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

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

  432. 

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

  434.     }

  435. 

  436.     return 0;

  437. }

  438. 

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

  440. {

  441.     d_debug("osc_host_param_handler()");

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

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

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

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

  446. 

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

  448.     {

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

  450. 

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

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

  453. 

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

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

  456. 

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

  458. 

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

  460.     }

  461. 

  462.     return 0;

  463. }

  464. 

  465. # ifdef CARDINAL_INIT_OSC_THREAD

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

  467. {

  468.     d_debug("osc_screenshot_handler()");

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

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

  471. 

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

  473.     DISTRHO_SAFE_ASSERT_RETURN(size > 4, 0);

  474. 

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

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

  477. 

  478.     bool ok = false;

  479. 

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

  481.     {

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

  483.         {

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

  485.             std::free(screenshot);

  486.         }

  487.     }

  488. 

  489.     const lo_address source = lo_message_get_source(m);

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

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

  492.     return 0;

  493. }

  494. # endif

  495. #endif

  496. 

  497. // -----------------------------------------------------------------------------------------------------------

  498. 

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

  500. static void WebBrowserDataLoaded(void* const data)

  501. {

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

  503. }

  504. #endif

  505. 

  506. // -----------------------------------------------------------------------------------------------------------

  507. 

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

  509. {

  510.     using namespace rack;

  511. 

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

  513.     settings::allowCursorLock = false;

  514.     settings::tooltips = true;

  515.     settings::cableOpacity = 0.5f;

  516.     settings::cableTension = 0.75f;

  517.     settings::rackBrightness = 1.0f;

  518.     settings::haloBrightness = 0.25f;

  519.     settings::knobMode = settings::KNOB_MODE_LINEAR;

  520.     settings::knobScroll = false;

  521.     settings::knobScrollSensitivity = 0.001f;

  522.     settings::lockModules = false;

  523.     settings::browserSort = settings::BROWSER_SORT_UPDATED;

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

  525.     settings::invertZoom = false;

  526.     settings::squeezeModules = true;

  527.     settings::preferDarkPanels = true;

  528.     settings::uiTheme = "dark";

  529. 

  530.     // runtime behaviour

  531.     settings::devMode = true;

  532.     settings::isPlugin = true;

  533.    #ifdef HEADLESS_BEHAVIOUR

  534.     settings::headless = true;

  535.    #endif

  536. 

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

  538.     settings::cableColors = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  555.     };

  556. 

  557.     system::init();

  558.     logger::init();

  559.     random::init();

  560.     ui::init();

  561. 

  562.    #ifdef CARDINAL_COMMON_UI_ONLY

  563.     constexpr const bool isRealInstance = true;

  564.    #else

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

  566.    #endif

  567. 

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

  569.     {

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

  571.                                            #if DISTRHO_PLUGIN_HAS_UI

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

  573.                                            #endif

  574.                                             nullptr))

  575.         {

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

  577.             {

  578.                 asset::systemDir = resourcePath;

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

  580.             }

  581.         }

  582. 

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

  584.         {

  585.            #ifdef CARDINAL_PLUGIN_SOURCE_DIR

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

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

  588.             asset::bundlePath.clear();

  589. 

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

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

  592.            #endif

  593.             {

  594.                #if defined(DISTRHO_OS_WASM)

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

  596.                #elif defined(ARCH_MAC)

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

  598.                #elif defined(ARCH_WIN)

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

  600.                #else

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

  602.                #endif

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

  604.             }

  605.         }

  606.     }

  607. 

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

  609.     {

  610.        #if defined(DISTRHO_OS_WASM)

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

  612.        #elif defined(ARCH_MAC)

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

  614.        #elif defined(ARCH_WIN)

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

  616.        #else

  617.         std::string xdgConfigDir;

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

  619.             xdgConfigDir = xdgEnv;

  620.         if (xdgConfigDir.empty())

  621.             xdgConfigDir = system::join(homeDir(), ".config");

  622. 

  623.         const std::string xdgDirsConfigPath(system::join(xdgConfigDir, "user-dirs.dirs"));

  624. 

  625.         if (system::exists(xdgDirsConfigPath))

  626.         {

  627.             std::ifstream xdgDirsConfigFile(xdgDirsConfigPath, std::ios::in|std::ios::ate);

  628.             std::string xdgDirsConfig(xdgDirsConfigFile.tellg(), 0);

  629. 

  630.             xdgDirsConfigFile.seekg(0);

  631.             xdgDirsConfigFile.read(&xdgDirsConfig[0], xdgDirsConfig.size());

  632. 

  633.             if (const char* const xdgDocsDir = std::strstr(xdgDirsConfig.c_str(), "XDG_DOCUMENTS_DIR=\""))

  634.             {

  635.                 if (const char* const xdgDocsDirNL = std::strstr(xdgDocsDir, "\"\n"))

  636.                 {

  637.                     asset::userDir = std::string(xdgDocsDir + 19, xdgDocsDirNL - xdgDocsDir - 19);

  638. 

  639.                     if (string::startsWith(asset::userDir, "$HOME"))

  640.                         asset::userDir.replace(asset::userDir.begin(), asset::userDir.begin() + 5, homeDir());

  641. 

  642.                     if (! system::exists(asset::userDir))

  643.                         asset::userDir.clear();

  644.                 }

  645.             }

  646.         }

  647. 

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

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

  650.        #endif

  651. 

  652.         if (isRealInstance)

  653.         {

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

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

  656.             EM_ASM({

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

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

  659.             }, WebBrowserDataLoaded, this);

  660.            #endif

  661.         }

  662.     }

  663. 

  664.    #ifndef CARDINAL_COMMON_DSP_ONLY

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

  666.     {

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

  668.         asset::configDir = asset::userDir;

  669.        #else

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

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

  672.         else

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

  674. 

  675.         if (isRealInstance)

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

  677.        #endif

  678.     }

  679.    #endif

  680.    

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

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

  683. 

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

  685.    #ifdef DISTRHO_OS_WASM

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

  687.    #else

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

  689.    #endif

  690. 

  691.     // Log environment

  692.     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());

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

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

  695.     if (plugin != nullptr) {

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

  697.    #if DISTRHO_PLUGIN_HAS_UI

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

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

  700.    #endif

  701.     }

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

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

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

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

  706. 

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

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

  709.     {

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

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

  712.     }

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

  714.     {

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

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

  717.     }

  718. 

  719.     INFO("Initializing plugins");

  720.     plugin::initStaticPlugins();

  721. 

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

  723.     app::browserInit();

  724. 

  725.     loadSettings(isRealInstance);

  726. 

  727.    #if defined(CARDINAL_INIT_OSC_THREAD)

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

  729.     const char* port;

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

  731.         port = portEnv;

  732.     else

  733.         port = CARDINAL_DEFAULT_REMOTE_PORT;

  734.     startRemoteServer(port);

  735.    #elif defined(HAVE_LIBLO)

  736.     if (isStandalone()) {

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

  738.     } else {

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

  740.     }

  741.    #else

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

  743.    #endif

  744. }

  745. 

  746. Initializer::~Initializer()

  747. {

  748.     using namespace rack;

  749. 

  750.    #ifdef HAVE_LIBLO

  751.     stopRemoteServer();

  752.    #endif

  753. 

  754.     if (shouldSaveSettings)

  755.     {

  756.         INFO("Save settings");

  757.         settings::save();

  758.     }

  759. 

  760.     INFO("Clearing asset paths");

  761.     asset::bundlePath.clear();

  762.     asset::systemDir.clear();

  763.     asset::userDir.clear();

  764. 

  765.     INFO("Destroying plugins");

  766.     plugin::destroyStaticPlugins();

  767. 

  768.     INFO("Destroying colourized assets");

  769.     asset::destroy();

  770. 

  771.     INFO("Destroying settings");

  772.     settings::destroy();

  773. 

  774.     INFO("Destroying logger");

  775.     logger::destroy();

  776. }

  777. 

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

  779. {

  780.     using namespace rack;

  781. 

  782.     if (isRealInstance)

  783.     {

  784.         INFO("Loading settings");

  785.         settings::load();

  786.         shouldSaveSettings = true;

  787.     }

  788. 

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

  790.     settings::safeMode = false;

  791.     settings::token.clear();

  792.     settings::windowMaximized = false;

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

  794.     settings::pixelRatio = 0.0;

  795.     settings::sampleRate = 0;

  796.     settings::threadCount = 1;

  797.     settings::autosaveInterval = 0;

  798.     settings::skipLoadOnLaunch = true;

  799.     settings::autoCheckUpdates = false;

  800.     settings::showTipsOnLaunch = false;

  801.     settings::tipIndex = -1;

  802. 

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

  804.     {

  805.         settings::uiTheme = "dark";

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

  807.     }

  808. 

  809.     // reload dark/light mode as necessary

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

  811. }

  812. 

  813. #ifdef HAVE_LIBLO

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

  815. {

  816.    #ifdef CARDINAL_INIT_OSC_THREAD

  817.     if (oscServerThread != nullptr)

  818.         return true;

  819. 

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

  821.         return false;

  822. 

  823.     oscServer = lo_server_thread_get_server(oscServerThread);

  824. 

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

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

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

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

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

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

  831.     lo_server_thread_start(oscServerThread);

  832.    #else

  833.     if (oscServer != nullptr)

  834.         return true;

  835. 

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

  837.         return false;

  838. 

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

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

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

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

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

  844.    #endif

  845. 

  846.     return true;

  847. }

  848. 

  849. void Initializer::stopRemoteServer()

  850. {

  851.     DISTRHO_SAFE_ASSERT(remotePluginInstance == nullptr);

  852. 

  853.    #ifdef CARDINAL_INIT_OSC_THREAD

  854.     if (oscServerThread != nullptr)

  855.     {

  856.         lo_server_thread_stop(oscServerThread);

  857.         lo_server_thread_del_method(oscServerThread, nullptr, nullptr);

  858.         lo_server_thread_free(oscServerThread);

  859.         oscServerThread = oscServer = nullptr;

  860.     }

  861.    #else

  862.     if (oscServer != nullptr)

  863.     {

  864.         lo_server_del_method(oscServer, nullptr, nullptr);

  865.         lo_server_free(oscServer);

  866.         oscServer = nullptr;

  867.     }

  868.    #endif

  869. }

  870. 

  871. void Initializer::stepRemoteServer()

  872. {

  873.     DISTRHO_SAFE_ASSERT_RETURN(oscServer != nullptr,);

  874.     DISTRHO_SAFE_ASSERT_RETURN(remotePluginInstance != nullptr,);

  875. 

  876.    #ifndef CARDINAL_INIT_OSC_THREAD

  877.     for (;;)

  878.     {

  879.         try {

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

  881.                 break;

  882.         } DISTRHO_SAFE_EXCEPTION_CONTINUE("stepRemoteServer")

  883.     }

  884.    #endif

  885. }

  886. #endif // HAVE_LIBLO

  887. 

  888. // --------------------------------------------------------------------------------------------------------------------

  889. 

  890. END_NAMESPACE_DISTRHO

  891. 

  892. // --------------------------------------------------------------------------------------------------------------------

  893. 

  894. namespace rack {

  895. 

  896. bool isMini()

  897. {

  898. #if CARDINAL_VARIANT_MINI

  899.     return true;

  900. #else

  901.     return false;

  902. #endif

  903. }

  904. 

  905. bool isStandalone()

  906. {

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

  908.     return standalone;

  909. }

  910. 

  911. #ifdef ARCH_WIN

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

  913. {

  914.     int csidl;

  915.     switch (type)

  916.     {

  917.     case kSpecialPathUserProfile:

  918.         csidl = CSIDL_PROFILE;

  919.         break;

  920.     case kSpecialPathCommonProgramFiles:

  921.         csidl = CSIDL_PROGRAM_FILES_COMMON;

  922.         break;

  923.     case kSpecialPathProgramFiles:

  924.         csidl = CSIDL_PROGRAM_FILES;

  925.         break;

  926.     case kSpecialPathAppData:

  927.         csidl = CSIDL_APPDATA;

  928.         break;

  929.     case kSpecialPathMyDocuments:

  930.         csidl = CSIDL_MYDOCUMENTS;

  931.         break;

  932.     default:

  933.         return {};

  934.     }

  935. 

  936.     WCHAR path[MAX_PATH] = {};

  937. 

  938.     if (SHGetFolderPathW(nullptr, csidl, nullptr, SHGFP_TYPE_CURRENT, path) == S_OK)

  939.         return string::UTF16toUTF8(path);

  940. 

  941.     return {};

  942. }

  943. #endif

  944. 

  945. #ifdef DISTRHO_OS_WASM

  946. char* patchFromURL = nullptr;

  947. char* patchRemoteURL = nullptr;

  948. char* patchStorageSlug = nullptr;

  949. 

  950. void syncfs()

  951. {

  952.     settings::save();

  953. 

  954.    #ifndef CARDINAL_COMMON_UI_ONLY

  955.     EM_ASM({

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

  957.     });

  958.    #endif

  959. }

  960. #endif

  961. 

  962. std::string homeDir()

  963. {

  964.    #ifdef ARCH_WIN

  965.     return getSpecialPath(kSpecialPathUserProfile);

  966.    #else

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

  968.         return home;

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

  970.         return pwd->pw_dir;

  971.    #endif

  972.     return {};

  973. }

  974. 

  975. } // namespace rack

  976. 

  977. // --------------------------------------------------------------------------------------------------------------------

  978. 

  979. namespace patchUtils

  980. {

  981. 

  982. using namespace rack;

  983. 

  984. #ifndef HEADLESS_BEHAVIOUR

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

  986. {

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

  988.         return action();

  989. 

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

  991. }

  992. #endif

  993. 

  994. void loadDialog()

  995. {

  996. #ifndef HEADLESS_BEHAVIOUR

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

  998.         std::string dir;

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

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

  1001.         else

  1002.             dir = homeDir();

  1003. 

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

  1005.         DISTRHO_SAFE_ASSERT_RETURN(pcontext != nullptr,);

  1006. 

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

  1008.         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);

  1009. 

  1010.         DISTRHO_NAMESPACE::FileBrowserOptions opts;

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

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

  1013.         opts.title = "Open patch";

  1014.         ui->openFileBrowser(opts);

  1015.     });

  1016. #endif

  1017. }

  1018. 

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

  1020. {

  1021. #ifndef HEADLESS_BEHAVIOUR

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

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

  1024. 

  1025.         if (asTemplate)

  1026.         {

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

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

  1029.         }

  1030. 

  1031.        #ifdef DISTRHO_OS_WASM

  1032.         syncfs();

  1033.        #endif

  1034. 

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

  1036.             if (remoteDetails->autoDeploy)

  1037.                 remoteUtils::sendFullPatchToRemote(remoteDetails);

  1038.     });

  1039. #endif

  1040. }

  1041. 

  1042. void loadSelectionDialog()

  1043. {

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

  1045. 

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

  1047.     system::createDirectories(selectionDir);

  1048. 

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

  1050.         if (!pathC) {

  1051.             // No path selected

  1052.             return;

  1053.         }

  1054. 

  1055.         try {

  1056.             w->loadSelection(pathC);

  1057.         }

  1058.         catch (Exception& e) {

  1059.             async_dialog_message(e.what());

  1060.         }

  1061. 

  1062.         std::free(pathC);

  1063. 

  1064.        #ifdef DISTRHO_OS_WASM

  1065.         syncfs();

  1066.        #endif

  1067. 

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

  1069.             if (remoteDetails->autoDeploy)

  1070.                 remoteUtils::sendFullPatchToRemote(remoteDetails);

  1071.     });

  1072. }

  1073. 

  1074. void loadTemplate(const bool factory)

  1075. {

  1076.     try {

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

  1078.     }

  1079.     catch (Exception& e) {

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

  1081.         if (!factory)

  1082.             return loadTemplate(true);

  1083. 

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

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

  1086. 

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

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

  1089.     }

  1090. 

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

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

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

  1094. 

  1095.    #ifdef DISTRHO_OS_WASM

  1096.     syncfs();

  1097.    #endif

  1098. 

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

  1100.         if (remoteDetails->autoDeploy)

  1101.             remoteUtils::sendFullPatchToRemote(remoteDetails);

  1102. }

  1103. 

  1104. 

  1105. void loadTemplateDialog(const bool factory)

  1106. {

  1107. #ifndef HEADLESS_BEHAVIOUR

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

  1109.         loadTemplate(factory);

  1110.     });

  1111. #endif

  1112. }

  1113. 

  1114. void revertDialog()

  1115. {

  1116. #ifndef HEADLESS_BEHAVIOUR

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

  1118.         return;

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

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

  1121. 

  1122.        #ifdef DISTRHO_OS_WASM

  1123.         syncfs();

  1124.        #endif

  1125. 

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

  1127.             if (remoteDetails->autoDeploy)

  1128.                 remoteUtils::sendFullPatchToRemote(remoteDetails);

  1129.     });

  1130. #endif

  1131. }

  1132. 

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

  1134. {

  1135. #ifndef HEADLESS_BEHAVIOUR

  1136.     if (path.empty()) {

  1137.         return;

  1138.     }

  1139. 

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

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

  1142. 

  1143.     try {

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

  1145.     }

  1146.     catch (Exception& e) {

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

  1148.         return;

  1149.     }

  1150. 

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

  1152. 

  1153.    #ifdef DISTRHO_OS_WASM

  1154.     syncfs();

  1155.    #else

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

  1157.    #endif

  1158. #endif

  1159. }

  1160. 

  1161. #ifndef HEADLESS_BEHAVIOUR

  1162. static void saveAsDialog(const bool uncompressed)

  1163. {

  1164.     std::string dir;

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

  1166.     {

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

  1168.     }

  1169.     else

  1170.     {

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

  1172.         system::createDirectories(dir);

  1173.     }

  1174. 

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

  1176.     DISTRHO_SAFE_ASSERT_RETURN(pcontext != nullptr,);

  1177. 

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

  1179.     DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);

  1180. 

  1181.     DISTRHO_NAMESPACE::FileBrowserOptions opts;

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

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

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

  1185.     opts.title = "Save patch";

  1186.     ui->savingUncompressed = uncompressed;

  1187.     ui->openFileBrowser(opts);

  1188. }

  1189. #endif

  1190. 

  1191. void saveAsDialog()

  1192. {

  1193. #ifndef HEADLESS_BEHAVIOUR

  1194.     saveAsDialog(false);

  1195. #endif

  1196. }

  1197. 

  1198. void saveAsDialogUncompressed()

  1199. {

  1200. #ifndef HEADLESS_BEHAVIOUR

  1201.     saveAsDialog(true);

  1202. #endif

  1203. }

  1204. 

  1205. void saveTemplateDialog()

  1206. {

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

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

  1209. 

  1210.         try {

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

  1212.         }

  1213.         catch (Exception& e) {

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

  1215.             return;

  1216.         }

  1217. 

  1218.        #ifdef DISTRHO_OS_WASM

  1219.         syncfs();

  1220.        #endif

  1221.     });

  1222. }

  1223. 

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

  1225. {

  1226. #ifdef DISTRHO_OS_WASM

  1227.     EM_ASM({

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

  1229.     }, url.c_str());

  1230. #else

  1231.     system::openBrowser(url);

  1232. #endif

  1233. }

  1234. 

  1235. }

  1236. 

  1237. // --------------------------------------------------------------------------------------------------------------------

  1238. 

  1239. void async_dialog_filebrowser(const bool saving,

  1240.                               const char* const defaultName,

  1241.                               const char* const startDir,

  1242.                               const char* const title,

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

  1244. {

  1245. #ifndef HEADLESS_BEHAVIOUR

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

  1247.     DISTRHO_SAFE_ASSERT_RETURN(pcontext != nullptr,);

  1248. 

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

  1250.     DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);

  1251. 

  1252.     // only 1 dialog possible at a time

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

  1254. 

  1255.     DISTRHO_NAMESPACE::FileBrowserOptions opts;

  1256.     opts.saving = saving;

  1257.     opts.defaultName = defaultName;

  1258.     opts.startDir = startDir;

  1259.     opts.title = title;

  1260. 

  1261.     ui->filebrowseraction = action;

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

  1263. #endif

  1264. }

  1265. 

  1266. void async_dialog_message(const char* const message)

  1267. {

  1268. #ifndef HEADLESS_BEHAVIOUR

  1269.     asyncDialog::create(message);

  1270. #endif

  1271. }

  1272. 

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

  1274. {

  1275. #ifndef HEADLESS_BEHAVIOUR

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

  1277. #endif

  1278. }

  1279. 

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

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

  1282. {

  1283. #ifndef HEADLESS_BEHAVIOUR

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

  1285. #endif

  1286. }