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.
5714 Commits
16 Branches
284MB
Tree: c47340d4b0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c47340d4b0'
${ noResults }
Carla/source/frontend/xycontroller-ui

566 lines
19KB
Raw Blame History 

  1. #!/usr/bin/env python3

  2. # -*- coding: utf-8 -*-

  3. 

  4. # XY Controller UI, taken from Cadence

  5. # Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com>

  6. #

  7. # This program is free software; you can redistribute it and/or

  8. # modify it under the terms of the GNU General Public License as

  9. # published by the Free Software Foundation; either version 2 of

  10. # the License, or any later version.

  11. #

  12. # This program is distributed in the hope that it will be useful,

  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of

  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  15. # GNU General Public License for more details.

  16. #

  17. # For a full copy of the GNU General Public License see the doc/GPL.txt file.

  18. 

  19. # ------------------------------------------------------------------------------------------------------------

  20. # Imports (Global)

  21. 

  22. from PyQt5.QtCore import pyqtSignal, pyqtSlot, Qt, QPointF, QRectF, QSize, QTimer

  23. from PyQt5.QtGui import QColor, QPainter, QPen

  24. from PyQt5.QtWidgets import QGraphicsScene, QGraphicsSceneMouseEvent, QMainWindow

  25. 

  26. # -----------------------------------------------------------------------

  27. # Imports (Custom)

  28. 

  29. from carla_shared import *

  30. from carla_utils import *

  31. 

  32. import ui_xycontroller

  33. 

  34. # -----------------------------------------------------------------------

  35. # Imports (ExternalUI)

  36. 

  37. from carla_app import CarlaApplication

  38. from externalui import ExternalUI

  39. from widgets.paramspinbox import ParamSpinBox

  40. 

  41. # ------------------------------------------------------------------------------------------------------------

  42. 

  43. XYCONTROLLER_PARAMETER_X = 0

  44. XYCONTROLLER_PARAMETER_Y = 1

  45. 

  46. # ------------------------------------------------------------------------------------------------------------

  47. 

  48. class XYGraphicsScene(QGraphicsScene):

  49.     # signals

  50.     cursorMoved = pyqtSignal(float,float)

  51. 

  52.     def __init__(self, parent):

  53.         QGraphicsScene.__init__(self, parent)

  54. 

  55.         self.cc_x = 1

  56.         self.cc_y = 2

  57. 

  58.         self.m_channels  = []

  59.         self.m_mouseLock = False

  60.         self.m_smooth    = False

  61.         self.m_smooth_x  = 0.0

  62.         self.m_smooth_y  = 0.0

  63. 

  64.         self.setBackgroundBrush(Qt.black)

  65. 

  66.         cursorPen = QPen(QColor(255, 255, 255), 2)

  67.         cursorBrush = QColor(255, 255, 255, 50)

  68.         self.m_cursor = self.addEllipse(QRectF(-10, -10, 20, 20), cursorPen, cursorBrush)

  69. 

  70.         linePen = QPen(QColor(200, 200, 200, 100), 1, Qt.DashLine)

  71.         self.m_lineH = self.addLine(-9999, 0, 9999, 0, linePen)

  72.         self.m_lineV = self.addLine(0, -9999, 0, 9999, linePen)

  73. 

  74.         self.p_size = QRectF(-100, -100, 100, 100)

  75. 

  76.     # -------------------------------------------------------------------

  77. 

  78.     def setControlX(self, x: int):

  79.         self.cc_x = x

  80. 

  81.     def setControlY(self, y: int):

  82.         self.cc_y = y

  83. 

  84.     def setChannels(self, channels):

  85.         self.m_channels = channels

  86. 

  87.     def setPosX(self, x: float, forward: bool = True):

  88.         if self.m_mouseLock:

  89.             return

  90. 

  91.         posX = x * (self.p_size.x() + self.p_size.width())

  92.         self.m_cursor.setPos(posX, self.m_cursor.y())

  93.         self.m_lineV.setX(posX)

  94. 

  95.         if forward:

  96.             value = posX / (self.p_size.x() + self.p_size.width());

  97.             self.sendMIDI(value, None)

  98.         else:

  99.             self.m_smooth_x = posX;

  100. 

  101.     def setPosY(self, y: float, forward: bool = True):

  102.         if self.m_mouseLock:

  103.             return;

  104. 

  105.         posY = y * (self.p_size.y() + self.p_size.height())

  106.         self.m_cursor.setPos(self.m_cursor.x(), posY)

  107.         self.m_lineH.setY(posY)

  108. 

  109.         if forward:

  110.             value = posY / (self.p_size.y() + self.p_size.height())

  111.             self.sendMIDI(None, value)

  112.         else:

  113.             self.m_smooth_y = posY

  114. 

  115.     def setSmooth(self, smooth: bool):

  116.         self.m_smooth = smooth

  117. 

  118.     def setSmoothValues(self, x: float, y: float):

  119.         self.m_smooth_x = x * (self.p_size.x() + self.p_size.width());

  120.         self.m_smooth_y = y * (self.p_size.y() + self.p_size.height());

  121. 

  122.     # -------------------------------------------------------------------

  123. 

  124.     def updateSize(self, size: QSize):

  125.         self.p_size.setRect(-(float(size.width())/2),

  126.                             -(float(size.height())/2),

  127.                             size.width(),

  128.                             size.height());

  129. 

  130.     def updateSmooth(self):

  131.         if not self.m_smooth:

  132.             return

  133. 

  134.         if self.m_cursor.x() == self.m_smooth_x and self.m_cursor.y() == self.m_smooth_y:

  135.             return

  136. 

  137.         same = 0

  138.         if abs(self.m_cursor.x() - self.m_smooth_x) <= 0.0005:

  139.             self.m_smooth_x = self.m_cursor.x()

  140.             same += 1

  141. 

  142.         if abs(self.m_cursor.y() - self.m_smooth_y) <= 0.0005:

  143.             self.m_smooth_y = self.m_cursor.y()

  144.             same += 1

  145. 

  146.         if same == 2:

  147.             return

  148. 

  149.         newX = float(self.m_smooth_x + self.m_cursor.x()*7) / 8

  150.         newY = float(self.m_smooth_y + self.m_cursor.y()*7) / 8

  151.         pos  = QPointF(newX, newY)

  152. 

  153.         self.m_cursor.setPos(pos)

  154.         self.m_lineH.setY(pos.y())

  155.         self.m_lineV.setX(pos.x())

  156. 

  157.         xp = pos.x() / (self.p_size.x() + self.p_size.width())

  158.         yp = pos.y() / (self.p_size.y() + self.p_size.height())

  159. 

  160.         self.sendMIDI(xp, yp)

  161.         self.cursorMoved.emit(xp, yp)

  162. 

  163.     # -------------------------------------------------------------------

  164. 

  165.     def handleMousePos(self, pos: QPointF):

  166.         if not self.p_size.contains(pos):

  167.             if pos.x() < self.p_size.x():

  168.                 pos.setX(self.p_size.x())

  169.             elif pos.x() > (self.p_size.x() + self.p_size.width()):

  170.                 pos.setX(self.p_size.x() + self.p_size.width());

  171. 

  172.             if pos.y() < self.p_size.y():

  173.                 pos.setY(self.p_size.y())

  174.             elif pos.y() > (self.p_size.y() + self.p_size.height()):

  175.                 pos.setY(self.p_size.y() + self.p_size.height())

  176. 

  177.         self.m_smooth_x = pos.x()

  178.         self.m_smooth_y = pos.y()

  179. 

  180.         if not self.m_smooth:

  181.             self.m_cursor.setPos(pos)

  182.             self.m_lineH.setY(pos.y())

  183.             self.m_lineV.setX(pos.x())

  184. 

  185.             xp = pos.x() / (self.p_size.x() + self.p_size.width());

  186.             yp = pos.y() / (self.p_size.y() + self.p_size.height());

  187. 

  188.             self.sendMIDI(xp, yp)

  189.             self.cursorMoved.emit(xp, yp)

  190. 

  191.     def sendMIDI(self, xp, yp):

  192.         rate = float(0xff) / 4;

  193. 

  194.         if xp is not None:

  195.             value = xp * rate + rate

  196.             #foreach (const int& channel, m_channels)

  197.                 #qMidiOutData.put(0xB0 + channel - 1, cc_x, value);

  198. 

  199.         if yp is not None:

  200.             value = yp * rate + rate

  201.             #foreach (const int& channel, m_channels)

  202.                 #qMidiOutData.put(0xB0 + channel - 1, cc_y, value);

  203. 

  204.     # -------------------------------------------------------------------

  205. 

  206.     def keyPressEvent(self, event): # QKeyEvent

  207.         event.accept()

  208. 

  209.     def wheelEvent(self, event): # QGraphicsSceneWheelEvent

  210.         event.accept()

  211. 

  212.     def mousePressEvent(self, event: QGraphicsSceneMouseEvent):

  213.         self.m_mouseLock = True

  214.         self.handleMousePos(event.scenePos())

  215.         self.parent().setCursor(Qt.CrossCursor)

  216.         QGraphicsScene.mousePressEvent(self, event);

  217. 

  218.     def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):

  219.         self.handleMousePos(event.scenePos())

  220.         QGraphicsScene.mouseMoveEvent(self, event);

  221. 

  222.     def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent):

  223.         self.m_mouseLock = False

  224.         self.parent().setCursor(Qt.ArrowCursor)

  225.         QGraphicsScene.mouseReleaseEvent(self, event)

  226. 

  227. # -----------------------------------------------------------------------

  228. # External UI

  229. 

  230. class XYControllerUI(ExternalUI, QMainWindow):

  231.     def __init__(self):

  232.         ExternalUI.__init__(self)

  233.         QMainWindow.__init__(self)

  234.         self.ui = ui_xycontroller.Ui_XYControllerW()

  235.         self.ui.setupUi(self)

  236. 

  237.         self.fSaveSizeNowChecker = -1

  238. 

  239.         # ---------------------------------------------------------------

  240.         # Internal stuff

  241. 

  242.         self.cc_x = 1

  243.         self.cc_y = 2

  244.         self.m_channels = []

  245. 

  246.         # ---------------------------------------------------------------

  247.         # Set-up GUI stuff

  248. 

  249.         self.scene = XYGraphicsScene(self)

  250. 

  251.         self.ui.dial_x.setImage(2)

  252.         self.ui.dial_y.setImage(2)

  253.         self.ui.dial_x.setLabel("X")

  254.         self.ui.dial_y.setLabel("Y")

  255.         self.ui.keyboard.setOctaves(10)

  256. 

  257.         self.ui.graphicsView.setScene(self.scene)

  258.         self.ui.graphicsView.setRenderHints(QPainter.Antialiasing)

  259. 

  260.         for MIDI_CC in MIDI_CC_LIST:

  261.             self.ui.cb_control_x.addItem(MIDI_CC)

  262.             self.ui.cb_control_y.addItem(MIDI_CC)

  263. 

  264.         self.ui.graphicsView.centerOn(0, 0)

  265. 

  266.         # ---------------------------------------------------------------

  267.         # Connect actions to functions

  268. 

  269.         self.scene.cursorMoved.connect(self.slot_sceneCursorMoved)

  270. 

  271.         self.ui.keyboard.noteOn.connect(self.slot_noteOn)

  272.         self.ui.keyboard.noteOff.connect(self.slot_noteOff)

  273. 

  274.         self.ui.cb_smooth.clicked.connect(self.slot_setSmooth)

  275. 

  276.         self.ui.dial_x.realValueChanged.connect(self.slot_knobValueChangedX)

  277.         self.ui.dial_y.realValueChanged.connect(self.slot_knobValueChangedY)

  278. 

  279.         self.ui.cb_control_x.currentIndexChanged[str].connect(self.slot_checkCC_X)

  280.         self.ui.cb_control_y.currentIndexChanged[str].connect(self.slot_checkCC_Y)

  281. 

  282.         self.ui.act_ch_01.triggered.connect(self.slot_checkChannel)

  283.         self.ui.act_ch_02.triggered.connect(self.slot_checkChannel)

  284.         self.ui.act_ch_03.triggered.connect(self.slot_checkChannel)

  285.         self.ui.act_ch_04.triggered.connect(self.slot_checkChannel)

  286.         self.ui.act_ch_05.triggered.connect(self.slot_checkChannel)

  287.         self.ui.act_ch_06.triggered.connect(self.slot_checkChannel)

  288.         self.ui.act_ch_07.triggered.connect(self.slot_checkChannel)

  289.         self.ui.act_ch_08.triggered.connect(self.slot_checkChannel)

  290.         self.ui.act_ch_09.triggered.connect(self.slot_checkChannel)

  291.         self.ui.act_ch_10.triggered.connect(self.slot_checkChannel)

  292.         self.ui.act_ch_11.triggered.connect(self.slot_checkChannel)

  293.         self.ui.act_ch_12.triggered.connect(self.slot_checkChannel)

  294.         self.ui.act_ch_13.triggered.connect(self.slot_checkChannel)

  295.         self.ui.act_ch_14.triggered.connect(self.slot_checkChannel)

  296.         self.ui.act_ch_15.triggered.connect(self.slot_checkChannel)

  297.         self.ui.act_ch_16.triggered.connect(self.slot_checkChannel)

  298.         self.ui.act_ch_all.triggered.connect(self.slot_checkChannel_all)

  299.         self.ui.act_ch_none.triggered.connect(self.slot_checkChannel_none)

  300. 

  301.         self.ui.act_show_keyboard.triggered.connect(self.slot_showKeyboard)

  302. 

  303.         # ---------------------------------------------------------------

  304.         # Final stuff

  305. 

  306.         self.fIdleTimer = self.startTimer(50)

  307.         self.setWindowTitle(self.fUiName)

  308.         self.ready()

  309. 

  310.         QTimer.singleShot(0, self.slot_updateScreen)

  311. 

  312.     # -------------------------------------------------------------------

  313. 

  314.     @pyqtSlot()

  315.     def slot_updateScreen(self):

  316.         self.scene.updateSize(self.ui.graphicsView.size())

  317. 

  318.         dial_x = self.ui.dial_x.rvalue()

  319.         dial_y = self.ui.dial_y.rvalue()

  320.         self.scene.setPosX(dial_x / 100, False)

  321.         self.scene.setPosY(dial_y / 100, False)

  322.         self.scene.setSmoothValues(dial_x / 100, dial_y / 100)

  323. 

  324.     @pyqtSlot(int)

  325.     def slot_noteOn(self, note):

  326.         pass

  327.         #foreach (const int& channel, m_channels)

  328.             #qMidiOutData.put(0x90 + channel - 1, note, 100);

  329. 

  330.     @pyqtSlot(int)

  331.     def slot_noteOff(self, note):

  332.         pass

  333.         #foreach (const int& channel, m_channels)

  334.             #qMidiOutData.put(0x80 + channel - 1, note, 0);

  335. 

  336.     @pyqtSlot(float)

  337.     def slot_knobValueChangedX(self, x: float):

  338.         self.sendControl(XYCONTROLLER_PARAMETER_X, x)

  339.         self.scene.setPosX(x / 100, True)

  340.         self.scene.setSmoothValues(x / 100, self.ui.dial_y.rvalue() / 100)

  341. 

  342.     @pyqtSlot(float)

  343.     def slot_knobValueChangedY(self, y: float):

  344.         self.sendControl(XYCONTROLLER_PARAMETER_Y, y)

  345.         self.scene.setPosY(y / 100, True)

  346.         self.scene.setSmoothValues(self.ui.dial_x.rvalue() / 100, y / 100)

  347. 

  348.     @pyqtSlot(str)

  349.     def slot_checkCC_X(self, text):

  350.         if not text:

  351.             return

  352. 

  353.         tmp_cc_x = int(text.split(" ",1)[0], 16)

  354. 

  355.         self.cc_x = tmp_cc_x;

  356.         self.scene.setControlX(self.cc_x);

  357. 

  358.     @pyqtSlot(str)

  359.     def slot_checkCC_Y(self, text):

  360.         if not text:

  361.             return

  362. 

  363.         tmp_cc_y = int(text.split(" ",1)[0], 16)

  364. 

  365.         self.cc_y = tmp_cc_y;

  366.         self.scene.setControlY(self.cc_y);

  367. 

  368.     @pyqtSlot(bool)

  369.     def slot_checkChannel(self, clicked):

  370.         if not self.sender():

  371.             return

  372. 

  373.         channel = int(self.sender().text())

  374. 

  375.         if clicked and channel not in self.m_channels:

  376.             self.m_channels.append(channel)

  377.         elif not clicked and channel in self.m_channels:

  378.             self.m_channels.remove(channel);

  379. 

  380.         self.scene.setChannels(self.m_channels);

  381. 

  382.     @pyqtSlot()

  383.     def slot_checkChannel_all(self):

  384.         self.ui.act_ch_01.setChecked(True)

  385.         self.ui.act_ch_02.setChecked(True)

  386.         self.ui.act_ch_03.setChecked(True)

  387.         self.ui.act_ch_04.setChecked(True)

  388.         self.ui.act_ch_05.setChecked(True)

  389.         self.ui.act_ch_06.setChecked(True)

  390.         self.ui.act_ch_07.setChecked(True)

  391.         self.ui.act_ch_08.setChecked(True)

  392.         self.ui.act_ch_09.setChecked(True)

  393.         self.ui.act_ch_10.setChecked(True)

  394.         self.ui.act_ch_11.setChecked(True)

  395.         self.ui.act_ch_12.setChecked(True)

  396.         self.ui.act_ch_13.setChecked(True)

  397.         self.ui.act_ch_14.setChecked(True)

  398.         self.ui.act_ch_15.setChecked(True)

  399.         self.ui.act_ch_16.setChecked(True)

  400. 

  401.         self.m_channels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

  402.         self.scene.setChannels(self.m_channels)

  403. 

  404.     @pyqtSlot()

  405.     def slot_checkChannel_none(self):

  406.         self.ui.act_ch_01.setChecked(False)

  407.         self.ui.act_ch_02.setChecked(False)

  408.         self.ui.act_ch_03.setChecked(False)

  409.         self.ui.act_ch_04.setChecked(False)

  410.         self.ui.act_ch_05.setChecked(False)

  411.         self.ui.act_ch_06.setChecked(False)

  412.         self.ui.act_ch_07.setChecked(False)

  413.         self.ui.act_ch_08.setChecked(False)

  414.         self.ui.act_ch_09.setChecked(False)

  415.         self.ui.act_ch_10.setChecked(False)

  416.         self.ui.act_ch_11.setChecked(False)

  417.         self.ui.act_ch_12.setChecked(False)

  418.         self.ui.act_ch_13.setChecked(False)

  419.         self.ui.act_ch_14.setChecked(False)

  420.         self.ui.act_ch_15.setChecked(False)

  421.         self.ui.act_ch_16.setChecked(False)

  422. 

  423.         self.m_channels = []

  424.         self.scene.setChannels(self.m_channels)

  425. 

  426.     @pyqtSlot(bool)

  427.     def slot_setSmooth(self, smooth):

  428.         self.sendConfigure("smooth", "yes" if smooth else "no")

  429.         self.scene.setSmooth(smooth)

  430. 

  431.         if smooth:

  432.             dial_x = self.ui.dial_x.rvalue()

  433.             dial_y = self.ui.dial_y.rvalue()

  434.             self.scene.setSmoothValues(dial_x / 100, dial_y / 100)

  435. 

  436.     @pyqtSlot(float, float)

  437.     def slot_sceneCursorMoved(self, xp, yp):

  438.         self.sendControl(XYCONTROLLER_PARAMETER_X, xp * 100)

  439.         self.sendControl(XYCONTROLLER_PARAMETER_Y, yp * 100)

  440. 

  441.         self.ui.dial_x.setValue(xp * 100, False)

  442.         self.ui.dial_y.setValue(yp * 100, False)

  443. 

  444.     @pyqtSlot(bool)

  445.     def slot_showKeyboard(self, yesno):

  446.         self.ui.scrollArea.setVisible(yesno)

  447.         QTimer.singleShot(0, self.slot_updateScreen)

  448. 

  449.     # -------------------------------------------------------------------

  450.     # DSP Callbacks

  451. 

  452.     def dspParameterChanged(self, index, value):

  453.         if index == XYCONTROLLER_PARAMETER_X:

  454.             self.ui.dial_x.setValue(value, False)

  455.             self.scene.setPosX(value / 100, False)

  456.         elif index == XYCONTROLLER_PARAMETER_Y:

  457.             self.ui.dial_y.setValue(value, False)

  458.             self.scene.setPosY(value / 100, False)

  459.         else:

  460.             return

  461. 

  462.         self.scene.setSmoothValues(self.ui.dial_x.rvalue() / 100,

  463.                                    self.ui.dial_y.rvalue() / 100)

  464. 

  465.     def dspStateChanged(self, key, value):

  466.         print("dspStateChanged", key, value)

  467. 

  468.         if key == "guiWidth":

  469.             try:

  470.                 width = int(value)

  471.             except:

  472.                 width = 0

  473. 

  474.             if width > 0:

  475.                 self.resize(width, self.height())

  476. 

  477.         elif key == "guiHeight":

  478.             try:

  479.                 height = int(value)

  480.             except:

  481.                 height = 0

  482. 

  483.             if height > 0:

  484.                 self.resize(self.width(), height)

  485. 

  486.         elif key == "smooth":

  487.             smooth = (value == "yes")

  488.             self.ui.cb_smooth.blockSignals(True)

  489.             self.ui.cb_smooth.setChecked(smooth)

  490.             self.ui.cb_smooth.blockSignals(False)

  491.             self.scene.setSmooth(smooth)

  492. 

  493.             if smooth:

  494.                 dial_x = self.ui.dial_x.rvalue()

  495.                 dial_y = self.ui.dial_y.rvalue()

  496.                 self.scene.setSmoothValues(dial_x / 100, dial_y / 100)

  497. 

  498.     # -------------------------------------------------------------------

  499.     # ExternalUI Callbacks

  500. 

  501.     def uiShow(self):

  502.         self.show()

  503. 

  504.     def uiFocus(self):

  505.         self.setWindowState((self.windowState() & ~Qt.WindowMinimized) | Qt.WindowActive)

  506.         self.show()

  507. 

  508.         self.raise_()

  509.         self.activateWindow()

  510. 

  511.     def uiHide(self):

  512.         self.hide()

  513. 

  514.     def uiQuit(self):

  515.         self.closeExternalUI()

  516.         self.close()

  517.         app.quit()

  518. 

  519.     def uiTitleChanged(self, uiTitle):

  520.         self.setWindowTitle(uiTitle)

  521. 

  522.     # -------------------------------------------------------------------

  523.     # Qt events

  524. 

  525.     def showEvent(self, event):

  526.         self.slot_updateScreen()

  527.         QMainWindow.showEvent(self, event)

  528. 

  529.     def resizeEvent(self, event):

  530.         self.fSaveSizeNowChecker = 0

  531.         self.slot_updateScreen()

  532.         QMainWindow.resizeEvent(self, event)

  533. 

  534.     def timerEvent(self, event):

  535.         if event.timerId() == self.fIdleTimer:

  536.             self.idleExternalUI()

  537.             self.scene.updateSmooth()

  538. 

  539.             if self.fSaveSizeNowChecker == 11:

  540.                 self.sendConfigure("guiWidth", str(self.width()))

  541.                 self.sendConfigure("guiHeight", str(self.height()))

  542.                 self.fSaveSizeNowChecker = -1

  543.             elif self.fSaveSizeNowChecker >= 0:

  544.                 self.fSaveSizeNowChecker += 1

  545. 

  546.         QMainWindow.timerEvent(self, event)

  547. 

  548.     def closeEvent(self, event):

  549.         self.closeExternalUI()

  550.         QMainWindow.closeEvent(self, event)

  551. 

  552.         # there might be other qt windows open which will block the UI from quitting

  553.         app.quit()

  554. 

  555. #--------------- main ------------------

  556. if __name__ == '__main__':

  557.     import resources_rc

  558. 

  559.     pathBinaries, _ = getPaths()

  560.     gCarla.utils = CarlaUtils(os.path.join(pathBinaries, "libcarla_utils." + DLL_EXTENSION))

  561.     gCarla.utils.set_process_name("XYController")

  562. 

  563.     app = CarlaApplication("XYController")

  564.     gui = XYControllerUI()

  565.     app.exit_exec()