falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
7040 Commits
17 Branches
992MB
Tree: 5e505428f3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5e505428f3'
${ noResults }
Carla/source/frontend/xycontroller-ui

740 lines
26KB
Raw Blame History 

  1. #!/usr/bin/env python3

  2. # SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>

  3. # SPDX-License-Identifier: GPL-2.0-or-later

  4. 

  5. # ------------------------------------------------------------------------------------------------------------

  6. # Imports (Global)

  7. 

  8. from qt_compat import qt_config

  9. 

  10. if qt_config == 5:

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

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

  13.     from PyQt5.QtWidgets import QGraphicsScene, QGraphicsSceneMouseEvent, QMainWindow, QApplication

  14. elif qt_config == 6:

  15.     from PyQt6.QtCore import pyqtSignal, pyqtSlot, QT_VERSION, Qt, QPointF, QRectF, QSize, QTimer

  16.     from PyQt6.QtGui import QColor, QPainter, QPen

  17.     from PyQt6.QtWidgets import QGraphicsScene, QGraphicsSceneMouseEvent, QMainWindow, QApplication

  18. 

  19. import ctypes

  20. from time import sleep

  21. 

  22. # -----------------------------------------------------------------------

  23. # Imports (Custom)

  24. 

  25. from carla_shared import *

  26. from carla_utils import *

  27. from widgets.scalabledial import ScalableDial

  28. 

  29. import ui_xycontroller

  30. 

  31. # -----------------------------------------------------------------------

  32. # Imports (ExternalUI)

  33. 

  34. from carla_app import CarlaApplication

  35. from externalui import ExternalUI

  36. from widgets.paramspinbox import ParamSpinBox

  37. 

  38. # ------------------------------------------------------------------------------------------------------------

  39. XYCONTROLLER_PARAMETER_SMOOTH   = 0

  40. XYCONTROLLER_PARAMETER_LINEAR   = 1

  41. XYCONTROLLER_PARAMETER_SPEED    = 2

  42. XYCONTROLLER_PARAMETER_REVERSEY = 3

  43. XYCONTROLLER_PARAMETER_X        = 4

  44. XYCONTROLLER_PARAMETER_Y        = 5

  45. XYCONTROLLER_PARAMETER_OUT_X    = 6

  46. XYCONTROLLER_PARAMETER_OUT_Y    = 7

  47. 

  48. # ------------------------------------------------------------------------------------------------------------

  49. 

  50. class XYGraphicsScene(QGraphicsScene):

  51.     # signals

  52.     cursorMoved = pyqtSignal(float,float)

  53.     knobsUpdate = pyqtSignal(float,float)

  54. 

  55.     def __init__(self, parent):

  56.         QGraphicsScene.__init__(self, parent)

  57. 

  58.         self.cc_x = 1

  59.         self.cc_y = 2

  60.         self.rparent = parent

  61. 

  62.         self.m_channels  = []

  63.         self.m_mouseLock = False

  64.         self.m_smooth    = False

  65.         self.m_linear    = False

  66.         self.m_speed     = 8.0    # 1.0 to 100.0

  67.         self.m_rSmooth   = False  # Using right button

  68.         self.m_smooth_x  = 0.0

  69.         self.m_smooth_y  = 0.0

  70. 

  71.         self.reverseY    = 1.0    # -1.0 when reversed

  72. 

  73.         self.xpPrev      = 0.0

  74.         self.ypPrev      = 0.0

  75. 

  76.         self.time:     ctypes.c_uint64 = 0 # I sure just int is quite enough here, but...

  77.         self.prevTime: ctypes.c_uint64 = 0

  78. 

  79.         self.setBackgroundBrush(Qt.black)

  80. 

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

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

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

  84. 

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

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

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

  88. 

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

  90. 

  91.     # -------------------------------------------------------------------

  92. 

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

  94.         self.cc_x = x

  95. 

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

  97.         self.cc_y = y

  98. 

  99.     def setChannels(self, channels):

  100.         self.m_channels = channels

  101. 

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

  103.         if self.m_mouseLock:

  104.             return

  105. 

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

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

  108.         self.m_lineV.setX(posX)

  109. 

  110.         if forward:

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

  112.             self.sendMIDI(value, None)

  113.         else:

  114.             self.m_smooth_x = posX

  115. 

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

  117.         if self.m_mouseLock:

  118.             return

  119. 

  120.         posY = y * (self.p_size.y() + self.p_size.height()) * self.reverseY

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

  122.         self.m_lineH.setY(posY)

  123. 

  124.         if forward:

  125.             value = posY / (self.p_size.y() + self.p_size.height()) * self.reverseY

  126.             self.sendMIDI(None, value)

  127.         else:

  128.             self.m_smooth_y = posY

  129. 

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

  131.         self.m_smooth_x = x * (self.p_size.x() + self.p_size.width())

  132.         self.m_smooth_y = y * (self.p_size.y() + self.p_size.height()) * self.reverseY

  133. 

  134.     def setReverseY(self, rev: bool):

  135.         self.reverseY = 1 - (int(rev) * 2)  # 1.0 or -1.0

  136. 

  137.     # -------------------------------------------------------------------

  138. 

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

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

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

  142.                             size.width(),

  143.                             size.height())

  144. 

  145.     def updatePos(self, pos: QPointF, filterSame: bool = False, knobsOnly: bool = False):

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

  147.         yp = pos.y() / (self.p_size.y() + self.p_size.height()) * self.reverseY

  148.         if knobsOnly:

  149.             self.knobsUpdate.emit(xp * 100, yp * 100)

  150.             return

  151. 

  152.         self.m_cursor.setPos(pos)

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

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

  155. 

  156.         # Set 0.05% precision, yet exact final value settling, esp. zero

  157.         xp = round(xp * 1000) / 1000

  158.         yp = round(yp * 1000) / 1000

  159. 

  160.         self.sendMIDI(xp, yp, filterSame)

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

  162. 

  163.     def updateSmooth(self, time):

  164.         if not (self.m_smooth or self.m_rSmooth):

  165.             return

  166. 

  167.         dx = self.m_smooth_x - self.m_cursor.x()

  168.         dy = self.m_smooth_y - self.m_cursor.y()

  169. 

  170.         if dx == dy == 0:

  171.             return

  172. 

  173.         same = 0

  174.         if abs(dx) <= 0.0005:

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

  176.             same += 1

  177. 

  178.         if abs(dy) <= 0.0005:

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

  180.             same += 1

  181. 

  182.         if same == 2:

  183.             return

  184. 

  185.         speed = self.m_speed

  186. 

  187.         mod = QApplication.keyboardModifiers()

  188.         if (mod & Qt.ControlModifier):

  189.             speed /= 2

  190.         elif (mod & Qt.ShiftModifier):

  191.             speed *= 2

  192. 

  193.         if self.m_linear:

  194.             newX = self.m_cursor.x() + max(min(dx / speed, 1), -1) * speed

  195.             newY = self.m_cursor.y() + max(min(dy / speed, 1), -1) * speed

  196.         else:

  197.             precision = 64 / speed

  198.             newX = float(self.m_smooth_x + self.m_cursor.x()*(precision-1)) / precision

  199.             newY = float(self.m_smooth_y + self.m_cursor.y()*(precision-1)) / precision

  200. 

  201.         pos  = QPointF(newX, newY)

  202. 

  203.         self.updatePos(pos, ((time - self.prevTime) == 1)) # Continuous calls or Not

  204. 

  205.         self.prevTime = time

  206. 

  207.     # -------------------------------------------------------------------

  208. 

  209.     def handleMousePos(self, event):

  210. 

  211.         if (event.buttons() & Qt.MiddleButton):

  212.             pos = QPointF(0, 0)

  213.         else:

  214.             pos = QPointF(event.scenePos())

  215. 

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

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

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

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

  220.                 pos.setX(self.p_size.x() + self.p_size.width())

  221. 

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

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

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

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

  226. 

  227.         self.updatePos(pos, knobsOnly=True)

  228. 

  229.         self.m_smooth_x = pos.x()

  230.         self.m_smooth_y = pos.y()

  231. 

  232.         self.m_rSmooth = event.buttons() & Qt.RightButton

  233. 

  234.         # When not smooth, update each time;

  235.         # (commented-out part) When smooth, update (re-send same) if click position is same (when smoothing not sends anything). (To match non-smoothed behaviour)

  236.         if (not (self.m_smooth or self.m_rSmooth)): # or (abs(self.m_cursor.x() - self.m_smooth_x) <= 0.0005 and abs(self.m_cursor.y() - self.m_smooth_y) <= 0.0005):

  237.             self.updatePos(pos)

  238. 

  239.     def sendMIDI(self, xp, yp, filterSame = False):

  240.         rate = float(0xff) / 4

  241.         prefix = []

  242.         msgd = []

  243. 

  244.         if xp is not None:

  245.             value = int(xp * rate + rate)

  246.             if not (filterSame and (value == self.xpPrev)):

  247.                 prefix = ["cc"]

  248. 

  249.                 msgd.append(self.cc_x)

  250.                 msgd.append(value)

  251. 

  252.             self.xpPrev = value

  253. 

  254.         if yp is not None:

  255.             value = int(yp * rate + rate)

  256.             if not (filterSame and (value == self.ypPrev)):

  257.                 if prefix == []:

  258.                     prefix = ["cc"]

  259.                 else:

  260.                     prefix = ["cc2"]

  261. 

  262.                 msgd.append(self.cc_y)

  263.                 msgd.append(value)

  264. 

  265.             self.ypPrev = value

  266. 

  267.         if not (prefix == []):

  268.             self.rparent.send(prefix + msgd)

  269. 

  270.     # -------------------------------------------------------------------

  271. 

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

  273.         event.accept()

  274. 

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

  276.         event.accept()

  277. 

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

  279.         self.m_mouseLock = True

  280.         self.handleMousePos(event)

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

  282.         QGraphicsScene.mousePressEvent(self, event)

  283. 

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

  285.         self.handleMousePos(event)

  286.         QGraphicsScene.mouseMoveEvent(self, event)

  287. 

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

  289.         self.m_mouseLock = False

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

  291.         QGraphicsScene.mouseReleaseEvent(self, event)

  292. 

  293. # -----------------------------------------------------------------------

  294. # External UI

  295. 

  296. class XYControllerUI(ExternalUI, QMainWindow):

  297.     def __init__(self):

  298.         ExternalUI.__init__(self)

  299.         QMainWindow.__init__(self)

  300.         self.ui = ui_xycontroller.Ui_XYControllerW()

  301.         self.ui.setupUi(self)

  302. 

  303.         self.fSaveSizeNowChecker = -1

  304. 

  305.         self.isXActual = False

  306.         self.isYActual = False

  307. 

  308.         # ---------------------------------------------------------------

  309.         # Set-up GUI stuff

  310. 

  311.         self.scene = XYGraphicsScene(self)

  312. 

  313.         # Now knobs are QWidgets, not QDials.

  314.         self.ui.dial_x = ScalableDial(self.ui.dial_x, 0, 400, 0, -100, 100, "X", 64, -1, "%", "tube", 1, {})

  315.         self.ui.dial_y = ScalableDial(self.ui.dial_y, 1, 400, 0, -100, 100, "Y", 64, -1, "%", "tube", 1, {})

  316. 

  317.         # These are outputs (7-seg displays).

  318.         self.ui.dial_out_x = ScalableDial(self.ui.dial_out_x, 2, 400, 0, -100, 100, "Out X", 64, -1, "%", "tube", 1, {'Auto7segWidth':1, }, isOutput=True)

  319.         self.ui.dial_out_y = ScalableDial(self.ui.dial_out_y, 3, 400, 0, -100, 100, "Out Y", 64, -1, "%", "tube", 1, {'Auto7segWidth':1, }, isOutput=True)

  320. 

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

  322. 

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

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

  325. 

  326.         for MIDI_CC in MIDI_CC_LIST:

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

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

  329. 

  330.         # ---------------------------------------------------------------

  331.         # Initial state

  332. 

  333.         self.m_channels = [1]

  334. 

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

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

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

  338. 

  339.         # ---------------------------------------------------------------

  340.         # Connect actions to functions

  341. 

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

  343.         self.scene.knobsUpdate.connect(self.slot_setKnobs)

  344. 

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

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

  347. 

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

  349. 

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

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

  352. 

  353. 

  354.         if QT_VERSION >= 0x60000:

  355.             self.ui.cb_control_x.currentTextChanged.connect(self.slot_checkCC_X)

  356.             self.ui.cb_control_y.currentTextChanged.connect(self.slot_checkCC_Y)

  357.         else:

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

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

  360. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  379. 

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

  381. 

  382.         # ---------------------------------------------------------------

  383.         # Final stuff

  384. 

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

  386.         self.setWindowTitle(self.fUiName)

  387.         self.ready()

  388. 

  389.     # -------------------------------------------------------------------

  390. 

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

  392.         self.scene.m_smooth = smooth

  393. 

  394.         x = self.ui.dial_x.rvalue() / 100

  395.         y = self.ui.dial_y.rvalue() / 100

  396.         if smooth:

  397.             self.scene.setSmoothValues(x, y)

  398.         else:

  399.             self.scene.setPosX(x, True)

  400.             self.scene.setPosY(y, True)

  401.             self.slot_sceneCursorMoved(x, y)

  402. 

  403.     @pyqtSlot()

  404.     def slot_updateScreen(self):

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

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

  407. 

  408.     @pyqtSlot(int)

  409.     def slot_noteOn(self, note):

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

  411. 

  412.     @pyqtSlot(int)

  413.     def slot_noteOff(self, note):

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

  415. 

  416.     @pyqtSlot(float)

  417.     def slot_knobValueChangedX(self, x:float, external:bool=False, firstRun:bool=False):

  418.         if not external:

  419.             self.sendControl(XYCONTROLLER_PARAMETER_X, x)

  420.         else:

  421.             self.ui.dial_x.setValue(x, False)

  422. 

  423.         if (not self.scene.m_smooth) or firstRun:

  424.             self.sendControl(XYCONTROLLER_PARAMETER_OUT_X, x)

  425.             self.ui.dial_out_x.setValue(x, False)

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

  427. 

  428.         else:

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

  430. 

  431.     @pyqtSlot(float)

  432.     def slot_knobValueChangedY(self, y:float, external:bool=False, firstRun:bool=False):

  433.         if not external:

  434.             self.sendControl(XYCONTROLLER_PARAMETER_Y, y)

  435.         else:

  436.             self.ui.dial_y.setValue(y, False)

  437. 

  438.         if (not self.scene.m_smooth) or firstRun:

  439.             self.sendControl(XYCONTROLLER_PARAMETER_OUT_Y, y)

  440.             self.ui.dial_out_y.setValue(y, False)

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

  442. 

  443.         else:

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

  445. 

  446.     @pyqtSlot(str)

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

  448.         if not text:

  449.             return

  450. 

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

  452. 

  453.         self.scene.setControlX(cc_x)

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

  455. 

  456.     @pyqtSlot(str)

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

  458.         if not text:

  459.             return

  460. 

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

  462. 

  463.         self.scene.setControlY(cc_y)

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

  465. 

  466.     @pyqtSlot(bool)

  467.     def slot_checkChannel(self, clicked):

  468.         if not self.sender():

  469.             return

  470. 

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

  472. 

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

  474.             self.m_channels.append(channel)

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

  476.             self.m_channels.remove(channel)

  477. 

  478.         self.scene.setChannels(self.m_channels)

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

  480. 

  481.     @pyqtSlot()

  482.     def slot_checkChannel_all(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  499. 

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

  501.         self.scene.setChannels(self.m_channels)

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

  503. 

  504.     @pyqtSlot()

  505.     def slot_checkChannel_none(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  522. 

  523.         self.m_channels = []

  524.         self.scene.setChannels(self.m_channels)

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

  526. 

  527.     @pyqtSlot(bool)

  528.     def slot_setSmooth(self, smooth):

  529.         self.setSmooth(smooth)

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

  531.         self.sendControl(XYCONTROLLER_PARAMETER_SMOOTH, int(smooth))

  532. 

  533.     @pyqtSlot(float, float)

  534.     def slot_sceneCursorMoved(self, xp: float, yp: float):

  535.         self.ui.dial_out_x.setValue(xp * 100, False)

  536.         self.ui.dial_out_y.setValue(yp * 100, False)

  537.         self.sendControl(XYCONTROLLER_PARAMETER_OUT_X, xp * 100)

  538.         self.sendControl(XYCONTROLLER_PARAMETER_OUT_Y, yp * 100)

  539. 

  540.     @pyqtSlot(bool)

  541.     def slot_showKeyboard(self, yesno):

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

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

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

  545. 

  546.     @pyqtSlot(float, float)

  547.     def slot_setKnobs(self, x, y):

  548.         self.ui.dial_x.setValue(x, False)

  549.         self.ui.dial_y.setValue(y, False)

  550.         self.sendControl(XYCONTROLLER_PARAMETER_X, x)

  551.         self.sendControl(XYCONTROLLER_PARAMETER_Y, y)

  552. 

  553.     # -------------------------------------------------------------------

  554.     # DSP Callbacks

  555. 

  556.     # NOTE It called continuously with params 6, 7 (outs, not used here), is this good?

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

  558.         if index == XYCONTROLLER_PARAMETER_SMOOTH:

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

  560.             self.ui.cb_smooth.setChecked(bool(value))

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

  562.             self.setSmooth(bool(value))

  563. 

  564.         elif index == XYCONTROLLER_PARAMETER_LINEAR:

  565.             self.scene.m_linear = bool(value)

  566. 

  567.         elif index == XYCONTROLLER_PARAMETER_SPEED:

  568.             self.scene.m_speed = value

  569. 

  570.         elif index == XYCONTROLLER_PARAMETER_REVERSEY:

  571.             self.scene.setReverseY(bool(value))

  572. 

  573.         elif index == XYCONTROLLER_PARAMETER_X:

  574.             self.slot_knobValueChangedX(value, True, not self.isXActual)

  575.             self.isXActual = True

  576. 

  577.         elif index == XYCONTROLLER_PARAMETER_Y:

  578.             self.slot_knobValueChangedY(value, True, not self.isYActual)

  579.             if self.isXActual and not self.isYActual:

  580.                 # Run it once, BUT when both X & Y are received (they can be shuffled).

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

  582.                 self.isYActual = True

  583. 

  584.         else:

  585.             return

  586. 

  587. 

  588.     def dspStateChanged(self, key: str, value: str):

  589.         if key == "guiWidth":

  590.             try:

  591.                 width = int(value)

  592.             except:

  593.                 width = 0

  594. 

  595.             if width > 0:

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

  597. 

  598.         elif key == "guiHeight":

  599.             try:

  600.                 height = int(value)

  601.             except:

  602.                 height = 0

  603. 

  604.             if height > 0:

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

  606. 

  607.         elif key == "smooth":

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

  609.             self.setSmooth(bool(smooth))

  610. 

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

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

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

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

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

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

  617. 

  618.         elif key == "channels":

  619.             if value:

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

  621.             else:

  622.                 self.m_channels = []

  623.             self.scene.setChannels(self.m_channels)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  640. 

  641.         elif key == "cc_x":

  642.             cc_x = int(value)

  643.             self.scene.setControlX(cc_x)

  644. 

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

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

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

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

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

  650.                     break

  651. 

  652.         elif key == "cc_y":

  653.             cc_y = int(value)

  654.             self.scene.setControlY(cc_y)

  655. 

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

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

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

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

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

  661.                     break

  662. 

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

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

  665.             return

  666.         if onOff:

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

  668.         else:

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

  670. 

  671.     # -------------------------------------------------------------------

  672.     # ExternalUI Callbacks

  673. 

  674.     def uiShow(self):

  675.         self.show()

  676. 

  677.     def uiFocus(self):

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

  679.         self.show()

  680. 

  681.         self.raise_()

  682.         self.activateWindow()

  683. 

  684.     def uiHide(self):

  685.         self.hide()

  686. 

  687.     def uiQuit(self):

  688.         self.closeExternalUI()

  689.         self.close()

  690.         app.quit()

  691. 

  692.     def uiTitleChanged(self, uiTitle):

  693.         self.setWindowTitle(uiTitle)

  694. 

  695.     # -------------------------------------------------------------------

  696.     # Qt events

  697. 

  698.     def showEvent(self, event):

  699.         self.slot_updateScreen()

  700.         QMainWindow.showEvent(self, event)

  701. 

  702.     def resizeEvent(self, event):

  703.         self.fSaveSizeNowChecker = 0

  704.         self.slot_updateScreen()

  705.         QMainWindow.resizeEvent(self, event)

  706. 

  707.     def timerEvent(self, event):

  708.         self.scene.time += 1

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

  710.             self.idleExternalUI()

  711.             self.scene.updateSmooth(self.scene.time)

  712. 

  713.             if self.fSaveSizeNowChecker == 11:

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

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

  716.                 self.fSaveSizeNowChecker = -1

  717.             elif self.fSaveSizeNowChecker >= 0:

  718.                 self.fSaveSizeNowChecker += 1

  719. 

  720.         QMainWindow.timerEvent(self, event)

  721. 

  722.     def closeEvent(self, event):

  723.         self.closeExternalUI()

  724.         QMainWindow.closeEvent(self, event)

  725. 

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

  727.         app.quit()

  728. 

  729. #--------------- main ------------------

  730. if __name__ == '__main__':

  731.     import resources_rc

  732. 

  733.     pathBinaries, _ = getPaths()

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

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

  736. 

  737.     app = CarlaApplication("XYController")

  738.     gui = XYControllerUI()

  739.     app.exit_exec()