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

498 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 (Config)

  21. 

  22. from carla_config import *

  23. 

  24. # ------------------------------------------------------------------------------------------------------------

  25. # Imports (Global)

  26. 

  27. if config_UseQt5:

  28.     from PyQt5.QtCore import pyqtSignal, pyqtSlot, qCritical, Qt, QPointF, QRectF, QTimer, QSize

  29.     from PyQt5.QtGui import QColor, QFont, QPainter, QPixmap

  30.     from PyQt5.QtWidgets import QScrollArea, QWidget

  31. else:

  32.     from PyQt4.QtCore import pyqtSignal, pyqtSlot, qCritical, Qt, QPointF, QRectF, QTimer, QSize

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

  34. 

  35. # ------------------------------------------------------------------------------------------------------------

  36. 

  37. kMidiKey2RectMapHorizontal = {

  38.     '0':  QRectF(0,   0, 24, 57), # C

  39.     '1':  QRectF(14,  0, 15, 33), # C#

  40.     '2':  QRectF(24,  0, 24, 57), # D

  41.     '3':  QRectF(42,  0, 15, 33), # D#

  42.     '4':  QRectF(48,  0, 24, 57), # E

  43.     '5':  QRectF(72,  0, 24, 57), # F

  44.     '6':  QRectF(84,  0, 15, 33), # F#

  45.     '7':  QRectF(96,  0, 24, 57), # G

  46.     '8':  QRectF(112, 0, 15, 33), # G#

  47.     '9':  QRectF(120, 0, 24, 57), # A

  48.     '10': QRectF(140, 0, 15, 33), # A#

  49.     '11': QRectF(144, 0, 24, 57)  # B

  50. }

  51. 

  52. kMidiKey2RectMapVertical = {

  53.     '11': QRectF(0,  0,  57, 24), # B

  54.     '10': QRectF(0, 13,  33, 15), # A#

  55.     '9':  QRectF(0, 24,  57, 24), # A

  56.     '8':  QRectF(0, 41,  33, 15), # G#

  57.     '7':  QRectF(0, 48,  57, 24), # G

  58.     '6':  QRectF(0, 69,  33, 15), # F#

  59.     '5':  QRectF(0, 72,  57, 24), # F

  60.     '4':  QRectF(0, 96,  57, 24), # E

  61.     '3':  QRectF(0, 111, 33, 15), # D#

  62.     '2':  QRectF(0, 120, 57, 24), # D

  63.     '1':  QRectF(0, 139, 33, 15), # C#

  64.     '0':  QRectF(0, 144, 57, 24)  # C

  65. }

  66. 

  67. kMidiKeyboard2KeyMap = {

  68.     # 3th octave

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

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

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

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

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

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

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

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

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

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

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

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

  81.     # 4th octave

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

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

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

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

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

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

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

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

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

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

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

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

  94. }

  95. 

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

  97. 

  98. # ------------------------------------------------------------------------------------------------------------

  99. # MIDI Keyboard, using a pixmap for painting

  100. 

  101. class PixmapKeyboard(QWidget):

  102.     # enum Orientation

  103.     HORIZONTAL = 0

  104.     VERTICAL   = 1

  105. 

  106.     # signals

  107.     noteOn   = pyqtSignal(int)

  108.     noteOff  = pyqtSignal(int)

  109.     notesOn  = pyqtSignal()

  110.     notesOff = pyqtSignal()

  111. 

  112.     def __init__(self, parent):

  113.         QWidget.__init__(self, parent)

  114. 

  115.         self.fOctaves = 6

  116.         self.fLastMouseNote = -1

  117. 

  118.         self.fEnabledKeys = []

  119. 

  120.         self.fFont = self.font()

  121.         self.fFont.setFamily("Monospace")

  122.         self.fFont.setPixelSize(12)

  123.         self.fFont.setBold(True)

  124. 

  125.         self.fPixmap = QPixmap("")

  126. 

  127.         self.setCursor(Qt.PointingHandCursor)

  128.         self.setMode(self.HORIZONTAL)

  129. 

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

  131.         self.fEnabledKeys = []

  132. 

  133.         if sendSignal:

  134.             self.notesOff.emit()

  135. 

  136.         self.update()

  137. 

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

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

  140.             self.fEnabledKeys.append(note)

  141. 

  142.             if sendSignal:

  143.                 self.noteOn.emit(note)

  144. 

  145.             self.update()

  146. 

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

  148.             self.notesOn.emit()

  149. 

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

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

  152.             self.fEnabledKeys.remove(note)

  153. 

  154.             if sendSignal:

  155.                 self.noteOff.emit(note)

  156. 

  157.             self.update()

  158. 

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

  160.             self.notesOff.emit()

  161. 

  162.     def setMode(self, mode):

  163.         if mode == self.HORIZONTAL:

  164.             self.fMidiMap = kMidiKey2RectMapHorizontal

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

  166.             self.fPixmapMode = self.HORIZONTAL

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

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

  169.         elif mode == self.VERTICAL:

  170.             self.fMidiMap = kMidiKey2RectMapVertical

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

  172.             self.fPixmapMode = self.VERTICAL

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

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

  175.         else:

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

  177.             return self.setMode(self.HORIZONTAL)

  178. 

  179.         self.setOctaves(self.fOctaves)

  180. 

  181.     def setOctaves(self, octaves):

  182.         if octaves < 1:

  183.             octaves = 1

  184.         elif octaves > 10:

  185.             octaves = 10

  186. 

  187.         self.fOctaves = octaves

  188. 

  189.         if self.fPixmapMode == self.HORIZONTAL:

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

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

  192.         elif self.fPixmapMode == self.VERTICAL:

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

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

  195. 

  196.         self.update()

  197. 

  198.     def handleMousePos(self, pos):

  199.         if self.fPixmapMode == self.HORIZONTAL:

  200.             if pos.x() < 0 or pos.x() > self.fOctaves * self.fWidth:

  201.                 return

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

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

  204.         elif self.fPixmapMode == self.VERTICAL:

  205.             if pos.y() < 0 or pos.y() > self.fOctaves * self.fHeight:

  206.                 return

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

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

  209.         else:

  210.             return

  211. 

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

  213.             note = 1

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

  215.             note = 3

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

  217.             note = 6

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

  219.             note = 8

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

  221.             note = 10

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

  223.             note = 0

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

  225.             note = 2

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

  227.             note = 4

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

  229.             note = 5

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

  231.             note = 7

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

  233.             note = 9

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

  235.             note = 11

  236.         else:

  237.             note = -1

  238. 

  239.         if note != -1:

  240.             note += octave * 12

  241. 

  242.             if self.fLastMouseNote != note:

  243.                 self.sendNoteOff(self.fLastMouseNote)

  244.                 self.sendNoteOn(note)

  245. 

  246.         elif self.fLastMouseNote != -1:

  247.             self.sendNoteOff(self.fLastMouseNote)

  248. 

  249.         self.fLastMouseNote = note

  250. 

  251.     def minimumSizeHint(self):

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

  253. 

  254.     def sizeHint(self):

  255.         if self.fPixmapMode == self.HORIZONTAL:

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

  257.         elif self.fPixmapMode == self.VERTICAL:

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

  259.         else:

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

  261. 

  262.     def keyPressEvent(self, event):

  263.         if not event.isAutoRepeat():

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

  265.             if qKey in kMidiKeyboard2KeyMap.keys():

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

  267.         QWidget.keyPressEvent(self, event)

  268. 

  269.     def keyReleaseEvent(self, event):

  270.         if not event.isAutoRepeat():

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

  272.             if qKey in kMidiKeyboard2KeyMap.keys():

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

  274.         QWidget.keyReleaseEvent(self, event)

  275. 

  276.     def mousePressEvent(self, event):

  277.         self.fLastMouseNote = -1

  278.         self.handleMousePos(event.pos())

  279.         self.setFocus()

  280.         QWidget.mousePressEvent(self, event)

  281. 

  282.     def mouseMoveEvent(self, event):

  283.         self.handleMousePos(event.pos())

  284.         QWidget.mouseMoveEvent(self, event)

  285. 

  286.     def mouseReleaseEvent(self, event):

  287.         if self.fLastMouseNote != -1:

  288.             self.sendNoteOff(self.fLastMouseNote)

  289.             self.fLastMouseNote = -1

  290.         QWidget.mouseReleaseEvent(self, event)

  291. 

  292.     def paintEvent(self, event):

  293.         painter = QPainter(self)

  294.         event.accept()

  295. 

  296.         # -------------------------------------------------------------

  297.         # Paint clean keys (as background)

  298. 

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

  300.             if self.fPixmapMode == self.HORIZONTAL:

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

  302.             elif self.fPixmapMode == self.VERTICAL:

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

  304.             else:

  305.                 return

  306. 

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

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

  309. 

  310.         if not self.isEnabled():

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

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

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

  314.             return

  315. 

  316.         # -------------------------------------------------------------

  317.         # Paint (white) pressed keys

  318. 

  319.         paintedWhite = False

  320. 

  321.         for note in self.fEnabledKeys:

  322.             pos = self._getRectFromMidiNote(note)

  323. 

  324.             if self._isNoteBlack(note):

  325.                 continue

  326. 

  327.             if note < 12:

  328.                 octave = 0

  329.             elif note < 24:

  330.                 octave = 1

  331.             elif note < 36:

  332.                 octave = 2

  333.             elif note < 48:

  334.                 octave = 3

  335.             elif note < 60:

  336.                 octave = 4

  337.             elif note < 72:

  338.                 octave = 5

  339.             elif note < 84:

  340.                 octave = 6

  341.             elif note < 96:

  342.                 octave = 7

  343.             elif note < 108:

  344.                 octave = 8

  345.             elif note < 120:

  346.                 octave = 9

  347.             elif note < 132:

  348.                 octave = 10

  349.             else:

  350.                 # cannot paint this note

  351.                 continue

  352. 

  353.             if self.fPixmapMode == self.VERTICAL:

  354.                 octave = self.fOctaves - octave - 1

  355. 

  356.             if self.fPixmapMode == self.HORIZONTAL:

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

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

  359.             elif self.fPixmapMode == self.VERTICAL:

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

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

  362.             else:

  363.                 return

  364. 

  365.             paintedWhite = True

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

  367. 

  368.         # -------------------------------------------------------------

  369.         # Clear white keys border

  370. 

  371.         if paintedWhite:

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

  373.                 for note in kBlackNotes:

  374.                     pos = self._getRectFromMidiNote(note)

  375. 

  376.                     if self.fPixmapMode == self.HORIZONTAL:

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

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

  379.                     elif self.fPixmapMode == self.VERTICAL:

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

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

  382.                     else:

  383.                         return

  384. 

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

  386. 

  387.         # -------------------------------------------------------------

  388.         # Paint (black) pressed keys

  389. 

  390.         for note in self.fEnabledKeys:

  391.             pos = self._getRectFromMidiNote(note)

  392. 

  393.             if not self._isNoteBlack(note):

  394.                 continue

  395. 

  396.             if note < 12:

  397.                 octave = 0

  398.             elif note < 24:

  399.                 octave = 1

  400.             elif note < 36:

  401.                 octave = 2

  402.             elif note < 48:

  403.                 octave = 3

  404.             elif note < 60:

  405.                 octave = 4

  406.             elif note < 72:

  407.                 octave = 5

  408.             elif note < 84:

  409.                 octave = 6

  410.             elif note < 96:

  411.                 octave = 7

  412.             elif note < 108:

  413.                 octave = 8

  414.             elif note < 120:

  415.                 octave = 9

  416.             elif note < 132:

  417.                 octave = 10

  418.             else:

  419.                 # cannot paint this note

  420.                 continue

  421. 

  422.             if self.fPixmapMode == self.VERTICAL:

  423.                 octave = self.fOctaves - octave - 1

  424. 

  425.             if self.fPixmapMode == self.HORIZONTAL:

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

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

  428.             elif self.fPixmapMode == self.VERTICAL:

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

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

  431.             else:

  432.                 return

  433. 

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

  435. 

  436.         # Paint C-number note info

  437.         painter.setFont(self.fFont)

  438.         painter.setPen(Qt.black)

  439. 

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

  441.             if self.fPixmapMode == self.HORIZONTAL:

  442.                 painter.drawText(i * 168 + (4 if i == 0 else 3), 35, 20, 20, Qt.AlignCenter, "C%i" % (i-1))

  443.             elif self.fPixmapMode == self.VERTICAL:

  444.                 painter.drawText(33, (self.fOctaves * 168) - (i * 168) - 20, 20, 20, Qt.AlignCenter, "C%i" % (i-1))

  445. 

  446.     def _isNoteBlack(self, note):

  447.         baseNote = note % 12

  448.         return bool(baseNote in kBlackNotes)

  449. 

  450.     def _getRectFromMidiNote(self, note):

  451.         baseNote = note % 12

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

  453. 

  454. # ------------------------------------------------------------------------------------------------------------

  455. # Horizontal scroll area for keyboard

  456. 

  457. class PixmapKeyboardHArea(QScrollArea):

  458.     def __init__(self, parent):

  459.         QScrollArea.__init__(self, parent)

  460. 

  461.         self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)

  462.         self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

  463. 

  464.         self.keyboard = PixmapKeyboard(self)

  465.         self.keyboard.setOctaves(10)

  466.         self.setWidget(self.keyboard)

  467. 

  468.         self.setEnabled(False)

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

  470. 

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

  472. 

  473.     def setEnabled(self, yesNo):

  474.         self.keyboard.setEnabled(yesNo)

  475.         QScrollArea.setEnabled(self, yesNo)

  476. 

  477.     @pyqtSlot()

  478.     def slot_initScrollbarValue(self):

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

  480. 

  481. # ------------------------------------------------------------------------------------------------------------

  482. # Main Testing

  483. 

  484. if __name__ == '__main__':

  485.     import sys

  486.     from PyQt5.QtWidgets import QApplication

  487.     import resources_rc

  488. 

  489.     app = QApplication(sys.argv)

  490. 

  491.     gui = PixmapKeyboard(None)

  492.     gui.setMode(gui.HORIZONTAL)

  493.     #gui.setMode(gui.VERTICAL)

  494.     gui.setEnabled(True)

  495.     gui.show()

  496. 

  497.     sys.exit(app.exec_())