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

336 lines
12KB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. 

  4. # A piano roll viewer/editor

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

  6. # Copyright (C) 2014-2015 Perry Nguyen

  7. #

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

  9. # modify it under the terms of the GNU General Public License as

  10. # published by the Free Software Foundation; either version 2 of

  11. # the License, or any later version.

  12. #

  13. # This program is distributed in the hope that it will be useful,

  14. # but WITHOUT ANY WARRANTY; without even the implied warranty of

  15. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  16. # GNU General Public License for more details.

  17. #

  18. # For a full copy of the GNU General Public License see the doc/GPL.txt file.

  19. 

  20. # ------------------------------------------------------------------------------------------------------------

  21. # Imports (Global)

  22. 

  23. from PyQt5.QtCore import pyqtSlot, Qt, QEvent

  24. from PyQt5.QtGui import QKeyEvent

  25. from PyQt5.QtWidgets import QMainWindow

  26. 

  27. # ------------------------------------------------------------------------------------------------------------

  28. # Imports (Custom)

  29. 

  30. from carla_shared import *

  31. from carla_utils import *

  32. from widgets.pianoroll import *

  33. 

  34. import ui_midipattern

  35. 

  36. # ------------------------------------------------------------------------------------------------------------

  37. # Imports (ExternalUI)

  38. 

  39. from carla_app import CarlaApplication

  40. from externalui import ExternalUI

  41. 

  42. # ------------------------------------------------------------------------------------------------------------

  43. 

  44. class MidiPatternW(ExternalUI, QMainWindow):

  45.     TICKS_PER_BEAT = 48

  46. 

  47.     def __init__(self):

  48.         ExternalUI.__init__(self)

  49.         QMainWindow.__init__(self)

  50.         self.ui = ui_midipattern.Ui_MidiPatternW()

  51.         self.ui.setupUi(self)

  52.         self.ui.piano = self.ui.graphicsView.piano

  53. 

  54.         # to be filled with note-on events, while waiting for their matching note-off

  55.         self.fPendingNoteOns = [] # (channel, note, velocity, time)

  56. 

  57.         self.fTimeSignature = (4,4)

  58.         self.fTransportInfo = {

  59.             "playing": False,

  60.             "frame": 0,

  61.             "bar": 0,

  62.             "beat": 0,

  63.             "tick": 0,

  64.             "bpm": 120.0,

  65.         }

  66. 

  67.         self.ui.act_edit_insert.triggered.connect(self.slot_editInsertMode)

  68.         self.ui.act_edit_velocity.triggered.connect(self.slot_editVelocityMode)

  69.         self.ui.act_edit_select_all.triggered.connect(self.slot_editSelectAll)

  70. 

  71.         self.ui.piano.midievent.connect(self.sendMsg)

  72.         self.ui.piano.measureupdate.connect(self.updateMeasureBox)

  73.         self.ui.piano.modeupdate.connect(self.ui.modeIndicator.changeMode)

  74.         self.ui.piano.modeupdate.connect(self.slot_modeChanged)

  75. 

  76.         self.ui.timeSigBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  77.         self.ui.measureBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  78.         self.ui.defaultLengthBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  79.         self.ui.quantizeBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  80. 

  81.         self.ui.timeSigBox.currentIndexChanged[str].connect(self.slot_setTimeSignature)

  82.         self.ui.measureBox.currentIndexChanged[str].connect(self.ui.piano.setMeasures)

  83.         self.ui.defaultLengthBox.currentIndexChanged[str].connect(self.ui.piano.setDefaultLength)

  84.         self.ui.quantizeBox.currentIndexChanged[str].connect(self.ui.piano.setGridDiv)

  85.         self.ui.hSlider.valueChanged.connect(self.ui.graphicsView.setZoomX)

  86.         self.ui.vSlider.valueChanged.connect(self.ui.graphicsView.setZoomY)

  87. 

  88.         self.ui.graphicsView.setFocus()

  89. 

  90.         self.fIdleTimer = self.startTimer(30)

  91.         self.setWindowTitle(self.fUiName)

  92.         self.ready()

  93. 

  94.     def slot_editInsertMode(self):

  95.         ev = QKeyEvent(QEvent.User, Qt.Key_F, Qt.NoModifier)

  96.         self.ui.piano.keyPressEvent(ev)

  97. 

  98.     def slot_editVelocityMode(self):

  99.         ev = QKeyEvent(QEvent.User, Qt.Key_D, Qt.NoModifier)

  100.         self.ui.piano.keyPressEvent(ev)

  101. 

  102.     def slot_editSelectAll(self):

  103.         ev = QKeyEvent(QEvent.User, Qt.Key_A, Qt.NoModifier)

  104.         self.ui.piano.keyPressEvent(ev)

  105. 

  106.     def slot_modeChanged(self, mode):

  107.         if mode == "insert_mode":

  108.             self.ui.act_edit_insert.setChecked(True)

  109.             self.ui.act_edit_velocity.setChecked(False)

  110.         elif mode == "velocity_mode":

  111.             self.ui.act_edit_insert.setChecked(False)

  112.             self.ui.act_edit_velocity.setChecked(True)

  113.         else:

  114.             self.ui.act_edit_insert.setChecked(False)

  115.             self.ui.act_edit_velocity.setChecked(False)

  116. 

  117.     def slot_paramChanged(self, index):

  118.         sender = self.sender()

  119. 

  120.         if sender == self.ui.timeSigBox:

  121.             param = 0

  122.         elif sender == self.ui.measureBox:

  123.             param = 1

  124.             index += 1

  125.         elif sender == self.ui.defaultLengthBox:

  126.             param = 2

  127.         elif sender == self.ui.quantizeBox:

  128.             param = 3

  129.         else:

  130.             return

  131. 

  132.         self.sendControl(param, index)

  133. 

  134.     def slot_setTimeSignature(self, sigtext):

  135.         try:

  136.            timesig = tuple(map(float, sigtext.split('/')))

  137.         except ValueError:

  138.             return

  139. 

  140.         if len(timesig) != 2:

  141.             return

  142. 

  143.         self.fTimeSignature = timesig

  144.         self.ui.piano.setTimeSig(timesig)

  145. 

  146.     # -------------------------------------------------------------------

  147.     # DSP Callbacks

  148. 

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

  150.         value = int(value)

  151. 

  152.         if index == 0: # TimeSig

  153.             self.ui.timeSigBox.blockSignals(True)

  154.             self.ui.timeSigBox.setCurrentIndex(value)

  155.             self.slot_setTimeSignature(self.ui.timeSigBox.currentText())

  156.             self.ui.timeSigBox.blockSignals(False)

  157. 

  158.         elif index == 1: # Measures

  159.             self.ui.measureBox.blockSignals(True)

  160.             self.ui.measureBox.setCurrentIndex(value-1)

  161.             self.ui.piano.setMeasures(self.ui.measureBox.currentText())

  162.             self.ui.measureBox.blockSignals(False)

  163. 

  164.         elif index == 2: # DefLength

  165.             self.ui.defaultLengthBox.blockSignals(True)

  166.             self.ui.defaultLengthBox.setCurrentIndex(value)

  167.             self.ui.piano.setDefaultLength(self.ui.defaultLengthBox.currentText())

  168.             self.ui.defaultLengthBox.blockSignals(False)

  169. 

  170.         elif index == 3: # Quantize

  171.             self.ui.quantizeBox.blockSignals(True)

  172.             self.ui.quantizeBox.setCurrentIndex(value)

  173.             self.ui.piano.setQuantize(self.ui.quantizeBox.currentText())

  174.             self.ui.quantizeBox.blockSignals(False)

  175. 

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

  177.         pass

  178. 

  179.     # -------------------------------------------------------------------

  180.     # ExternalUI Callbacks

  181. 

  182.     def uiShow(self):

  183.         self.show()

  184. 

  185.     def uiFocus(self):

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

  187.         self.show()

  188. 

  189.         self.raise_()

  190.         self.activateWindow()

  191. 

  192.     def uiHide(self):

  193.         self.hide()

  194. 

  195.     def uiQuit(self):

  196.         self.closeExternalUI()

  197.         self.close()

  198.         app.quit()

  199. 

  200.     def uiTitleChanged(self, uiTitle):

  201.         self.setWindowTitle(uiTitle)

  202. 

  203.     # -------------------------------------------------------------------

  204.     # Qt events

  205. 

  206.     def timerEvent(self, event):

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

  208.             self.idleExternalUI()

  209.         QMainWindow.timerEvent(self, event)

  210. 

  211.     def closeEvent(self, event):

  212.         self.closeExternalUI()

  213.         QMainWindow.closeEvent(self, event)

  214. 

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

  216.         app.quit()

  217. 

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

  219.     # Custom callback

  220. 

  221.     def updateMeasureBox(self, index):

  222.         self.ui.measureBox.setCurrentIndex(index-1)

  223. 

  224.     def sendMsg(self, data):

  225.         msg = data[0]

  226.         if msg == "midievent-add":

  227.             note, start, length, vel = data[1:5]

  228.             note_start = start * self.TICKS_PER_BEAT

  229.             note_stop = note_start + length * 4. * self.fTimeSignature[0] / self.fTimeSignature[1] * self.TICKS_PER_BEAT

  230.             self.send([msg, note_start, 3, MIDI_STATUS_NOTE_ON, note, vel])

  231.             self.send([msg, note_stop, 3, MIDI_STATUS_NOTE_OFF, note, vel])

  232. 

  233.         elif msg == "midievent-remove":

  234.             note, start, length, vel = data[1:5]

  235.             note_start = start * self.TICKS_PER_BEAT

  236.             note_stop = note_start + length * 4. * self.fTimeSignature[0] / self.fTimeSignature[1] * self.TICKS_PER_BEAT

  237.             self.send([msg, note_start, 3, MIDI_STATUS_NOTE_ON, note, vel])

  238.             self.send([msg, note_stop, 3, MIDI_STATUS_NOTE_OFF, note, vel])

  239. 

  240.     def msgCallback(self, msg):

  241.         msg = charPtrToString(msg)

  242. 

  243.         if msg == "midi-clear-all":

  244.             # clear all notes

  245.             self.ui.piano.clearNotes()

  246. 

  247.         elif msg == "midievent-add":

  248.             # adds single midi event

  249.             time = int(self.readlineblock())

  250.             size = int(self.readlineblock())

  251.             data = tuple(int(self.readlineblock()) for x in range(size))

  252. 

  253.             self.handleMidiEvent(time, size, data)

  254. 

  255.         elif msg == "transport":

  256.             playing, frame, bar, beat, tick = tuple(int(i) for i in self.readlineblock().split(":"))

  257.             bpm = float(self.readlineblock())

  258.             playing = bool(int(playing))

  259. 

  260.             old_frame = self.fTransportInfo['frame']

  261. 

  262.             self.fTransportInfo = {

  263.                 "playing": playing,

  264.                 "frame": frame,

  265.                 "bar": bar,

  266.                 "beat": beat,

  267.                 "tick": tick,

  268.                 "bpm": bpm,

  269.                 "ticksPerBeat": self.TICKS_PER_BEAT,

  270.             }

  271. 

  272.             if old_frame != frame:

  273.                 self.ui.piano.movePlayHead(self.fTransportInfo)

  274. 

  275.         elif msg == "parameters":

  276.             timesig, measures, deflength, quantize = tuple(int(i) for i in self.readlineblock().split(":"))

  277.             self.dspParameterChanged(0, timesig)

  278.             self.dspParameterChanged(1, measures)

  279.             self.dspParameterChanged(2, deflength)

  280.             self.dspParameterChanged(3, quantize)

  281. 

  282.         else:

  283.             ExternalUI.msgCallback(self, msg)

  284. 

  285.     # -------------------------------------------------------------------

  286.     # Internal stuff

  287. 

  288.     def handleMidiEvent(self, time, size, data):

  289.         #print("handleMidiEvent", time, size, data)

  290. 

  291.         status  = MIDI_GET_STATUS_FROM_DATA(data)

  292.         channel = MIDI_GET_CHANNEL_FROM_DATA(data)

  293. 

  294.         if status == MIDI_STATUS_NOTE_ON:

  295.             note = data[1]

  296.             velo = data[2]

  297. 

  298.             # append (channel, note, velo, time) for later

  299.             self.fPendingNoteOns.append((channel, note, velo, time))

  300. 

  301.         elif status == MIDI_STATUS_NOTE_OFF:

  302.             note = data[1]

  303. 

  304.             # find previous note-on that matches this note and channel

  305.             for noteOnMsg in self.fPendingNoteOns:

  306.                 on_channel, on_note, on_velo, on_time = noteOnMsg

  307. 

  308.                 if on_channel != channel:

  309.                     continue

  310.                 if on_note != note:

  311.                     continue

  312. 

  313.                 # found it

  314.                 self.fPendingNoteOns.remove(noteOnMsg)

  315.                 break

  316. 

  317.             else:

  318.                 return

  319. 

  320.             self.ui.piano.drawNote(note,

  321.                                    on_time/self.TICKS_PER_BEAT,

  322.                                    (time-on_time)/self.TICKS_PER_BEAT/self.fTimeSignature[0], on_velo)

  323. 

  324. 

  325. #--------------- main ------------------

  326. if __name__ == '__main__':

  327.     import resources_rc

  328. 

  329.     pathBinaries, pathResources = getPaths()

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

  331.     gCarla.utils.set_process_name("MidiPattern")

  332. 

  333.     app = CarlaApplication("MidiPattern")

  334.     gui = MidiPatternW()

  335.     app.exit_exec()