falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
2515 Commits
16 Branches
275MB
Tree: 7bd34192f5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7bd34192f5'
${ noResults }
Carla/source/bridges-ui/CarlaBridgeUI.cpp

675 lines
16KB
Raw Blame History 

  1. /*

  2.  * Carla Bridge UI

  3.  * Copyright (C) 2011-2014 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 2 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 doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaBridgeUI.hpp"

  19. #include "CarlaMIDI.h"

  20. 

  21. #include "CarlaBase64Utils.hpp"

  22. 

  23. #ifdef BRIDGE_LV2

  24. # undef NULL

  25. # define NULL nullptr

  26. # include "lv2/atom-util.h"

  27. #endif

  28. 

  29. CARLA_BRIDGE_START_NAMESPACE

  30. 

  31. // ---------------------------------------------------------------------

  32. 

  33. CarlaBridgeUI::CarlaBridgeUI() noexcept

  34.     : CarlaPipeClient(),

  35.       fQuitReceived(false),

  36. #ifdef BRIDGE_LV2

  37.       fUridMapComplete(false),

  38. #endif

  39.       fToolkit(nullptr),

  40.       fLib(nullptr),

  41.       fLibFilename(),

  42.       leakDetector_CarlaBridgeUI()

  43. {

  44.     carla_debug("CarlaBridgeUI::CarlaBridgeUI()");

  45. 

  46.     try {

  47.         fToolkit = CarlaBridgeToolkit::createNew(this);

  48.     } CARLA_SAFE_EXCEPTION_RETURN("CarlaBridgeToolkit::createNew",);

  49. }

  50. 

  51. CarlaBridgeUI::~CarlaBridgeUI() noexcept

  52. {

  53.     carla_debug("CarlaBridgeUI::~CarlaBridgeUI()");

  54. 

  55.     if (fLib != nullptr)

  56.     {

  57.         lib_close(fLib);

  58.         fLib = nullptr;

  59.     }

  60. 

  61.     if (isPipeRunning() && ! fQuitReceived)

  62.     {

  63.         const CarlaMutexLocker cml(getPipeLock());

  64.         writeMessage("exiting\n", 8);

  65.         flushMessages();

  66.     }

  67. 

  68.     if (fToolkit != nullptr)

  69.     {

  70.         fToolkit->quit();

  71.         delete fToolkit;

  72.         fToolkit = nullptr;

  73.     }

  74. 

  75.     closePipeClient();

  76. }

  77. 

  78. // ---------------------------------------------------------------------

  79. // Host DSP State

  80. 

  81. void CarlaBridgeUI::sendControl(const uint32_t index, const float value) const noexcept

  82. {

  83.     char tmpBuf[0xff+1];

  84.     tmpBuf[0xff] = '\0';

  85. 

  86.     const CarlaMutexLocker cml(getPipeLock());

  87.     const ScopedLocale csl;

  88. 

  89.     writeMessage("control\n", 8);

  90. 

  91.     {

  92.         std::snprintf(tmpBuf, 0xff, "%i\n", index);

  93.         writeMessage(tmpBuf);

  94. 

  95.         std::snprintf(tmpBuf, 0xff, "%f\n", value);

  96.         writeMessage(tmpBuf);

  97.     }

  98. 

  99.     flushMessages();

  100. }

  101. 

  102. void CarlaBridgeUI::sendProgram(const uint32_t index) const noexcept

  103. {

  104.     char tmpBuf[0xff+1];

  105.     tmpBuf[0xff] = '\0';

  106. 

  107.     const CarlaMutexLocker cml(getPipeLock());

  108. 

  109.     writeMessage("program\n", 8);

  110. 

  111.     {

  112.         std::snprintf(tmpBuf, 0xff, "%i\n", index);

  113.         writeMessage(tmpBuf);

  114.     }

  115. 

  116.     flushMessages();

  117. }

  118. 

  119. void CarlaBridgeUI::sendConfigure(const char* const key, const char* const value) const noexcept

  120. {

  121.     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  122.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  123. 

  124.     const CarlaMutexLocker cml(getPipeLock());

  125. 

  126.     writeMessage("configure\n", 10);

  127. 

  128.     {

  129.         writeAndFixMessage(key);

  130.         writeAndFixMessage(value);

  131.     }

  132. 

  133.     flushMessages();

  134. }

  135. 

  136. void CarlaBridgeUI::sendNote(const bool onOff, const uint8_t channel, const uint8_t note, const uint8_t velocity) const noexcept

  137. {

  138.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  139.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  140.     CARLA_SAFE_ASSERT_RETURN(velocity < MAX_MIDI_VALUE,);

  141. 

  142.     char tmpBuf[0xff+1];

  143.     tmpBuf[0xff] = '\0';

  144. 

  145.     const CarlaMutexLocker cml(getPipeLock());

  146. 

  147.     writeMessage("note\n", 5);

  148. 

  149.     {

  150.         std::snprintf(tmpBuf, 0xff, "%s\n", bool2str(onOff));

  151.         writeMessage(tmpBuf);

  152. 

  153.         std::snprintf(tmpBuf, 0xff, "%i\n", channel);

  154.         writeMessage(tmpBuf);

  155. 

  156.         std::snprintf(tmpBuf, 0xff, "%i\n", note);

  157.         writeMessage(tmpBuf);

  158. 

  159.         std::snprintf(tmpBuf, 0xff, "%i\n", velocity);

  160.         writeMessage(tmpBuf);

  161.     }

  162. 

  163.     flushMessages();

  164. }

  165. 

  166. #ifdef BRIDGE_LV2

  167. void CarlaBridgeUI::sendAtom(const uint32_t index, const LV2_Atom* const atom) const noexcept

  168. {

  169.     CARLA_SAFE_ASSERT_RETURN(atom != nullptr,);

  170. 

  171.     char tmpBuf[0xff+1];

  172.     tmpBuf[0xff] = '\0';

  173. 

  174.     CarlaString base64atom(CarlaString::asBase64(atom, lv2_atom_total_size(atom)));

  175. 

  176.     const CarlaMutexLocker cml(getPipeLock());

  177. 

  178.     writeMessage("atom\n", 5);

  179. 

  180.     {

  181.         std::snprintf(tmpBuf, 0xff, "%i\n", index);

  182.         writeMessage(tmpBuf);

  183. 

  184.         std::snprintf(tmpBuf, 0xff, "%i\n", atom->size);

  185.         writeMessage(tmpBuf);

  186. 

  187.         writeAndFixMessage(base64atom.buffer());

  188.     }

  189. 

  190.     flushMessages();

  191. }

  192. 

  193. void CarlaBridgeUI::sendURID(const LV2_URID urid, const char* const uri) const noexcept

  194. {

  195.     CARLA_SAFE_ASSERT_RETURN(urid != 0,);

  196.     CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0',);

  197. 

  198.     char tmpBuf[0xff+1];

  199.     tmpBuf[0xff] = '\0';

  200. 

  201.     const CarlaMutexLocker cml(getPipeLock());

  202. 

  203.     writeMessage("urid\n", 5);

  204. 

  205.     {

  206.         std::snprintf(tmpBuf, 0xff, "%i\n", urid);

  207.         writeMessage(tmpBuf);

  208. 

  209.         writeAndFixMessage(uri);

  210.     }

  211. 

  212.     flushMessages();

  213. }

  214. #endif

  215. 

  216. 

  217. bool CarlaBridgeUI::libOpen(const char* const filename) noexcept

  218. {

  219.     CARLA_SAFE_ASSERT_RETURN(fLib == nullptr, false);

  220. 

  221.     fLib = lib_open(filename);

  222. 

  223.     if (fLib != nullptr)

  224.     {

  225.         fLibFilename = filename;

  226.         return true;

  227.     }

  228. 

  229.     return false;

  230. }

  231. 

  232. void* CarlaBridgeUI::libSymbol(const char* const symbol) const noexcept

  233. {

  234.     CARLA_SAFE_ASSERT_RETURN(fLib != nullptr, nullptr);

  235. 

  236.     return lib_symbol<void*>(fLib, symbol);

  237. }

  238. 

  239. const char* CarlaBridgeUI::libError() const noexcept

  240. {

  241.     CARLA_SAFE_ASSERT_RETURN(fLibFilename.isNotEmpty(), nullptr);

  242. 

  243.     return lib_error(fLibFilename);

  244. }

  245. 

  246. // ---------------------------------------------------------------------

  247. 

  248. bool CarlaBridgeUI::msgReceived(const char* const msg) noexcept

  249. {

  250. #ifdef BRIDGE_LV2

  251.     if (! fUridMapComplete) {

  252.         CARLA_SAFE_ASSERT_RETURN(std::strcmp(msg, "urid") == 0, true);

  253.     }

  254. #endif

  255. 

  256.     if (std::strcmp(msg, "control") == 0)

  257.     {

  258.         uint32_t index;

  259.         float value;

  260. 

  261.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  262.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  263. 

  264.         dspParameterChanged(index, value);

  265.         return true;

  266.     }

  267. 

  268.     if (std::strcmp(msg, "program") == 0)

  269.     {

  270.         uint32_t index;

  271. 

  272.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  273. 

  274.         dspProgramChanged(index);

  275.         return true;

  276.     }

  277. 

  278.     if (std::strcmp(msg, "mprogram") == 0)

  279.     {

  280.         uint32_t bank, program;

  281. 

  282.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(bank), true);

  283.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(program), true);

  284. 

  285.         dspMidiProgramChanged(bank, program);

  286.         return true;

  287.     }

  288. 

  289.     if (std::strcmp(msg, "configure") == 0)

  290.     {

  291.         const char* key;

  292.         const char* value;

  293. 

  294.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(key), true);

  295.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(value), true);

  296. 

  297.         dspStateChanged(key, value);

  298. 

  299.         delete[] key;

  300.         delete[] value;

  301.         return true;

  302.     }

  303. 

  304.     if (std::strcmp(msg, "note") == 0)

  305.     {

  306.         bool onOff;

  307.         uint8_t channel, note, velocity;

  308. 

  309.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(onOff), true);

  310.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsByte(channel), true);

  311.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsByte(note), true);

  312.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsByte(velocity), true);

  313. 

  314.         dspNoteReceived(onOff, channel, note, velocity);

  315.     }

  316. 

  317. #ifdef BRIDGE_LV2

  318.     if (std::strcmp(msg, "atom") == 0)

  319.     {

  320.         uint32_t index, size;

  321.         const char* base64atom;

  322. 

  323.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  324.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(size), true);

  325.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(base64atom), true);

  326. 

  327.         std::vector<uint8_t> chunk(carla_getChunkFromBase64String(base64atom));

  328.         delete[] base64atom;

  329.         CARLA_SAFE_ASSERT_RETURN(chunk.size() >= sizeof(LV2_Atom), true);

  330. 

  331.         const LV2_Atom* const atom((const LV2_Atom*)chunk.data());

  332.         CARLA_SAFE_ASSERT_RETURN(atom->size == chunk.size(), true);

  333. 

  334.         dspAtomReceived(index, atom);

  335.         return true;

  336.     }

  337. 

  338.     if (std::strcmp(msg, "urid") == 0)

  339.     {

  340.         uint32_t urid;

  341.         const char* uri;

  342. 

  343.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(urid), true);

  344.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(uri), true);

  345. 

  346.         if (urid == 0)

  347.         {

  348.             CARLA_SAFE_ASSERT_RETURN(std::strcmp(uri, "Complete") == 0, true);

  349.             fUridMapComplete = true;

  350.         }

  351.         else

  352.         {

  353.             dspURIDReceived(urid, uri);

  354.         }

  355. 

  356.         delete[] uri;

  357.         return true;

  358.     }

  359. #endif

  360. 

  361.     CARLA_SAFE_ASSERT_RETURN(fToolkit != nullptr, true);

  362. 

  363.     if (std::strcmp(msg, "show") == 0)

  364.     {

  365.         fToolkit->show();

  366.         return true;

  367.     }

  368. 

  369.     if (std::strcmp(msg, "focus") == 0)

  370.     {

  371.         fToolkit->focus();

  372.         return true;

  373.     }

  374. 

  375.     if (std::strcmp(msg, "hide") == 0)

  376.     {

  377.         fToolkit->hide();

  378.         return true;

  379.     }

  380. 

  381.     if (std::strcmp(msg, "quit") == 0)

  382.     {

  383.         fQuitReceived = true;

  384.         fToolkit->quit();

  385.         return true;

  386.     }

  387. 

  388.     if (std::strcmp(msg, "uiTitle") == 0)

  389.     {

  390.         const char* title;

  391. 

  392.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(title), true);

  393. 

  394.         fToolkit->setTitle(title);

  395. 

  396.         delete[] title;

  397.         return true;

  398.     }

  399. 

  400.     carla_stderr("CarlaBridgeUI::msgReceived : %s", msg);

  401.     return false;

  402. }

  403. 

  404. // ---------------------------------------------------------------------

  405. 

  406. bool CarlaBridgeUI::init(const int argc, const char* argv[])

  407. {

  408.     CARLA_SAFE_ASSERT_RETURN(fToolkit != nullptr, false);

  409. 

  410.     if (! fToolkit->init(argc, argv))

  411.         return false;

  412. 

  413.     if (argc == 7)

  414.     {

  415.         if (! initPipeClient(argv))

  416.         {

  417.             fToolkit->quit();

  418.             delete fToolkit;

  419.             fToolkit = nullptr;

  420.             return false;

  421.         }

  422. 

  423. #ifdef BRIDGE_LV2

  424.         // wait for URID map to complete

  425.         for (int i=0; i<20 && ! fUridMapComplete; ++i)

  426.         {

  427.             idlePipe();

  428.             carla_msleep(100);

  429.         }

  430. 

  431.         if (! fUridMapComplete)

  432.         {

  433.             fToolkit->quit();

  434.             delete fToolkit;

  435.             fToolkit = nullptr;

  436.             closePipeClient();

  437.         }

  438. #endif

  439.     }

  440. 

  441.     return true;

  442. }

  443. 

  444. void CarlaBridgeUI::exec(const bool showUI)

  445. {

  446.     CARLA_SAFE_ASSERT_RETURN(fToolkit != nullptr,);

  447. 

  448.     fToolkit->exec(showUI);

  449. }

  450. 

  451. // ---------------------------------------------------------------------

  452. 

  453. CARLA_BRIDGE_END_NAMESPACE

  454. 

  455. #include "CarlaPipeUtils.cpp"

  456. 

  457. // ---------------------------------------------------------------------

  458. 

  459. #if 0

  460. // ---------------------------------------------------------------------

  461. // ui initialization

  462. 

  463. bool CarlaBridgeUI::uiInit(const char*, const char* const, const char* const)

  464. {

  465.     carla_debug("CarlaBridgeUI::uiInit()");

  466. 

  467.     fUI.init();

  468. 

  469.     return true;

  470. }

  471. 

  472. void CarlaBridgeUI::uiClose()

  473. {

  474.     carla_debug("CarlaBridgeUI::uiClose()");

  475. 

  476.     if (isOscControlRegistered() && ! fUI.quit)

  477.         sendOscExiting();

  478. 

  479.     fUI.close();

  480. }

  481. 

  482. // ---------------------------------------------------------------------

  483. // ui toolkit

  484. 

  485. void CarlaBridgeUI::toolkitShow()

  486. {

  487.     CARLA_SAFE_ASSERT_RETURN(fUI.toolkit != nullptr,);

  488.     carla_debug("CarlaBridgeUI::toolkitShow()");

  489. 

  490.     fUI.toolkit->show();

  491. }

  492. 

  493. void CarlaBridgeUI::toolkitHide()

  494. {

  495.     CARLA_SAFE_ASSERT_RETURN(fUI.toolkit != nullptr,);

  496.     carla_debug("CarlaBridgeUI::toolkitHide()");

  497. 

  498.     fUI.toolkit->hide();

  499. }

  500. 

  501. void CarlaBridgeUI::toolkitResize(const int width, const int height)

  502. {

  503.     CARLA_SAFE_ASSERT_RETURN(fUI.toolkit != nullptr,);

  504.     carla_debug("CarlaBridgeUI::toolkitResize(%i, %i)", width, height);

  505. 

  506.     fUI.toolkit->resize(width, height);

  507. }

  508. 

  509. void CarlaBridgeUI::toolkitExec(const bool showGui)

  510. {

  511.     CARLA_SAFE_ASSERT_RETURN(fUI.toolkit != nullptr,);

  512.     carla_debug("CarlaBridgeUI::toolkitExec(%s)", bool2str(showGui));

  513. 

  514.     fUI.toolkit->exec(showGui);

  515. }

  516. 

  517. void CarlaBridgeUI::toolkitQuit()

  518. {

  519.     carla_debug("CarlaBridgeUI::toolkitQuit()");

  520. 

  521.     fUI.quit = true;

  522. }

  523. 

  524. // ---------------------------------------------------------------------

  525. // osc stuff

  526. 

  527. void CarlaBridgeUI::oscInit(const char* const url)

  528. {

  529.     carla_debug("CarlaBridgeUI::oscInit(\"%s\")", url);

  530. 

  531.     fOsc.init(url);

  532. }

  533. 

  534. bool CarlaBridgeUI::oscIdle(const bool onlyOnce) const

  535. {

  536.     if (onlyOnce)

  537.         fOsc.idleOnce();

  538.     else

  539.         fOsc.idle();

  540. 

  541.     return ! fUI.quit;

  542. }

  543. 

  544. void CarlaBridgeUI::oscClose()

  545. {

  546.     carla_debug("CarlaBridgeUI::oscClose()");

  547. 

  548.     fOsc.close();

  549. }

  550. 

  551. bool CarlaBridgeUI::isOscControlRegistered() const noexcept

  552. {

  553.     return fOsc.isControlRegistered();

  554. }

  555. 

  556. void CarlaBridgeUI::sendOscUpdate() const

  557. {

  558.     carla_debug("CarlaBridgeUI::sendOscUpdate()");

  559. 

  560.     if (fOscData.target != nullptr)

  561.         osc_send_update(fOscData, fOsc.getServerPath());

  562. }

  563. 

  564. // ---------------------------------------------------------------------

  565. 

  566. void CarlaBridgeUI::sendOscConfigure(const char* const key, const char* const value) const

  567. {

  568.     carla_debug("CarlaBridgeUI::sendOscConfigure(\"%s\", \"%s\")", key, value);

  569. 

  570.     if (fOscData.target != nullptr)

  571.         osc_send_configure(fOscData, key, value);

  572. }

  573. 

  574. void CarlaBridgeUI::sendOscControl(const int32_t index, const float value) const

  575. {

  576.     carla_debug("CarlaBridgeUI::sendOscControl(%i, %f)", index, value);

  577. 

  578.     if (fOscData.target != nullptr)

  579.         osc_send_control(fOscData, index, value);

  580. }

  581. 

  582. void CarlaBridgeUI::sendOscProgram(const uint32_t index) const

  583. {

  584.     carla_debug("CarlaBridgeUI::sendOscProgram(%i)", index);

  585. 

  586.     if (fOscData.target != nullptr)

  587.         osc_send_program(fOscData, index);

  588. }

  589. 

  590. void CarlaBridgeUI::sendOscMidiProgram(const uint32_t index) const

  591. {

  592.     carla_debug("CarlaBridgeUI::sendOscMidiProgram(%i)", index);

  593. 

  594.     if (fOscData.target != nullptr)

  595.         osc_send_midi_program(fOscData, index);

  596. }

  597. 

  598. void CarlaBridgeUI::sendOscMidi(const uint8_t midiBuf[4]) const

  599. {

  600.     carla_debug("CarlaBridgeUI::sendOscMidi(%p)", midiBuf);

  601. 

  602.     if (fOscData.target != nullptr)

  603.         osc_send_midi(fOscData, midiBuf);

  604. }

  605. 

  606. void CarlaBridgeUI::sendOscExiting() const

  607. {

  608.     carla_debug("CarlaBridgeUI::sendOscExiting()");

  609. 

  610.     if (fOscData.target != nullptr)

  611.         osc_send_exiting(fOscData);

  612. }

  613. 

  614. #ifdef BRIDGE_LV2

  615. void CarlaBridgeUI::sendOscLv2AtomTransfer(const uint32_t portIndex, const char* const atomBuf) const

  616. {

  617.     carla_debug("CarlaBridgeUI::sendOscLv2TransferAtom(%i, \"%s\")", portIndex, atomBuf);

  618. 

  619.     if (fOscData.target != nullptr)

  620.         osc_send_lv2_atom_transfer(fOscData, portIndex, atomBuf);

  621. }

  622. 

  623. void CarlaBridgeUI::sendOscLv2UridMap(const uint32_t urid, const char* const uri) const

  624. {

  625.     carla_debug("CarlaBridgeUI::sendOscLv2UridMap(%i, \"%s\")", urid, uri);

  626. 

  627.     if (fOscData.target != nullptr)

  628.         osc_send_lv2_urid_map(fOscData, urid, uri);

  629. }

  630. #endif

  631. 

  632. // ---------------------------------------------------------------------

  633. 

  634. void* CarlaBridgeUI::getContainerId()

  635. {

  636.     carla_debug("CarlaBridgeUI::getContainerId()");

  637.     return fUI.toolkit->getContainerId();

  638. }

  639. 

  640. void* CarlaBridgeUI::getContainerId2()

  641. {

  642.     carla_debug("CarlaBridgeUI::getContainerId2()");

  643.     return fUI.toolkit->getContainerId2();

  644. }

  645. 

  646. bool CarlaBridgeUI::uiLibOpen(const char* const filename)

  647. {

  648.     CARLA_ASSERT(fUI.lib == nullptr);

  649.     CARLA_ASSERT(filename != nullptr);

  650.     carla_debug("CarlaBridgeUI::uiLibOpen(\"%s\")", filename);

  651. 

  652.     fUI.lib      = lib_open(filename);

  653.     fUI.filename = filename;

  654. 

  655.     return (fUI.lib != nullptr);

  656. }

  657. 

  658. bool CarlaBridgeUI::uiLibClose()

  659. {

  660.     CARLA_SAFE_ASSERT_RETURN(fUI.lib != nullptr, false);

  661.     carla_debug("CarlaBridgeUI::uiLibClose()");

  662. 

  663.     const bool closed = lib_close(fUI.lib);

  664.     fUI.lib = nullptr;

  665.     return closed;

  666. }

  667. 

  668. const char* CarlaBridgeUI::uiLibError()

  669. {

  670.     carla_debug("CarlaBridgeUI::uiLibError()");

  671. 

  672.     return lib_error(fUI.filename);

  673. }

  674. #endif