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

555 lines
18KB
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. class XYGraphicsScene(QGraphicsScene):

  44.     # signals

  45.     cursorMoved = pyqtSignal(float,float)

  46. 

  47.     def __init__(self, parent):

  48.         QGraphicsScene.__init__(self, parent)

  49. 

  50.         self.cc_x = 1

  51.         self.cc_y = 2

  52. 

  53.         self.m_channels  = []

  54.         self.m_mouseLock = False

  55.         self.m_smooth    = False

  56.         self.m_smooth_x  = 0.0

  57.         self.m_smooth_y  = 0.0

  58. 

  59.         self.setBackgroundBrush(Qt.black)

  60. 

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

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

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

  64. 

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

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

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

  68. 

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

  70. 

  71.     # -------------------------------------------------------------------

  72. 

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

  74.         self.cc_x = x

  75. 

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

  77.         self.cc_y = y

  78. 

  79.     def setChannels(self, channels):

  80.         self.m_channels = channels

  81. 

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

  83.         if self.m_mouseLock:

  84.             return

  85. 

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

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

  88.         self.m_lineV.setX(posX)

  89. 

  90.         if forward:

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

  92.             self.sendMIDI(value, None)

  93.         else:

  94.             self.m_smooth_x = posX;

  95. 

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

  97.         if self.m_mouseLock:

  98.             return;

  99. 

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

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

  102.         self.m_lineH.setY(posY)

  103. 

  104.         if forward:

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

  106.             self.sendMIDI(None, value)

  107.         else:

  108.             self.m_smooth_y = posY

  109. 

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

  111.         self.m_smooth = smooth

  112. 

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

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

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

  116. 

  117.     # -------------------------------------------------------------------

  118. 

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

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

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

  122.                             size.width(),

  123.                             size.height());

  124. 

  125.     def updateSmooth(self):

  126.         if not self.m_smooth:

  127.             return

  128. 

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

  130.             return

  131. 

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

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

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

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

  136. 

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

  138.             return;

  139. 

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

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

  142.         pos  = QPointF(newX, newY)

  143. 

  144.         self.m_cursor.setPos(pos)

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

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

  147. 

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

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

  150. 

  151.         self.sendMIDI(xp, yp)

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

  153. 

  154.     # -------------------------------------------------------------------

  155. 

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

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

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

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

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

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

  162. 

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

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

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

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

  167. 

  168.         m_smooth_x = pos.x()

  169.         m_smooth_y = pos.y()

  170. 

  171.         if not self.m_smooth:

  172.             self.m_cursor.setPos(pos)

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

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

  175. 

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

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

  178. 

  179.             self.sendMIDI(xp, yp)

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

  181. 

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

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

  184. 

  185.         if xp is not None:

  186.             value = xp * rate + rate

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

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

  189. 

  190.         if yp is not None:

  191.             value = yp * rate + rate

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

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

  194. 

  195.     # -------------------------------------------------------------------

  196. 

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

  198.         event.accept()

  199. 

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

  201.         event.accept()

  202. 

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

  204.         m_mouseLock = True

  205.         self.handleMousePos(event.scenePos())

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

  207.         QGraphicsScene.mousePressEvent(self, event);

  208. 

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

  210.         self.handleMousePos(event.scenePos())

  211.         QGraphicsScene.mouseMoveEvent(self, event);

  212. 

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

  214.         m_mouseLock = False

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

  216.         QGraphicsScene.mouseReleaseEvent(self, event)

  217. 

  218. # -----------------------------------------------------------------------

  219. # External UI

  220. 

  221. class XYControllerUI(ExternalUI, QMainWindow):

  222.     def __init__(self):

  223.         ExternalUI.__init__(self)

  224.         QMainWindow.__init__(self)

  225.         self.ui = ui_xycontroller.Ui_XYControllerW()

  226.         self.ui.setupUi(self)

  227. 

  228.         self.fSaveSizeNowChecker = -1

  229. 

  230.         # ---------------------------------------------------------------

  231.         # Internal stuff

  232. 

  233.         self.cc_x = 1

  234.         self.cc_y = 2

  235.         self.m_channels = []

  236. 

  237.         # ---------------------------------------------------------------

  238.         # Set-up GUI stuff

  239. 

  240.         self.scene = XYGraphicsScene(self)

  241. 

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

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

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

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

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

  247. 

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

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

  250. 

  251.         for MIDI_CC in MIDI_CC_LIST:

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

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

  254. 

  255.         # ---------------------------------------------------------------

  256.         # Connect actions to functions

  257. 

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

  259. 

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

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

  262. 

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

  264. 

  265.         self.ui.dial_x.valueChanged.connect(self.slot_updateSceneX)

  266.         self.ui.dial_y.valueChanged.connect(self.slot_updateSceneY)

  267. 

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

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

  270. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  289. 

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

  291. 

  292.         # ---------------------------------------------------------------

  293.         # Final stuff

  294. 

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

  296.         self.setWindowTitle(self.fUiName)

  297.         self.ready()

  298. 

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

  300. 

  301.     # -------------------------------------------------------------------

  302. 

  303.     @pyqtSlot(bool)

  304.     def slot_buttonClicked(self, click):

  305.         smooth = not click

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

  307. 

  308.     @pyqtSlot()

  309.     def slot_updateScreen(self):

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

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

  312. 

  313.         dial_x = self.ui.dial_x.value()

  314.         dial_y = self.ui.dial_y.value()

  315.         self.slot_updateSceneX(dial_x)

  316.         self.slot_updateSceneY(dial_y)

  317.         self.scene.setSmoothValues(float(dial_x) / 100, float(dial_y) / 100)

  318. 

  319.     @pyqtSlot(int)

  320.     def slot_noteOn(self, note):

  321.         pass

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

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

  324. 

  325.     @pyqtSlot(int)

  326.     def slot_noteOff(self, note):

  327.         pass

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

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

  330. 

  331.     @pyqtSlot(int)

  332.     def slot_updateSceneX(self, x):

  333.         self.scene.setSmoothValues(float(x) / 100, float(self.ui.dial_y.value()) / 100)

  334.         self.scene.setPosX(float(x) / 100, bool(self.sender()))

  335. 

  336.     @pyqtSlot(int)

  337.     def slot_updateSceneY(self, y):

  338.         self.scene.setSmoothValues(float(self.ui.dial_x.value()) / 100, float(y) / 100)

  339.         self.scene.setPosY(float(y) / 100, bool(self.sender()))

  340. 

  341.     @pyqtSlot(str)

  342.     def slot_checkCC_X(self, text):

  343.         if not text:

  344.             return

  345. 

  346.         #bool ok;

  347.         #int tmp_cc_x = text.split(" ").at(0).toInt(&ok, 16);

  348. 

  349.         #if (ok)

  350.         #{

  351.             #cc_x = tmp_cc_x;

  352.             #scene.setControlX(cc_x);

  353.         #}

  354. 

  355.     @pyqtSlot(str)

  356.     def slot_checkCC_Y(self, text):

  357.         if not text:

  358.             return

  359. 

  360.         #bool ok;

  361.         #int tmp_cc_y = text.split(" ").at(0).toInt(&ok, 16);

  362. 

  363.         #if (ok)

  364.         #{

  365.             #cc_y = tmp_cc_y;

  366.             #scene.setControlY(cc_y);

  367.         #}

  368. 

  369.     @pyqtSlot(bool)

  370.     def slot_checkChannel(self, clicked):

  371.         if not self.sender():

  372.             return

  373. 

  374.         #bool ok;

  375.         #int channel = ((QAction*)sender()).text().toInt(&ok);

  376. 

  377.         #if (ok)

  378.         #{

  379.             #if (clicked && ! m_channels.contains(channel))

  380.                 #m_channels.append(channel);

  381.             #else if ((! clicked) && m_channels.contains(channel))

  382.                 #m_channels.removeOne(channel);

  383.             #scene.setChannels(m_channels);

  384.         #}

  385. 

  386.     @pyqtSlot()

  387.     def slot_checkChannel_all(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  404. 

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

  406.         self.scene.setChannels(self.m_channels)

  407. 

  408.     @pyqtSlot()

  409.     def slot_checkChannel_none(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  426. 

  427.         self.m_channels = []

  428.         self.scene.setChannels(self.m_channels)

  429. 

  430.     @pyqtSlot(bool)

  431.     def slot_setSmooth(self, yesno):

  432.         self.scene.setSmooth(yesno)

  433. 

  434.     @pyqtSlot(float, float)

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

  436.         self.ui.dial_x.blockSignals(True)

  437.         self.ui.dial_y.blockSignals(True)

  438. 

  439.         self.ui.dial_x.setValue(xp * 100)

  440.         self.ui.dial_y.setValue(yp * 100)

  441. 

  442.         self.ui.dial_x.blockSignals(False)

  443.         self.ui.dial_y.blockSignals(False)

  444. 

  445.     @pyqtSlot(bool)

  446.     def slot_showKeyboard(self, yesno):

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

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

  449. 

  450.     # -------------------------------------------------------------------

  451.     # DSP Callbacks

  452. 

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

  454.         if index != 0:

  455.             return

  456. 

  457.         #nextCurPage = int(value)

  458. 

  459.         #if nextCurPage != self.fCurPage and nextCurPage >= 1 and nextCurPage <= 100:

  460.             #self.saveCurrentTextState()

  461.             #self.fCurPage = nextCurPage

  462. 

  463.             #self.fTextEdit.setPlainText(self.fNotes[self.fCurPage-1])

  464.             #self.fProgressBar.setValue(self.fCurPage)

  465.             #self.fProgressBar.update()

  466. 

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

  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.             # TODO

  489.             #self.fButton.setChecked(not readOnly)

  490. 

  491.     # -------------------------------------------------------------------

  492.     # ExternalUI Callbacks

  493. 

  494.     def uiShow(self):

  495.         self.show()

  496. 

  497.     def uiFocus(self):

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

  499.         self.show()

  500. 

  501.         self.raise_()

  502.         self.activateWindow()

  503. 

  504.     def uiHide(self):

  505.         self.hide()

  506. 

  507.     def uiQuit(self):

  508.         self.closeExternalUI()

  509.         self.close()

  510.         app.quit()

  511. 

  512.     def uiTitleChanged(self, uiTitle):

  513.         self.setWindowTitle(uiTitle)

  514. 

  515.     # -------------------------------------------------------------------

  516.     # Qt events

  517. 

  518.     def resizeEvent(self, event):

  519.         self.fSaveSizeNowChecker = 0

  520.         self.slot_updateScreen()

  521.         QMainWindow.resizeEvent(self, event)

  522. 

  523.     def timerEvent(self, event):

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

  525.             self.idleExternalUI()

  526.             self.scene.updateSmooth()

  527. 

  528.             if self.fSaveSizeNowChecker == 11:

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

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

  531.                 self.fSaveSizeNowChecker = -1

  532.             elif self.fSaveSizeNowChecker >= 0:

  533.                 self.fSaveSizeNowChecker += 1

  534. 

  535.         QMainWindow.timerEvent(self, event)

  536. 

  537.     def closeEvent(self, event):

  538.         self.closeExternalUI()

  539.         QMainWindow.closeEvent(self, event)

  540. 

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

  542.         app.quit()

  543. 

  544. #--------------- main ------------------

  545. if __name__ == '__main__':

  546.     import resources_rc

  547. 

  548.     pathBinaries, _ = getPaths()

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

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

  551. 

  552.     app = CarlaApplication("XYController")

  553.     gui = XYControllerUI()

  554.     app.exit_exec()