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.
79 Commits
2 Branches
161MB
Tree: 69eabc528b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '69eabc528b'
${ noResults }
Cadence/src/xycontroller.py

623 lines
22KB
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 (self.m_mouseLock == False):

  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 (self.m_mouseLock == False):

  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. 

  103.         if (param == self.cc_x):

  104.           sendUpdate = True

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

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

  107. 

  108.           if (xp < -1.0):

  109.             xp = -1.0

  110.           elif (xp > 1.0):

  111.             xp = 1.0

  112. 

  113.           self.setPosX(xp, False)

  114. 

  115.         if (param == self.cc_y):

  116.           sendUpdate = True

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

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

  119. 

  120.           if (yp < -1.0):

  121.             yp = -1.0

  122.           elif (yp > 1.0):

  123.             yp = 1.0

  124. 

  125.           self.setPosY(yp, False)

  126. 

  127.         if (sendUpdate):

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

  129. 

  130.     def handleMousePos(self, pos):

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

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

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

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

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

  136. 

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

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

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

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

  141. 

  142.         self.m_smooth_x = pos.x()

  143.         self.m_smooth_y = pos.y()

  144. 

  145.         if (self.m_smooth == False):

  146.           self.m_cursor.setPos(pos)

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

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

  149. 

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

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

  152. 

  153.           self.sendMIDI(xp, yp)

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

  155. 

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

  157.         global jack_midi_out_data

  158.         rate = float(0xff)/4

  159. 

  160.         if (xp != None):

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

  162.           for channel in self.m_channels:

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

  164. 

  165.         if (yp != None):

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

  167.           for channel in self.m_channels:

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

  169. 

  170.     def updateSize(self, size):

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

  172. 

  173.     def updateSmooth(self):

  174.         if (self.m_smooth):

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

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

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

  178.             pos = QPointF(new_x, new_y)

  179. 

  180.             self.m_cursor.setPos(pos)

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

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

  183. 

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

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

  186. 

  187.             self.sendMIDI(xp, yp)

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

  189. 

  190.     def keyPressEvent(self, event):

  191.         event.accept()

  192. 

  193.     def wheelEvent(self, event):

  194.         event.accept()

  195. 

  196.     def mousePressEvent(self, event):

  197.         self.m_mouseLock = True

  198.         self.handleMousePos(event.scenePos())

  199.         QGraphicsScene.mousePressEvent(self, event)

  200. 

  201.     def mouseMoveEvent(self, event):

  202.         self.handleMousePos(event.scenePos())

  203.         QGraphicsScene.mouseMoveEvent(self, event)

  204. 

  205.     def mouseReleaseEvent(self, event):

  206.         self.m_mouseLock = False

  207.         QGraphicsScene.mouseReleaseEvent(self, event)

  208. 

  209. # XY Controller Window

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

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

  212.         QMainWindow.__init__(self, parent)

  213.         self.setupUi(self)

  214. 

  215.         # -------------------------------------------------------------

  216.         # Internal stuff

  217. 

  218.         self.cc_x = 1

  219.         self.cc_y = 2

  220.         self.m_channels = []

  221. 

  222.         # -------------------------------------------------------------

  223.         # Set-up GUI stuff

  224. 

  225.         self.dial_x.setPixmap(2)

  226.         self.dial_y.setPixmap(2)

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

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

  229.         self.keyboard.setOctaves(6)

  230. 

  231.         self.scene = XYGraphicsScene(self)

  232.         self.graphicsView.setScene(self.scene)

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

  234. 

  235.         for MIDI_CC in MIDI_CC_LIST:

  236.           self.cb_control_x.addItem(MIDI_CC)

  237.           self.cb_control_y.addItem(MIDI_CC)

  238. 

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

  240.         # Load Settings

  241. 

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

  243.         self.loadSettings()

  244. 

  245.         # -------------------------------------------------------------

  246.         # Connect actions to functions

  247. 

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

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

  250. 

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

  252. 

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

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

  255. 

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

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

  258. 

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

  260. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  279. 

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

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

  282. 

  283.         # -------------------------------------------------------------

  284.         # Final stuff

  285. 

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

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

  288. 

  289.     def updateScreen(self):

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

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

  292. 

  293.         dial_x = self.dial_x.value()

  294.         dial_y = self.dial_y.value()

  295.         self.slot_updateSceneX(dial_x)

  296.         self.slot_updateSceneY(dial_y)

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

  298. 

  299.     @pyqtSlot(int)

  300.     def slot_noteOn(self, note):

  301.         global jack_midi_out_data

  302.         for channel in self.m_channels:

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

  304. 

  305.     @pyqtSlot(int)

  306.     def slot_noteOff(self, note):

  307.         global jack_midi_out_data

  308.         for channel in self.m_channels:

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

  310. 

  311.     @pyqtSlot(int)

  312.     def slot_updateSceneX(self, x):

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

  314. 

  315.     @pyqtSlot(int)

  316.     def slot_updateSceneY(self, y):

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

  318. 

  319.     @pyqtSlot(str)

  320.     def slot_checkCC_X(self, text):

  321.         if (text):

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

  323.           self.scene.setControlX(self.cc_x)

  324. 

  325.     @pyqtSlot(str)

  326.     def slot_checkCC_Y(self, text):

  327.         if (text):

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

  329.           self.scene.setControlY(self.cc_y)

  330. 

  331.     @pyqtSlot(bool)

  332.     def slot_checkChannel(self, clicked):

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

  334.         if (clicked and channel not in self.m_channels):

  335.           self.m_channels.append(channel)

  336.         elif (not clicked and channel in self.m_channels):

  337.           self.m_channels.remove(channel)

  338.         self.scene.setChannels(self.m_channels)

  339. 

  340.     @pyqtSlot()

  341.     def slot_checkChannel_all(self):

  342.         self.act_ch_01.setChecked(True)

  343.         self.act_ch_02.setChecked(True)

  344.         self.act_ch_03.setChecked(True)

  345.         self.act_ch_04.setChecked(True)

  346.         self.act_ch_05.setChecked(True)

  347.         self.act_ch_06.setChecked(True)

  348.         self.act_ch_07.setChecked(True)

  349.         self.act_ch_08.setChecked(True)

  350.         self.act_ch_09.setChecked(True)

  351.         self.act_ch_10.setChecked(True)

  352.         self.act_ch_11.setChecked(True)

  353.         self.act_ch_12.setChecked(True)

  354.         self.act_ch_13.setChecked(True)

  355.         self.act_ch_14.setChecked(True)

  356.         self.act_ch_15.setChecked(True)

  357.         self.act_ch_16.setChecked(True)

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

  359.         self.scene.setChannels(self.m_channels)

  360. 

  361.     @pyqtSlot()

  362.     def slot_checkChannel_none(self):

  363.         self.act_ch_01.setChecked(False)

  364.         self.act_ch_02.setChecked(False)

  365.         self.act_ch_03.setChecked(False)

  366.         self.act_ch_04.setChecked(False)

  367.         self.act_ch_05.setChecked(False)

  368.         self.act_ch_06.setChecked(False)

  369.         self.act_ch_07.setChecked(False)

  370.         self.act_ch_08.setChecked(False)

  371.         self.act_ch_09.setChecked(False)

  372.         self.act_ch_10.setChecked(False)

  373.         self.act_ch_11.setChecked(False)

  374.         self.act_ch_12.setChecked(False)

  375.         self.act_ch_13.setChecked(False)

  376.         self.act_ch_14.setChecked(False)

  377.         self.act_ch_15.setChecked(False)

  378.         self.act_ch_16.setChecked(False)

  379.         self.m_channels = []

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

  381. 

  382.     @pyqtSlot(bool)

  383.     def slot_setSmooth(self, yesno):

  384.         self.scene.setSmooth(yesno)

  385. 

  386.     @pyqtSlot(float, float)

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

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

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

  390. 

  391.     @pyqtSlot(bool)

  392.     def slot_showKeyboard(self, yesno):

  393.         self.scrollArea.setVisible(yesno)

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

  395. 

  396.     @pyqtSlot()

  397.     def slot_about(self):

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

  399.             "<br>Version %s"

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

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

  402. 

  403.     @pyqtSlot()

  404.     def slot_updateScreen(self):

  405.         self.updateScreen()

  406. 

  407.     def saveSettings(self):

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

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

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

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

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

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

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

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

  416. 

  417.     def loadSettings(self):

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

  419. 

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

  421.         self.act_show_keyboard.setChecked(showKeyboard)

  422.         self.scrollArea.setVisible(showKeyboard)

  423. 

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

  425.         self.cb_smooth.setChecked(smooth)

  426.         self.scene.setSmooth(smooth)

  427. 

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

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

  430. 

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

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

  433.         self.scene.setControlX(self.cc_x)

  434.         self.scene.setControlY(self.cc_y)

  435. 

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

  437. 

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

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

  440. 

  441.         self.scene.setChannels(self.m_channels)

  442. 

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

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

  445.           if (self.cc_x == cc):

  446.             self.cb_control_x.setCurrentIndex(i)

  447.           if (self.cc_y == cc):

  448.             self.cb_control_y.setCurrentIndex(i)

  449. 

  450.         if (1 in self.m_channels):

  451.           self.act_ch_01.setChecked(True)

  452.         if (2 in self.m_channels):

  453.           self.act_ch_02.setChecked(True)

  454.         if (3 in self.m_channels):

  455.           self.act_ch_03.setChecked(True)

  456.         if (4 in self.m_channels):

  457.           self.act_ch_04.setChecked(True)

  458.         if (5 in self.m_channels):

  459.           self.act_ch_05.setChecked(True)

  460.         if (6 in self.m_channels):

  461.           self.act_ch_06.setChecked(True)

  462.         if (7 in self.m_channels):

  463.           self.act_ch_07.setChecked(True)

  464.         if (8 in self.m_channels):

  465.           self.act_ch_08.setChecked(True)

  466.         if (9 in self.m_channels):

  467.           self.act_ch_09.setChecked(True)

  468.         if (10 in self.m_channels):

  469.           self.act_ch_10.setChecked(True)

  470.         if (11 in self.m_channels):

  471.           self.act_ch_11.setChecked(True)

  472.         if (12 in self.m_channels):

  473.           self.act_ch_12.setChecked(True)

  474.         if (13 in self.m_channels):

  475.           self.act_ch_13.setChecked(True)

  476.         if (14 in self.m_channels):

  477.           self.act_ch_14.setChecked(True)

  478.         if (15 in self.m_channels):

  479.           self.act_ch_15.setChecked(True)

  480.         if (16 in self.m_channels):

  481.           self.act_ch_16.setChecked(True)

  482. 

  483.     def timerEvent(self, event):

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

  485.           global jack_midi_in_data

  486.           if (jack_midi_in_data.empty() == False):

  487.             while (True):

  488.               try:

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

  490.               except QuequeEmpty:

  491.                 break

  492. 

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

  494.               mode    =  data1 & 0xF0

  495. 

  496.               if (channel in self.m_channels):

  497.                 if (mode == 0x80):

  498.                   self.keyboard.noteOff(data2, False)

  499.                 elif (mode == 0x90):

  500.                   self.keyboard.noteOn(data2, False)

  501.                 elif (mode == 0xB0):

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

  503. 

  504.               jack_midi_in_data.task_done()

  505. 

  506.           self.scene.updateSmooth()

  507. 

  508.         QMainWindow.timerEvent(self, event)

  509. 

  510.     def resizeEvent(self, event):

  511.         self.updateScreen()

  512.         QMainWindow.resizeEvent(self, event)

  513. 

  514.     def closeEvent(self, event):

  515.         self.saveSettings()

  516.         QMainWindow.closeEvent(self, event)

  517. 

  518. # -------------------------------------------------------------

  519. # JACK Stuff

  520. 

  521. static_event = jacklib.jack_midi_event_t()

  522. static_mtype = jacklib.c_ubyte*3

  523. 

  524. def jack_process_callback(nframes, arg):

  525.     global jack_midi_in_port, jack_midi_out_port, jack_midi_in_data, jack_midi_out_data

  526. 

  527.     # MIDI In

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

  529. 

  530.     if (midi_in_buffer):

  531.       event_count = jacklib.midi_get_event_count(midi_in_buffer)

  532. 

  533.       for i in range(event_count):

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

  535.           if (static_event.size == 1):

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

  537.           elif (static_event.size == 2):

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

  539.           elif (static_event.size >= 3):

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

  541. 

  542.           if (jack_midi_in_data.full()):

  543.             break

  544. 

  545.     # MIDI Out

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

  547. 

  548.     if (midi_out_buffer):

  549.       jacklib.midi_clear_buffer(midi_out_buffer)

  550. 

  551.       if (jack_midi_out_data.empty() == False):

  552.         while (True):

  553.           try:

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

  555.           except QuequeEmpty:

  556.             break

  557. 

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

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

  560. 

  561.           jack_midi_out_data.task_done()

  562. 

  563.     return 0

  564. 

  565. def jack_session_callback(event, arg):

  566.   if (WINDOWS):

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

  568.   else:

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

  570.       filepath = "jack_xycontroller"

  571.     else:

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

  573. 

  574.   event.command_line = str(filepath).encode("ascii")

  575.   jacklib.session_reply(jack_client, event)

  576. 

  577.   if (event.type == jacklib.JackSessionSaveAndQuit):

  578.     app.quit()

  579. 

  580.   #jacklib.session_event_free(event)

  581. 

  582. #--------------- main ------------------

  583. if __name__ == '__main__':

  584. 

  585.     # App initialization

  586.     app = QApplication(sys.argv)

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

  588.     app.setApplicationVersion(VERSION)

  589.     app.setOrganizationName("falkTX")

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

  591. 

  592.     # Start jack

  593.     jack_status = jacklib.jack_status_t(0)

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

  595. 

  596.     if not jack_client:

  597.       QMessageBox.critical(None, app.translate("XYControllerW", "Error"), app.translate("XYControllerW", "Could not connect to JACK, possible errors:\n%s" % (get_jack_status_error_string(jack_status))))

  598.       sys.exit(1)

  599. 

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

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

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

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

  604.     jacklib.activate(jack_client)

  605. 

  606.     # Show GUI

  607.     gui = XYControllerW()

  608.     gui.show()

  609. 

  610.     # Set-up custom signal handling

  611.     set_up_signals(gui)

  612. 

  613.     # App-Loop

  614.     ret = app.exec_()

  615. 

  616.     # Close Jack

  617.     if (jack_client):

  618.       jacklib.deactivate(jack_client)

  619.       jacklib.client_close(jack_client)

  620. 

  621.     # Exit properly

  622.     sys.exit(ret)