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.
1460 Commits
16 Branches
14GB
Tree: b12c598776
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b12c598776'
${ noResults }
Carla/source/widgets/pixmapkeyboard.py

483 lines
16KB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. 

  4. # Pixmap Keyboard, a custom Qt4 widget

  5. # Copyright (C) 2011-2014 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 PyQt4.QtCore import pyqtSignal, pyqtSlot, qCritical, Qt, QPointF, QRectF, QTimer, QSize

  23. from PyQt4.QtGui import QColor, QFont, QPainter, QPixmap, QScrollArea, QWidget

  24. 

  25. # ------------------------------------------------------------------------------------------------------------

  26. 

  27. kMidiKey2RectMapHorizontal = {

  28.     '0':  QRectF(0,   0, 17, 59), # C

  29.     '1':  QRectF(13,  0,  8, 41), # C#

  30.     '2':  QRectF(17,  0, 17, 59), # D

  31.     '3':  QRectF(31,  0,  8, 41), # D#

  32.     '4':  QRectF(34,  0, 17, 59), # E

  33.     '5':  QRectF(51,  0, 17, 59), # F

  34.     '6':  QRectF(63,  0,  8, 41), # F#

  35.     '7':  QRectF(68,  0, 17, 59), # G

  36.     '8':  QRectF(81,  0,  8, 41), # G#

  37.     '9':  QRectF(85,  0, 17, 59), # A

  38.     '10': QRectF(99,  0,  8, 41), # A#

  39.     '11': QRectF(102, 0, 17, 59)  # B

  40. }

  41. 

  42. kMidiKey2RectMapVertical = {

  43.     '11': QRectF(0,  0,  59, 17), # B

  44.     '10': QRectF(0, 11,  41,  8), # A#

  45.     '9':  QRectF(0, 16,  59, 17), # A

  46.     '8':  QRectF(0, 29,  41,  8), # G#

  47.     '7':  QRectF(0, 33,  59, 18), # G

  48.     '6':  QRectF(0, 47,  41,  8), # F#

  49.     '5':  QRectF(0, 50,  59, 17), # F

  50.     '4':  QRectF(0, 67,  59, 17), # E

  51.     '3':  QRectF(0, 79,  41,  8), # D#

  52.     '2':  QRectF(0, 84,  59, 17), # D

  53.     '1':  QRectF(0, 97,  41,  8), # C#

  54.     '0':  QRectF(0, 101, 59, 17)  # C

  55. }

  56. 

  57. kMidiKeyboard2KeyMap = {

  58.     # 3th octave

  59.     '%i' % Qt.Key_Z: 48,

  60.     '%i' % Qt.Key_S: 49,

  61.     '%i' % Qt.Key_X: 50,

  62.     '%i' % Qt.Key_D: 51,

  63.     '%i' % Qt.Key_C: 52,

  64.     '%i' % Qt.Key_V: 53,

  65.     '%i' % Qt.Key_G: 54,

  66.     '%i' % Qt.Key_B: 55,

  67.     '%i' % Qt.Key_H: 56,

  68.     '%i' % Qt.Key_N: 57,

  69.     '%i' % Qt.Key_J: 58,

  70.     '%i' % Qt.Key_M: 59,

  71.     # 4th octave

  72.     '%i' % Qt.Key_Q: 60,

  73.     '%i' % Qt.Key_2: 61,

  74.     '%i' % Qt.Key_W: 62,

  75.     '%i' % Qt.Key_3: 63,

  76.     '%i' % Qt.Key_E: 64,

  77.     '%i' % Qt.Key_R: 65,

  78.     '%i' % Qt.Key_5: 66,

  79.     '%i' % Qt.Key_T: 67,

  80.     '%i' % Qt.Key_6: 68,

  81.     '%i' % Qt.Key_Y: 69,

  82.     '%i' % Qt.Key_7: 70,

  83.     '%i' % Qt.Key_U: 71,

  84. }

  85. 

  86. kBlackNotes = (1, 3, 6, 8, 10)

  87. 

  88. # ------------------------------------------------------------------------------------------------------------

  89. # MIDI Keyboard, using a pixmap for painting

  90. 

  91. class PixmapKeyboard(QWidget):

  92.     # enum Orientation

  93.     HORIZONTAL = 0

  94.     VERTICAL   = 1

  95. 

  96.     # signals

  97.     noteOn   = pyqtSignal(int)

  98.     noteOff  = pyqtSignal(int)

  99.     notesOn  = pyqtSignal()

  100.     notesOff = pyqtSignal()

  101. 

  102.     def __init__(self, parent):

  103.         QWidget.__init__(self, parent)

  104. 

  105.         self.fOctaves = 6

  106.         self.fLastMouseNote = -1

  107. 

  108.         self.fEnabledKeys = []

  109. 

  110.         self.fFont   = QFont("Monospace", 7, QFont.Normal)

  111.         self.fPixmap = QPixmap("")

  112. 

  113.         self.setCursor(Qt.PointingHandCursor)

  114.         self.setMode(self.HORIZONTAL)

  115. 

  116.     def allNotesOff(self, sendSignal=True):

  117.         self.fEnabledKeys = []

  118. 

  119.         if sendSignal:

  120.             self.notesOff.emit()

  121. 

  122.         self.update()

  123. 

  124.     def sendNoteOn(self, note, sendSignal=True):

  125.         if 0 <= note <= 127 and note not in self.fEnabledKeys:

  126.             self.fEnabledKeys.append(note)

  127. 

  128.             if sendSignal:

  129.                 self.noteOn.emit(note)

  130. 

  131.             self.update()

  132. 

  133.         if len(self.fEnabledKeys) == 1:

  134.             self.notesOn.emit()

  135. 

  136.     def sendNoteOff(self, note, sendSignal=True):

  137.         if 0 <= note <= 127 and note in self.fEnabledKeys:

  138.             self.fEnabledKeys.remove(note)

  139. 

  140.             if sendSignal:

  141.                 self.noteOff.emit(note)

  142. 

  143.             self.update()

  144. 

  145.         if len(self.fEnabledKeys) == 0:

  146.             self.notesOff.emit()

  147. 

  148.     def setMode(self, mode):

  149.         if mode == self.HORIZONTAL:

  150.             self.fMidiMap = kMidiKey2RectMapHorizontal

  151.             self.fPixmap.load(":/bitmaps/kbd_h_dark.png")

  152.             self.fPixmapMode = self.HORIZONTAL

  153.             self.fWidth  = self.fPixmap.width()

  154.             self.fHeight = self.fPixmap.height() / 2

  155.         elif mode == self.VERTICAL:

  156.             self.fMidiMap = kMidiKey2RectMapVertical

  157.             self.fPixmap.load(":/bitmaps/kbd_v_dark.png")

  158.             self.fPixmapMode = self.VERTICAL

  159.             self.fWidth  = self.fPixmap.width() / 2

  160.             self.fHeight = self.fPixmap.height()

  161.         else:

  162.             qCritical("PixmapKeyboard::setMode(%i) - invalid mode" % mode)

  163.             return self.setMode(self.HORIZONTAL)

  164. 

  165.         self.setOctaves(self.fOctaves)

  166. 

  167.     def setOctaves(self, octaves):

  168.         if octaves < 1:

  169.             octaves = 1

  170.         elif octaves > 10:

  171.             octaves = 10

  172. 

  173.         self.fOctaves = octaves

  174. 

  175.         if self.fPixmapMode == self.HORIZONTAL:

  176.             self.setMinimumSize(self.fWidth * self.fOctaves, self.fHeight)

  177.             self.setMaximumSize(self.fWidth * self.fOctaves, self.fHeight)

  178.         elif self.fPixmapMode == self.VERTICAL:

  179.             self.setMinimumSize(self.fWidth, self.fHeight * self.fOctaves)

  180.             self.setMaximumSize(self.fWidth, self.fHeight * self.fOctaves)

  181. 

  182.         self.update()

  183. 

  184.     def handleMousePos(self, pos):

  185.         if self.fPixmapMode == self.HORIZONTAL:

  186.             if pos.x() < 0 or pos.x() > self.fOctaves * 119:

  187.                 return

  188.             octave = int(pos.x() / self.fWidth)

  189.             keyPos = QPointF(pos.x() % self.fWidth, pos.y())

  190.         elif self.fPixmapMode == self.VERTICAL:

  191.             if pos.y() < 0 or pos.y() > self.fOctaves * 119:

  192.                 return

  193.             octave = int(self.fOctaves - pos.y() / self.fHeight)

  194.             keyPos = QPointF(pos.x(), (pos.y()-1) % self.fHeight)

  195.         else:

  196.             return

  197. 

  198.         if self.fMidiMap['1'].contains(keyPos):   # C#

  199.             note = 1

  200.         elif self.fMidiMap['3'].contains(keyPos): # D#

  201.             note = 3

  202.         elif self.fMidiMap['6'].contains(keyPos): # F#

  203.             note = 6

  204.         elif self.fMidiMap['8'].contains(keyPos): # G#

  205.             note = 8

  206.         elif self.fMidiMap['10'].contains(keyPos):# A#

  207.             note = 10

  208.         elif self.fMidiMap['0'].contains(keyPos): # C

  209.             note = 0

  210.         elif self.fMidiMap['2'].contains(keyPos): # D

  211.             note = 2

  212.         elif self.fMidiMap['4'].contains(keyPos): # E

  213.             note = 4

  214.         elif self.fMidiMap['5'].contains(keyPos): # F

  215.             note = 5

  216.         elif self.fMidiMap['7'].contains(keyPos): # G

  217.             note = 7

  218.         elif self.fMidiMap['9'].contains(keyPos): # A

  219.             note = 9

  220.         elif self.fMidiMap['11'].contains(keyPos):# B

  221.             note = 11

  222.         else:

  223.             note = -1

  224. 

  225.         if note != -1:

  226.             note += octave * 12

  227. 

  228.             if self.fLastMouseNote != note:

  229.                 self.sendNoteOff(self.fLastMouseNote)

  230.                 self.sendNoteOn(note)

  231. 

  232.         elif self.fLastMouseNote != -1:

  233.             self.sendNoteOff(self.fLastMouseNote)

  234. 

  235.         self.fLastMouseNote = note

  236. 

  237.     def minimumSizeHint(self):

  238.         return QSize(self.fWidth, self.fHeight)

  239. 

  240.     def sizeHint(self):

  241.         if self.fPixmapMode == self.HORIZONTAL:

  242.             return QSize(self.fWidth * self.fOctaves, self.fHeight)

  243.         elif self.fPixmapMode == self.VERTICAL:

  244.             return QSize(self.fWidth, self.fHeight * self.fOctaves)

  245.         else:

  246.             return QSize(self.fWidth, self.fHeight)

  247. 

  248.     def keyPressEvent(self, event):

  249.         if not event.isAutoRepeat():

  250.             qKey = str(event.key())

  251.             if qKey in kMidiKeyboard2KeyMap.keys():

  252.                 self.sendNoteOn(kMidiKeyboard2KeyMap.get(qKey))

  253.         QWidget.keyPressEvent(self, event)

  254. 

  255.     def keyReleaseEvent(self, event):

  256.         if not event.isAutoRepeat():

  257.             qKey = str(event.key())

  258.             if qKey in kMidiKeyboard2KeyMap.keys():

  259.                 self.sendNoteOff(kMidiKeyboard2KeyMap.get(qKey))

  260.         QWidget.keyReleaseEvent(self, event)

  261. 

  262.     def mousePressEvent(self, event):

  263.         self.fLastMouseNote = -1

  264.         self.handleMousePos(event.pos())

  265.         self.setFocus()

  266.         QWidget.mousePressEvent(self, event)

  267. 

  268.     def mouseMoveEvent(self, event):

  269.         self.handleMousePos(event.pos())

  270.         QWidget.mouseMoveEvent(self, event)

  271. 

  272.     def mouseReleaseEvent(self, event):

  273.         if self.fLastMouseNote != -1:

  274.             self.sendNoteOff(self.fLastMouseNote)

  275.             self.fLastMouseNote = -1

  276.         QWidget.mouseReleaseEvent(self, event)

  277. 

  278.     def paintEvent(self, event):

  279.         painter = QPainter(self)

  280.         event.accept()

  281. 

  282.         # -------------------------------------------------------------

  283.         # Paint clean keys (as background)

  284. 

  285.         for octave in range(self.fOctaves):

  286.             if self.fPixmapMode == self.HORIZONTAL:

  287.                 target = QRectF(self.fWidth * octave, 0, self.fWidth, self.fHeight)

  288.             elif self.fPixmapMode == self.VERTICAL:

  289.                 target = QRectF(0, self.fHeight * octave, self.fWidth, self.fHeight)

  290.             else:

  291.                 return

  292. 

  293.             source = QRectF(0, 0, self.fWidth, self.fHeight)

  294.             painter.drawPixmap(target, self.fPixmap, source)

  295. 

  296.         if not self.isEnabled():

  297.             painter.setBrush(QColor(0, 0, 0, 150))

  298.             painter.setPen(QColor(0, 0, 0, 150))

  299.             painter.drawRect(0, 0, self.width(), self.height())

  300.             return

  301. 

  302.         # -------------------------------------------------------------

  303.         # Paint (white) pressed keys

  304. 

  305.         paintedWhite = False

  306. 

  307.         for note in self.fEnabledKeys:

  308.             pos = self._getRectFromMidiNote(note)

  309. 

  310.             if self._isNoteBlack(note):

  311.                 continue

  312. 

  313.             if note < 12:

  314.                 octave = 0

  315.             elif note < 24:

  316.                 octave = 1

  317.             elif note < 36:

  318.                 octave = 2

  319.             elif note < 48:

  320.                 octave = 3

  321.             elif note < 60:

  322.                 octave = 4

  323.             elif note < 72:

  324.                 octave = 5

  325.             elif note < 84:

  326.                 octave = 6

  327.             elif note < 96:

  328.                 octave = 7

  329.             elif note < 108:

  330.                 octave = 8

  331.             elif note < 120:

  332.                 octave = 9

  333.             elif note < 132:

  334.                 octave = 10

  335.             else:

  336.                 # cannot paint this note

  337.                 continue

  338. 

  339.             if self.fPixmapMode == self.VERTICAL:

  340.                 octave = self.fOctaves - octave - 1

  341. 

  342.             if self.fPixmapMode == self.HORIZONTAL:

  343.                 target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())

  344.                 source = QRectF(pos.x(), self.fHeight, pos.width(), pos.height())

  345.             elif self.fPixmapMode == self.VERTICAL:

  346.                 target = QRectF(pos.x(), pos.y() + (self.fHeight * octave), pos.width(), pos.height())

  347.                 source = QRectF(self.fWidth, pos.y(), pos.width(), pos.height())

  348.             else:

  349.                 return

  350. 

  351.             paintedWhite = True

  352.             painter.drawPixmap(target, self.fPixmap, source)

  353. 

  354.         # -------------------------------------------------------------

  355.         # Clear white keys border

  356. 

  357.         if paintedWhite:

  358.             for octave in range(self.fOctaves):

  359.                 for note in kBlackNotes:

  360.                     pos = self._getRectFromMidiNote(note)

  361. 

  362.                     if self.fPixmapMode == self.HORIZONTAL:

  363.                         target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())

  364.                         source = QRectF(pos.x(), 0, pos.width(), pos.height())

  365.                     elif self.fPixmapMode == self.VERTICAL:

  366.                         target = QRectF(pos.x(), pos.y() + (self.fHeight * octave), pos.width(), pos.height())

  367.                         source = QRectF(0, pos.y(), pos.width(), pos.height())

  368.                     else:

  369.                         return

  370. 

  371.                     painter.drawPixmap(target, self.fPixmap, source)

  372. 

  373.         # -------------------------------------------------------------

  374.         # Paint (black) pressed keys

  375. 

  376.         for note in self.fEnabledKeys:

  377.             pos = self._getRectFromMidiNote(note)

  378. 

  379.             if not self._isNoteBlack(note):

  380.                 continue

  381. 

  382.             if note < 12:

  383.                 octave = 0

  384.             elif note < 24:

  385.                 octave = 1

  386.             elif note < 36:

  387.                 octave = 2

  388.             elif note < 48:

  389.                 octave = 3

  390.             elif note < 60:

  391.                 octave = 4

  392.             elif note < 72:

  393.                 octave = 5

  394.             elif note < 84:

  395.                 octave = 6

  396.             elif note < 96:

  397.                 octave = 7

  398.             elif note < 108:

  399.                 octave = 8

  400.             elif note < 120:

  401.                 octave = 9

  402.             elif note < 132:

  403.                 octave = 10

  404.             else:

  405.                 # cannot paint this note

  406.                 continue

  407. 

  408.             if self.fPixmapMode == self.VERTICAL:

  409.                 octave = self.fOctaves - octave - 1

  410. 

  411.             if self.fPixmapMode == self.HORIZONTAL:

  412.                 target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())

  413.                 source = QRectF(pos.x(), self.fHeight, pos.width(), pos.height())

  414.             elif self.fPixmapMode == self.VERTICAL:

  415.                 target = QRectF(pos.x(), pos.y() + (self.fHeight * octave), pos.width(), pos.height())

  416.                 source = QRectF(self.fWidth, pos.y(), pos.width(), pos.height())

  417.             else:

  418.                 return

  419. 

  420.             painter.drawPixmap(target, self.fPixmap, source)

  421. 

  422.         # Paint C-number note info

  423.         painter.setFont(self.fFont)

  424.         painter.setPen(Qt.black)

  425. 

  426.         for i in range(self.fOctaves):

  427.             if self.fPixmapMode == self.HORIZONTAL:

  428.                 painter.drawText(i * 119 + (2 if i == 0 else 1), 45, 16, 16, Qt.AlignCenter, "C%i" % (i-1))

  429.             elif self.fPixmapMode == self.VERTICAL:

  430.                 painter.drawText(44, (self.fOctaves * 119) - (i * 119) - 16, 16, 16, Qt.AlignCenter, "C%i" % (i-1))

  431. 

  432.     def _isNoteBlack(self, note):

  433.         baseNote = note % 12

  434.         return bool(baseNote in kBlackNotes)

  435. 

  436.     def _getRectFromMidiNote(self, note):

  437.         baseNote = note % 12

  438.         return self.fMidiMap.get(str(baseNote))

  439. 

  440. # ------------------------------------------------------------------------------------------------------------

  441. # Horizontal scroll area for keyboard

  442. 

  443. class PixmapKeyboardHArea(QScrollArea):

  444.     def __init__(self, parent):

  445.         QScrollArea.__init__(self, parent)

  446. 

  447.         self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)

  448.         self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

  449. 

  450.         self.keyboard = PixmapKeyboard(self)

  451.         self.keyboard.setOctaves(10)

  452.         self.setWidget(self.keyboard)

  453. 

  454.         self.setEnabled(False)

  455.         self.setFixedHeight(self.keyboard.height() + self.horizontalScrollBar().height()/2 + 2)

  456. 

  457.         QTimer.singleShot(0, self.slot_initScrollbarValue)

  458. 

  459.     def setEnabled(self, yesNo):

  460.         self.keyboard.setEnabled(yesNo)

  461.         QScrollArea.setEnabled(self, yesNo)

  462. 

  463.     @pyqtSlot()

  464.     def slot_initScrollbarValue(self):

  465.         self.horizontalScrollBar().setValue(self.horizontalScrollBar().maximum()/2)

  466. 

  467. # ------------------------------------------------------------------------------------------------------------

  468. # Main Testing

  469. 

  470. if __name__ == '__main__':

  471.     import sys

  472.     from PyQt4.QtGui import QApplication

  473.     import resources_rc

  474. 

  475.     app = QApplication(sys.argv)

  476. 

  477.     gui = PixmapKeyboard(None)

  478.     gui.setMode(gui.VERTICAL)

  479.     gui.setEnabled(True)

  480.     gui.show()

  481. 

  482.     sys.exit(app.exec_())