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

624 lines
22KB
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.         self.rparent = parent

  58. 

  59.         self.m_channels  = []

  60.         self.m_mouseLock = False

  61.         self.m_smooth    = False

  62.         self.m_smooth_x  = 0.0

  63.         self.m_smooth_y  = 0.0

  64. 

  65.         self.setBackgroundBrush(Qt.black)

  66. 

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

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

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

  70. 

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

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

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

  74. 

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

  76. 

  77.     # -------------------------------------------------------------------

  78. 

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

  80.         self.cc_x = x

  81. 

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

  83.         self.cc_y = y

  84. 

  85.     def setChannels(self, channels):

  86.         self.m_channels = channels

  87. 

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

  89.         if self.m_mouseLock:

  90.             return

  91. 

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

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

  94.         self.m_lineV.setX(posX)

  95. 

  96.         if forward:

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

  98.             self.sendMIDI(value, None)

  99.         else:

  100.             self.m_smooth_x = posX;

  101. 

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

  103.         if self.m_mouseLock:

  104.             return;

  105. 

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

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

  108.         self.m_lineH.setY(posY)

  109. 

  110.         if forward:

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

  112.             self.sendMIDI(None, value)

  113.         else:

  114.             self.m_smooth_y = posY

  115. 

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

  117.         self.m_smooth = smooth

  118. 

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

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

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

  122. 

  123.     # -------------------------------------------------------------------

  124. 

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

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

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

  128.                             size.width(),

  129.                             size.height());

  130. 

  131.     def updateSmooth(self):

  132.         if not self.m_smooth:

  133.             return

  134. 

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

  136.             return

  137. 

  138.         same = 0

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

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

  141.             same += 1

  142. 

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

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

  145.             same += 1

  146. 

  147.         if same == 2:

  148.             return

  149. 

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

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

  152.         pos  = QPointF(newX, newY)

  153. 

  154.         self.m_cursor.setPos(pos)

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

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

  157. 

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

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

  160. 

  161.         self.sendMIDI(xp, yp)

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

  163. 

  164.     # -------------------------------------------------------------------

  165. 

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

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

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

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

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

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

  172. 

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

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

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

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

  177. 

  178.         self.m_smooth_x = pos.x()

  179.         self.m_smooth_y = pos.y()

  180. 

  181.         if not self.m_smooth:

  182.             self.m_cursor.setPos(pos)

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

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

  185. 

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

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

  188. 

  189.             self.sendMIDI(xp, yp)

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

  191. 

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

  193.         rate = float(0xff) / 4

  194.         msgd = ["cc2" if xp is not None and yp is not None else "cc"]

  195. 

  196.         if xp is not None:

  197.             msgd.append(self.cc_x)

  198.             msgd.append(int(xp * rate + rate))

  199. 

  200.         if yp is not None:

  201.             msgd.append(self.cc_y)

  202.             msgd.append(int(yp * rate + rate))

  203. 

  204.         self.rparent.send(msgd)

  205. 

  206.     # -------------------------------------------------------------------

  207. 

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

  209.         event.accept()

  210. 

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

  212.         event.accept()

  213. 

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

  215.         self.m_mouseLock = True

  216.         self.handleMousePos(event.scenePos())

  217.         self.rparent.setCursor(Qt.CrossCursor)

  218.         QGraphicsScene.mousePressEvent(self, event);

  219. 

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

  221.         self.handleMousePos(event.scenePos())

  222.         QGraphicsScene.mouseMoveEvent(self, event);

  223. 

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

  225.         self.m_mouseLock = False

  226.         self.rparent.setCursor(Qt.ArrowCursor)

  227.         QGraphicsScene.mouseReleaseEvent(self, event)

  228. 

  229. # -----------------------------------------------------------------------

  230. # External UI

  231. 

  232. class XYControllerUI(ExternalUI, QMainWindow):

  233.     def __init__(self):

  234.         ExternalUI.__init__(self)

  235.         QMainWindow.__init__(self)

  236.         self.ui = ui_xycontroller.Ui_XYControllerW()

  237.         self.ui.setupUi(self)

  238. 

  239.         self.fSaveSizeNowChecker = -1

  240. 

  241.         # ---------------------------------------------------------------

  242.         # Set-up GUI stuff

  243. 

  244.         self.scene = XYGraphicsScene(self)

  245. 

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

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

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

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

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

  251. 

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

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

  254. 

  255.         for MIDI_CC in MIDI_CC_LIST:

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

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

  258. 

  259.         # ---------------------------------------------------------------

  260.         # Initial state

  261. 

  262.         self.m_channels = [1]

  263. 

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

  265.         self.ui.act_show_keyboard.setChecked(True)

  266.         self.ui.cb_control_y.setCurrentIndex(1)

  267. 

  268.         # ---------------------------------------------------------------

  269.         # Connect actions to functions

  270. 

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

  272. 

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

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

  275. 

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

  277. 

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

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

  280. 

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

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

  283. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  302. 

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

  304. 

  305.         # ---------------------------------------------------------------

  306.         # Final stuff

  307. 

  308.         self.fIdleTimer = self.startTimer(60)

  309.         self.setWindowTitle(self.fUiName)

  310.         self.ready()

  311. 

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

  313. 

  314.     @pyqtSlot()

  315.     def slot_updateScreen(self):

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

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

  318. 

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

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

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

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

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

  324. 

  325.     @pyqtSlot(int)

  326.     def slot_noteOn(self, note):

  327.         self.send(["note", True, note])

  328. 

  329.     @pyqtSlot(int)

  330.     def slot_noteOff(self, note):

  331.         self.send(["note", False, note])

  332. 

  333.     @pyqtSlot(float)

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

  335.         self.sendControl(XYCONTROLLER_PARAMETER_X, x)

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

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

  338. 

  339.     @pyqtSlot(float)

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

  341.         self.sendControl(XYCONTROLLER_PARAMETER_Y, y)

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

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

  344. 

  345.     @pyqtSlot(str)

  346.     def slot_checkCC_X(self, text: str):

  347.         if not text:

  348.             return

  349. 

  350.         cc_x = int(text.split(" ",1)[0])

  351. 

  352.         self.scene.setControlX(cc_x)

  353.         self.sendConfigure("cc_x", str(cc_x))

  354. 

  355.     @pyqtSlot(str)

  356.     def slot_checkCC_Y(self, text: str):

  357.         if not text:

  358.             return

  359. 

  360.         cc_y = int(text.split(" ",1)[0])

  361. 

  362.         self.scene.setControlY(cc_y)

  363.         self.sendConfigure("cc_y", str(cc_y))

  364. 

  365.     @pyqtSlot(bool)

  366.     def slot_checkChannel(self, clicked):

  367.         if not self.sender():

  368.             return

  369. 

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

  371. 

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

  373.             self.m_channels.append(channel)

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

  375.             self.m_channels.remove(channel)

  376. 

  377.         self.scene.setChannels(self.m_channels)

  378.         self.sendConfigure("channels", ",".join(str(c) for c in self.m_channels))

  379. 

  380.     @pyqtSlot()

  381.     def slot_checkChannel_all(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  398. 

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

  400.         self.scene.setChannels(self.m_channels)

  401.         self.sendConfigure("channels", ",".join(str(c) for c in self.m_channels))

  402. 

  403.     @pyqtSlot()

  404.     def slot_checkChannel_none(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  421. 

  422.         self.m_channels = []

  423.         self.scene.setChannels(self.m_channels)

  424.         self.sendConfigure("channels", "")

  425. 

  426.     @pyqtSlot(bool)

  427.     def slot_setSmooth(self, smooth):

  428.         self.scene.setSmooth(smooth)

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

  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: float, yp: float):

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

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

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

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

  442. 

  443.     @pyqtSlot(bool)

  444.     def slot_showKeyboard(self, yesno):

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

  446.         self.sendConfigure("show-midi-keyboard", "yes" if yesno else "no")

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

  448. 

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

  450.     # DSP Callbacks

  451. 

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

  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: str, value: str):

  466.         if key == "guiWidth":

  467.             try:

  468.                 width = int(value)

  469.             except:

  470.                 width = 0

  471. 

  472.             if width > 0:

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

  474. 

  475.         elif key == "guiHeight":

  476.             try:

  477.                 height = int(value)

  478.             except:

  479.                 height = 0

  480. 

  481.             if height > 0:

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

  483. 

  484.         elif key == "smooth":

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

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

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

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

  489.             self.scene.setSmooth(smooth)

  490. 

  491.             if smooth:

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

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

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

  495. 

  496.         elif key == "show-midi-keyboard":

  497.             show = (value == "yes")

  498.             self.ui.act_show_keyboard.blockSignals(True)

  499.             self.ui.act_show_keyboard.setChecked(show)

  500.             self.ui.act_show_keyboard.blockSignals(False)

  501.             self.ui.scrollArea.setVisible(show)

  502. 

  503.         elif key == "channels":

  504.             if value:

  505.                 self.m_channels = [int(c) for c in value.split(",")]

  506.             else:

  507.                 self.m_channels = []

  508.             self.scene.setChannels(self.m_channels)

  509.             self.ui.act_ch_01.setChecked(bool(1 in self.m_channels))

  510.             self.ui.act_ch_02.setChecked(bool(2 in self.m_channels))

  511.             self.ui.act_ch_03.setChecked(bool(3 in self.m_channels))

  512.             self.ui.act_ch_04.setChecked(bool(4 in self.m_channels))

  513.             self.ui.act_ch_05.setChecked(bool(5 in self.m_channels))

  514.             self.ui.act_ch_06.setChecked(bool(6 in self.m_channels))

  515.             self.ui.act_ch_07.setChecked(bool(7 in self.m_channels))

  516.             self.ui.act_ch_08.setChecked(bool(8 in self.m_channels))

  517.             self.ui.act_ch_09.setChecked(bool(9 in self.m_channels))

  518.             self.ui.act_ch_10.setChecked(bool(10 in self.m_channels))

  519.             self.ui.act_ch_11.setChecked(bool(11 in self.m_channels))

  520.             self.ui.act_ch_12.setChecked(bool(12 in self.m_channels))

  521.             self.ui.act_ch_13.setChecked(bool(13 in self.m_channels))

  522.             self.ui.act_ch_14.setChecked(bool(14 in self.m_channels))

  523.             self.ui.act_ch_15.setChecked(bool(15 in self.m_channels))

  524.             self.ui.act_ch_16.setChecked(bool(16 in self.m_channels))

  525. 

  526.         elif key == "cc_x":

  527.             cc_x = int(value)

  528.             self.scene.setControlX(cc_x)

  529. 

  530.             for cc_index in range(len(MIDI_CC_LIST)):

  531.                 if cc_x == int(MIDI_CC_LIST[cc_index].split(" ",1)[0]):

  532.                     self.ui.cb_control_x.blockSignals(True)

  533.                     self.ui.cb_control_x.setCurrentIndex(cc_index)

  534.                     self.ui.cb_control_x.blockSignals(False)

  535.                     break

  536. 

  537.         elif key == "cc_y":

  538.             cc_y = int(value)

  539.             self.scene.setControlY(cc_y)

  540. 

  541.             for cc_index in range(len(MIDI_CC_LIST)):

  542.                 if cc_y == int(MIDI_CC_LIST[cc_index].split(" ",1)[0]):

  543.                     self.ui.cb_control_y.blockSignals(True)

  544.                     self.ui.cb_control_y.setCurrentIndex(cc_index)

  545.                     self.ui.cb_control_y.blockSignals(False)

  546.                     break

  547. 

  548.     def dspNoteReceived(self, onOff, channel, note, velocity):

  549.         if channel+1 not in self.m_channels:

  550.             return

  551.         if onOff:

  552.             self.ui.keyboard.sendNoteOn(note, False)

  553.         else:

  554.             self.ui.keyboard.sendNoteOff(note, False)

  555. 

  556.     # -------------------------------------------------------------------

  557.     # ExternalUI Callbacks

  558. 

  559.     def uiShow(self):

  560.         self.show()

  561. 

  562.     def uiFocus(self):

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

  564.         self.show()

  565. 

  566.         self.raise_()

  567.         self.activateWindow()

  568. 

  569.     def uiHide(self):

  570.         self.hide()

  571. 

  572.     def uiQuit(self):

  573.         self.closeExternalUI()

  574.         self.close()

  575.         app.quit()

  576. 

  577.     def uiTitleChanged(self, uiTitle):

  578.         self.setWindowTitle(uiTitle)

  579. 

  580.     # -------------------------------------------------------------------

  581.     # Qt events

  582. 

  583.     def showEvent(self, event):

  584.         self.slot_updateScreen()

  585.         QMainWindow.showEvent(self, event)

  586. 

  587.     def resizeEvent(self, event):

  588.         self.fSaveSizeNowChecker = 0

  589.         self.slot_updateScreen()

  590.         QMainWindow.resizeEvent(self, event)

  591. 

  592.     def timerEvent(self, event):

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

  594.             self.idleExternalUI()

  595.             self.scene.updateSmooth()

  596. 

  597.             if self.fSaveSizeNowChecker == 11:

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

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

  600.                 self.fSaveSizeNowChecker = -1

  601.             elif self.fSaveSizeNowChecker >= 0:

  602.                 self.fSaveSizeNowChecker += 1

  603. 

  604.         QMainWindow.timerEvent(self, event)

  605. 

  606.     def closeEvent(self, event):

  607.         self.closeExternalUI()

  608.         QMainWindow.closeEvent(self, event)

  609. 

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

  611.         app.quit()

  612. 

  613. #--------------- main ------------------

  614. if __name__ == '__main__':

  615.     import resources_rc

  616. 

  617.     pathBinaries, _ = getPaths()

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

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

  620. 

  621.     app = CarlaApplication("XYController")

  622.     gui = XYControllerUI()

  623.     app.exit_exec()