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.
1041 Commits
2 Branches
42MB
Tree: 35bacbbace
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '35bacbbace'
${ noResults }
Cadence/c++/widgets/pixmapkeyboard.cpp

615 lines
17KB
Raw Blame History 

  1. /*

  2.  * Pixmap Keyboard, a custom Qt4 widget

  3.  * Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the COPYING file

  16.  */

  17. 

  18. #include "pixmapkeyboard.hpp"

  19. 

  20. #include <QtCore/QTimer>

  21. #include <QtGui/QKeyEvent>

  22. #include <QtGui/QMouseEvent>

  23. #include <QtGui/QPainter>

  24. 

  25. #ifndef Q_COMPILER_LAMBDA

  26. static std::map<int, QRectF> kMidiKey2RectMapHorizontal;

  27. #else

  28. static std::map<int, QRectF> kMidiKey2RectMapHorizontal = {

  29.     {0,  QRectF(0,   0, 18, 64)}, // C

  30.     {1,  QRectF(13,  0, 11, 42)}, // C#

  31.     {2,  QRectF(18,  0, 25, 64)}, // D

  32.     {3,  QRectF(37,  0, 11, 42)}, // D#

  33.     {4,  QRectF(42,  0, 18, 64)}, // E

  34.     {5,  QRectF(60,  0, 18, 64)}, // F

  35.     {6,  QRectF(73,  0, 11, 42)}, // F#

  36.     {7,  QRectF(78,  0, 25, 64)}, // G

  37.     {8,  QRectF(97,  0, 11, 42)}, // G#

  38.     {9,  QRectF(102, 0, 25, 64)}, // A

  39.     {10, QRectF(121, 0, 11, 42)}, // A#

  40.     {11, QRectF(126, 0, 18, 64)}  // B

  41. };

  42. #endif

  43. 

  44. #ifndef Q_COMPILER_LAMBDA

  45. static std::map<int, QRectF> kMidiKey2RectMapVertical;

  46. #else

  47. static std::map<int, QRectF> kMidiKey2RectMapVertical = {

  48.     {11, QRectF(0,  0,  64, 18)}, // B

  49.     {10, QRectF(0, 14,  42,  7)}, // A#

  50.     {9,  QRectF(0, 18,  64, 24)}, // A

  51.     {8,  QRectF(0, 38,  42,  7)}, // G#

  52.     {7,  QRectF(0, 42,  64, 24)}, // G

  53.     {6,  QRectF(0, 62,  42,  7)}, // F#

  54.     {5,  QRectF(0, 66,  64, 18)}, // F

  55.     {4,  QRectF(0, 84,  64, 18)}, // E

  56.     {3,  QRectF(0, 98,  42,  7)}, // D#

  57.     {2,  QRectF(0, 102, 64, 24)}, // D

  58.     {1,  QRectF(0, 122, 42,  7)}, // C#

  59.     {0,  QRectF(0, 126, 64, 18)}  // C

  60. };

  61. #endif

  62. 

  63. #ifndef Q_COMPILER_LAMBDA

  64. static std::map<int, int> kMidiKeyboard2KeyMap;

  65. #else

  66. static const std::map<int, int> kMidiKeyboard2KeyMap = {

  67.     // bottom row, 3rd octave

  68.     {Qt::Key_Z, 48},

  69.     {Qt::Key_S, 49},

  70.     {Qt::Key_X, 50},

  71.     {Qt::Key_D, 51},

  72.     {Qt::Key_C, 52},

  73.     {Qt::Key_V, 53},

  74.     {Qt::Key_G, 54},

  75.     {Qt::Key_B, 55},

  76.     {Qt::Key_H, 56},

  77.     {Qt::Key_N, 57},

  78.     {Qt::Key_J, 58},

  79.     {Qt::Key_M, 59},

  80.     // top row, 4th octave

  81.     {Qt::Key_Q, 60},

  82.     {Qt::Key_2, 61},

  83.     {Qt::Key_W, 62},

  84.     {Qt::Key_3, 63},

  85.     {Qt::Key_E, 64},

  86.     {Qt::Key_R, 65},

  87.     {Qt::Key_5, 66},

  88.     {Qt::Key_T, 67},

  89.     {Qt::Key_6, 68},

  90.     {Qt::Key_Y, 69},

  91.     {Qt::Key_7, 70},

  92.     {Qt::Key_U, 71},

  93.     // continue the top row in to the 5th octave

  94.     {Qt::Key_I, 72},

  95.     {Qt::Key_9, 73},

  96.     {Qt::Key_O, 74},

  97.     {Qt::Key_0, 75},

  98.     {Qt::Key_P, 76}

  99. };

  100. #endif

  101. 

  102. #ifndef Q_COMPILER_LAMBDA

  103. static QVector<int> kBlackNotes;

  104. #else

  105. static const QVector<int> kBlackNotes = {1, 3, 6, 8, 10};

  106. #endif

  107. 

  108. #ifndef Q_COMPILER_LAMBDA

  109. static const struct PixmapKeyboardInit {

  110.     PixmapKeyboardInit() {

  111.         // kMidiKey2RectMapHorizontal

  112.         kMidiKey2RectMapHorizontal[0]  = QRectF(0,   0, 18, 64); // C

  113.         kMidiKey2RectMapHorizontal[1]  = QRectF(13,  0, 11, 42); // C#

  114.         kMidiKey2RectMapHorizontal[2]  = QRectF(18,  0, 25, 64); // D

  115.         kMidiKey2RectMapHorizontal[3]  = QRectF(37,  0, 11, 42); // D#

  116.         kMidiKey2RectMapHorizontal[4]  = QRectF(42,  0, 18, 64); // E

  117.         kMidiKey2RectMapHorizontal[5]  = QRectF(60,  0, 18, 64); // F

  118.         kMidiKey2RectMapHorizontal[6]  = QRectF(73,  0, 11, 42); // F#

  119.         kMidiKey2RectMapHorizontal[7]  = QRectF(78,  0, 25, 64); // G

  120.         kMidiKey2RectMapHorizontal[8]  = QRectF(97,  0, 11, 42); // G#

  121.         kMidiKey2RectMapHorizontal[9]  = QRectF(102, 0, 25, 64); // A

  122.         kMidiKey2RectMapHorizontal[10] = QRectF(121, 0, 11, 42); // A#

  123.         kMidiKey2RectMapHorizontal[11] = QRectF(126, 0, 18, 64); // B

  124. 

  125.         // kMidiKey2RectMapVertical

  126.         kMidiKey2RectMapVertical[11] = QRectF(0,  0,  64, 18); // B

  127.         kMidiKey2RectMapVertical[10] = QRectF(0, 14,  42,  7); // A#

  128.         kMidiKey2RectMapVertical[9]  = QRectF(0, 18,  64, 24); // A

  129.         kMidiKey2RectMapVertical[8]  = QRectF(0, 38,  42,  7); // G#

  130.         kMidiKey2RectMapVertical[7]  = QRectF(0, 42,  64, 24); // G

  131.         kMidiKey2RectMapVertical[6]  = QRectF(0, 62,  42,  7); // F#

  132.         kMidiKey2RectMapVertical[5]  = QRectF(0, 66,  64, 18); // F

  133.         kMidiKey2RectMapVertical[4]  = QRectF(0, 84,  64, 18); // E

  134.         kMidiKey2RectMapVertical[3]  = QRectF(0, 98,  42,  7); // D#

  135.         kMidiKey2RectMapVertical[2]  = QRectF(0, 102, 64, 24); // D

  136.         kMidiKey2RectMapVertical[1]  = QRectF(0, 122, 42,  7); // C#

  137.         kMidiKey2RectMapVertical[0]  = QRectF(0, 126, 64, 18); // C

  138. 

  139.         // kMidiKeyboard2KeyMap, 3th octave

  140.         kMidiKeyboard2KeyMap[Qt::Key_Z] = 48;

  141.         kMidiKeyboard2KeyMap[Qt::Key_S] = 49;

  142.         kMidiKeyboard2KeyMap[Qt::Key_X] = 50;

  143.         kMidiKeyboard2KeyMap[Qt::Key_D] = 51;

  144.         kMidiKeyboard2KeyMap[Qt::Key_C] = 52;

  145.         kMidiKeyboard2KeyMap[Qt::Key_V] = 53;

  146.         kMidiKeyboard2KeyMap[Qt::Key_G] = 54;

  147.         kMidiKeyboard2KeyMap[Qt::Key_B] = 55;

  148.         kMidiKeyboard2KeyMap[Qt::Key_H] = 56;

  149.         kMidiKeyboard2KeyMap[Qt::Key_N] = 57;

  150.         kMidiKeyboard2KeyMap[Qt::Key_J] = 58;

  151.         kMidiKeyboard2KeyMap[Qt::Key_M] = 59;

  152.         // kMidiKeyboard2KeyMap, 4th octave

  153.         kMidiKeyboard2KeyMap[Qt::Key_Q] = 60;

  154.         kMidiKeyboard2KeyMap[Qt::Key_2] = 61;

  155.         kMidiKeyboard2KeyMap[Qt::Key_W] = 62;

  156.         kMidiKeyboard2KeyMap[Qt::Key_3] = 63;

  157.         kMidiKeyboard2KeyMap[Qt::Key_E] = 64;

  158.         kMidiKeyboard2KeyMap[Qt::Key_R] = 65;

  159.         kMidiKeyboard2KeyMap[Qt::Key_5] = 66;

  160.         kMidiKeyboard2KeyMap[Qt::Key_T] = 67;

  161.         kMidiKeyboard2KeyMap[Qt::Key_6] = 68;

  162.         kMidiKeyboard2KeyMap[Qt::Key_Y] = 69;

  163.         kMidiKeyboard2KeyMap[Qt::Key_7] = 70;

  164.         kMidiKeyboard2KeyMap[Qt::Key_U] = 71;

  165.         // kMidiKeyboard2KeyMap, 5th octave

  166.         kMidiKeyboard2KeyMap[Qt::Key_I] = 72;

  167.         kMidiKeyboard2KeyMap[Qt::Key_9] = 73;

  168.         kMidiKeyboard2KeyMap[Qt::Key_O] = 74;

  169.         kMidiKeyboard2KeyMap[Qt::Key_0] = 75;

  170.         kMidiKeyboard2KeyMap[Qt::Key_P] = 76;

  171. 

  172.         // kBlackNotes

  173.         kBlackNotes << 1;

  174.         kBlackNotes << 3;

  175.         kBlackNotes << 6;

  176.         kBlackNotes << 8;

  177.         kBlackNotes << 10;

  178.     }

  179. } _pixmapKeyboardInitInit;

  180. #endif

  181. 

  182. PixmapKeyboard::PixmapKeyboard(QWidget* parent)

  183.     : QWidget(parent),

  184.       fPixmap(""),

  185.       fPixmapMode(HORIZONTAL),

  186.       fColorStr("orange"),

  187.       fFont("Monospace", 7, QFont::Normal),

  188.       fOctaves(6),

  189.       fLastMouseNote(-1),

  190.       fWidth(0),

  191.       fHeight(0),

  192.       fMidiMap(kMidiKey2RectMapHorizontal)

  193. {

  194.     setCursor(Qt::PointingHandCursor);

  195.     setMode(HORIZONTAL);

  196. }

  197. 

  198. void PixmapKeyboard::allNotesOff()

  199. {

  200.     fEnabledKeys.clear();

  201. 

  202.     emit notesOff();

  203.     update();

  204. }

  205. 

  206. void PixmapKeyboard::sendNoteOn(int note, bool sendSignal)

  207. {

  208.     if (0 <= note && note <= 127 && ! fEnabledKeys.contains(note))

  209.     {

  210.         fEnabledKeys.append(note);

  211. 

  212.         if (sendSignal)

  213.             emit noteOn(note);

  214. 

  215.         update();

  216.     }

  217. 

  218.     if (fEnabledKeys.count() == 1)

  219.         emit notesOn();

  220. }

  221. 

  222. void PixmapKeyboard::sendNoteOff(int note, bool sendSignal)

  223. {

  224.     if (note >= 0 && note <= 127 && fEnabledKeys.contains(note))

  225.     {

  226.         fEnabledKeys.removeOne(note);

  227. 

  228.         if (sendSignal)

  229.             emit noteOff(note);

  230. 

  231.         update();

  232.     }

  233. 

  234.     if (fEnabledKeys.count() == 0)

  235.         emit notesOff();

  236. }

  237. 

  238. void PixmapKeyboard::setMode(Orientation mode, Color color)

  239. {

  240.     if (color == COLOR_CLASSIC)

  241.     {

  242.         fColorStr = "classic";

  243.     }

  244.     else if (color == COLOR_ORANGE)

  245.     {

  246.         fColorStr = "orange";

  247.     }

  248.     else

  249.     {

  250.         qCritical("PixmapKeyboard::setMode(%i, %i) - invalid color", mode, color);

  251.         return setMode(mode);

  252.     }

  253. 

  254.     if (mode == HORIZONTAL)

  255.     {

  256.         fMidiMap = kMidiKey2RectMapHorizontal;

  257.         fPixmap.load(QString(":/bitmaps/kbd_h_%1.png").arg(fColorStr));

  258.         fPixmapMode = HORIZONTAL;

  259.         fWidth  = fPixmap.width();

  260.         fHeight = fPixmap.height() / 2;

  261.     }

  262.     else if (mode == VERTICAL)

  263.     {

  264.         fMidiMap = kMidiKey2RectMapVertical;

  265.         fPixmap.load(QString(":/bitmaps/kbd_v_%1.png").arg(fColorStr));

  266.         fPixmapMode = VERTICAL;

  267.         fWidth  = fPixmap.width() / 2;

  268.         fHeight = fPixmap.height();

  269.     }

  270.     else

  271.     {

  272.         qCritical("PixmapKeyboard::setMode(%i, %i) - invalid mode", mode, color);

  273.         return setMode(HORIZONTAL);

  274.     }

  275. 

  276.     setOctaves(fOctaves);

  277. }

  278. 

  279. void PixmapKeyboard::setOctaves(int octaves)

  280. {

  281.     Q_ASSERT(octaves >= 1 && octaves <= 10);

  282. 

  283.     if (octaves < 1)

  284.         octaves = 1;

  285.     else if (octaves > 10)

  286.         octaves = 10;

  287. 

  288.     fOctaves = octaves;

  289. 

  290.     if (fPixmapMode == HORIZONTAL)

  291.     {

  292.         setMinimumSize(fWidth * fOctaves, fHeight);

  293.         setMaximumSize(fWidth * fOctaves, fHeight);

  294.     }

  295.     else if (fPixmapMode == VERTICAL)

  296.     {

  297.         setMinimumSize(fWidth, fHeight * fOctaves);

  298.         setMaximumSize(fWidth, fHeight * fOctaves);

  299.     }

  300. 

  301.     update();

  302. }

  303. 

  304. void PixmapKeyboard::handleMousePos(const QPoint& pos)

  305. {

  306.     int note, octave;

  307.     QPointF keyPos;

  308. 

  309.     if (fPixmapMode == HORIZONTAL)

  310.     {

  311.         if (pos.x() < 0 or pos.x() > fOctaves * 144)

  312.             return;

  313.         int posX = pos.x() - 1;

  314.         octave = posX / fWidth;

  315.         keyPos = QPointF(posX % fWidth, pos.y());

  316.     }

  317.     else if (fPixmapMode == VERTICAL)

  318.     {

  319.         if (pos.y() < 0 or pos.y() > fOctaves * 144)

  320.             return;

  321.         int posY = pos.y() - 1;

  322.         octave = fOctaves - posY / fHeight;

  323.         keyPos = QPointF(pos.x(), posY % fHeight);

  324.     }

  325.     else

  326.         return;

  327. 

  328.     if (fMidiMap[1].contains(keyPos))      // C#

  329.         note = 1;

  330.     else if (fMidiMap[3].contains(keyPos)) // D#

  331.         note = 3;

  332.     else if (fMidiMap[6].contains(keyPos)) // F#

  333.         note = 6;

  334.     else if (fMidiMap[8].contains(keyPos)) // G#

  335.         note = 8;

  336.     else if (fMidiMap[10].contains(keyPos))// A#

  337.         note = 10;

  338.     else if (fMidiMap[0].contains(keyPos)) // C

  339.         note = 0;

  340.     else if (fMidiMap[2].contains(keyPos)) // D

  341.         note = 2;

  342.     else if (fMidiMap[4].contains(keyPos)) // E

  343.         note = 4;

  344.     else if (fMidiMap[5].contains(keyPos)) // F

  345.         note = 5;

  346.     else if (fMidiMap[7].contains(keyPos)) // G

  347.         note = 7;

  348.     else if (fMidiMap[9].contains(keyPos)) // A

  349.         note = 9;

  350.     else if (fMidiMap[11].contains(keyPos))// B

  351.         note = 11;

  352.     else

  353.         note = -1;

  354. 

  355.     if (note != -1)

  356.     {

  357.         note += octave * 12;

  358. 

  359.         if (fLastMouseNote != note)

  360.         {

  361.             sendNoteOff(fLastMouseNote);

  362.             sendNoteOn(note);

  363.         }

  364.     }

  365.     else if (fLastMouseNote != -1)

  366.         sendNoteOff(fLastMouseNote);

  367. 

  368.     fLastMouseNote = note;

  369. }

  370. 

  371. void PixmapKeyboard::keyPressEvent(QKeyEvent* event)

  372. {

  373.     if (! event->isAutoRepeat())

  374.     {

  375.         int qKey = event->key();

  376.         std::map<int, int>::const_iterator it = kMidiKeyboard2KeyMap.find(qKey);

  377.         if (it != kMidiKeyboard2KeyMap.end())

  378.             sendNoteOn(it->second);

  379.     }

  380.     QWidget::keyPressEvent(event);

  381. }

  382. 

  383. void PixmapKeyboard::keyReleaseEvent(QKeyEvent* event)

  384. {

  385.     if (! event->isAutoRepeat())

  386.     {

  387.         int qKey = event->key();

  388.         std::map<int, int>::const_iterator it = kMidiKeyboard2KeyMap.find(qKey);

  389.         if (it != kMidiKeyboard2KeyMap.end())

  390.             sendNoteOff(it->second);

  391.     }

  392.     QWidget::keyReleaseEvent(event);

  393. }

  394. 

  395. void PixmapKeyboard::mousePressEvent(QMouseEvent* event)

  396. {

  397.     fLastMouseNote = -1;

  398.     handleMousePos(event->pos());

  399.     setFocus();

  400.     QWidget::mousePressEvent(event);

  401. }

  402. 

  403. void PixmapKeyboard::mouseMoveEvent(QMouseEvent* event)

  404. {

  405.     handleMousePos(event->pos());

  406.     QWidget::mouseMoveEvent(event);

  407. }

  408. 

  409. void PixmapKeyboard::mouseReleaseEvent(QMouseEvent* event)

  410. {

  411.     if (fLastMouseNote != -1)

  412.     {

  413.         sendNoteOff(fLastMouseNote);

  414.         fLastMouseNote = -1;

  415.     }

  416.     QWidget::mouseReleaseEvent(event);

  417. }

  418. 

  419. void PixmapKeyboard::paintEvent(QPaintEvent* event)

  420. {

  421.     QPainter painter(this);

  422.     event->accept();

  423. 

  424.     // -------------------------------------------------------------

  425.     // Paint clean keys (as background)

  426. 

  427.     for (int octave=0; octave < fOctaves; ++octave)

  428.     {

  429.         QRectF target;

  430. 

  431.         if (fPixmapMode == HORIZONTAL)

  432.             target = QRectF(fWidth * octave, 0, fWidth, fHeight);

  433.         else if (fPixmapMode == VERTICAL)

  434.             target = QRectF(0, fHeight * octave, fWidth, fHeight);

  435.         else

  436.             return;

  437. 

  438.         QRectF source = QRectF(0, 0, fWidth, fHeight);

  439.         painter.drawPixmap(target, fPixmap, source);

  440.     }

  441. 

  442.     // -------------------------------------------------------------

  443.     // Paint (white) pressed keys

  444. 

  445.     bool paintedWhite = false;

  446. 

  447.     for (int i=0, count=fEnabledKeys.count(); i < count; ++i)

  448.     {

  449.         int octave, note = fEnabledKeys[i];

  450.         const QRectF& pos(_getRectFromMidiNote(note));

  451. 

  452.         if (_isNoteBlack(note))

  453.             continue;

  454. 

  455.         if (note < 12)

  456.             octave = 0;

  457.         else if (note < 24)

  458.             octave = 1;

  459.         else if (note < 36)

  460.             octave = 2;

  461.         else if (note < 48)

  462.             octave = 3;

  463.         else if (note < 60)

  464.             octave = 4;

  465.         else if (note < 72)

  466.             octave = 5;

  467.         else if (note < 84)

  468.             octave = 6;

  469.         else if (note < 96)

  470.             octave = 7;

  471.         else if (note < 108)

  472.             octave = 8;

  473.         else if (note < 120)

  474.             octave = 9;

  475.         else if (note < 132)

  476.             octave = 10;

  477.         else

  478.             // cannot paint this note

  479.             continue;

  480. 

  481.         if (fPixmapMode == VERTICAL)

  482.             octave = fOctaves - octave - 1;

  483. 

  484.         QRectF target, source;

  485. 

  486.         if (fPixmapMode == HORIZONTAL)

  487.         {

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

  489.             source = QRectF(pos.x(), fHeight, pos.width(), pos.height());

  490.         }

  491.         else if (fPixmapMode == VERTICAL)

  492.         {

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

  494.             source = QRectF(fWidth, pos.y(), pos.width(), pos.height());

  495.         }

  496.         else

  497.             return;

  498. 

  499.         paintedWhite = true;

  500.         painter.drawPixmap(target, fPixmap, source);

  501.     }

  502. 

  503.     // -------------------------------------------------------------

  504.     // Clear white keys border

  505. 

  506.     if (paintedWhite)

  507.     {

  508.         for (int octave=0; octave < fOctaves; ++octave)

  509.         {

  510.             foreach (int note, kBlackNotes)

  511.             {

  512.                 QRectF target, source;

  513.                 const QRectF& pos(_getRectFromMidiNote(note));

  514. 

  515.                 if (fPixmapMode == HORIZONTAL)

  516.                 {

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

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

  519.                 }

  520.                 else if (fPixmapMode == VERTICAL)

  521.                 {

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

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

  524.                 }

  525.                 else

  526.                     return;

  527. 

  528.                 painter.drawPixmap(target, fPixmap, source);

  529.             }

  530.         }

  531.     }

  532. 

  533.     // -------------------------------------------------------------

  534.     // Paint (black) pressed keys

  535. 

  536.     for (int i=0, count=fEnabledKeys.count(); i < count; ++i)

  537.     {

  538.         int octave, note = fEnabledKeys[i];

  539.         const QRectF& pos(_getRectFromMidiNote(note));

  540. 

  541.         if (! _isNoteBlack(note))

  542.             continue;

  543. 

  544.         if (note < 12)

  545.             octave = 0;

  546.         else if (note < 24)

  547.             octave = 1;

  548.         else if (note < 36)

  549.             octave = 2;

  550.         else if (note < 48)

  551.             octave = 3;

  552.         else if (note < 60)

  553.             octave = 4;

  554.         else if (note < 72)

  555.             octave = 5;

  556.         else if (note < 84)

  557.             octave = 6;

  558.         else if (note < 96)

  559.             octave = 7;

  560.         else if (note < 108)

  561.             octave = 8;

  562.         else if (note < 120)

  563.             octave = 9;

  564.         else if (note < 132)

  565.             octave = 10;

  566.         else

  567.             // cannot paint this note

  568.             continue;

  569. 

  570.         if (fPixmapMode == VERTICAL)

  571.             octave = fOctaves - octave - 1;

  572. 

  573.         QRectF target, source;

  574. 

  575.         if (fPixmapMode == HORIZONTAL)

  576.         {

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

  578.             source = QRectF(pos.x(), fHeight, pos.width(), pos.height());

  579.         }

  580.         else if (fPixmapMode == VERTICAL)

  581.         {

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

  583.             source = QRectF(fWidth, pos.y(), pos.width(), pos.height());

  584.         }

  585.         else

  586.             return;

  587. 

  588.         painter.drawPixmap(target, fPixmap, source);

  589.     }

  590. 

  591.     // Paint C-number note info

  592.     painter.setFont(fFont);

  593.     painter.setPen(Qt::black);

  594. 

  595.     for (int i=0; i < fOctaves; ++i)

  596.     {

  597.         if (fPixmapMode == HORIZONTAL)

  598.             painter.drawText(i * 144, 48, 18, 18, Qt::AlignCenter, QString("C%1").arg(i-1));

  599.         else if (fPixmapMode == VERTICAL)

  600.             painter.drawText(45, (fOctaves * 144) - (i * 144) - 16, 18, 18, Qt::AlignCenter, QString("C%1").arg(i-1));

  601.     }

  602. }

  603. 

  604. bool PixmapKeyboard::_isNoteBlack(int note) const

  605. {

  606.     const int baseNote = note % 12;

  607.     return kBlackNotes.contains(baseNote);

  608. }

  609. 

  610. const QRectF& PixmapKeyboard::_getRectFromMidiNote(int note) const

  611. {

  612.     const int baseNote = note % 12;

  613.     return fMidiMap[baseNote];

  614. }