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.
361 Commits
2 Branches
236MB
Tree: e5a867fcb8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e5a867fcb8'
${ noResults }
Cadence/c++/xycontroller/xycontroller.cpp

937 lines
27KB
Raw Blame History 

  1. /*

  2.  * Simple JACK Audio Meter

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

  4.  *

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

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

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * 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 <QtCore/Qt>

  19. 

  20. #ifndef Q_COMPILER_LAMBDA

  21. #  define nullptr (0)

  22. #endif

  23. 

  24. #define VERSION "0.5.0"

  25. 

  26. //#include "../jack_utils.h"

  27. #include "ui_xycontroller.h"

  28. 

  29. //#include <QtCore/QMutex>

  30. #include <QtCore/QSettings>

  31. #include <QtCore/QTimer>

  32. #include <QtGui/QApplication>

  33. #include <QtGui/QGraphicsItem>

  34. #include <QtGui/QGraphicsScene>

  35. #include <QtGui/QGraphicsSceneEvent>

  36. #include <QtGui/QKeyEvent>

  37. #include <QtGui/QMainWindow>

  38. #include <QtGui/QMessageBox>

  39. 

  40. // -------------------------------

  41. 

  42. class Queue {

  43. public:

  44.     Queue(int size_) :

  45.         size(size_)

  46.     {

  47.     }

  48. 

  49.     ~Queue()

  50.     {

  51.     }

  52. 

  53.     void put_nowait(int, int, int)

  54.     {

  55.         //const QMutexLocker m(&mutex);

  56.     }

  57. 

  58. private:

  59.     const int size;

  60.     //QMutex mutex;

  61. };

  62. 

  63. qreal abs_q(const qreal value)

  64. {

  65.     if (value < 1.0)

  66.         return -value;

  67.     return value;

  68. }

  69. 

  70. #if 0

  71. jack_client_t* jack_client = nullptr;

  72. jack_port_t* jack_midi_in_port  = nullptr;

  73. jack_port_t* jack_midi_out_port = nullptr;

  74. #endif

  75. Queue jack_midi_in_data  = Queue(512);

  76. Queue jack_midi_out_data = Queue(512);

  77. 

  78. QVector<QString> MIDI_CC_LIST;

  79. void MIDI_CC_LIST__init()

  80. {

  81.     //MIDI_CC_LIST << "0x00 Bank Select";

  82.     MIDI_CC_LIST << "0x01 Modulation";

  83.     MIDI_CC_LIST << "0x02 Breath";

  84.     MIDI_CC_LIST << "0x03 (Undefined)";

  85.     MIDI_CC_LIST << "0x04 Foot";

  86.     MIDI_CC_LIST << "0x05 Portamento";

  87.     //MIDI_CC_LIST << "0x06 (Data Entry MSB)";

  88.     MIDI_CC_LIST << "0x07 Volume";

  89.     MIDI_CC_LIST << "0x08 Balance";

  90.     MIDI_CC_LIST << "0x09 (Undefined)";

  91.     MIDI_CC_LIST << "0x0A Pan";

  92.     MIDI_CC_LIST << "0x0B Expression";

  93.     MIDI_CC_LIST << "0x0C FX Control 1";

  94.     MIDI_CC_LIST << "0x0D FX Control 2";

  95.     MIDI_CC_LIST << "0x0E (Undefined)";

  96.     MIDI_CC_LIST << "0x0F (Undefined)";

  97.     MIDI_CC_LIST << "0x10 General Purpose 1";

  98.     MIDI_CC_LIST << "0x11 General Purpose 2";

  99.     MIDI_CC_LIST << "0x12 General Purpose 3";

  100.     MIDI_CC_LIST << "0x13 General Purpose 4";

  101.     MIDI_CC_LIST << "0x14 (Undefined)";

  102.     MIDI_CC_LIST << "0x15 (Undefined)";

  103.     MIDI_CC_LIST << "0x16 (Undefined)";

  104.     MIDI_CC_LIST << "0x17 (Undefined)";

  105.     MIDI_CC_LIST << "0x18 (Undefined)";

  106.     MIDI_CC_LIST << "0x19 (Undefined)";

  107.     MIDI_CC_LIST << "0x1A (Undefined)";

  108.     MIDI_CC_LIST << "0x1B (Undefined)";

  109.     MIDI_CC_LIST << "0x1C (Undefined)";

  110.     MIDI_CC_LIST << "0x1D (Undefined)";

  111.     MIDI_CC_LIST << "0x1E (Undefined)";

  112.     MIDI_CC_LIST << "0x1F (Undefined)";

  113.     //MIDI_CC_LIST << "0x20 *Bank Select";

  114.     //MIDI_CC_LIST << "0x21 *Modulation";

  115.     //MIDI_CC_LIST << "0x22 *Breath";

  116.     //MIDI_CC_LIST << "0x23 *(Undefined)";

  117.     //MIDI_CC_LIST << "0x24 *Foot";

  118.     //MIDI_CC_LIST << "0x25 *Portamento";

  119.     //MIDI_CC_LIST << "0x26 *(Data Entry MSB)";

  120.     //MIDI_CC_LIST << "0x27 *Volume";

  121.     //MIDI_CC_LIST << "0x28 *Balance";

  122.     //MIDI_CC_LIST << "0x29 *(Undefined)";

  123.     //MIDI_CC_LIST << "0x2A *Pan";

  124.     //MIDI_CC_LIST << "0x2B *Expression";

  125.     //MIDI_CC_LIST << "0x2C *FX *Control 1";

  126.     //MIDI_CC_LIST << "0x2D *FX *Control 2";

  127.     //MIDI_CC_LIST << "0x2E *(Undefined)";

  128.     //MIDI_CC_LIST << "0x2F *(Undefined)";

  129.     //MIDI_CC_LIST << "0x30 *General Purpose 1";

  130.     //MIDI_CC_LIST << "0x31 *General Purpose 2";

  131.     //MIDI_CC_LIST << "0x32 *General Purpose 3";

  132.     //MIDI_CC_LIST << "0x33 *General Purpose 4";

  133.     //MIDI_CC_LIST << "0x34 *(Undefined)";

  134.     //MIDI_CC_LIST << "0x35 *(Undefined)";

  135.     //MIDI_CC_LIST << "0x36 *(Undefined)";

  136.     //MIDI_CC_LIST << "0x37 *(Undefined)";

  137.     //MIDI_CC_LIST << "0x38 *(Undefined)";

  138.     //MIDI_CC_LIST << "0x39 *(Undefined)";

  139.     //MIDI_CC_LIST << "0x3A *(Undefined)";

  140.     //MIDI_CC_LIST << "0x3B *(Undefined)";

  141.     //MIDI_CC_LIST << "0x3C *(Undefined)";

  142.     //MIDI_CC_LIST << "0x3D *(Undefined)";

  143.     //MIDI_CC_LIST << "0x3E *(Undefined)";

  144.     //MIDI_CC_LIST << "0x3F *(Undefined)";

  145.     //MIDI_CC_LIST << "0x40 Damper On/Off"; // <63 off, >64 on

  146.     //MIDI_CC_LIST << "0x41 Portamento On/Off"; // <63 off, >64 on

  147.     //MIDI_CC_LIST << "0x42 Sostenuto On/Off"; // <63 off, >64 on

  148.     //MIDI_CC_LIST << "0x43 Soft Pedal On/Off"; // <63 off, >64 on

  149.     //MIDI_CC_LIST << "0x44 Legato Footswitch"; // <63 Normal, >64 Legato

  150.     //MIDI_CC_LIST << "0x45 Hold 2"; // <63 off, >64 on

  151.     MIDI_CC_LIST << "0x46 Control 1 [Variation]";

  152.     MIDI_CC_LIST << "0x47 Control 2 [Timbre]";

  153.     MIDI_CC_LIST << "0x48 Control 3 [Release]";

  154.     MIDI_CC_LIST << "0x49 Control 4 [Attack]";

  155.     MIDI_CC_LIST << "0x4A Control 5 [Brightness]";

  156.     MIDI_CC_LIST << "0x4B Control 6 [Decay]";

  157.     MIDI_CC_LIST << "0x4C Control 7 [Vib Rate]";

  158.     MIDI_CC_LIST << "0x4D Control 8 [Vib Depth]";

  159.     MIDI_CC_LIST << "0x4E Control 9 [Vib Delay]";

  160.     MIDI_CC_LIST << "0x4F Control 10 [Undefined]";

  161.     MIDI_CC_LIST << "0x50 General Purpose 5";

  162.     MIDI_CC_LIST << "0x51 General Purpose 6";

  163.     MIDI_CC_LIST << "0x52 General Purpose 8";

  164.     MIDI_CC_LIST << "0x53 General Purpose 9";

  165.     MIDI_CC_LIST << "0x54 Portamento Control";

  166.     MIDI_CC_LIST << "0x5B FX 1 Depth [Reverb]";

  167.     MIDI_CC_LIST << "0x5C FX 2 Depth [Tremolo]";

  168.     MIDI_CC_LIST << "0x5D FX 3 Depth [Chorus]";

  169.     MIDI_CC_LIST << "0x5E FX 4 Depth [Detune]";

  170.     MIDI_CC_LIST << "0x5F FX 5 Depth [Phaser]";

  171. }

  172. 

  173. // -------------------------------

  174. // XY Controller Scene

  175. 

  176. class XYGraphicsScene : public QGraphicsScene

  177. {

  178.     Q_OBJECT

  179. 

  180. public:

  181.     XYGraphicsScene(QWidget* parent) : QGraphicsScene(parent), m_parent(parent)

  182.     {

  183.         cc_x = 1;

  184.         cc_y = 2;

  185. 

  186.         m_mouseLock = false;

  187.         m_smooth = false;

  188.         m_smooth_x = 0;

  189.         m_smooth_y = 0;

  190. 

  191.         setBackgroundBrush(Qt::black);

  192. 

  193.         QPen cursorPen(QColor(255, 255, 255), 2);

  194.         QColor cursorBrush(255, 255, 255, 50);

  195.         m_cursor = addEllipse(QRectF(-10, -10, 20, 20), cursorPen, cursorBrush);

  196. 

  197.         QPen linePen(QColor(200, 200, 200, 100), 1, Qt::DashLine);

  198.         m_lineH = addLine(-9999, 0, 9999, 0, linePen);

  199.         m_lineV = addLine(0, -9999, 0, 9999, linePen);

  200. 

  201.         p_size = QRectF(-100, -100, 100, 100);

  202.     }

  203. 

  204.     ~XYGraphicsScene()

  205.     {

  206.     }

  207. 

  208.     void setControlX(int x)

  209.     {

  210.         cc_x = x;

  211.     }

  212. 

  213.     void setControlY(int y)

  214.     {

  215.         cc_y = y;

  216.     }

  217. 

  218.     void setChannels(QList<int> channels)

  219.     {

  220.         m_channels = channels;

  221.     }

  222. 

  223.     void setPosX(qreal x, bool forward=true)

  224.     {

  225.         if (! m_mouseLock)

  226.         {

  227.             qreal pos_x = x * (p_size.x() + p_size.width());

  228.             m_cursor->setPos(pos_x, m_cursor->y());

  229.             m_lineV->setX(pos_x);

  230. 

  231.             if (forward)

  232.             {

  233.                 qreal value = pos_x / (p_size.x() + p_size.width());

  234.                 sendMIDI(&value, nullptr);

  235.             }

  236.             else

  237.                 m_smooth_x = pos_x;

  238.         }

  239.     }

  240. 

  241.     void setPosY(qreal y, bool forward=true)

  242.     {

  243.         if (! m_mouseLock)

  244.         {

  245.             qreal pos_y = y * (p_size.y() + p_size.height());

  246.             m_cursor->setPos(m_cursor->x(), pos_y);

  247.             m_lineH->setY(pos_y);

  248. 

  249.             if (forward)

  250.             {

  251.                 qreal value = pos_y / (p_size.y() + p_size.height());

  252.                 sendMIDI(nullptr, &value);

  253.             }

  254.             else

  255.                 m_smooth_y = pos_y;

  256.         }

  257.     }

  258. 

  259.     void setSmooth(bool smooth)

  260.     {

  261.         m_smooth = smooth;

  262.     }

  263. 

  264.     void setSmoothValues(int x, int y)

  265.     {

  266.         m_smooth_x = x * (p_size.x() + p_size.width());

  267.         m_smooth_y = y * (p_size.y() + p_size.height());

  268.     }

  269. 

  270.     void handleCC(int param, int value)

  271.     {

  272.         bool sendUpdate = false;

  273.         qreal xp, yp;

  274.         xp = yp = 0.0;

  275. 

  276.         if (param == cc_x)

  277.         {

  278.             sendUpdate = true;

  279.             xp = (float(value) / 63) - 1.0;

  280.             yp = m_cursor->y() / (p_size.y() + p_size.height());

  281. 

  282.             if (xp < -1.0)

  283.                 xp = -1.0;

  284.             else if (xp > 1.0)

  285.                 xp = 1.0;

  286. 

  287.             setPosX(xp, false);

  288.         }

  289. 

  290.         if (param == cc_y)

  291.         {

  292.             sendUpdate = true;

  293.             xp = m_cursor->x() / (p_size.x() + p_size.width());

  294.             yp = (float(value) / 63) - 1.0;

  295. 

  296.             if (yp < -1.0)

  297.                 yp = -1.0;

  298.             else if (yp > 1.0)

  299.                 yp = 1.0;

  300. 

  301.             setPosY(yp, false);

  302.         }

  303. 

  304.         if (sendUpdate)

  305.             emit cursorMoved(xp, yp);

  306.     }

  307. 

  308.     void updateSize(QSize size)

  309.     {

  310.         p_size.setRect(-(size.width() / 2), -(size.height() / 2), size.width(), size.height());

  311.     }

  312. 

  313.     void updateSmooth()

  314.     {

  315.         if (! m_smooth)

  316.             return;

  317. 

  318.         if (m_cursor->x() != m_smooth_x || m_cursor->y() != m_smooth_y)

  319.         {

  320.             if (abs(m_cursor->x() - m_smooth_x) <= 0.001)

  321.             {

  322.                 m_smooth_x = m_cursor->x();

  323.                 return;

  324.             }

  325.             else if (abs(m_cursor->y() - m_smooth_y) <= 0.001)

  326.             {

  327.                 m_smooth_y = m_cursor->y();

  328.                 return;

  329.             }

  330. 

  331.             qreal new_x = (m_smooth_x + m_cursor->x() * 3) / 4;

  332.             qreal new_y = (m_smooth_y + m_cursor->y() * 3) / 4;

  333.             QPointF pos(new_x, new_y);

  334. 

  335.             m_cursor->setPos(pos);

  336.             m_lineH->setY(pos.y());

  337.             m_lineV->setX(pos.x());

  338. 

  339.             qreal xp = pos.x() / (p_size.x() + p_size.width());

  340.             qreal yp = pos.y() / (p_size.y() + p_size.height());

  341. 

  342.             sendMIDI(&xp, &yp);

  343.             emit cursorMoved(xp, yp);

  344.         }

  345.     }

  346. 

  347. protected:

  348.     void handleMousePos(QPointF pos)

  349.     {

  350.         if (! p_size.contains(pos))

  351.         {

  352.             if (pos.x() < p_size.x())

  353.                 pos.setX(p_size.x());

  354.             else if (pos.x() > p_size.x() + p_size.width())

  355.                 pos.setX(p_size.x() + p_size.width());

  356. 

  357.             if (pos.y() < p_size.y())

  358.                 pos.setY(p_size.y());

  359.             else if (pos.y() > p_size.y() + p_size.height())

  360.                 pos.setY(p_size.y() + p_size.height());

  361.         }

  362. 

  363.         m_smooth_x = pos.x();

  364.         m_smooth_y = pos.y();

  365. 

  366.         if (! m_smooth)

  367.         {

  368.             m_cursor->setPos(pos);

  369.             m_lineH->setY(pos.y());

  370.             m_lineV->setX(pos.x());

  371. 

  372.             qreal xp = pos.x() / (p_size.x() + p_size.width());

  373.             qreal yp = pos.y() / (p_size.y() + p_size.height());

  374. 

  375.             sendMIDI(&xp, &yp);

  376. 

  377.             emit cursorMoved(xp, yp);

  378.         }

  379.     }

  380. 

  381.     void sendMIDI(qreal* xp=nullptr, qreal* yp=nullptr)

  382.     {

  383.         qreal rate = qreal(0xff) / 4;

  384. 

  385.         if (xp != nullptr)

  386.         {

  387.             int value = *xp * rate + rate;

  388.             foreach (const int& channel, m_channels)

  389.                 jack_midi_out_data.put_nowait(0xB0 + channel - 1, cc_x, value);

  390.         }

  391. 

  392.         if (yp != nullptr)

  393.         {

  394.             int value = *yp * rate + rate;

  395.             foreach (const int& channel, m_channels)

  396.                 jack_midi_out_data.put_nowait(0xB0 + channel - 1, cc_y, value);

  397.         }

  398.     }

  399. 

  400.     void keyPressEvent(QKeyEvent* event)

  401.     {

  402.         event->accept();

  403.     }

  404. 

  405.     void wheelEvent(QGraphicsSceneWheelEvent* event)

  406.     {

  407.         event->accept();

  408.     }

  409. 

  410.     void mousePressEvent(QGraphicsSceneMouseEvent* event)

  411.     {

  412.         m_mouseLock = true;

  413.         handleMousePos(event->scenePos());

  414.         parent()->setCursor(Qt::CrossCursor);

  415.         QGraphicsScene::mousePressEvent(event);

  416.     }

  417. 

  418.     void mouseMoveEvent(QGraphicsSceneMouseEvent* event)

  419.     {

  420.         handleMousePos(event->scenePos());

  421.         QGraphicsScene::mouseMoveEvent(event);

  422.     }

  423. 

  424.     void mouseReleaseEvent(QGraphicsSceneMouseEvent* event)

  425.     {

  426.         m_mouseLock = false;

  427.         parent()->setCursor(Qt::ArrowCursor);

  428.         QGraphicsScene::mouseReleaseEvent(event);

  429.     }

  430. 

  431.     QWidget* parent() const

  432.     {

  433.         return m_parent;

  434.     }

  435. 

  436. signals:

  437.     void cursorMoved(qreal, qreal);

  438. 

  439. private:

  440.     int cc_x;

  441.     int cc_y;

  442.     QList<int> m_channels;

  443. 

  444.     bool m_mouseLock;

  445.     bool m_smooth;

  446.     int m_smooth_x;

  447.     int m_smooth_y;

  448. 

  449.     QGraphicsEllipseItem* m_cursor;

  450.     QGraphicsLineItem* m_lineH;

  451.     QGraphicsLineItem* m_lineV;

  452. 

  453.     QRectF p_size;

  454. 

  455.     QWidget* const m_parent;

  456. };

  457. 

  458. // -------------------------------

  459. // XY Controller Window

  460. 

  461. namespace Ui {

  462. class XYControllerW;

  463. }

  464. 

  465. class XYControllerW : public QMainWindow

  466. {

  467.     Q_OBJECT

  468. 

  469. public:

  470.     XYControllerW() :

  471.         QMainWindow(nullptr),

  472.         scene(this),

  473.         settings("Cadence", "XY-Controller"),

  474.         ui(new Ui::XYControllerW)

  475.     {

  476.         ui->setupUi(this);

  477. 

  478.         // -------------------------------------------------------------

  479.         // Internal stuff

  480. 

  481.         cc_x = 1;

  482.         cc_y = 2;

  483. 

  484.         // -------------------------------------------------------------

  485.         // Set-up GUI stuff

  486. 

  487.         ui->dial_x->setPixmap(2);

  488.         ui->dial_y->setPixmap(2);

  489.         ui->dial_x->setLabel("X");

  490.         ui->dial_y->setLabel("Y");

  491.         ui->keyboard->setOctaves(6);

  492. 

  493.         ui->graphicsView->setScene(&scene);

  494.         ui->graphicsView->setRenderHints(QPainter::Antialiasing);

  495. 

  496.         foreach (const QString& MIDI_CC, MIDI_CC_LIST)

  497.         {

  498.             ui->cb_control_x->addItem(MIDI_CC);

  499.             ui->cb_control_y->addItem(MIDI_CC);

  500.         }

  501. 

  502.         // -------------------------------------------------------------

  503.         // Load Settings

  504. 

  505.         loadSettings();

  506. 

  507.         // -------------------------------------------------------------

  508.         // Connect actions to functions

  509. 

  510.         connect(ui->keyboard, SIGNAL(noteOn(int)), SLOT(noteOn(int)));

  511.         connect(ui->keyboard, SIGNAL(noteOff(int)), SLOT(noteOff(int)));

  512. 

  513.         connect(ui->cb_smooth, SIGNAL(clicked(bool)), SLOT(setSmooth(bool)));

  514. 

  515.         connect(ui->dial_x, SIGNAL(valueChanged(int)), SLOT(updateSceneX(int)));

  516.         connect(ui->dial_y, SIGNAL(valueChanged(int)), SLOT(updateSceneY(int)));

  517. 

  518.         connect(ui->cb_control_x, SIGNAL(currentIndexChanged(QString)), SLOT(checkCC_X(QString)));

  519.         connect(ui->cb_control_y, SIGNAL(currentIndexChanged(QString)), SLOT(checkCC_Y(QString)));

  520. 

  521.         connect(&scene, SIGNAL(cursorMoved(qreal, qreal)), SLOT(sceneCursorMoved(qreal, qreal)));

  522. 

  523.         connect(ui->act_ch_01, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  524.         connect(ui->act_ch_02, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  525.         connect(ui->act_ch_03, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  526.         connect(ui->act_ch_04, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  527.         connect(ui->act_ch_05, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  528.         connect(ui->act_ch_06, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  529.         connect(ui->act_ch_07, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  530.         connect(ui->act_ch_08, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  531.         connect(ui->act_ch_09, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  532.         connect(ui->act_ch_10, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  533.         connect(ui->act_ch_11, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  534.         connect(ui->act_ch_12, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  535.         connect(ui->act_ch_13, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  536.         connect(ui->act_ch_14, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  537.         connect(ui->act_ch_15, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  538.         connect(ui->act_ch_16, SIGNAL(triggered(bool)), SLOT(checkChannel(bool)));

  539.         connect(ui->act_ch_all, SIGNAL(triggered()), SLOT(checkChannel_all()));

  540.         connect(ui->act_ch_none, SIGNAL(triggered()), SLOT(checkChannel_none()));

  541. 

  542.         connect(ui->act_show_keyboard, SIGNAL(triggered(bool)), SLOT(showKeyboard(bool)));

  543.         connect(ui->act_about, SIGNAL(triggered()), SLOT(about()));

  544. 

  545.         // -------------------------------------------------------------

  546.         // Final stuff

  547. 

  548.         m_midiInTimerId = startTimer(50);

  549.         QTimer::singleShot(0, this, SLOT(updateScreen()));

  550.     }

  551. 

  552. protected slots:

  553.     void noteOn(int note)

  554.     {

  555.         foreach (const int& channel, m_channels)

  556.             jack_midi_out_data.put_nowait(0x90 + channel - 1, note, 100);

  557.     }

  558. 

  559.     void noteOff(int note)

  560.     {

  561.         foreach (const int& channel, m_channels)

  562.             jack_midi_out_data.put_nowait(0x80 + channel - 1, note, 0);

  563.     }

  564. 

  565.     void updateSceneX(int x)

  566.     {

  567.         scene.setPosX(float(x) / 100, bool(sender()));

  568.     }

  569. 

  570.     void updateSceneY(int y)

  571.     {

  572.         scene.setPosY(float(y) / 100, bool(sender()));

  573.     }

  574. 

  575.     void checkCC_X(QString text)

  576.     {

  577.         if (! text.isEmpty())

  578.         {

  579.             bool ok;

  580.             int tmp_cc_x = text.split(" ").at(0).toInt(&ok, 16);

  581. 

  582.             if (ok)

  583.             {

  584.                 cc_x = tmp_cc_x;

  585.                 scene.setControlX(cc_x);

  586.             }

  587.         }

  588.     }

  589. 

  590.     void checkCC_Y(QString text)

  591.     {

  592.         if (! text.isEmpty())

  593.         {

  594.             bool ok;

  595.             int tmp_cc_y = text.split(" ").at(0).toInt(&ok, 16);

  596. 

  597.             if (ok)

  598.             {

  599.                 cc_y = tmp_cc_y;

  600.                 scene.setControlY(cc_y);

  601.             }

  602.         }

  603.     }

  604. 

  605.     void checkChannel(bool clicked)

  606.     {

  607.         if (! sender())

  608.             return;

  609. 

  610.         bool ok;

  611.         int channel = ((QAction*)sender())->text().toInt(&ok);

  612. 

  613.         if (ok)

  614.         {

  615.             if (clicked && ! m_channels.contains(channel))

  616.                 m_channels.append(channel);

  617.             else if ((! clicked) && m_channels.contains(channel))

  618.                 m_channels.removeOne(channel);

  619.             scene.setChannels(m_channels);

  620.         }

  621.     }

  622. 

  623.     void checkChannel_all()

  624.     {

  625.         ui->act_ch_01->setChecked(true);

  626.         ui->act_ch_02->setChecked(true);

  627.         ui->act_ch_03->setChecked(true);

  628.         ui->act_ch_04->setChecked(true);

  629.         ui->act_ch_05->setChecked(true);

  630.         ui->act_ch_06->setChecked(true);

  631.         ui->act_ch_07->setChecked(true);

  632.         ui->act_ch_08->setChecked(true);

  633.         ui->act_ch_09->setChecked(true);

  634.         ui->act_ch_10->setChecked(true);

  635.         ui->act_ch_11->setChecked(true);

  636.         ui->act_ch_12->setChecked(true);

  637.         ui->act_ch_13->setChecked(true);

  638.         ui->act_ch_14->setChecked(true);

  639.         ui->act_ch_15->setChecked(true);

  640.         ui->act_ch_16->setChecked(true);

  641. 

  642. #ifdef Q_COMPILER_INITIALIZER_LISTS

  643.         m_channels = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};

  644. #else

  645.         m_channels.clear();

  646. 

  647.         for (int i=1; i <= 16; i++)

  648.             m_channels << i;

  649. #endif

  650.         scene.setChannels(m_channels);

  651.     }

  652. 

  653.     void checkChannel_none()

  654.     {

  655.         ui->act_ch_01->setChecked(false);

  656.         ui->act_ch_02->setChecked(false);

  657.         ui->act_ch_03->setChecked(false);

  658.         ui->act_ch_04->setChecked(false);

  659.         ui->act_ch_05->setChecked(false);

  660.         ui->act_ch_06->setChecked(false);

  661.         ui->act_ch_07->setChecked(false);

  662.         ui->act_ch_08->setChecked(false);

  663.         ui->act_ch_09->setChecked(false);

  664.         ui->act_ch_10->setChecked(false);

  665.         ui->act_ch_11->setChecked(false);

  666.         ui->act_ch_12->setChecked(false);

  667.         ui->act_ch_13->setChecked(false);

  668.         ui->act_ch_14->setChecked(false);

  669.         ui->act_ch_15->setChecked(false);

  670.         ui->act_ch_16->setChecked(false);

  671. 

  672.         m_channels.clear();

  673.         scene.setChannels(m_channels);

  674.     }

  675. 

  676.     void setSmooth(bool yesno)

  677.     {

  678.         scene.setSmooth(yesno);

  679.     }

  680. 

  681.     void sceneCursorMoved(qreal xp, qreal yp)

  682.     {

  683.         ui->dial_x->blockSignals(true);

  684.         ui->dial_y->blockSignals(true);

  685. 

  686.         ui->dial_x->setValue(xp * 100);

  687.         ui->dial_y->setValue(yp * 100);

  688. 

  689.         ui->dial_x->blockSignals(false);

  690.         ui->dial_y->blockSignals(false);

  691.     }

  692. 

  693.     void showKeyboard(bool yesno)

  694.     {

  695.         ui->scrollArea->setVisible(yesno);

  696.         QTimer::singleShot(0, this, SLOT(updateScreen()));

  697.     }

  698. 

  699.     void about()

  700.     {

  701.         QMessageBox::about(this, tr("About XY Controller"), tr("<h3>XY Controller</h3>"

  702.                                                                "<br>Version %1"

  703.                                                                "<br>XY Controller is a simple XY widget that sends and receives data from Jack MIDI.<br>"

  704.                                                                "<br>Copyright (C) 2012 falkTX").arg(VERSION));

  705.     }

  706. 

  707.     void updateScreen()

  708.     {

  709.         scene.updateSize(ui->graphicsView->size());

  710.         ui->graphicsView->centerOn(0, 0);

  711. 

  712.         int dial_x = ui->dial_x->value();

  713.         int dial_y = ui->dial_y->value();

  714.         updateSceneX(dial_x);

  715.         updateSceneY(dial_y);

  716.         scene.setSmoothValues(float(dial_x) / 100, float(dial_y) / 100);

  717.     }

  718. 

  719. protected:

  720.     void saveSettings()

  721.     {

  722.         QVariantList varChannelList;

  723.         foreach (const int& channel, m_channels)

  724.             varChannelList << channel;

  725. 

  726.         settings.setValue("Geometry", saveGeometry());

  727.         settings.setValue("ShowKeyboard", ui->scrollArea->isVisible());

  728.         settings.setValue("Smooth", ui->cb_smooth->isChecked());

  729.         settings.setValue("DialX", ui->dial_x->value());

  730.         settings.setValue("DialY", ui->dial_y->value());

  731.         settings.setValue("ControlX", cc_x);

  732.         settings.setValue("ControlY", cc_y);

  733.         settings.setValue("Channels", varChannelList);

  734.     }

  735. 

  736.     void loadSettings()

  737.     {

  738.         restoreGeometry(settings.value("Geometry").toByteArray());

  739. 

  740.         bool showKeyboard = settings.value("ShowKeyboard", false).toBool();

  741.         ui->act_show_keyboard->setChecked(showKeyboard);

  742.         ui->scrollArea->setVisible(showKeyboard);

  743. 

  744.         bool smooth = settings.value("Smooth", false).toBool();

  745.         ui->cb_smooth->setChecked(smooth);

  746.         scene.setSmooth(smooth);

  747. 

  748.         ui->dial_x->setValue(settings.value("DialX", 50).toInt());

  749.         ui->dial_y->setValue(settings.value("DialY", 50).toInt());

  750. 

  751.         cc_x = settings.value("ControlX", 1).toInt();

  752.         cc_y = settings.value("ControlY", 2).toInt();

  753.         scene.setControlX(cc_x);

  754.         scene.setControlY(cc_y);

  755. 

  756.         m_channels.clear();

  757. 

  758.         if (settings.contains("Channels"))

  759.         {

  760.             QVariantList channels = settings.value("Channels").toList();

  761. 

  762. 

  763.             foreach (const QVariant& var, channels)

  764.             {

  765.                 bool ok;

  766.                 int channel = var.toInt(&ok);

  767. 

  768.                 if (ok)

  769.                     m_channels.append(channel);

  770.             }

  771.         }

  772.         else

  773. #ifdef Q_COMPILER_INITIALIZER_LISTS

  774.             m_channels = { 1 };

  775. #else

  776.             m_channels << 1;

  777. #endif

  778. 

  779.         scene.setChannels(m_channels);

  780. 

  781.         for (int i=0; i < MIDI_CC_LIST.size(); i++)

  782.         {

  783.             bool ok;

  784.             int cc = MIDI_CC_LIST[i].split(" ").at(0).toInt(&ok, 16);

  785. 

  786.             if (ok)

  787.             {

  788.                 if (cc_x == cc)

  789.                     ui->cb_control_x->setCurrentIndex(i);

  790.                 if (cc_y == cc)

  791.                     ui->cb_control_y->setCurrentIndex(i);

  792.             }

  793.         }

  794. 

  795.         if (m_channels.contains(1))

  796.             ui->act_ch_01->setChecked(true);

  797.         if (m_channels.contains(2))

  798.             ui->act_ch_02->setChecked(true);

  799.         if (m_channels.contains(3))

  800.             ui->act_ch_03->setChecked(true);

  801.         if (m_channels.contains(4))

  802.             ui->act_ch_04->setChecked(true);

  803.         if (m_channels.contains(5))

  804.             ui->act_ch_05->setChecked(true);

  805.         if (m_channels.contains(6))

  806.             ui->act_ch_06->setChecked(true);

  807.         if (m_channels.contains(7))

  808.             ui->act_ch_07->setChecked(true);

  809.         if (m_channels.contains(8))

  810.             ui->act_ch_08->setChecked(true);

  811.         if (m_channels.contains(9))

  812.             ui->act_ch_09->setChecked(true);

  813.         if (m_channels.contains(10))

  814.             ui->act_ch_10->setChecked(true);

  815.         if (m_channels.contains(11))

  816.             ui->act_ch_11->setChecked(true);

  817.         if (m_channels.contains(12))

  818.             ui->act_ch_12->setChecked(true);

  819.         if (m_channels.contains(13))

  820.             ui->act_ch_13->setChecked(true);

  821.         if (m_channels.contains(14))

  822.             ui->act_ch_14->setChecked(true);

  823.         if (m_channels.contains(15))

  824.             ui->act_ch_15->setChecked(true);

  825.         if (m_channels.contains(16))

  826.             ui->act_ch_16->setChecked(true);

  827.     }

  828.     void timerEvent(QTimerEvent* event)

  829.     {

  830.         if (event->timerId() == m_midiInTimerId)

  831.         {

  832.             //if not jack_midi_in_data.empty():

  833.             //while True:

  834.             //try:

  835.             //    data1, data2, data3 = jack_midi_in_data.get_nowait()

  836.             //except QuequeEmpty:

  837.             //    break

  838. 

  839.             //channel = (data1 & 0x0F) + 1

  840.             //mode    = data1 & 0xF0

  841. 

  842.             //if channel in self.m_channels:

  843.             //    if mode == 0x80:

  844.             //        self.keyboard.sendNoteOff(data2, False)

  845.             //    elif mode == 0x90:

  846.             //        self.keyboard.sendNoteOn(data2, False)

  847.             //    elif mode == 0xB0:

  848.             //        self.scene.handleCC(data2, data3)

  849. 

  850.             //jack_midi_in_data.task_done()

  851. 

  852.             scene.updateSmooth();

  853.         }

  854. 

  855.         QMainWindow::timerEvent(event);

  856.     }

  857. 

  858.     void resizeEvent(QResizeEvent* event)

  859.     {

  860.         updateScreen();

  861.         QMainWindow::resizeEvent(event);

  862.     }

  863. 

  864.     void closeEvent(QCloseEvent* event)

  865.     {

  866.         saveSettings();

  867.         QMainWindow::closeEvent(event);

  868.     }

  869. 

  870. private:

  871.     int cc_x;

  872.     int cc_y;

  873.     QList<int> m_channels;

  874. 

  875.     int m_midiInTimerId;

  876. 

  877.     XYGraphicsScene scene;

  878.     QSettings settings;

  879. 

  880.     Ui::XYControllerW* ui;

  881. };

  882. 

  883. #include "xycontroller.moc"

  884. 

  885. // -------------------------------

  886. 

  887. // -------------------------------

  888. 

  889. int main(int argc, char* argv[])

  890. {

  891.     MIDI_CC_LIST__init();

  892. 

  893.     QApplication app(argc, argv);

  894.     app.setApplicationName("XY-Controller");

  895.     app.setApplicationVersion(VERSION);

  896.     app.setOrganizationName("Cadence");

  897.     //app.setWindowIcon(QIcon(":/48x48/xy-controller.png"));

  898. 

  899. #if 0

  900.     // JACK initialization

  901.     jack_status_t jStatus;

  902.     jack_options_t jOptions = static_cast<JackOptions>(JackNoStartServer/*|JackSessionID*/);

  903.     jack_client = jack_client_open("XY-Controller", jOptions, &jStatus);

  904. 

  905.     if (! jack_client)

  906.     {

  907.         std::string errorString(jack_status_get_error_string(jStatus));

  908.         QMessageBox::critical(nullptr, app.translate("XY-Controller", "Error"), app.translate("XY-Controller",

  909.                                                                                               "Could not connect to JACK, possible reasons:\n"

  910.                                                                                               "%1").arg(QString::fromStdString(errorString)));

  911.         return 1;

  912.     }

  913. 

  914.     jack_midi_in_port  = jack_port_register(jack_client, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);

  915.     jack_midi_out_port = jack_port_register(jack_client, "midi_out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);

  916. 

  917.     //jack_set_process_callback(jClient, process_callback, nullptr);

  918.     //jack_set_port_connect_callback(jClient, port_callback, nullptr);

  919.     //jack_set_session_callback(jClient, session_callback, argv[0]);

  920.     jack_activate(jack_client);

  921. #endif

  922. 

  923.     // Show GUI

  924.     XYControllerW gui;

  925.     gui.show();

  926. 

  927.     // App-Loop

  928.     int ret = app.exec();

  929. 

  930. #if 0

  931.     jack_deactivate(jack_client);

  932.     jack_client_close(jack_client);

  933. #endif

  934. 

  935.     return ret;

  936. }