falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
276 Commits
2 Branches
20MB
Tree: a7618a0534
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a7618a0534'
${ noResults }
Cadence/src/xycontroller.py

637 lines
23KB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. 

  4. # XY Controller for JACK, using jacklib

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

  6. #

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

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

  9. # the Free Software Foundation; either version 2 of the License, or

  10. # 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 COPYING file

  18. 

  19. # Imports (Global)

  20. from PyQt4.QtCore import pyqtSlot, Qt, QPointF, QRectF, QSettings, QTimer, QVariant

  21. from PyQt4.QtGui import QApplication, QColor, QIcon, QPainter, QPen, QGraphicsItem, QGraphicsScene, QMainWindow

  22. from queue import Queue, Empty as QuequeEmpty

  23. 

  24. # Imports (Custom)

  25. import ui_xycontroller

  26. from shared import *

  27. from jacklib_helpers import *

  28. 

  29. # Globals

  30. global jack_client, jack_midi_in_port, jack_midi_out_port, jack_midi_in_data, jack_midi_out_data

  31. jack_client = None

  32. jack_midi_in_port  = None

  33. jack_midi_out_port = None

  34. jack_midi_in_data  = Queue(512)

  35. jack_midi_out_data = Queue(512)

  36. 

  37. # XY Controller Scene

  38. class XYGraphicsScene(QGraphicsScene):

  39.     def __init__(self, parent):

  40.         QGraphicsScene.__init__(self, parent)

  41. 

  42.         self.cc_x = 1

  43.         self.cc_y = 2

  44.         self.m_channels = []

  45.         self.m_mouseLock = False

  46.         self.m_smooth = False

  47.         self.m_smooth_x = 0

  48.         self.m_smooth_y = 0

  49. 

  50.         self.setBackgroundBrush(Qt.black)

  51. 

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

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

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

  55. 

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

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

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

  59. 

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

  61. 

  62.     def setControlX(self, x):

  63.         self.cc_x = x

  64. 

  65.     def setControlY(self, y):

  66.         self.cc_y = y

  67. 

  68.     def setChannels(self, channels):

  69.         self.m_channels = channels

  70. 

  71.     def setPosX(self, x, forward=True):

  72.         if not self.m_mouseLock:

  73.             pos_x = x * (self.p_size.x() + self.p_size.width())

  74.             self.m_cursor.setPos(pos_x, self.m_cursor.y())

  75.             self.m_lineV.setX(pos_x)

  76. 

  77.             if forward:

  78.                 self.sendMIDI(pos_x / (self.p_size.x() + self.p_size.width()), None)

  79.             else:

  80.                 self.m_smooth_x = pos_x

  81. 

  82.     def setPosY(self, y, forward=True):

  83.         if not self.m_mouseLock:

  84.             pos_y = y * (self.p_size.y() + self.p_size.height())

  85.             self.m_cursor.setPos(self.m_cursor.x(), pos_y)

  86.             self.m_lineH.setY(pos_y)

  87. 

  88.             if forward:

  89.                 self.sendMIDI(None, pos_y / (self.p_size.y() + self.p_size.height()))

  90.             else:

  91.                 self.m_smooth_y = pos_y

  92. 

  93.     def setSmooth(self, smooth):

  94.         self.m_smooth = smooth

  95. 

  96.     def setSmoothValues(self, x, y):

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

  98.         self.m_smooth_y = y * (self.p_size.y() + self.p_size.height())

  99. 

  100.     def handleCC(self, param, value):

  101.         sendUpdate = False

  102.         xp = yp = 0.0

  103. 

  104.         if param == self.cc_x:

  105.             sendUpdate = True

  106.             xp = (float(value) / 63) - 1.0

  107.             yp = self.m_cursor.y() / (self.p_size.y() + self.p_size.height())

  108. 

  109.             if xp < -1.0:

  110.                 xp = -1.0

  111.             elif xp > 1.0:

  112.                 xp = 1.0

  113. 

  114.             self.setPosX(xp, False)

  115. 

  116.         if param == self.cc_y:

  117.             sendUpdate = True

  118.             xp = self.m_cursor.x() / (self.p_size.x() + self.p_size.width())

  119.             yp = (float(value) / 63) - 1.0

  120. 

  121.             if yp < -1.0:

  122.                 yp = -1.0

  123.             elif yp > 1.0:

  124.                 yp = 1.0

  125. 

  126.             self.setPosY(yp, False)

  127. 

  128.         if sendUpdate:

  129.             self.emit(SIGNAL("cursorMoved(double, double)"), xp, yp)

  130. 

  131.     def handleMousePos(self, pos):

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

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

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

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

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

  137. 

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

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

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

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

  142. 

  143.         self.m_smooth_x = pos.x()

  144.         self.m_smooth_y = pos.y()

  145. 

  146.         if not self.m_smooth:

  147.             self.m_cursor.setPos(pos)

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

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

  150. 

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

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

  153. 

  154.             self.sendMIDI(xp, yp)

  155.             self.emit(SIGNAL("cursorMoved(double, double)"), xp, yp)

  156. 

  157.     def sendMIDI(self, xp=None, yp=None):

  158.         global jack_midi_out_data

  159.         rate = float(0xff) / 4

  160. 

  161.         if xp != None:

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

  163.             for channel in self.m_channels:

  164.                 jack_midi_out_data.put_nowait((0xB0 + channel - 1, self.cc_x, value))

  165. 

  166.         if yp != None:

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

  168.             for channel in self.m_channels:

  169.                 jack_midi_out_data.put_nowait((0xB0 + channel - 1, self.cc_y, value))

  170. 

  171.     def updateSize(self, size):

  172.         self.p_size.setRect(-(size.width() / 2), -(size.height() / 2), size.width(), size.height())

  173. 

  174.     def updateSmooth(self):

  175.         if self.m_smooth:

  176.             if self.m_cursor.x() != self.m_smooth_x or self.m_cursor.y() != self.m_smooth_y:

  177.                 if abs(self.m_cursor.x() - self.m_smooth_x) <= 0.001:

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

  179.                     return

  180.                 elif abs(self.m_cursor.y() - self.m_smooth_y) <= 0.001:

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

  182.                     return

  183. 

  184.                 new_x = (self.m_smooth_x + self.m_cursor.x() * 3) / 4

  185.                 new_y = (self.m_smooth_y + self.m_cursor.y() * 3) / 4

  186.                 pos = QPointF(new_x, new_y)

  187. 

  188.                 self.m_cursor.setPos(pos)

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

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

  191. 

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

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

  194. 

  195.                 self.sendMIDI(xp, yp)

  196.                 self.emit(SIGNAL("cursorMoved(double, double)"), xp, yp)

  197. 

  198.     def keyPressEvent(self, event):

  199.         event.accept()

  200. 

  201.     def wheelEvent(self, event):

  202.         event.accept()

  203. 

  204.     def mousePressEvent(self, event):

  205.         self.m_mouseLock = True

  206.         self.handleMousePos(event.scenePos())

  207.         QGraphicsScene.mousePressEvent(self, event)

  208. 

  209.     def mouseMoveEvent(self, event):

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

  211.         QGraphicsScene.mouseMoveEvent(self, event)

  212. 

  213.     def mouseReleaseEvent(self, event):

  214.         self.m_mouseLock = False

  215.         QGraphicsScene.mouseReleaseEvent(self, event)

  216. 

  217. # XY Controller Window

  218. class XYControllerW(QMainWindow, ui_xycontroller.Ui_XYControllerW):

  219.     def __init__(self, parent=None):

  220.         QMainWindow.__init__(self, parent)

  221.         self.setupUi(self)

  222. 

  223.         # -------------------------------------------------------------

  224.         # Internal stuff

  225. 

  226.         self.cc_x = 1

  227.         self.cc_y = 2

  228.         self.m_channels = []

  229. 

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

  231.         # Set-up GUI stuff

  232. 

  233.         self.dial_x.setPixmap(2)

  234.         self.dial_y.setPixmap(2)

  235.         self.dial_x.setLabel("X")

  236.         self.dial_y.setLabel("Y")

  237.         self.keyboard.setOctaves(6)

  238. 

  239.         self.scene = XYGraphicsScene(self)

  240.         self.graphicsView.setScene(self.scene)

  241.         self.graphicsView.setRenderHints(QPainter.Antialiasing)

  242. 

  243.         for MIDI_CC in MIDI_CC_LIST:

  244.             self.cb_control_x.addItem(MIDI_CC)

  245.             self.cb_control_y.addItem(MIDI_CC)

  246. 

  247.         # -------------------------------------------------------------

  248.         # Load Settings

  249. 

  250.         self.settings = QSettings("Cadence", "XY-Controller")

  251.         self.loadSettings()

  252. 

  253.         # -------------------------------------------------------------

  254.         # Connect actions to functions

  255. 

  256.         self.connect(self.keyboard, SIGNAL("noteOn(int)"), SLOT("slot_noteOn(int)"))

  257.         self.connect(self.keyboard, SIGNAL("noteOff(int)"), SLOT("slot_noteOff(int)"))

  258. 

  259.         self.connect(self.cb_smooth, SIGNAL("clicked(bool)"), SLOT("slot_setSmooth(bool)"))

  260. 

  261.         self.connect(self.dial_x, SIGNAL("valueChanged(int)"), SLOT("slot_updateSceneX(int)"))

  262.         self.connect(self.dial_y, SIGNAL("valueChanged(int)"), SLOT("slot_updateSceneY(int)"))

  263. 

  264.         self.connect(self.cb_control_x, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_checkCC_X(QString)"))

  265.         self.connect(self.cb_control_y, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_checkCC_Y(QString)"))

  266. 

  267.         self.connect(self.scene, SIGNAL("cursorMoved(double, double)"), SLOT("slot_sceneCursorMoved(double, double)"))

  268. 

  269.         self.connect(self.act_ch_01, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  270.         self.connect(self.act_ch_02, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  271.         self.connect(self.act_ch_03, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  272.         self.connect(self.act_ch_04, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  273.         self.connect(self.act_ch_05, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  274.         self.connect(self.act_ch_06, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  275.         self.connect(self.act_ch_07, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  276.         self.connect(self.act_ch_08, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  277.         self.connect(self.act_ch_09, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  278.         self.connect(self.act_ch_10, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  279.         self.connect(self.act_ch_11, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  280.         self.connect(self.act_ch_12, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  281.         self.connect(self.act_ch_13, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  282.         self.connect(self.act_ch_14, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  283.         self.connect(self.act_ch_15, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  284.         self.connect(self.act_ch_16, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  285.         self.connect(self.act_ch_all, SIGNAL("triggered()"), SLOT("slot_checkChannel_all()"))

  286.         self.connect(self.act_ch_none, SIGNAL("triggered()"), SLOT("slot_checkChannel_none()"))

  287. 

  288.         self.connect(self.act_show_keyboard, SIGNAL("triggered(bool)"), SLOT("slot_showKeyboard(bool)"))

  289.         self.connect(self.act_about, SIGNAL("triggered()"), SLOT("slot_about()"))

  290. 

  291.         # -------------------------------------------------------------

  292.         # Final stuff

  293. 

  294.         self.m_midiInTimerId = self.startTimer(50)

  295.         QTimer.singleShot(0, self, SLOT("slot_updateScreen()"))

  296. 

  297.     def updateScreen(self):

  298.         self.scene.updateSize(self.graphicsView.size())

  299.         self.graphicsView.centerOn(0, 0)

  300. 

  301.         dial_x = self.dial_x.value()

  302.         dial_y = self.dial_y.value()

  303.         self.slot_updateSceneX(dial_x)

  304.         self.slot_updateSceneY(dial_y)

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

  306. 

  307.     @pyqtSlot(int)

  308.     def slot_noteOn(self, note):

  309.         global jack_midi_out_data

  310.         for channel in self.m_channels:

  311.             jack_midi_out_data.put_nowait((0x90 + channel - 1, note, 100))

  312. 

  313.     @pyqtSlot(int)

  314.     def slot_noteOff(self, note):

  315.         global jack_midi_out_data

  316.         for channel in self.m_channels:

  317.             jack_midi_out_data.put_nowait((0x80 + channel - 1, note, 0))

  318. 

  319.     @pyqtSlot(int)

  320.     def slot_updateSceneX(self, x):

  321.         self.scene.setPosX(float(x) / 100, not self.dial_x.isSliderDown())

  322. 

  323.     @pyqtSlot(int)

  324.     def slot_updateSceneY(self, y):

  325.         self.scene.setPosY(float(y) / 100, not self.dial_y.isSliderDown())

  326. 

  327.     @pyqtSlot(str)

  328.     def slot_checkCC_X(self, text):

  329.         if text:

  330.             self.cc_x = int(text.split(" ")[0], 16)

  331.             self.scene.setControlX(self.cc_x)

  332. 

  333.     @pyqtSlot(str)

  334.     def slot_checkCC_Y(self, text):

  335.         if text:

  336.             self.cc_y = int(text.split(" ")[0], 16)

  337.             self.scene.setControlY(self.cc_y)

  338. 

  339.     @pyqtSlot(bool)

  340.     def slot_checkChannel(self, clicked):

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

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

  343.             self.m_channels.append(channel)

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

  345.             self.m_channels.remove(channel)

  346.         self.scene.setChannels(self.m_channels)

  347. 

  348.     @pyqtSlot()

  349.     def slot_checkChannel_all(self):

  350.         self.act_ch_01.setChecked(True)

  351.         self.act_ch_02.setChecked(True)

  352.         self.act_ch_03.setChecked(True)

  353.         self.act_ch_04.setChecked(True)

  354.         self.act_ch_05.setChecked(True)

  355.         self.act_ch_06.setChecked(True)

  356.         self.act_ch_07.setChecked(True)

  357.         self.act_ch_08.setChecked(True)

  358.         self.act_ch_09.setChecked(True)

  359.         self.act_ch_10.setChecked(True)

  360.         self.act_ch_11.setChecked(True)

  361.         self.act_ch_12.setChecked(True)

  362.         self.act_ch_13.setChecked(True)

  363.         self.act_ch_14.setChecked(True)

  364.         self.act_ch_15.setChecked(True)

  365.         self.act_ch_16.setChecked(True)

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

  367.         self.scene.setChannels(self.m_channels)

  368. 

  369.     @pyqtSlot()

  370.     def slot_checkChannel_none(self):

  371.         self.act_ch_01.setChecked(False)

  372.         self.act_ch_02.setChecked(False)

  373.         self.act_ch_03.setChecked(False)

  374.         self.act_ch_04.setChecked(False)

  375.         self.act_ch_05.setChecked(False)

  376.         self.act_ch_06.setChecked(False)

  377.         self.act_ch_07.setChecked(False)

  378.         self.act_ch_08.setChecked(False)

  379.         self.act_ch_09.setChecked(False)

  380.         self.act_ch_10.setChecked(False)

  381.         self.act_ch_11.setChecked(False)

  382.         self.act_ch_12.setChecked(False)

  383.         self.act_ch_13.setChecked(False)

  384.         self.act_ch_14.setChecked(False)

  385.         self.act_ch_15.setChecked(False)

  386.         self.act_ch_16.setChecked(False)

  387.         self.m_channels = []

  388.         self.scene.setChannels(self.m_channels)

  389. 

  390.     @pyqtSlot(bool)

  391.     def slot_setSmooth(self, yesno):

  392.         self.scene.setSmooth(yesno)

  393. 

  394.     @pyqtSlot(float, float)

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

  396.         self.dial_x.blockSignals(True)

  397.         self.dial_y.blockSignals(True)

  398. 

  399.         self.dial_x.setValue(xp * 100)

  400.         self.dial_y.setValue(yp * 100)

  401. 

  402.         self.dial_x.blockSignals(False)

  403.         self.dial_y.blockSignals(False)

  404. 

  405.     @pyqtSlot(bool)

  406.     def slot_showKeyboard(self, yesno):

  407.         self.scrollArea.setVisible(yesno)

  408.         QTimer.singleShot(0, self, SLOT("slot_updateScreen()"))

  409. 

  410.     @pyqtSlot()

  411.     def slot_about(self):

  412.         QMessageBox.about(self, self.tr("About XY Controller"), self.tr("<h3>XY Controller</h3>"

  413.                                                                         "<br>Version %s"

  414.                                                                         "<br>XY Controller is a simple XY widget that sends and receives data from Jack MIDI.<br>"

  415.                                                                         "<br>Copyright (C) 2012 falkTX" % VERSION))

  416. 

  417.     @pyqtSlot()

  418.     def slot_updateScreen(self):

  419.         self.updateScreen()

  420. 

  421.     def saveSettings(self):

  422.         self.settings.setValue("Geometry", self.saveGeometry())

  423.         self.settings.setValue("ShowKeyboard", self.scrollArea.isVisible())

  424.         self.settings.setValue("Smooth", self.cb_smooth.isChecked())

  425.         self.settings.setValue("DialX", self.dial_x.value())

  426.         self.settings.setValue("DialY", self.dial_y.value())

  427.         self.settings.setValue("ControlX", self.cc_x)

  428.         self.settings.setValue("ControlY", self.cc_y)

  429.         self.settings.setValue("Channels", self.m_channels)

  430. 

  431.     def loadSettings(self):

  432.         self.restoreGeometry(self.settings.value("Geometry", ""))

  433. 

  434.         showKeyboard = self.settings.value("ShowKeyboard", False, type=bool)

  435.         self.act_show_keyboard.setChecked(showKeyboard)

  436.         self.scrollArea.setVisible(showKeyboard)

  437. 

  438.         smooth = self.settings.value("Smooth", False, type=bool)

  439.         self.cb_smooth.setChecked(smooth)

  440.         self.scene.setSmooth(smooth)

  441. 

  442.         self.dial_x.setValue(self.settings.value("DialX", 50, type=int))

  443.         self.dial_y.setValue(self.settings.value("DialY", 50, type=int))

  444. 

  445.         self.cc_x = self.settings.value("ControlX", 1, type=int)

  446.         self.cc_y = self.settings.value("ControlY", 2, type=int)

  447.         self.scene.setControlX(self.cc_x)

  448.         self.scene.setControlY(self.cc_y)

  449. 

  450.         self.m_channels = toList(self.settings.value("Channels", [1]))

  451. 

  452.         for i in range(len(self.m_channels)):

  453.             self.m_channels[i] = int(self.m_channels[i])

  454. 

  455.         self.scene.setChannels(self.m_channels)

  456. 

  457.         for i in range(len(MIDI_CC_LIST)):

  458.             cc = int(MIDI_CC_LIST[i].split(" ")[0], 16)

  459.             if self.cc_x == cc:

  460.                 self.cb_control_x.setCurrentIndex(i)

  461.             if self.cc_y == cc:

  462.                 self.cb_control_y.setCurrentIndex(i)

  463. 

  464.         if 1 in self.m_channels:

  465.             self.act_ch_01.setChecked(True)

  466.         if 2 in self.m_channels:

  467.             self.act_ch_02.setChecked(True)

  468.         if 3 in self.m_channels:

  469.             self.act_ch_03.setChecked(True)

  470.         if 4 in self.m_channels:

  471.             self.act_ch_04.setChecked(True)

  472.         if 5 in self.m_channels:

  473.             self.act_ch_05.setChecked(True)

  474.         if 6 in self.m_channels:

  475.             self.act_ch_06.setChecked(True)

  476.         if 7 in self.m_channels:

  477.             self.act_ch_07.setChecked(True)

  478.         if 8 in self.m_channels:

  479.             self.act_ch_08.setChecked(True)

  480.         if 9 in self.m_channels:

  481.             self.act_ch_09.setChecked(True)

  482.         if 10 in self.m_channels:

  483.             self.act_ch_10.setChecked(True)

  484.         if 11 in self.m_channels:

  485.             self.act_ch_11.setChecked(True)

  486.         if 12 in self.m_channels:

  487.             self.act_ch_12.setChecked(True)

  488.         if 13 in self.m_channels:

  489.             self.act_ch_13.setChecked(True)

  490.         if 14 in self.m_channels:

  491.             self.act_ch_14.setChecked(True)

  492.         if 15 in self.m_channels:

  493.             self.act_ch_15.setChecked(True)

  494.         if 16 in self.m_channels:

  495.             self.act_ch_16.setChecked(True)

  496. 

  497.     def timerEvent(self, event):

  498.         if event.timerId() == self.m_midiInTimerId:

  499.             global jack_midi_in_data

  500.             if not jack_midi_in_data.empty():

  501.                 while True:

  502.                     try:

  503.                         data1, data2, data3 = jack_midi_in_data.get_nowait()

  504.                     except QuequeEmpty:

  505.                         break

  506. 

  507.                     channel = (data1 & 0x0F) + 1

  508.                     mode    = data1 & 0xF0

  509. 

  510.                     if channel in self.m_channels:

  511.                         if mode == 0x80:

  512.                             self.keyboard.sendNoteOff(data2, False)

  513.                         elif mode == 0x90:

  514.                             self.keyboard.sendNoteOn(data2, False)

  515.                         elif mode == 0xB0:

  516.                             self.scene.handleCC(data2, data3)

  517. 

  518.                     jack_midi_in_data.task_done()

  519. 

  520.             self.scene.updateSmooth()

  521. 

  522.         QMainWindow.timerEvent(self, event)

  523. 

  524.     def resizeEvent(self, event):

  525.         self.updateScreen()

  526.         QMainWindow.resizeEvent(self, event)

  527. 

  528.     def closeEvent(self, event):

  529.         self.saveSettings()

  530.         QMainWindow.closeEvent(self, event)

  531. 

  532. # -------------------------------------------------------------

  533. # JACK Stuff

  534. 

  535. static_event = jacklib.jack_midi_event_t()

  536. static_mtype = jacklib.c_ubyte * 3

  537. 

  538. def jack_process_callback(nframes, arg):

  539.     global jack_midi_in_port, jack_midi_out_port, jack_midi_in_data, jack_midi_out_data

  540. 

  541.     # MIDI In

  542.     midi_in_buffer = jacklib.port_get_buffer(jack_midi_in_port, nframes)

  543. 

  544.     if midi_in_buffer:

  545.         event_count = jacklib.midi_get_event_count(midi_in_buffer)

  546. 

  547.         for i in range(event_count):

  548.             if jacklib.midi_event_get(jacklib.pointer(static_event), midi_in_buffer, i) == 0:

  549.                 if static_event.size == 1:

  550.                     jack_midi_in_data.put_nowait((static_event.buffer[0], 0, 0))

  551.                 elif static_event.size == 2:

  552.                     jack_midi_in_data.put_nowait((static_event.buffer[0], static_event.buffer[1], 0))

  553.                 elif static_event.size >= 3:

  554.                     jack_midi_in_data.put_nowait((static_event.buffer[0], static_event.buffer[1], static_event.buffer[2]))

  555. 

  556.                 if jack_midi_in_data.full():

  557.                     break

  558. 

  559.     # MIDI Out

  560.     midi_out_buffer = jacklib.port_get_buffer(jack_midi_out_port, nframes)

  561. 

  562.     if midi_out_buffer:

  563.         jacklib.midi_clear_buffer(midi_out_buffer)

  564. 

  565.         if not jack_midi_out_data.empty():

  566.             while True:

  567.                 try:

  568.                     mode, note, velo = jack_midi_out_data.get_nowait()

  569.                 except QuequeEmpty:

  570.                     break

  571. 

  572.                 data = static_mtype(mode, note, velo)

  573.                 jacklib.midi_event_write(midi_out_buffer, 0, data, 3)

  574. 

  575.                 jack_midi_out_data.task_done()

  576. 

  577.     return 0

  578. 

  579. def jack_session_callback(event, arg):

  580.     if WINDOWS:

  581.         filepath = os.path.join(sys.argv[0])

  582.     else:

  583.         if sys.argv[0].startswith("/"):

  584.             filepath = "jack_xycontroller"

  585.         else:

  586.             filepath = os.path.join(sys.path[0], "xycontroller.py")

  587. 

  588.     event.command_line = str(filepath).encode("utf-8")

  589.     jacklib.session_reply(jack_client, event)

  590. 

  591.     if event.type == jacklib.JackSessionSaveAndQuit:

  592.         app.quit()

  593. 

  594.     #jacklib.session_event_free(event)

  595. 

  596. #--------------- main ------------------

  597. if __name__ == '__main__':

  598.     # App initialization

  599.     app = QApplication(sys.argv)

  600.     app.setApplicationName("XY-Controller")

  601.     app.setApplicationVersion(VERSION)

  602.     app.setOrganizationName("falkTX")

  603.     #app.setWindowIcon(QIcon(":/48x48/xy-controller.png"))

  604. 

  605.     # Start jack

  606.     jack_status = jacklib.jack_status_t(0)

  607.     jack_client = jacklib.client_open("XY-Controller", jacklib.JackSessionID, jacklib.pointer(jack_status))

  608. 

  609.     if not jack_client:

  610.         QMessageBox.critical(None, app.translate("XYControllerW", "Error"), app.translate("XYControllerW",

  611.             "Could not connect to JACK, possible errors:\n%s" % (get_jack_status_error_string(jack_status))))

  612.         sys.exit(1)

  613. 

  614.     jack_midi_in_port = jacklib.port_register(jack_client, "midi_in", jacklib.JACK_DEFAULT_MIDI_TYPE, jacklib.JackPortIsInput, 0)

  615.     jack_midi_out_port = jacklib.port_register(jack_client, "midi_out", jacklib.JACK_DEFAULT_MIDI_TYPE, jacklib.JackPortIsOutput, 0)

  616.     jacklib.set_session_callback(jack_client, jack_session_callback, None)

  617.     jacklib.set_process_callback(jack_client, jack_process_callback, None)

  618.     jacklib.activate(jack_client)

  619. 

  620.     # Show GUI

  621.     gui = XYControllerW()

  622.     gui.show()

  623. 

  624.     # Set-up custom signal handling

  625.     set_up_signals(gui)

  626. 

  627.     # App-Loop

  628.     ret = app.exec_()

  629. 

  630.     # Close Jack

  631.     if jack_client:

  632.         jacklib.deactivate(jack_client)

  633.         jacklib.client_close(jack_client)

  634. 

  635.     # Exit properly

  636.     sys.exit(ret)