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

342 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-2020 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.noteclicked.connect(self.sendTemporaryNote)

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

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

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

  76. 

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

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

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

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

  81. 

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

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

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

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

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

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

  88. 

  89.         self.ui.graphicsView.setFocus()

  90. 

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

  92.         self.setWindowTitle(self.fUiName)

  93.         self.ready()

  94. 

  95.     def slot_editInsertMode(self):

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

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

  98. 

  99.     def slot_editVelocityMode(self):

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

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

  102. 

  103.     def slot_editSelectAll(self):

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

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

  106. 

  107.     def slot_modeChanged(self, mode):

  108.         if mode == "insert_mode":

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

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

  111.         elif mode == "velocity_mode":

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

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

  114.         else:

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

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

  117. 

  118.     def slot_paramChanged(self, index):

  119.         sender = self.sender()

  120. 

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

  122.             param = 0

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

  124.             param = 1

  125.             index += 1

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

  127.             param = 2

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

  129.             param = 3

  130.         else:

  131.             return

  132. 

  133.         self.sendControl(param, index)

  134. 

  135.     def slot_setTimeSignature(self, sigtext):

  136.         try:

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

  138.         except ValueError:

  139.             return

  140. 

  141.         if len(timesig) != 2:

  142.             return

  143. 

  144.         self.fTimeSignature = timesig

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

  146. 

  147.     # -------------------------------------------------------------------

  148.     # DSP Callbacks

  149. 

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

  151.         value = int(value)

  152. 

  153.         if index == 0: # TimeSig

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

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

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

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

  158. 

  159.         elif index == 1: # Measures

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

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

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

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

  164. 

  165.         elif index == 2: # DefLength

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

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

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

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

  170. 

  171.         elif index == 3: # Quantize

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

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

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

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

  176. 

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

  178.         pass

  179. 

  180.     # -------------------------------------------------------------------

  181.     # ExternalUI Callbacks

  182. 

  183.     def uiShow(self):

  184.         self.show()

  185. 

  186.     def uiFocus(self):

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

  188.         self.show()

  189. 

  190.         self.raise_()

  191.         self.activateWindow()

  192. 

  193.     def uiHide(self):

  194.         self.hide()

  195. 

  196.     def uiQuit(self):

  197.         self.closeExternalUI()

  198.         self.close()

  199.         app.quit()

  200. 

  201.     def uiTitleChanged(self, uiTitle):

  202.         self.setWindowTitle(uiTitle)

  203. 

  204.     # -------------------------------------------------------------------

  205.     # Qt events

  206. 

  207.     def timerEvent(self, event):

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

  209.             self.idleExternalUI()

  210.         QMainWindow.timerEvent(self, event)

  211. 

  212.     def closeEvent(self, event):

  213.         self.closeExternalUI()

  214.         QMainWindow.closeEvent(self, event)

  215. 

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

  217.         app.quit()

  218. 

  219.     # -------------------------------------------------------------------

  220.     # Custom callback

  221. 

  222.     def updateMeasureBox(self, index):

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

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

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

  226. 

  227.     def sendMsg(self, data):

  228.         msg = data[0]

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

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

  231.             note_start = start * self.TICKS_PER_BEAT

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

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

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

  235. 

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

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

  238.             note_start = start * self.TICKS_PER_BEAT

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

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

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

  242. 

  243.     def sendTemporaryNote(self, note, on):

  244.         self.send(["midi-note", note, on])

  245. 

  246.     def msgCallback(self, msg):

  247.         msg = charPtrToString(msg)

  248. 

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

  250.             # clear all notes

  251.             self.ui.piano.clearNotes()

  252. 

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

  254.             # adds single midi event

  255.             time = self.readlineblock_int()

  256.             size = self.readlineblock_int()

  257.             data = tuple(self.readlineblock_int() for x in range(size))

  258. 

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

  260. 

  261.         elif msg == "transport":

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

  263.             bpm = self.readlineblock_float()

  264.             playing = bool(int(playing))

  265. 

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

  267. 

  268.             self.fTransportInfo = {

  269.                 "playing": playing,

  270.                 "frame": frame,

  271.                 "bar": bar,

  272.                 "beat": beat,

  273.                 "tick": tick,

  274.                 "bpm": bpm,

  275.                 "ticksPerBeat": self.TICKS_PER_BEAT,

  276.             }

  277. 

  278.             if old_frame != frame:

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

  280. 

  281.         elif msg == "parameters":

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

  283.             self.dspParameterChanged(0, timesig)

  284.             self.dspParameterChanged(1, measures)

  285.             self.dspParameterChanged(2, deflength)

  286.             self.dspParameterChanged(3, quantize)

  287. 

  288.         else:

  289.             ExternalUI.msgCallback(self, msg)

  290. 

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

  292.     # Internal stuff

  293. 

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

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

  296. 

  297.         status  = MIDI_GET_STATUS_FROM_DATA(data)

  298.         channel = MIDI_GET_CHANNEL_FROM_DATA(data)

  299. 

  300.         if status == MIDI_STATUS_NOTE_ON:

  301.             note = data[1]

  302.             velo = data[2]

  303. 

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

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

  306. 

  307.         elif status == MIDI_STATUS_NOTE_OFF:

  308.             note = data[1]

  309. 

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

  311.             for noteOnMsg in self.fPendingNoteOns:

  312.                 on_channel, on_note, on_velo, on_time = noteOnMsg

  313. 

  314.                 if on_channel != channel:

  315.                     continue

  316.                 if on_note != note:

  317.                     continue

  318. 

  319.                 # found it

  320.                 self.fPendingNoteOns.remove(noteOnMsg)

  321.                 break

  322. 

  323.             else:

  324.                 return

  325. 

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

  327.                                    on_time/self.TICKS_PER_BEAT,

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

  329. 

  330. 

  331. #--------------- main ------------------

  332. if __name__ == '__main__':

  333.     import resources_rc

  334. 

  335.     pathBinaries, _ = getPaths()

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

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

  338. 

  339.     app = CarlaApplication("MidiPattern")

  340.     gui = MidiPatternW()

  341.     app.exit_exec()