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.
5173 Commits
16 Branches
152MB
Tree: cacad4a52f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cacad4a52f'
${ noResults }
Carla/source/frontend/C++/host.cpp

1678 lines
55KB
Raw Blame History 

  1. /*

  2.  * Carla plugin host

  3.  * Copyright (C) 2011-2019 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. //---------------------------------------------------------------------------------------------------------------------

  19. // Imports (Global)

  20. 

  21. #include <QtCore/QStringList>

  22. #include <QtCore/QTimer>

  23. 

  24. #include <QtGui/QPainter>

  25. 

  26. #include <QtWidgets/QFileDialog>

  27. #include <QtWidgets/QFileSystemModel>

  28. #include <QtWidgets/QMainWindow>

  29. #include <QtWidgets/QMessageBox>

  30. 

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

  32. // Imports (Custom)

  33. 

  34. #include "host.hpp"

  35. #include "ui_carla_host.hpp"

  36. 

  37. #include "../../backend/CarlaHost.h"

  38. #include "../../backend/CarlaUtils.h"

  39. #include "../../utils/CarlaBackendUtils.hpp"

  40. #include "../../utils/CarlaMathUtils.hpp"

  41. #include "../../utils/CarlaString.hpp"

  42. 

  43. //---------------------------------------------------------------------------------------------------------------------

  44. 

  45. CarlaObject gCarla;

  46. 

  47. //---------------------------------------------------------------------------------------------------------------------

  48. 

  49. Host::Host()

  50.     : isControl(false),

  51.       isPlugin(false),

  52.       isRemote(false),

  53.       nsmOK(false),

  54.       processMode(ENGINE_PROCESS_MODE_PATCHBAY),

  55.       transportMode(ENGINE_TRANSPORT_MODE_INTERNAL),

  56.       transportExtra(),

  57.       nextProcessMode(processMode),

  58.       processModeForced(false),

  59.       audioDriverForced(),

  60.       experimental(false),

  61.       exportLV2(false),

  62.       forceStereo(false),

  63.       manageUIs(false),

  64.       maxParameters(false),

  65.       preferPluginBridges(false),

  66.       preferUIBridges(false),

  67.       preventBadBehaviour(false),

  68.       showLogs(false),

  69.       showPluginBridges(false),

  70.       showWineBridges(false),

  71.       uiBridgesTimeout(0),

  72.       uisAlwaysOnTop(false),

  73.       pathBinaries(),

  74.       pathResources() {}

  75. 

  76. //---------------------------------------------------------------------------------------------------------------------

  77. 

  78. struct CachedSavedSettings {

  79.     uint _CARLA_KEY_MAIN_REFRESH_INTERVAL = 0;

  80.     bool _CARLA_KEY_MAIN_CONFIRM_EXIT = false;

  81.     bool _CARLA_KEY_CANVAS_FANCY_EYE_CANDY = false;

  82. };

  83. 

  84. //---------------------------------------------------------------------------------------------------------------------

  85. // Host Private Data

  86. 

  87. struct CarlaHostWindow::PrivateData {

  88.     Ui::CarlaHostW ui;

  89. 

  90.     int fIdleTimerNull = 0;

  91.     int fIdleTimerFast = 0;

  92.     int fIdleTimerSlow = 0;

  93. 

  94.     bool fLadspaRdfNeedsUpdate = true;

  95.     QStringList fLadspaRdfList;

  96. 

  97.     int fPluginCount = 0;

  98.     QList<QWidget*> fPluginList;

  99. 

  100.     void* fPluginDatabaseDialog = nullptr;

  101.     QStringList fFavoritePlugins;

  102. 

  103.     QCarlaString fProjectFilename;

  104.     bool fIsProjectLoading = false;

  105.     bool fCurrentlyRemovingAllPlugins = false;

  106. 

  107.     double fLastTransportBPM   = 0.0;

  108.     uint64_t fLastTransportFrame = 0;

  109.     bool fLastTransportState = false;

  110.     uint fBufferSize         = 0;

  111.     double fSampleRate       = 0.0;

  112.     QCarlaString fOscAddressTCP;

  113.     QCarlaString fOscAddressUDP;

  114.     QCarlaString fOscReportedHost;

  115. 

  116. #ifdef CARLA_OS_MAC

  117.     bool fMacClosingHelper = true;

  118. #endif

  119. 

  120.     // CancelableActionCallback Box

  121.     void* fCancelableActionBox = nullptr;

  122. 

  123.     // run a custom action after engine is properly closed

  124.     CustomActions fCustomStopAction = CUSTOM_ACTION_NONE;

  125. 

  126.     // first attempt of auto-start engine doesn't show an error

  127.     bool fFirstEngineInit = true;

  128. 

  129.     // to be filled with key-value pairs of current settings

  130.     CachedSavedSettings fSavedSettings;

  131. 

  132.     QCarlaString fClientName;

  133.     QCarlaString fSessionManagerName;

  134. 

  135.     //-----------------------------------------------------------------------------------------------------------------

  136.     // Internal stuff (patchbay)

  137. 

  138.     QImage fExportImage;

  139. 

  140.     bool fPeaksCleared = true;

  141. 

  142.     bool fExternalPatchbay = false;

  143.     QList<uint> fSelectedPlugins;

  144. 

  145.     int fCanvasWidth  = 0;

  146.     int fCanvasHeight = 0;

  147.     int fMiniCanvasUpdateTimeout = 0;

  148.     bool fWithCanvas;

  149. 

  150.     //-----------------------------------------------------------------------------------------------------------------

  151.     // GUI stuff (disk)

  152. 

  153.     QFileSystemModel fDirModel;

  154. 

  155.     //-----------------------------------------------------------------------------------------------------------------

  156. 

  157.     // CarlaHostWindow* hostWindow,

  158.     PrivateData(CarlaHostWindow* const hostWindow, const bool withCanvas)

  159.         : fWithCanvas(withCanvas),

  160.           fDirModel(hostWindow)

  161.     {

  162.         ui.setupUi(hostWindow);

  163.     }

  164. };

  165. 

  166. //---------------------------------------------------------------------------------------------------------------------

  167. // Host Window

  168. 

  169. CarlaHostWindow::CarlaHostWindow(Host& h, const bool withCanvas, QWidget* const parent)

  170.     : QMainWindow(parent),

  171.       host(h),

  172.       self(new PrivateData(this, withCanvas))

  173. {

  174.     gCarla.gui = this;

  175. 

  176.     static const char* const CARLA_CLIENT_NAME = getenv("CARLA_CLIENT_NAME");

  177.     static const char* const LADISH_APP_NAME   = getenv("LADISH_APP_NAME");

  178.     static const char* const NSM_URL           = getenv("NSM_URL");

  179. 

  180.     //-----------------------------------------------------------------------------------------------------------------

  181.     // Internal stuff

  182. 

  183.     // keep application signals alive

  184.     self->fIdleTimerNull = startTimer(1000);

  185. 

  186.     if (host.isControl)

  187.     {

  188.         self->fClientName         = "Carla-Control";

  189.         self->fSessionManagerName = "Control";

  190.     }

  191.     else if (host.isPlugin)

  192.     {

  193.         self->fClientName         = "Carla-Plugin";

  194.         self->fSessionManagerName = "Plugin";

  195.     }

  196.     else if (LADISH_APP_NAME != nullptr)

  197.     {

  198.         self->fClientName         = LADISH_APP_NAME;

  199.         self->fSessionManagerName = "LADISH";

  200.     }

  201.     else if (NSM_URL != nullptr && host.nsmOK)

  202.     {

  203.         self->fClientName         = "Carla.tmp";

  204.         self->fSessionManagerName = "Non Session Manager TMP";

  205.     }

  206.     else

  207.     {

  208.         self->fClientName         = CARLA_CLIENT_NAME != nullptr ? CARLA_CLIENT_NAME : "Carla";

  209.         self->fSessionManagerName = "";

  210.     }

  211. 

  212.     //-----------------------------------------------------------------------------------------------------------------

  213.     // Set up GUI (engine stopped)

  214. 

  215.     if (host.isPlugin || host.isControl)

  216.     {

  217.         self->ui.act_file_save->setVisible(false);

  218.         self->ui.act_engine_start->setEnabled(false);

  219.         self->ui.act_engine_start->setVisible(false);

  220.         self->ui.act_engine_stop->setEnabled(false);

  221.         self->ui.act_engine_stop->setVisible(false);

  222.         self->ui.menu_Engine->setEnabled(false);

  223.         self->ui.menu_Engine->setVisible(false);

  224.         if (QAction* const action = self->ui.menu_Engine->menuAction())

  225.             action->setVisible(false);

  226.         self->ui.tabWidget->removeTab(2);

  227. 

  228.         if (host.isControl)

  229.         {

  230.             self->ui.act_file_new->setVisible(false);

  231.             self->ui.act_file_open->setVisible(false);

  232.             self->ui.act_file_save_as->setVisible(false);

  233.             self->ui.tabUtils->removeTab(0);

  234.         }

  235.         else

  236.         {

  237.             self->ui.act_file_save_as->setText(tr("Export as..."));

  238. 

  239.             if (! withCanvas)

  240.                 if (QTabBar* const tabBar = self->ui.tabWidget->tabBar())

  241.                     tabBar->hide();

  242.         }

  243.     }

  244.     else

  245.     {

  246.         self->ui.act_engine_start->setEnabled(true);

  247. #ifdef CARLA_OS_WIN

  248.         self->ui.tabWidget->removeTab(2);

  249. #endif

  250.     }

  251. 

  252.     if (host.isControl)

  253.     {

  254.         self->ui.act_file_refresh->setEnabled(false);

  255.     }

  256.     else

  257.     {

  258.         self->ui.act_file_connect->setEnabled(false);

  259.         self->ui.act_file_connect->setVisible(false);

  260.         self->ui.act_file_refresh->setEnabled(false);

  261.         self->ui.act_file_refresh->setVisible(false);

  262.     }

  263. 

  264.     if (self->fSessionManagerName.isNotEmpty() && ! host.isPlugin)

  265.         self->ui.act_file_new->setEnabled(false);

  266. 

  267.     self->ui.act_file_open->setEnabled(false);

  268.     self->ui.act_file_save->setEnabled(false);

  269.     self->ui.act_file_save_as->setEnabled(false);

  270.     self->ui.act_engine_stop->setEnabled(false);

  271.     self->ui.act_plugin_remove_all->setEnabled(false);

  272. 

  273.     self->ui.act_canvas_show_internal->setChecked(false);

  274.     self->ui.act_canvas_show_internal->setVisible(false);

  275.     self->ui.act_canvas_show_external->setChecked(false);

  276.     self->ui.act_canvas_show_external->setVisible(false);

  277. 

  278.     self->ui.menu_PluginMacros->setEnabled(false);

  279.     self->ui.menu_Canvas->setEnabled(false);

  280. 

  281.     QWidget* const dockWidgetTitleBar = new QWidget(this);

  282.     self->ui.dockWidget->setTitleBarWidget(dockWidgetTitleBar);

  283. 

  284.     if (! withCanvas)

  285.     {

  286.         self->ui.act_canvas_show_internal->setVisible(false);

  287.         self->ui.act_canvas_show_external->setVisible(false);

  288.         self->ui.act_canvas_arrange->setVisible(false);

  289.         self->ui.act_canvas_refresh->setVisible(false);

  290.         self->ui.act_canvas_save_image->setVisible(false);

  291.         self->ui.act_canvas_zoom_100->setVisible(false);

  292.         self->ui.act_canvas_zoom_fit->setVisible(false);

  293.         self->ui.act_canvas_zoom_in->setVisible(false);

  294.         self->ui.act_canvas_zoom_out->setVisible(false);

  295.         self->ui.act_settings_show_meters->setVisible(false);

  296.         self->ui.act_settings_show_keyboard->setVisible(false);

  297.         self->ui.menu_Canvas_Zoom->setEnabled(false);

  298.         self->ui.menu_Canvas_Zoom->setVisible(false);

  299.         if (QAction* const action = self->ui.menu_Canvas_Zoom->menuAction())

  300.             action->setVisible(false);

  301.         self->ui.menu_Canvas->setEnabled(false);

  302.         self->ui.menu_Canvas->setVisible(false);

  303.         if (QAction* const action = self->ui.menu_Canvas->menuAction())

  304.             action->setVisible(false);

  305.         self->ui.tw_miniCanvas->hide();

  306.         self->ui.tabWidget->removeTab(1);

  307. #ifdef CARLA_OS_WIN

  308.         self->ui.tabWidget->tabBar().hide()

  309. #endif

  310.     }

  311. 

  312.     //-----------------------------------------------------------------------------------------------------------------

  313.     // Set up GUI (disk)

  314. 

  315.     const QString home(QDir::homePath());

  316.     self->fDirModel.setRootPath(home);

  317. 

  318.     if (const char* const* const exts = carla_get_supported_file_extensions())

  319.     {

  320.         QStringList filters;

  321.         const QString prefix("*.");

  322. 

  323.         for (uint i=0; exts[i] != nullptr; ++i)

  324.             filters.append(prefix + exts[i]);

  325. 

  326.         self->fDirModel.setNameFilters(filters);

  327.     }

  328. 

  329.     self->ui.fileTreeView->setModel(&self->fDirModel);

  330.     self->ui.fileTreeView->setRootIndex(self->fDirModel.index(home));

  331.     self->ui.fileTreeView->setColumnHidden(1, true);

  332.     self->ui.fileTreeView->setColumnHidden(2, true);

  333.     self->ui.fileTreeView->setColumnHidden(3, true);

  334.     self->ui.fileTreeView->setHeaderHidden(true);

  335. 

  336.     //-----------------------------------------------------------------------------------------------------------------

  337.     // Set up GUI (transport)

  338. 

  339.     const QFontMetrics fontMetrics(self->ui.l_transport_bbt->fontMetrics());

  340.     int minValueWidth = fontMetricsHorizontalAdvance(fontMetrics, "000|00|0000");

  341.     int minLabelWidth = fontMetricsHorizontalAdvance(fontMetrics, self->ui.label_transport_frame->text());

  342. 

  343.     int labelTimeWidth = fontMetricsHorizontalAdvance(fontMetrics, self->ui.label_transport_time->text());

  344.     int labelBBTWidth  = fontMetricsHorizontalAdvance(fontMetrics, self->ui.label_transport_bbt->text());

  345. 

  346.     if (minLabelWidth < labelTimeWidth)

  347.         minLabelWidth = labelTimeWidth;

  348.     if (minLabelWidth < labelBBTWidth)

  349.         minLabelWidth = labelBBTWidth;

  350. 

  351.     self->ui.label_transport_frame->setMinimumWidth(minLabelWidth + 3);

  352.     self->ui.label_transport_time->setMinimumWidth(minLabelWidth + 3);

  353.     self->ui.label_transport_bbt->setMinimumWidth(minLabelWidth + 3);

  354. 

  355.     self->ui.l_transport_bbt->setMinimumWidth(minValueWidth + 3);

  356.     self->ui.l_transport_frame->setMinimumWidth(minValueWidth + 3);

  357.     self->ui.l_transport_time->setMinimumWidth(minValueWidth + 3);

  358. 

  359.     if (host.isPlugin)

  360.     {

  361.         self->ui.b_transport_play->setEnabled(false);

  362.         self->ui.b_transport_stop->setEnabled(false);

  363.         self->ui.b_transport_backwards->setEnabled(false);

  364.         self->ui.b_transport_forwards->setEnabled(false);

  365.         self->ui.group_transport_controls->setEnabled(false);

  366.         self->ui.group_transport_controls->setVisible(false);

  367.         self->ui.cb_transport_link->setEnabled(false);

  368.         self->ui.cb_transport_link->setVisible(false);

  369.         self->ui.cb_transport_jack->setEnabled(false);

  370.         self->ui.cb_transport_jack->setVisible(false);

  371.         self->ui.dsb_transport_bpm->setEnabled(false);

  372.         self->ui.dsb_transport_bpm->setReadOnly(true);

  373.     }

  374. 

  375.     self->ui.w_transport->setEnabled(false);

  376. 

  377.     //-----------------------------------------------------------------------------------------------------------------

  378.     // Set up GUI (rack)

  379. 

  380.     // self->ui.listWidget->setHostAndParent(self->host, self);

  381. 

  382.     if (QScrollBar* const sb = self->ui.listWidget->verticalScrollBar())

  383.     {

  384.         self->ui.rackScrollBar->setMinimum(sb->minimum());

  385.         self->ui.rackScrollBar->setMaximum(sb->maximum());

  386.         self->ui.rackScrollBar->setValue(sb->value());

  387. 

  388.         /*

  389.         sb->rangeChanged.connect(self->ui.rackScrollBar.setRange);

  390.         sb->valueChanged.connect(self->ui.rackScrollBar.setValue);

  391.         self->ui.rackScrollBar->rangeChanged.connect(sb.setRange);

  392.         self->ui.rackScrollBar->valueChanged.connect(sb.setValue);

  393.         */

  394.     }

  395. 

  396.     /*

  397.     updateStyle();

  398.     */

  399. 

  400.     self->ui.rack->setStyleSheet("  \

  401.       CarlaRackList#CarlaRackList { \

  402.         background-color: black;    \

  403.       }                             \

  404.     ");

  405. 

  406.     //-----------------------------------------------------------------------------------------------------------------

  407.     // Set up GUI (patchbay)

  408. 

  409.     /*

  410.     self->ui.peak_in->setChannelCount(2);

  411.     self->ui.peak_in->setMeterColor(DigitalPeakMeter.COLOR_BLUE);

  412.     self->ui.peak_in->setMeterOrientation(DigitalPeakMeter.VERTICAL);

  413.     */

  414.     self->ui.peak_in->setFixedWidth(25);

  415. 

  416.     /*

  417.     self->ui.peak_out->setChannelCount(2);

  418.     self->ui.peak_out->setMeterColor(DigitalPeakMeter.COLOR_GREEN);

  419.     self->ui.peak_out->setMeterOrientation(DigitalPeakMeter.VERTICAL);

  420.     */

  421.     self->ui.peak_out->setFixedWidth(25);

  422. 

  423.     /*

  424.     self->ui.scrollArea = PixmapKeyboardHArea(self->ui.patchbay);

  425.     self->ui.keyboard   = self->ui.scrollArea.keyboard;

  426.     self->ui.patchbay.layout().addWidget(self->ui.scrollArea, 1, 0, 1, 0);

  427. 

  428.     self->ui.scrollArea->setEnabled(false);

  429. 

  430.     self->ui.miniCanvasPreview->setRealParent(self);

  431.     */

  432.     if (QTabBar* const tabBar = self->ui.tw_miniCanvas->tabBar())

  433.         tabBar->hide();

  434. 

  435.     //-----------------------------------------------------------------------------------------------------------------

  436.     // Set up GUI (special stuff for Mac OS)

  437. 

  438. #ifdef CARLA_OS_MAC

  439.     self->ui.act_file_quit->setMenuRole(QAction::QuitRole);

  440.     self->ui.act_settings_configure->setMenuRole(QAction::PreferencesRole);

  441.     self->ui.act_help_about->setMenuRole(QAction::AboutRole);

  442.     self->ui.act_help_about_qt->setMenuRole(QAction::AboutQtRole);

  443.     self->ui.menu_Settings->setTitle("Panels");

  444.     if (QAction* const action = self->ui.menu_Help.menuAction())

  445.         action->setVisible(false);

  446. #endif

  447. 

  448.     //-----------------------------------------------------------------------------------------------------------------

  449.     // Load Settings

  450. 

  451.     loadSettings(true);

  452. 

  453.     //-----------------------------------------------------------------------------------------------------------------

  454.     // Set-up Canvas

  455. 

  456.     /*

  457.     if (withCanvas)

  458.     {

  459.         self->scene = patchcanvas.PatchScene(self, self->ui.graphicsView);

  460.         self->ui.graphicsView->setScene(self->scene);

  461. 

  462.         if (self->fSavedSettings[CARLA_KEY_CANVAS_USE_OPENGL])

  463.         {

  464.             self->ui.glView = QGLWidget(self);

  465.             self->ui.graphicsView.setViewport(self->ui.glView);

  466.         }

  467. 

  468.         setupCanvas();

  469.     }

  470.     */

  471. 

  472.     //-----------------------------------------------------------------------------------------------------------------

  473.     // Connect actions to functions

  474. 

  475.     // TODO

  476. 

  477.     connect(self->ui.b_transport_play, SIGNAL(clicked(bool)), SLOT(slot_transportPlayPause(bool)));

  478.     connect(self->ui.b_transport_stop, SIGNAL(clicked()), SLOT(slot_transportStop()));

  479.     connect(self->ui.b_transport_backwards, SIGNAL(clicked()), SLOT(slot_transportBackwards()));

  480.     connect(self->ui.b_transport_forwards, SIGNAL(clicked()), SLOT(slot_transportForwards()));

  481.     connect(self->ui.dsb_transport_bpm, SIGNAL(valueChanged(qreal)), SLOT(slot_transportBpmChanged(qreal)));

  482.     connect(self->ui.cb_transport_jack, SIGNAL(clicked(bool)), SLOT(slot_transportJackEnabled(bool)));

  483.     connect(self->ui.cb_transport_link, SIGNAL(clicked(bool)), SLOT(slot_transportLinkEnabled(bool)));

  484. 

  485.     connect(self->ui.b_xruns, SIGNAL(clicked()), SLOT(slot_xrunClear()));

  486. 

  487.     connect(&host, SIGNAL(EngineStartedCallback(uint, int, int, int, float, QString)), SLOT(slot_handleEngineStartedCallback(uint, int, int, int, float, QString)));

  488.     connect(&host, SIGNAL(EngineStoppedCallback()), SLOT(slot_handleEngineStoppedCallback()));

  489. 

  490.     //-----------------------------------------------------------------------------------------------------------------

  491.     // Final setup

  492. 

  493.     self->ui.text_logs->clear();

  494.     setProperWindowTitle();

  495. 

  496.     // Disable non-supported features

  497.     const char* const* const features = carla_get_supported_features();

  498. 

  499.     if (! stringArrayContainsString(features, "link"))

  500.     {

  501.         self->ui.cb_transport_link->setEnabled(false);

  502.         self->ui.cb_transport_link->setVisible(false);

  503.     }

  504. 

  505.     if (! stringArrayContainsString(features, "juce"))

  506.     {

  507.         self->ui.act_help_about_juce->setEnabled(false);

  508.         self->ui.act_help_about_juce->setVisible(false);

  509.     }

  510. 

  511.     // Plugin needs to have timers always running so it receives messages

  512.     if (host.isPlugin || host.isRemote)

  513.         startTimers();

  514. 

  515.     // Qt needs this so it properly creates & resizes the canvas

  516.     self->ui.tabWidget->blockSignals(true);

  517.     self->ui.tabWidget->setCurrentIndex(1);

  518.     self->ui.tabWidget->setCurrentIndex(0);

  519.     self->ui.tabWidget->blockSignals(false);

  520. 

  521.     // Start in patchbay tab if using forced patchbay mode

  522.     if (host.processModeForced && host.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  523.         self->ui.tabWidget->setCurrentIndex(1);

  524. 

  525.     // Load initial project file if set

  526.     if (! (host.isControl || host.isPlugin))

  527.     {

  528.         /*

  529.         projectFile = getInitialProjectFile(QApplication.instance());

  530. 

  531.         if (projectFile)

  532.             loadProjectLater(projectFile);

  533.         */

  534.     }

  535. 

  536.     // For NSM we wait for the open message

  537.     if (NSM_URL != nullptr && host.nsmOK)

  538.     {

  539.         carla_nsm_ready(NSM_CALLBACK_INIT);

  540.         return;

  541.     }

  542. 

  543.     if (! host.isControl)

  544.         QTimer::singleShot(0, this, SLOT(slot_engineStart()));

  545. }

  546. 

  547. CarlaHostWindow::~CarlaHostWindow()

  548. {

  549.     delete self;

  550. }

  551. 

  552. //---------------------------------------------------------------------------------------------------------------------

  553. // Setup

  554. 

  555. #if 0

  556. def compactPlugin(self, pluginId):

  557.     if pluginId > self->fPluginCount:

  558.         return

  559. 

  560.     pitem = self->fPluginList[pluginId]

  561. 

  562.     if pitem is None:

  563.         return

  564. 

  565.     pitem.recreateWidget(true)

  566. 

  567. def changePluginColor(self, pluginId, color, colorStr):

  568.     if pluginId > self->fPluginCount:

  569.         return

  570. 

  571.     pitem = self->fPluginList[pluginId]

  572. 

  573.     if pitem is None:

  574.         return

  575. 

  576.     self->host.set_custom_data(pluginId, CUSTOM_DATA_TYPE_PROPERTY, "CarlaColor", colorStr)

  577.     pitem.recreateWidget(newColor = color)

  578. 

  579. def changePluginSkin(self, pluginId, skin):

  580.     if pluginId > self->fPluginCount:

  581.         return

  582. 

  583.     pitem = self->fPluginList[pluginId]

  584. 

  585.     if pitem is None:

  586.         return

  587. 

  588.     self->host.set_custom_data(pluginId, CUSTOM_DATA_TYPE_PROPERTY, "CarlaSkin", skin)

  589.     if skin not in ("default","rncbc","presets","mpresets"):

  590.         pitem.recreateWidget(newSkin = skin, newColor = (255,255,255))

  591.     else:

  592.         pitem.recreateWidget(newSkin = skin)

  593. 

  594. def switchPlugins(self, pluginIdA, pluginIdB):

  595.     if pluginIdA == pluginIdB:

  596.         return

  597.     if pluginIdA < 0 or pluginIdB < 0:

  598.         return

  599.     if pluginIdA >= self->fPluginCount or pluginIdB >= self->fPluginCount:

  600.         return

  601. 

  602.     self->host.switch_plugins(pluginIdA, pluginIdB)

  603. 

  604.     itemA = self->fPluginList[pluginIdA]

  605.     compactA = itemA.isCompacted()

  606.     guiShownA = itemA.isGuiShown()

  607. 

  608.     itemB = self->fPluginList[pluginIdB]

  609.     compactB = itemB.isCompacted()

  610.     guiShownB = itemB.isGuiShown()

  611. 

  612.     itemA.setPluginId(pluginIdA)

  613.     itemA.recreateWidget2(compactB, guiShownB)

  614. 

  615.     itemB.setPluginId(pluginIdB)

  616.     itemB.recreateWidget2(compactA, guiShownA)

  617. 

  618.     if self->fWithCanvas:

  619.         self->slot_canvasRefresh()

  620. #endif

  621. 

  622. void CarlaHostWindow::setLoadRDFsNeeded() noexcept

  623. {

  624.     self->fLadspaRdfNeedsUpdate = true;

  625. }

  626. 

  627. void CarlaHostWindow::setProperWindowTitle()

  628. {

  629.     QString title(self->fClientName);

  630. 

  631.     /*

  632.     if (self->fProjectFilename.isNotEmpty() && ! host.nsmOK)

  633.         title += QString(" - %s").arg(os.path.basename(self->fProjectFilename));

  634.     */

  635.     if (self->fSessionManagerName.isNotEmpty())

  636.         title += QString(" (%s)").arg(self->fSessionManagerName);

  637. 

  638.     setWindowTitle(title);

  639. }

  640. 

  641. void CarlaHostWindow::updateBufferSize(const uint newBufferSize)

  642. {

  643.     if (self->fBufferSize == newBufferSize)

  644.         return;

  645.     self->fBufferSize = newBufferSize;

  646.     self->ui.cb_buffer_size->clear();

  647.     self->ui.cb_buffer_size->addItem(QString("%1").arg(newBufferSize));

  648.     self->ui.cb_buffer_size->setCurrentIndex(0);

  649. }

  650. 

  651. void CarlaHostWindow::updateSampleRate(const double newSampleRate)

  652. {

  653.     if (carla_isEqual(self->fSampleRate, newSampleRate))

  654.         return;

  655.     self->fSampleRate = newSampleRate;

  656.     self->ui.cb_sample_rate->clear();

  657.     self->ui.cb_sample_rate->addItem(QString("%1").arg(newSampleRate));

  658.     self->ui.cb_sample_rate->setCurrentIndex(0);

  659.     refreshTransport(true);

  660. }

  661. 

  662. //---------------------------------------------------------------------------------------------------------------------

  663. // Engine (menu actions)

  664. 

  665. void CarlaHostWindow::slot_engineStart()

  666. {

  667.     /*

  668.     audioDriver = setEngineSettings(self->host)

  669.     */

  670.     const char* const audioDriver = "JACK";

  671.     const bool firstInit = self->fFirstEngineInit;

  672. 

  673.     self->fFirstEngineInit = false;

  674.     self->ui.text_logs->appendPlainText("======= Starting engine =======");

  675. 

  676.     if (carla_engine_init(audioDriver, self->fClientName.toUtf8()))

  677.     {

  678.         if (firstInit && ! (host.isControl or host.isPlugin))

  679.         {

  680.             QSafeSettings settings;

  681.             const double lastBpm = settings.valueDouble("LastBPM", 120.0);

  682.             if (lastBpm >= 20.0)

  683.                 carla_transport_bpm(lastBpm);

  684.         }

  685.         return;

  686.     }

  687.     else if (firstInit)

  688.     {

  689.         self->ui.text_logs->appendPlainText("Failed to start engine on first try, ignored");

  690.         return;

  691.     }

  692. 

  693.     const QCarlaString audioError(carla_get_last_error());

  694. 

  695.     if (audioError.isNotEmpty())

  696.     {

  697.         QMessageBox::critical(this,

  698.                               tr("Error"),

  699.                               tr("Could not connect to Audio backend '%1', possible reasons:\n%2").arg(audioDriver).arg(audioError));

  700.     }

  701.     else

  702.     {

  703.         QMessageBox::critical(this,

  704.                               tr("Error"),

  705.                               tr("Could not connect to Audio backend '%1'").arg(audioDriver));

  706.     }

  707. }

  708. 

  709. bool CarlaHostWindow::slot_engineStop(const bool forced)

  710. {

  711.     self->ui.text_logs->appendPlainText("======= Stopping engine =======");

  712. 

  713.     if (self->fPluginCount == 0)

  714.     {

  715.         engineStopFinal();

  716.         return true;

  717.     }

  718. 

  719.     if (! forced)

  720.     {

  721.         const QMessageBox::StandardButton ask = QMessageBox::question(this,

  722.             tr("Warning"),

  723.             tr("There are still some plugins loaded, you need to remove them to stop the engine.\n"

  724.                "Do you want to do this now?"),

  725.             QMessageBox::Yes | QMessageBox::No, QMessageBox::No);

  726. 

  727.         if (ask != QMessageBox::Yes)

  728.             return false;

  729.     }

  730. 

  731.     return slot_engineStopTryAgain();

  732. }

  733. 

  734. void CarlaHostWindow::slot_engineConfig()

  735. {

  736.     /*

  737.     dialog = RuntimeDriverSettingsW(self->fParentOrSelf, self->host)

  738. 

  739.     if not dialog.exec_():

  740.         return

  741. 

  742.     audioDevice, bufferSize, sampleRate = dialog.getValues()

  743. 

  744.     if self->host.is_engine_running():

  745.         self->host.set_engine_buffer_size_and_sample_rate(bufferSize, sampleRate)

  746.     else:

  747.         self->host.set_engine_option(ENGINE_OPTION_AUDIO_DEVICE, 0, audioDevice)

  748.         self->host.set_engine_option(ENGINE_OPTION_AUDIO_BUFFER_SIZE, bufferSize, "")

  749.         self->host.set_engine_option(ENGINE_OPTION_AUDIO_SAMPLE_RATE, sampleRate, "")

  750.     */

  751. }

  752. 

  753. bool CarlaHostWindow::slot_engineStopTryAgain()

  754. {

  755.     if (carla_is_engine_running() && ! carla_set_engine_about_to_close())

  756.     {

  757.         QTimer::singleShot(0, this, SLOT(slot_engineStopTryAgain()));

  758.         return false;

  759.     }

  760. 

  761.     engineStopFinal();

  762.     return true;

  763. }

  764. 

  765. void CarlaHostWindow::engineStopFinal()

  766. {

  767.     killTimers();

  768. 

  769.     if (carla_is_engine_running())

  770.     {

  771.         if (self->fCustomStopAction == CUSTOM_ACTION_PROJECT_LOAD)

  772.         {

  773.             /*

  774.             removeAllPlugins();

  775.             */

  776.         }

  777.         else if (self->fPluginCount != 0)

  778.         {

  779.             self->fCurrentlyRemovingAllPlugins = true;

  780.             /*

  781.             projectLoadingStarted();

  782.             */

  783.         }

  784. 

  785.         if (! carla_remove_all_plugins())

  786.         {

  787.             self->ui.text_logs->appendPlainText("Failed to remove all plugins, error was:");

  788.             self->ui.text_logs->appendPlainText(carla_get_last_error());

  789.         }

  790. 

  791.         if (! carla_engine_close())

  792.         {

  793.             self->ui.text_logs->appendPlainText("Failed to stop engine, error was:");

  794.             self->ui.text_logs->appendPlainText(carla_get_last_error());

  795.         }

  796.     }

  797. 

  798.     if (self->fCustomStopAction == CUSTOM_ACTION_APP_CLOSE)

  799.     {

  800.         close();

  801.     }

  802.     else if (self->fCustomStopAction == CUSTOM_ACTION_PROJECT_LOAD)

  803.     {

  804.         slot_engineStart();

  805.         /*

  806.         loadProjectNow();

  807.         */

  808.         carla_nsm_ready(NSM_CALLBACK_OPEN);

  809.     }

  810. 

  811.     self->fCustomStopAction = CUSTOM_ACTION_NONE;

  812. }

  813. 

  814. //---------------------------------------------------------------------------------------------------------------------

  815. // Engine (host callbacks)

  816. 

  817. void CarlaHostWindow::slot_handleEngineStartedCallback(uint pluginCount, int processMode, int transportMode, int bufferSize, float sampleRate, QString driverName)

  818. {

  819.     self->ui.menu_PluginMacros->setEnabled(true);

  820.     self->ui.menu_Canvas->setEnabled(true);

  821.     self->ui.w_transport->setEnabled(true);

  822. 

  823.     self->ui.act_canvas_show_internal->blockSignals(true);

  824.     self->ui.act_canvas_show_external->blockSignals(true);

  825. 

  826.     if (processMode == ENGINE_PROCESS_MODE_PATCHBAY) // and not self->host.isPlugin:

  827.     {

  828.         self->ui.act_canvas_show_internal->setChecked(true);

  829.         self->ui.act_canvas_show_internal->setVisible(true);

  830.         self->ui.act_canvas_show_external->setChecked(false);

  831.         self->ui.act_canvas_show_external->setVisible(true);

  832.         self->fExternalPatchbay = false;

  833.     }

  834.     else

  835.     {

  836.         self->ui.act_canvas_show_internal->setChecked(false);

  837.         self->ui.act_canvas_show_internal->setVisible(false);

  838.         self->ui.act_canvas_show_external->setChecked(true);

  839.         self->ui.act_canvas_show_external->setVisible(false);

  840.         self->fExternalPatchbay = true;

  841.     }

  842. 

  843.     self->ui.act_canvas_show_internal->blockSignals(false);

  844.     self->ui.act_canvas_show_external->blockSignals(false);

  845. 

  846.     if (! (host.isControl or host.isPlugin))

  847.     {

  848.         /*

  849.         const bool canSave = (self->fProjectFilename.isNotEmpty() and os.path.exists(self->fProjectFilename)) or not self->fSessionManagerName;

  850.         self->ui.act_file_save->setEnabled(canSave);

  851.         */

  852.         self->ui.act_engine_start->setEnabled(false);

  853.         self->ui.act_engine_stop->setEnabled(true);

  854.     }

  855. 

  856.     /*

  857.     if (! host.isPlugin)

  858.         enableTransport(transportMode != ENGINE_TRANSPORT_MODE_DISABLED);

  859.     */

  860. 

  861.     if (host.isPlugin || self->fSessionManagerName.isEmpty())

  862.     {

  863.         self->ui.act_file_open->setEnabled(true);

  864.         self->ui.act_file_save_as->setEnabled(true);

  865.     }

  866. 

  867.     self->ui.cb_transport_jack->setChecked(transportMode == ENGINE_TRANSPORT_MODE_JACK);

  868.     self->ui.cb_transport_jack->setEnabled(driverName == "JACK" and processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS);

  869. 

  870.     if (self->ui.cb_transport_link->isEnabled())

  871.         self->ui.cb_transport_link->setChecked(host.transportExtra.contains(":link:"));

  872. 

  873.     updateBufferSize(bufferSize);

  874.     updateSampleRate(int(sampleRate));

  875.     /*

  876.     refreshRuntimeInfo(0.0, 0);

  877.     */

  878.     startTimers();

  879. 

  880.     self->ui.text_logs->appendPlainText("======= Engine started ========");

  881.     self->ui.text_logs->appendPlainText("Carla engine started, details:");

  882.     self->ui.text_logs->appendPlainText(QString("  Driver name:  %1").arg(driverName));

  883.     self->ui.text_logs->appendPlainText(QString("  Sample rate:  %1").arg(int(sampleRate)));

  884.     self->ui.text_logs->appendPlainText(QString("  Process mode: %1").arg(EngineProcessMode2Str((EngineProcessMode)processMode)));

  885. }

  886. 

  887. void CarlaHostWindow::slot_handleEngineStoppedCallback()

  888. {

  889.     self->ui.text_logs->appendPlainText("======= Engine stopped ========");

  890. 

  891.     /*

  892.     patchcanvas.clear();

  893.     */

  894.     killTimers();

  895. 

  896.     // just in case

  897.     /*

  898.     removeAllPlugins();

  899.     refreshRuntimeInfo(0.0, 0);

  900.     */

  901. 

  902.     self->ui.menu_PluginMacros->setEnabled(false);

  903.     self->ui.menu_Canvas->setEnabled(false);

  904.     self->ui.w_transport->setEnabled(false);

  905. 

  906.     if (! (host.isControl || host.isPlugin))

  907.     {

  908.         self->ui.act_file_save->setEnabled(false);

  909.         self->ui.act_engine_start->setEnabled(true);

  910.         self->ui.act_engine_stop->setEnabled(false);

  911.     }

  912. 

  913.     if (host.isPlugin || self->fSessionManagerName.isEmpty())

  914.     {

  915.         self->ui.act_file_open->setEnabled(false);

  916.         self->ui.act_file_save_as->setEnabled(false);

  917.     }

  918. }

  919. 

  920. //---------------------------------------------------------------------------------------------------------------------

  921. // Settings

  922. 

  923. void CarlaHostWindow::saveSettings()

  924. {

  925.     QSafeSettings settings;

  926. 

  927.     settings.setValue("Geometry", saveGeometry());

  928.     settings.setValue("ShowToolbar", self->ui.toolBar->isEnabled());

  929. 

  930.     if (! host.isControl)

  931.         settings.setValue("ShowSidePanel", self->ui.dockWidget->isEnabled());

  932. 

  933.     QStringList diskFolders;

  934. 

  935.     /*

  936.     for i in range(self->ui.cb_disk.count()):

  937.         diskFolders.append(self->ui.cb_disk->itemData(i))

  938.     */

  939. 

  940.     settings.setValue("DiskFolders", diskFolders);

  941.     settings.setValue("LastBPM", self->fLastTransportBPM);

  942. 

  943.     settings.setValue("ShowMeters", self->ui.act_settings_show_meters->isChecked());

  944.     settings.setValue("ShowKeyboard", self->ui.act_settings_show_keyboard->isChecked());

  945.     settings.setValue("HorizontalScrollBarValue", self->ui.graphicsView->horizontalScrollBar()->value());

  946.     settings.setValue("VerticalScrollBarValue", self->ui.graphicsView->verticalScrollBar()->value());

  947. 

  948.     settings.setValue(CARLA_KEY_ENGINE_TRANSPORT_MODE, host.transportMode);

  949.     settings.setValue(CARLA_KEY_ENGINE_TRANSPORT_EXTRA, host.transportExtra);

  950. }

  951. 

  952. void CarlaHostWindow::loadSettings(bool firstTime)

  953. {

  954.      const QSafeSettings settings;

  955. 

  956.     if (firstTime)

  957.     {

  958.         const QByteArray geometry(settings.valueByteArray("Geometry"));

  959.         if (! geometry.isNull())

  960.             restoreGeometry(geometry);

  961. 

  962.         const bool showToolbar = settings.valueBool("ShowToolbar", true);

  963.         self->ui.act_settings_show_toolbar->setChecked(showToolbar);

  964.         self->ui.toolBar->setEnabled(showToolbar);

  965.         self->ui.toolBar->setVisible(showToolbar);

  966. 

  967.         // if settings.contains("SplitterState"):

  968.             //self->ui.splitter.restoreState(settings.value("SplitterState", b""))

  969.         //else:

  970.             //self->ui.splitter.setSizes([210, 99999])

  971. 

  972.         const bool showSidePanel = settings.valueBool("ShowSidePanel", true) && ! host.isControl;

  973.         self->ui.act_settings_show_side_panel->setChecked(showSidePanel);

  974.         slot_showSidePanel(showSidePanel);

  975. 

  976.         QStringList diskFolders;

  977.         diskFolders.append(QDir::homePath());

  978.         diskFolders = settings.valueStringList("DiskFolders", diskFolders);

  979. 

  980.         self->ui.cb_disk->setItemData(0, QDir::homePath());

  981. 

  982.         for (const auto& folder : diskFolders)

  983.         {

  984.             /*

  985.             if i == 0: continue;

  986.             folder = diskFolders[i];

  987.             self->ui.cb_disk->addItem(os.path.basename(folder), folder);

  988.             */

  989.         }

  990. 

  991.         //if MACOS and not settings.value(CARLA_KEY_MAIN_USE_PRO_THEME, true, bool):

  992.         //    self->setUnifiedTitleAndToolBarOnMac(true)

  993. 

  994.         const bool showMeters = settings.valueBool("ShowMeters", true);

  995.         self->ui.act_settings_show_meters->setChecked(showMeters);

  996.         self->ui.peak_in->setVisible(showMeters);

  997.         self->ui.peak_out->setVisible(showMeters);

  998. 

  999.         const bool showKeyboard = settings.valueBool("ShowKeyboard", true);

  1000.         self->ui.act_settings_show_keyboard->setChecked(showKeyboard);

  1001.         /*

  1002.         self->ui.scrollArea->setVisible(showKeyboard);

  1003.         */

  1004. 

  1005.         const QSafeSettings settingsDBf("falkTX", "CarlaDatabase2");

  1006.         self->fFavoritePlugins = settingsDBf.valueStringList("PluginDatabase/Favorites");

  1007. 

  1008.         /*

  1009.         QTimer::singleShot(100, slot_restoreCanvasScrollbarValues);

  1010.         */

  1011.     }

  1012. 

  1013.     // TODO - complete this

  1014.     self->fSavedSettings._CARLA_KEY_MAIN_CONFIRM_EXIT = settings.valueBool(CARLA_KEY_MAIN_CONFIRM_EXIT,

  1015.                                                                            CARLA_DEFAULT_MAIN_CONFIRM_EXIT);

  1016. 

  1017.     self->fSavedSettings._CARLA_KEY_MAIN_REFRESH_INTERVAL = settings.valueUInt(CARLA_KEY_MAIN_REFRESH_INTERVAL,

  1018.                                                                                CARLA_DEFAULT_MAIN_REFRESH_INTERVAL);

  1019. 

  1020.     self->fSavedSettings._CARLA_KEY_CANVAS_FANCY_EYE_CANDY = settings.valueBool(CARLA_KEY_CANVAS_FANCY_EYE_CANDY,

  1021.                                                                                 CARLA_DEFAULT_CANVAS_FANCY_EYE_CANDY);

  1022. 

  1023.     /*

  1024.     {

  1025.         CARLA_KEY_MAIN_PROJECT_FOLDER:      settings.value(CARLA_KEY_MAIN_PROJECT_FOLDER,      CARLA_DEFAULT_MAIN_PROJECT_FOLDER,      str),

  1026.         CARLA_KEY_MAIN_EXPERIMENTAL:        settings.value(CARLA_KEY_MAIN_EXPERIMENTAL,        CARLA_DEFAULT_MAIN_EXPERIMENTAL,        bool),

  1027.         CARLA_KEY_CANVAS_THEME:             settings.value(CARLA_KEY_CANVAS_THEME,             CARLA_DEFAULT_CANVAS_THEME,             str),

  1028.         CARLA_KEY_CANVAS_SIZE:              settings.value(CARLA_KEY_CANVAS_SIZE,              CARLA_DEFAULT_CANVAS_SIZE,              str),

  1029.         CARLA_KEY_CANVAS_AUTO_HIDE_GROUPS:  settings.value(CARLA_KEY_CANVAS_AUTO_HIDE_GROUPS,  CARLA_DEFAULT_CANVAS_AUTO_HIDE_GROUPS,  bool),

  1030.         CARLA_KEY_CANVAS_AUTO_SELECT_ITEMS: settings.value(CARLA_KEY_CANVAS_AUTO_SELECT_ITEMS, CARLA_DEFAULT_CANVAS_AUTO_SELECT_ITEMS, bool),

  1031.         CARLA_KEY_CANVAS_USE_BEZIER_LINES:  settings.value(CARLA_KEY_CANVAS_USE_BEZIER_LINES,  CARLA_DEFAULT_CANVAS_USE_BEZIER_LINES,  bool),

  1032.         CARLA_KEY_CANVAS_EYE_CANDY:         settings.value(CARLA_KEY_CANVAS_EYE_CANDY,         CARLA_DEFAULT_CANVAS_EYE_CANDY,         bool),

  1033.         CARLA_KEY_CANVAS_USE_OPENGL:        settings.value(CARLA_KEY_CANVAS_USE_OPENGL,        CARLA_DEFAULT_CANVAS_USE_OPENGL,        bool),

  1034.         CARLA_KEY_CANVAS_ANTIALIASING:      settings.value(CARLA_KEY_CANVAS_ANTIALIASING,      CARLA_DEFAULT_CANVAS_ANTIALIASING,      int),

  1035.         CARLA_KEY_CANVAS_HQ_ANTIALIASING:   settings.value(CARLA_KEY_CANVAS_HQ_ANTIALIASING,   CARLA_DEFAULT_CANVAS_HQ_ANTIALIASING,   bool),

  1036.         CARLA_KEY_CANVAS_FULL_REPAINTS:     settings.value(CARLA_KEY_CANVAS_FULL_REPAINTS,     CARLA_DEFAULT_CANVAS_FULL_REPAINTS,     bool),

  1037.         CARLA_KEY_CANVAS_INLINE_DISPLAYS:   settings.value(CARLA_KEY_CANVAS_INLINE_DISPLAYS,   CARLA_DEFAULT_CANVAS_INLINE_DISPLAYS,   bool),

  1038.         CARLA_KEY_CUSTOM_PAINTING:         (settings.value(CARLA_KEY_MAIN_USE_PRO_THEME,    true,   bool) and

  1039.                                             settings.value(CARLA_KEY_MAIN_PRO_THEME_COLOR, "Black", str).lower() == "black"),

  1040.     }

  1041.     */

  1042. 

  1043.     const QSafeSettings settings2("falkTX", "Carla2");

  1044. 

  1045.     if (host.experimental)

  1046.     {

  1047.         const bool visible = settings2.valueBool(CARLA_KEY_EXPERIMENTAL_JACK_APPS,

  1048.                                                  CARLA_DEFAULT_EXPERIMENTAL_JACK_APPS);

  1049.         self->ui.act_plugin_add_jack->setVisible(visible);

  1050.     }

  1051.     else

  1052.     {

  1053.         self->ui.act_plugin_add_jack->setVisible(false);

  1054.     }

  1055. 

  1056.     self->fMiniCanvasUpdateTimeout = self->fSavedSettings._CARLA_KEY_CANVAS_FANCY_EYE_CANDY ? 1000 : 0;

  1057. 

  1058.     /*

  1059.     setEngineSettings(host);

  1060.     */

  1061.     restartTimersIfNeeded();

  1062. }

  1063. 

  1064. //---------------------------------------------------------------------------------------------------------------------

  1065. // Settings (menu actions)

  1066. 

  1067. void CarlaHostWindow::slot_showSidePanel(const bool yesNo)

  1068. {

  1069.     self->ui.dockWidget->setEnabled(yesNo);

  1070.     self->ui.dockWidget->setVisible(yesNo);

  1071. }

  1072. 

  1073. void CarlaHostWindow::slot_showToolbar(const bool yesNo)

  1074. {

  1075.     self->ui.toolBar->setEnabled(yesNo);

  1076.     self->ui.toolBar->setVisible(yesNo);

  1077. }

  1078. 

  1079. void CarlaHostWindow::slot_showCanvasMeters(const bool yesNo)

  1080. {

  1081.     self->ui.peak_in->setVisible(yesNo);

  1082.     self->ui.peak_out->setVisible(yesNo);

  1083.     /*

  1084.     QTimer::singleShot(0, slot_miniCanvasCheckAll);

  1085.     */

  1086. }

  1087. 

  1088. void CarlaHostWindow::slot_showCanvasKeyboard(const bool yesNo)

  1089. {

  1090.     /*

  1091.     self->ui.scrollArea->setVisible(yesNo);

  1092.     QTimer::singleShot(0, slot_miniCanvasCheckAll);

  1093.     */

  1094. }

  1095. 

  1096. void CarlaHostWindow::slot_configureCarla()

  1097. {

  1098.     /*

  1099.     CarlaSettingsW dialog(self->fParentOrSelf, self->host, true, hasGL);

  1100.     if not dialog.exec_():

  1101.         return

  1102.     */

  1103. 

  1104.     loadSettings(false);

  1105. 

  1106.     /*

  1107.     patchcanvas.clear()

  1108. 

  1109.     setupCanvas();

  1110.     slot_miniCanvasCheckAll();

  1111.     */

  1112. 

  1113.     if (host.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK and host.isPlugin)

  1114.         pass();

  1115.     else if (carla_is_engine_running())

  1116.         carla_patchbay_refresh(self->fExternalPatchbay);

  1117. }

  1118. 

  1119. //---------------------------------------------------------------------------------------------------------------------

  1120. // Transport

  1121. 

  1122. void CarlaHostWindow::refreshTransport(const bool forced)

  1123. {

  1124.     if (not self->ui.l_transport_time->isVisible())

  1125.         return;

  1126.     if (carla_isZero(self->fSampleRate) or ! carla_is_engine_running())

  1127.         return;

  1128. 

  1129.     const CarlaTransportInfo* const timeInfo = carla_get_transport_info();

  1130.     const bool     playing  = timeInfo->playing;

  1131.     const uint64_t frame    = timeInfo->frame;

  1132.     const double   bpm      = timeInfo->bpm;

  1133. 

  1134.     if (playing != self->fLastTransportState || forced)

  1135.     {

  1136.         if (playing)

  1137.         {

  1138.             const QIcon icon(":/16x16/media-playback-pause.svgz");

  1139.             self->ui.b_transport_play->setChecked(true);

  1140.             self->ui.b_transport_play->setIcon(icon);

  1141.             // self->ui.b_transport_play->setText(tr("&Pause"));

  1142.         }

  1143.         else

  1144.         {

  1145.             const QIcon icon(":/16x16/media-playback-start.svgz");

  1146.             self->ui.b_transport_play->setChecked(false);

  1147.             self->ui.b_transport_play->setIcon(icon);

  1148.             // self->ui.b_play->setText(tr("&Play"));

  1149.         }

  1150. 

  1151.         self->fLastTransportState = playing;

  1152.     }

  1153. 

  1154.     if (frame != self->fLastTransportFrame || forced)

  1155.     {

  1156.         self->fLastTransportFrame = frame;

  1157. 

  1158.         const uint32_t time = frame / self->fSampleRate;

  1159.         const uint32_t secs =  time % 60;

  1160.         const uint32_t mins = (time / 60) % 60;

  1161.         const uint32_t hrs  = (time / 3600) % 60;

  1162.         self->ui.l_transport_time->setText(QString("%1:%2:%3").arg(hrs, 2, 10, QChar('0')).arg(mins, 2, 10, QChar('0')).arg(secs, 2, 10, QChar('0')));

  1163. 

  1164.         const uint32_t frame1 =  frame % 1000;

  1165.         const uint32_t frame2 = (frame / 1000) % 1000;

  1166.         const uint32_t frame3 = (frame / 1000000) % 1000;

  1167.         self->ui.l_transport_frame->setText(QString("%1'%2'%3").arg(frame3, 3, 10, QChar('0')).arg(frame2, 3, 10, QChar('0')).arg(frame1, 3, 10, QChar('0')));

  1168. 

  1169.         const int32_t bar  = timeInfo->bar;

  1170.         const int32_t beat = timeInfo->beat;

  1171.         const int32_t tick = timeInfo->tick;

  1172.         self->ui.l_transport_bbt->setText(QString("%1|%2|%3").arg(bar, 3, 10, QChar('0')).arg(beat, 2, 10, QChar('0')).arg(tick, 4, 10, QChar('0')));

  1173.     }

  1174. 

  1175.     if (carla_isNotEqual(bpm, self->fLastTransportBPM) || forced)

  1176.     {

  1177.         self->fLastTransportBPM = bpm;

  1178. 

  1179.         if (bpm > 0.0)

  1180.         {

  1181.             self->ui.dsb_transport_bpm->blockSignals(true);

  1182.             self->ui.dsb_transport_bpm->setValue(bpm);

  1183.             self->ui.dsb_transport_bpm->blockSignals(false);

  1184.             self->ui.dsb_transport_bpm->setStyleSheet("");

  1185.         }

  1186.         else

  1187.         {

  1188.             self->ui.dsb_transport_bpm->setStyleSheet("QDoubleSpinBox { color: palette(mid); }");

  1189.         }

  1190.     }

  1191. }

  1192. 

  1193. //---------------------------------------------------------------------------------------------------------------------

  1194. // Transport (menu actions)

  1195. 

  1196. void CarlaHostWindow::slot_transportPlayPause(const bool toggled)

  1197. {

  1198.     if (host.isPlugin || ! carla_is_engine_running())

  1199.         return;

  1200. 

  1201.     if (toggled)

  1202.         carla_transport_play();

  1203.     else

  1204.         carla_transport_pause();

  1205. 

  1206.     refreshTransport();

  1207. }

  1208. 

  1209. void CarlaHostWindow::slot_transportStop()

  1210. {

  1211.     if (host.isPlugin || ! carla_is_engine_running())

  1212.         return;

  1213. 

  1214.     carla_transport_pause();

  1215.     carla_transport_relocate(0);

  1216. 

  1217.     refreshTransport();

  1218. }

  1219. 

  1220. void CarlaHostWindow::slot_transportBackwards()

  1221. {

  1222.     if (host.isPlugin || ! carla_is_engine_running())

  1223.         return;

  1224. 

  1225.     int64_t newFrame = carla_get_current_transport_frame() - 100000;

  1226. 

  1227.     if (newFrame < 0)

  1228.         newFrame = 0;

  1229. 

  1230.     carla_transport_relocate(newFrame);

  1231. }

  1232. 

  1233. void CarlaHostWindow::slot_transportBpmChanged(const qreal newValue)

  1234. {

  1235.     carla_transport_bpm(newValue);

  1236. }

  1237. 

  1238. void CarlaHostWindow::slot_transportForwards()

  1239. {

  1240.     if (carla_isZero(self->fSampleRate) || host.isPlugin || ! carla_is_engine_running())

  1241.         return;

  1242. 

  1243.     const int64_t newFrame = carla_get_current_transport_frame() + int(self->fSampleRate*2.5);

  1244.     carla_transport_relocate(newFrame);

  1245. }

  1246. 

  1247. void CarlaHostWindow::slot_transportJackEnabled(const bool clicked)

  1248. {

  1249.     if (! carla_is_engine_running())

  1250.         return;

  1251.     host.transportMode = clicked ? ENGINE_TRANSPORT_MODE_JACK : ENGINE_TRANSPORT_MODE_INTERNAL;

  1252.     carla_set_engine_option(ENGINE_OPTION_TRANSPORT_MODE, host.transportMode, host.transportExtra.toUtf8());

  1253. }

  1254. 

  1255. void CarlaHostWindow::slot_transportLinkEnabled(const bool clicked)

  1256. {

  1257.     if (! carla_is_engine_running())

  1258.         return;

  1259.     const char* const extra = clicked ? ":link:" : "";

  1260.     host.transportExtra = extra;

  1261.     carla_set_engine_option(ENGINE_OPTION_TRANSPORT_MODE, host.transportMode, host.transportExtra.toUtf8());

  1262. }

  1263. 

  1264. //---------------------------------------------------------------------------------------------------------------------

  1265. // Other

  1266. 

  1267. void CarlaHostWindow::slot_xrunClear()

  1268. {

  1269.     carla_clear_engine_xruns();

  1270. }

  1271. 

  1272. //---------------------------------------------------------------------------------------------------------------------

  1273. // Timers

  1274. 

  1275. void CarlaHostWindow::startTimers()

  1276. {

  1277.     if (self->fIdleTimerFast == 0)

  1278.         self->fIdleTimerFast = startTimer(self->fSavedSettings._CARLA_KEY_MAIN_REFRESH_INTERVAL);

  1279. 

  1280.     if (self->fIdleTimerSlow == 0)

  1281.         self->fIdleTimerSlow = startTimer(self->fSavedSettings._CARLA_KEY_MAIN_REFRESH_INTERVAL*4);

  1282. }

  1283. 

  1284. void CarlaHostWindow::restartTimersIfNeeded()

  1285. {

  1286.     if (self->fIdleTimerFast != 0)

  1287.     {

  1288.         killTimer(self->fIdleTimerFast);

  1289.         self->fIdleTimerFast = startTimer(self->fSavedSettings._CARLA_KEY_MAIN_REFRESH_INTERVAL);

  1290.     }

  1291. 

  1292.     if (self->fIdleTimerSlow != 0)

  1293.     {

  1294.         killTimer(self->fIdleTimerSlow);

  1295.         self->fIdleTimerSlow = startTimer(self->fSavedSettings._CARLA_KEY_MAIN_REFRESH_INTERVAL*4);;

  1296.     }

  1297. }

  1298. 

  1299. void CarlaHostWindow::killTimers()

  1300. {

  1301.     if (self->fIdleTimerFast != 0)

  1302.     {

  1303.         killTimer(self->fIdleTimerFast);

  1304.         self->fIdleTimerFast = 0;

  1305.     }

  1306. 

  1307.     if (self->fIdleTimerSlow != 0)

  1308.     {

  1309.         killTimer(self->fIdleTimerSlow);

  1310.         self->fIdleTimerSlow = 0;

  1311.     }

  1312. }

  1313. 

  1314. //---------------------------------------------------------------------------------------------------------------------

  1315. // timer event

  1316. 

  1317. void CarlaHostWindow::refreshRuntimeInfo(const float load, const int xruns)

  1318. {

  1319.     const QString txt1(xruns >= 0 ? QString("%1").arg(xruns) : QString("--"));

  1320.     const QString txt2(xruns == 1 ? "" : "s");

  1321.     self->ui.b_xruns->setText(QString("%1 Xrun%2").arg(txt1).arg(txt2));

  1322.     self->ui.pb_dsp_load->setValue(int(load));

  1323. }

  1324. 

  1325. void CarlaHostWindow::getAndRefreshRuntimeInfo()

  1326. {

  1327.     if (! self->ui.pb_dsp_load->isVisible())

  1328.         return;

  1329.     if (! carla_is_engine_running())

  1330.         return;

  1331.     const CarlaRuntimeEngineInfo* const info = carla_get_runtime_engine_info();

  1332.     refreshRuntimeInfo(info->load, info->xruns);

  1333. }

  1334. 

  1335. void CarlaHostWindow::idleFast()

  1336. {

  1337.     carla_engine_idle();

  1338.     refreshTransport();

  1339. 

  1340.     if (self->fPluginCount == 0 || self->fCurrentlyRemovingAllPlugins)

  1341.         return;

  1342. 

  1343.     for (auto& pitem : self->fPluginList)

  1344.     {

  1345.         if (pitem == nullptr)

  1346.             break;

  1347. 

  1348.         /*

  1349.         pitem->getWidget().idleFast();

  1350.         */

  1351.     }

  1352. 

  1353.     for (uint pluginId : self->fSelectedPlugins)

  1354.     {

  1355.         self->fPeaksCleared = false;

  1356.         if (self->ui.peak_in->isVisible())

  1357.         {

  1358.             /*

  1359.             self->ui.peak_in->displayMeter(1, carla_get_input_peak_value(pluginId, true))

  1360.             self->ui.peak_in->displayMeter(2, carla_get_input_peak_value(pluginId, false))

  1361.             */

  1362.         }

  1363.         if (self->ui.peak_out->isVisible())

  1364.         {

  1365.             /*

  1366.             self->ui.peak_out->displayMeter(1, carla_get_output_peak_value(pluginId, true))

  1367.             self->ui.peak_out->displayMeter(2, carla_get_output_peak_value(pluginId, false))

  1368.             */

  1369.         }

  1370.         return;

  1371.     }

  1372. 

  1373.     if (self->fPeaksCleared)

  1374.         return;

  1375. 

  1376.     self->fPeaksCleared = true;

  1377.     /*

  1378.     self->ui.peak_in->displayMeter(1, 0.0, true);

  1379.     self->ui.peak_in->displayMeter(2, 0.0, true);

  1380.     self->ui.peak_out->displayMeter(1, 0.0, true);

  1381.     self->ui.peak_out->displayMeter(2, 0.0, true);

  1382.     */

  1383. }

  1384. 

  1385. void CarlaHostWindow::idleSlow()

  1386. {

  1387.     getAndRefreshRuntimeInfo();

  1388. 

  1389.     if (self->fPluginCount == 0 || self->fCurrentlyRemovingAllPlugins)

  1390.         return;

  1391. 

  1392.     for (auto& pitem : self->fPluginList)

  1393.     {

  1394.         if (pitem == nullptr)

  1395.             break;

  1396. 

  1397.         /*

  1398.         pitem->getWidget().idleSlow();

  1399.         */

  1400.     }

  1401. }

  1402. 

  1403. void CarlaHostWindow::timerEvent(QTimerEvent* const event)

  1404. {

  1405.     if (event->timerId() == self->fIdleTimerFast)

  1406.         idleFast();

  1407. 

  1408.     else if (event->timerId() == self->fIdleTimerSlow)

  1409.         idleSlow();

  1410. 

  1411.     QMainWindow::timerEvent(event);

  1412. }

  1413. 

  1414. //---------------------------------------------------------------------------------------------------------------------

  1415. // color/style change event

  1416. 

  1417. void CarlaHostWindow::changeEvent(QEvent* const event)

  1418. {

  1419.     switch (event->type())

  1420.     {

  1421.     case QEvent::PaletteChange:

  1422.     case QEvent::StyleChange:

  1423.         updateStyle();

  1424.         break;

  1425.     default:

  1426.         break;

  1427.     }

  1428. 

  1429.     QWidget::changeEvent(event);

  1430. }

  1431. 

  1432. void CarlaHostWindow::updateStyle()

  1433. {

  1434.     // Rack padding images setup

  1435.     QImage rack_imgL(":/bitmaps/rack_padding_left.png");

  1436.     QImage rack_imgR(":/bitmaps/rack_padding_right.png");

  1437. 

  1438.     const qreal min_value = 0.07;

  1439. #if QT_VERSION >= 0x50600

  1440.     const qreal value_fix = 1.0/(1.0-rack_imgL.scaled(1, 1, Qt::IgnoreAspectRatio, Qt::SmoothTransformation).pixelColor(0,0).blackF());

  1441. #else

  1442.     const qreal value_fix = 1.5;

  1443. #endif

  1444. 

  1445.     const QColor bg_color = self->ui.rack->palette().window().color();

  1446.     const qreal  bg_value = 1.0 - bg_color.blackF();

  1447. 

  1448.     QColor pad_color;

  1449. 

  1450.     if (carla_isNotZero(bg_value) && bg_value < min_value)

  1451.         pad_color = bg_color.lighter(100*min_value/bg_value*value_fix);

  1452.     else

  1453.         pad_color = QColor::fromHsvF(0.0, 0.0, min_value*value_fix);

  1454. 

  1455.     QPainter painter;

  1456.     QRect fillRect(rack_imgL.rect().adjusted(-1,-1,1,1));

  1457. 

  1458.     painter.begin(&rack_imgL);

  1459.     painter.setCompositionMode(QPainter::CompositionMode_Multiply);

  1460.     painter.setBrush(pad_color);

  1461.     painter.drawRect(fillRect);

  1462.     painter.end();

  1463. 

  1464.     const QPixmap rack_pixmapL(QPixmap::fromImage(rack_imgL));

  1465.     QPalette imgL_palette; //(self->ui.pad_left->palette());

  1466.     imgL_palette.setBrush(QPalette::Window, QBrush(rack_pixmapL));

  1467.     self->ui.pad_left->setPalette(imgL_palette);

  1468.     self->ui.pad_left->setAutoFillBackground(true);

  1469. 

  1470.     painter.begin(&rack_imgR);

  1471.     painter.setCompositionMode(QPainter::CompositionMode_Multiply);

  1472.     painter.setBrush(pad_color);

  1473.     painter.drawRect(fillRect);

  1474.     painter.end();

  1475. 

  1476.     const QPixmap rack_pixmapR(QPixmap::fromImage(rack_imgR));

  1477.     QPalette imgR_palette; //(self->ui.pad_right->palette());

  1478.     imgR_palette.setBrush(QPalette::Window, QBrush(rack_pixmapR));

  1479.     self->ui.pad_right->setPalette(imgR_palette);

  1480.     self->ui.pad_right->setAutoFillBackground(true);

  1481. }

  1482. 

  1483. //---------------------------------------------------------------------------------------------------------------------

  1484. // close event

  1485. 

  1486. bool CarlaHostWindow::shouldIgnoreClose()

  1487. {

  1488.     if (host.isControl || host.isPlugin)

  1489.         return false;

  1490.     if (self->fCustomStopAction == CUSTOM_ACTION_APP_CLOSE)

  1491.         return false;

  1492.     if (self->fSavedSettings._CARLA_KEY_MAIN_CONFIRM_EXIT)

  1493.         return QMessageBox::question(this, tr("Quit"),

  1494.                                            tr("Are you sure you want to quit Carla?"),

  1495.                                            QMessageBox::Yes|QMessageBox::No) == QMessageBox::No;

  1496.     return false;

  1497. }

  1498. 

  1499. void CarlaHostWindow::closeEvent(QCloseEvent* const event)

  1500. {

  1501.     if (shouldIgnoreClose())

  1502.     {

  1503.         event->ignore();

  1504.         return;

  1505.     }

  1506. 

  1507. #ifdef CARLA_OS_MAC

  1508.     if (self->fMacClosingHelper && ! (host.isControl || host.isPlugin))

  1509.     {

  1510.         self->fCustomStopAction = CUSTOM_ACTION_APP_CLOSE;

  1511.         self->fMacClosingHelper = false;

  1512.         event->ignore();

  1513. 

  1514.         for i in reversed(range(self->fPluginCount)):

  1515.             carla_show_custom_ui(i, false);

  1516. 

  1517.         QTimer::singleShot(100, SIGNAL(close()));

  1518.         return;

  1519.     }

  1520. #endif

  1521. 

  1522.     killTimers();

  1523.     saveSettings();

  1524. 

  1525.     if (carla_is_engine_running() && ! (host.isControl or host.isPlugin))

  1526.     {

  1527.         if (! slot_engineStop(true))

  1528.         {

  1529.             self->fCustomStopAction = CUSTOM_ACTION_APP_CLOSE;

  1530.             event->ignore();

  1531.             return;

  1532.         }

  1533.     }

  1534. 

  1535.     QMainWindow::closeEvent(event);

  1536. }

  1537. 

  1538. //---------------------------------------------------------------------------------------------------------------------

  1539. // Engine callback

  1540. 

  1541. void _engineCallback(void* const ptr, EngineCallbackOpcode action, uint pluginId, int value1, int value2, int value3, float valuef, const char* const valueStr)

  1542. {

  1543.     /*

  1544.     carla_stdout("_engineCallback(%p, %i:%s, %u, %i, %i, %i, %f, %s)",

  1545.                  ptr, action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valuef, valueStr);

  1546.     */

  1547. 

  1548.     Host* const host = (Host*)(ptr);

  1549.     CARLA_SAFE_ASSERT_RETURN(host != nullptr,);

  1550. 

  1551.     switch (action)

  1552.     {

  1553.     case ENGINE_CALLBACK_ENGINE_STARTED:

  1554.         host->processMode   = static_cast<EngineProcessMode>(value1);

  1555.         host->transportMode = static_cast<EngineTransportMode>(value2);

  1556.         break;

  1557.     case ENGINE_CALLBACK_PROCESS_MODE_CHANGED:

  1558.         host->processMode   = static_cast<EngineProcessMode>(value1);

  1559.         break;

  1560.     case ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED:

  1561.         host->transportMode  = static_cast<EngineTransportMode>(value1);

  1562.         host->transportExtra = valueStr;

  1563.         break;

  1564.     default:

  1565.         break;

  1566.     }

  1567. 

  1568.     // TODO

  1569.     switch (action)

  1570.     {

  1571.     case ENGINE_CALLBACK_ENGINE_STARTED:

  1572.         emit host->EngineStartedCallback(pluginId, value1, value2, value3, valuef, valueStr);

  1573.         break;

  1574.     case ENGINE_CALLBACK_ENGINE_STOPPED:

  1575.         emit host->EngineStoppedCallback();

  1576.         break;

  1577. 

  1578.     // FIXME

  1579.     default:

  1580.         break;

  1581.     }

  1582. }

  1583. 

  1584. //---------------------------------------------------------------------------------------------------------------------

  1585. // File callback

  1586. 

  1587. static const char* _fileCallback(void*, const FileCallbackOpcode action, const bool isDir, const char* const title, const char* const filter)

  1588. {

  1589.     QString ret;

  1590.     const QFileDialog::Options options = QFileDialog::Options(isDir ? QFileDialog::ShowDirsOnly : 0x0);

  1591. 

  1592.     switch (action)

  1593.     {

  1594.     case FILE_CALLBACK_DEBUG:

  1595.         break;

  1596.     case FILE_CALLBACK_OPEN:

  1597.         ret = QFileDialog::getOpenFileName(gCarla.gui, title, "", filter, nullptr, options);

  1598.         break;

  1599.     case FILE_CALLBACK_SAVE:

  1600.         ret = QFileDialog::getSaveFileName(gCarla.gui, title, "", filter, nullptr, options);

  1601.         break;

  1602.     }

  1603. 

  1604.     if (ret.isEmpty())

  1605.         return nullptr;

  1606. 

  1607.     static const char* fileRet = nullptr;

  1608. 

  1609.     if (fileRet != nullptr)

  1610.         delete[] fileRet;

  1611. 

  1612.     fileRet = carla_strdup_safe(ret.toUtf8());

  1613.     return fileRet;

  1614. }

  1615. 

  1616. //---------------------------------------------------------------------------------------------------------------------

  1617. // Init host

  1618. 

  1619. Host& initHost(const QString /*initName*/, const bool isControl, const bool isPlugin, const bool failError)

  1620. {

  1621.     CarlaString pathBinaries, pathResources;

  1622.     // = getPaths(libPrefix)

  1623. 

  1624.     //-----------------------------------------------------------------------------------------------------------------

  1625.     // Print info

  1626. 

  1627.     // ----------------------------------------------------------------------------------------------------------------

  1628.     // Init host

  1629. 

  1630.     if (failError)

  1631.     {

  1632. //         # no try

  1633. //         host = HostClass() if HostClass is not None else CarlaHostQtDLL(libname, loadGlobal)

  1634.     }

  1635.     else

  1636.     {

  1637. //         try:

  1638. //             host = HostClass() if HostClass is not None else CarlaHostQtDLL(libname, loadGlobal)

  1639. //         except:

  1640. //             host = CarlaHostQtNull()

  1641.     }

  1642. 

  1643.     static Host host;

  1644.     host.isControl = isControl;

  1645.     host.isPlugin  = isPlugin;

  1646. 

  1647.     carla_set_engine_callback(_engineCallback, &host);

  1648.     carla_set_file_callback(_fileCallback, nullptr);

  1649. 

  1650.     // If it's a plugin the paths are already set

  1651.     if (! isPlugin)

  1652.     {

  1653.         host.pathBinaries  = pathBinaries;

  1654.         host.pathResources = pathResources;

  1655.         carla_set_engine_option(ENGINE_OPTION_PATH_BINARIES,  0, pathBinaries);

  1656.         carla_set_engine_option(ENGINE_OPTION_PATH_RESOURCES, 0, pathResources);

  1657. 

  1658.         /*

  1659.         if (! isControl)

  1660.             host.nsmOK = carla_nsm_init(getpid(), initName);

  1661.         */

  1662.     }

  1663. 

  1664.     // ----------------------------------------------------------------------------------------------------------------

  1665.     // Done

  1666. 

  1667.     return host;

  1668. }

  1669. 

  1670. //---------------------------------------------------------------------------------------------------------------------

  1671. // Load host settings

  1672. 

  1673. void loadHostSettings(Host& /*host*/)

  1674. {

  1675. }

  1676. 

  1677. //---------------------------------------------------------------------------------------------------------------------