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

995 lines
29KB
Raw Blame History 

  1. /*

  2.  * Simple JACK Audio Meter

  3.  * Copyright (C) 2011-2012 Filipe Coelho <falktx@falktx.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 "../queue.h"

  28. #include "ui_xycontroller.h"

  29. 

  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. float abs_f(const float value)

  43. {

  44.     return (value < 1.0f) ? -value : value;

  45. }

  46. 

  47. jack_client_t* jClient = nullptr;

  48. jack_port_t* jMidiInPort  = nullptr;

  49. jack_port_t* jMidiOutPort = nullptr;

  50. 

  51. static Queue qMidiInData;

  52. static Queue qMidiOutData;

  53. 

  54. QVector<QString> MIDI_CC_LIST;

  55. void MIDI_CC_LIST__init()

  56. {

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

  58.     MIDI_CC_LIST << "0x01 Modulation";

  59.     MIDI_CC_LIST << "0x02 Breath";

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

  61.     MIDI_CC_LIST << "0x04 Foot";

  62.     MIDI_CC_LIST << "0x05 Portamento";

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

  64.     MIDI_CC_LIST << "0x07 Volume";

  65.     MIDI_CC_LIST << "0x08 Balance";

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

  67.     MIDI_CC_LIST << "0x0A Pan";

  68.     MIDI_CC_LIST << "0x0B Expression";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  147. }

  148. 

  149. // -------------------------------

  150. // XY Controller Scene

  151. 

  152. class XYGraphicsScene : public QGraphicsScene

  153. {

  154.     Q_OBJECT

  155. 

  156. public:

  157.     XYGraphicsScene(QWidget* parent)

  158.         : QGraphicsScene(parent),

  159.           m_parent(parent)

  160.     {

  161.         cc_x = 1;

  162.         cc_y = 2;

  163. 

  164.         m_mouseLock = false;

  165.         m_smooth    = false;

  166.         m_smooth_x  = 0.0f;

  167.         m_smooth_y  = 0.0f;

  168. 

  169.         setBackgroundBrush(Qt::black);

  170. 

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

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

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

  174. 

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

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

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

  178. 

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

  180.     }

  181. 

  182.     void setControlX(int x)

  183.     {

  184.         cc_x = x;

  185.     }

  186. 

  187.     void setControlY(int y)

  188.     {

  189.         cc_y = y;

  190.     }

  191. 

  192.     void setChannels(QList<int> channels)

  193.     {

  194.         m_channels = channels;

  195.     }

  196. 

  197.     void setPosX(float x, bool forward=true)

  198.     {

  199.         if (m_mouseLock)

  200.             return;

  201. 

  202.         float posX = x * (p_size.x() + p_size.width());

  203.         m_cursor->setPos(posX, m_cursor->y());

  204.         m_lineV->setX(posX);

  205. 

  206.         if (forward)

  207.         {

  208.             float value = posX / (p_size.x() + p_size.width());

  209.             sendMIDI(&value, nullptr);

  210.         }

  211.         else

  212.             m_smooth_x = posX;

  213.     }

  214. 

  215.     void setPosY(float y, bool forward=true)

  216.     {

  217.         if (m_mouseLock)

  218.             return;

  219. 

  220.         float posY = y * (p_size.y() + p_size.height());

  221.         m_cursor->setPos(m_cursor->x(), posY);

  222.         m_lineH->setY(posY);

  223. 

  224.         if (forward)

  225.         {

  226.             float value = posY / (p_size.y() + p_size.height());

  227.             sendMIDI(nullptr, &value);

  228.         }

  229.         else

  230.             m_smooth_y = posY;

  231.     }

  232. 

  233.     void setSmooth(bool smooth)

  234.     {

  235.         m_smooth = smooth;

  236.     }

  237. 

  238.     void setSmoothValues(float x, float y)

  239.     {

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

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

  242.     }

  243. 

  244.     void handleCC(int param, int value)

  245.     {

  246.         bool sendUpdate = false;

  247.         float xp, yp;

  248.         xp = yp = 0.0f;

  249. 

  250.         if (param == cc_x)

  251.         {

  252.             sendUpdate = true;

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

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

  255. 

  256.             setPosX(xp, false);

  257.         }

  258. 

  259.         if (param == cc_y)

  260.         {

  261.             sendUpdate = true;

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

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

  264. 

  265.             setPosY(yp, false);

  266.         }

  267. 

  268.         if (xp < -1.0f)

  269.             xp = -1.0f;

  270.         else if (xp > 1.0f)

  271.             xp = 1.0f;

  272. 

  273.         if (yp < -1.0f)

  274.             yp = -1.0f;

  275.         else if (yp > 1.0f)

  276.             yp = 1.0f;

  277. 

  278.         if (sendUpdate)

  279.             emit cursorMoved(xp, yp);

  280.     }

  281. 

  282.     void updateSize(QSize size)

  283.     {

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

  285.     }

  286. 

  287.     void updateSmooth()

  288.     {

  289.         if (! m_smooth)

  290.             return;

  291. 

  292.         if (m_cursor->x() == m_smooth_x && m_cursor->y() == m_smooth_y)

  293.             return;

  294. 

  295.         if (abs_f(m_cursor->x() - m_smooth_x) <= 0.0005f)

  296.             m_smooth_x = m_cursor->x();

  297.         if (abs_f(m_cursor->y() - m_smooth_y) <= 0.0005f)

  298.             m_smooth_y = m_cursor->y();

  299. 

  300.         if (m_cursor->x() == m_smooth_x && m_cursor->y() == m_smooth_y)

  301.             return;

  302. 

  303.         float newX = float(m_smooth_x + m_cursor->x()*7) / 8;

  304.         float newY = float(m_smooth_y + m_cursor->y()*7) / 8;

  305.         QPointF pos(newX, newY);

  306. 

  307.         m_cursor->setPos(pos);

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

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

  310. 

  311.         float xp = pos.x() / (p_size.x() + p_size.width());

  312.         float yp = pos.y() / (p_size.y() + p_size.height());

  313. 

  314.         sendMIDI(&xp, &yp);

  315.         emit cursorMoved(xp, yp);

  316.     }

  317. 

  318. protected:

  319.     void handleMousePos(QPointF pos)

  320.     {

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

  322.         {

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

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

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

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

  327. 

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

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

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

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

  332.         }

  333. 

  334.         m_smooth_x = pos.x();

  335.         m_smooth_y = pos.y();

  336. 

  337.         if (! m_smooth)

  338.         {

  339.             m_cursor->setPos(pos);

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

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

  342. 

  343.             float xp = pos.x() / (p_size.x() + p_size.width());

  344.             float yp = pos.y() / (p_size.y() + p_size.height());

  345. 

  346.             sendMIDI(&xp, &yp);

  347.             emit cursorMoved(xp, yp);

  348.         }

  349.     }

  350. 

  351.     void sendMIDI(float* xp=nullptr, float* yp=nullptr)

  352.     {

  353.         float rate = float(0xff) / 4;

  354. 

  355.         if (xp != nullptr)

  356.         {

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

  358.             foreach (const int& channel, m_channels)

  359.                 qMidiOutData.put(0xB0 + channel - 1, cc_x, value);

  360.         }

  361. 

  362.         if (yp != nullptr)

  363.         {

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

  365.             foreach (const int& channel, m_channels)

  366.                 qMidiOutData.put(0xB0 + channel - 1, cc_y, value);

  367.         }

  368.     }

  369. 

  370.     void keyPressEvent(QKeyEvent* event)

  371.     {

  372.         event->accept();

  373.     }

  374. 

  375.     void wheelEvent(QGraphicsSceneWheelEvent* event)

  376.     {

  377.         event->accept();

  378.     }

  379. 

  380.     void mousePressEvent(QGraphicsSceneMouseEvent* event)

  381.     {

  382.         m_mouseLock = true;

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

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

  385.         QGraphicsScene::mousePressEvent(event);

  386.     }

  387. 

  388.     void mouseMoveEvent(QGraphicsSceneMouseEvent* event)

  389.     {

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

  391.         QGraphicsScene::mouseMoveEvent(event);

  392.     }

  393. 

  394.     void mouseReleaseEvent(QGraphicsSceneMouseEvent* event)

  395.     {

  396.         m_mouseLock = false;

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

  398.         QGraphicsScene::mouseReleaseEvent(event);

  399.     }

  400. 

  401. signals:

  402.     void cursorMoved(float, float);

  403. 

  404. private:

  405.     int cc_x;

  406.     int cc_y;

  407.     QList<int> m_channels;

  408. 

  409.     bool  m_mouseLock;

  410.     bool  m_smooth;

  411.     float m_smooth_x;

  412.     float m_smooth_y;

  413. 

  414.     QGraphicsEllipseItem* m_cursor;

  415.     QGraphicsLineItem* m_lineH;

  416.     QGraphicsLineItem* m_lineV;

  417. 

  418.     QRectF p_size;

  419. 

  420.     // fake parent

  421.     QWidget* const m_parent;

  422.     QWidget* parent() const

  423.     {

  424.         return m_parent;

  425.     }

  426. };

  427. 

  428. // -------------------------------

  429. // XY Controller Window

  430. 

  431. namespace Ui {

  432. class XYControllerW;

  433. }

  434. 

  435. class XYControllerW : public QMainWindow

  436. {

  437.     Q_OBJECT

  438. 

  439. public:

  440.     XYControllerW()

  441.         : QMainWindow(nullptr),

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

  443.           scene(this),

  444.           ui(new Ui::XYControllerW)

  445.     {

  446.         ui->setupUi(this);

  447. 

  448.         // -------------------------------------------------------------

  449.         // Internal stuff

  450. 

  451.         cc_x = 1;

  452.         cc_y = 2;

  453. 

  454.         // -------------------------------------------------------------

  455.         // Set-up GUI stuff

  456. 

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

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

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

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

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

  462. 

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

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

  465. 

  466.         foreach (const QString& MIDI_CC, MIDI_CC_LIST)

  467.         {

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

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

  470.         }

  471. 

  472.         // -------------------------------------------------------------

  473.         // Load Settings

  474. 

  475.         loadSettings();

  476. 

  477.         // -------------------------------------------------------------

  478.         // Connect actions to functions

  479. 

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

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

  482. 

  483.         connect(ui->cb_smooth, SIGNAL(clicked(bool)), SLOT(slot_setSmooth(bool)));

  484. 

  485.         connect(ui->dial_x, SIGNAL(valueChanged(int)), SLOT(slot_updateSceneX(int)));

  486.         connect(ui->dial_y, SIGNAL(valueChanged(int)), SLOT(slot_updateSceneY(int)));

  487. 

  488.         connect(ui->cb_control_x, SIGNAL(currentIndexChanged(QString)), SLOT(slot_checkCC_X(QString)));

  489.         connect(ui->cb_control_y, SIGNAL(currentIndexChanged(QString)), SLOT(slot_checkCC_Y(QString)));

  490. 

  491.         connect(&scene, SIGNAL(cursorMoved(float,float)), SLOT(slot_sceneCursorMoved(float,float)));

  492. 

  493.         connect(ui->act_ch_01, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  494.         connect(ui->act_ch_02, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  495.         connect(ui->act_ch_03, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  496.         connect(ui->act_ch_04, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  497.         connect(ui->act_ch_05, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  498.         connect(ui->act_ch_06, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  499.         connect(ui->act_ch_07, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  500.         connect(ui->act_ch_08, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  501.         connect(ui->act_ch_09, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  502.         connect(ui->act_ch_10, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  503.         connect(ui->act_ch_11, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  504.         connect(ui->act_ch_12, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  505.         connect(ui->act_ch_13, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  506.         connect(ui->act_ch_14, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  507.         connect(ui->act_ch_15, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  508.         connect(ui->act_ch_16, SIGNAL(triggered(bool)), SLOT(slot_checkChannel(bool)));

  509.         connect(ui->act_ch_all, SIGNAL(triggered()), SLOT(slot_checkChannel_all()));

  510.         connect(ui->act_ch_none, SIGNAL(triggered()), SLOT(slot_checkChannel_none()));

  511. 

  512.         connect(ui->act_show_keyboard, SIGNAL(triggered(bool)), SLOT(slot_showKeyboard(bool)));

  513.         connect(ui->act_about, SIGNAL(triggered()), SLOT(slot_about()));

  514. 

  515.         // -------------------------------------------------------------

  516.         // Final stuff

  517. 

  518.         m_midiInTimerId = startTimer(30);

  519.         QTimer::singleShot(0, this, SLOT(slot_updateScreen()));

  520.     }

  521. 

  522.     void updateScreen()

  523.     {

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

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

  526. 

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

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

  529.         slot_updateSceneX(dial_x);

  530.         slot_updateSceneY(dial_y);

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

  532.     }

  533. 

  534. protected slots:

  535.     void slot_noteOn(int note)

  536.     {

  537.         foreach (const int& channel, m_channels)

  538.             qMidiOutData.put(0x90 + channel - 1, note, 100);

  539.     }

  540. 

  541.     void slot_noteOff(int note)

  542.     {

  543.         foreach (const int& channel, m_channels)

  544.             qMidiOutData.put(0x80 + channel - 1, note, 0);

  545.     }

  546. 

  547.     void slot_updateSceneX(int x)

  548.     {

  549.         scene.setSmoothValues(float(x) / 100, float(ui->dial_y->value()) / 100);

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

  551.     }

  552. 

  553.     void slot_updateSceneY(int y)

  554.     {

  555.         scene.setSmoothValues(float(ui->dial_x->value()) / 100, float(y) / 100);

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

  557.     }

  558. 

  559.     void slot_checkCC_X(QString text)

  560.     {

  561.         if (text.isEmpty())

  562.             return;

  563. 

  564.         bool ok;

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

  566. 

  567.         if (ok)

  568.         {

  569.             cc_x = tmp_cc_x;

  570.             scene.setControlX(cc_x);

  571.         }

  572.     }

  573. 

  574.     void slot_checkCC_Y(QString text)

  575.     {

  576.         if (text.isEmpty())

  577.             return;

  578. 

  579.         bool ok;

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

  581. 

  582.         if (ok)

  583.         {

  584.             cc_y = tmp_cc_y;

  585.             scene.setControlY(cc_y);

  586.         }

  587.     }

  588. 

  589.     void slot_checkChannel(bool clicked)

  590.     {

  591.         if (! sender())

  592.             return;

  593. 

  594.         bool ok;

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

  596. 

  597.         if (ok)

  598.         {

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

  600.                 m_channels.append(channel);

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

  602.                 m_channels.removeOne(channel);

  603.             scene.setChannels(m_channels);

  604.         }

  605.     }

  606. 

  607.     void slot_checkChannel_all()

  608.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  625. 

  626. #ifdef Q_COMPILER_INITIALIZER_LISTS

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

  628. #else

  629.         m_channels.clear();

  630. 

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

  632.             m_channels << i;

  633. #endif

  634.         scene.setChannels(m_channels);

  635.     }

  636. 

  637.     void slot_checkChannel_none()

  638.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  655. 

  656.         m_channels.clear();

  657.         scene.setChannels(m_channels);

  658.     }

  659. 

  660.     void slot_setSmooth(bool yesno)

  661.     {

  662.         scene.setSmooth(yesno);

  663.     }

  664. 

  665.     void slot_sceneCursorMoved(float xp, float yp)

  666.     {

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

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

  669. 

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

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

  672. 

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

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

  675.     }

  676. 

  677.     void slot_showKeyboard(bool yesno)

  678.     {

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

  680.         QTimer::singleShot(0, this, SLOT(slot_updateScreen()));

  681.     }

  682. 

  683.     void slot_about()

  684.     {

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

  686.                                                                "<br>Version %1"

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

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

  689.     }

  690. 

  691.     void slot_updateScreen()

  692.     {

  693.         updateScreen();

  694.     }

  695. 

  696. protected:

  697.     void saveSettings()

  698.     {

  699.         QVariantList varChannelList;

  700.         foreach (const int& channel, m_channels)

  701.             varChannelList << channel;

  702. 

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

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

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

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

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

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

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

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

  711.     }

  712. 

  713.     void loadSettings()

  714.     {

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

  716. 

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

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

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

  720. 

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

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

  723.         scene.setSmooth(smooth);

  724. 

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

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

  727. 

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

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

  730.         scene.setControlX(cc_x);

  731.         scene.setControlY(cc_y);

  732. 

  733.         m_channels.clear();

  734. 

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

  736.         {

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

  738. 

  739.             foreach (const QVariant& var, channels)

  740.             {

  741.                 bool ok;

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

  743. 

  744.                 if (ok)

  745.                     m_channels.append(channel);

  746.             }

  747.         }

  748.         else

  749. #ifdef Q_COMPILER_INITIALIZER_LISTS

  750.             m_channels = { 1 };

  751. #else

  752.             m_channels << 1;

  753. #endif

  754. 

  755.         scene.setChannels(m_channels);

  756. 

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

  758.         {

  759.             bool ok;

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

  761. 

  762.             if (ok)

  763.             {

  764.                 if (cc_x == cc)

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

  766.                 if (cc_y == cc)

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

  768.             }

  769.         }

  770. 

  771.         if (m_channels.contains(1))

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

  773.         if (m_channels.contains(2))

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

  775.         if (m_channels.contains(3))

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

  777.         if (m_channels.contains(4))

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

  779.         if (m_channels.contains(5))

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

  781.         if (m_channels.contains(6))

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

  783.         if (m_channels.contains(7))

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

  785.         if (m_channels.contains(8))

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

  787.         if (m_channels.contains(9))

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

  789.         if (m_channels.contains(10))

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

  791.         if (m_channels.contains(11))

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

  793.         if (m_channels.contains(12))

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

  795.         if (m_channels.contains(13))

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

  797.         if (m_channels.contains(14))

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

  799.         if (m_channels.contains(15))

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

  801.         if (m_channels.contains(16))

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

  803.     }

  804. 

  805.     void timerEvent(QTimerEvent* event)

  806.     {

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

  808.         {

  809.             if (! qMidiInData.isEmpty())

  810.             {

  811.                 unsigned char d1, d2, d3;

  812.                 qMidiInInternal.copyDataFrom(&qMidiInData);

  813. 

  814.                 while (qMidiInInternal.get(&d1, &d2, &d3, false))

  815.                 {

  816.                     int channel = (d1 & 0x0F) + 1;

  817.                     int mode    = d1 & 0xF0;

  818. 

  819.                     if (m_channels.contains(channel))

  820.                     {

  821.                         if (mode == 0x80)

  822.                             ui->keyboard->sendNoteOff(d2, false);

  823.                         else if (mode == 0x90)

  824.                             ui->keyboard->sendNoteOn(d2, false);

  825.                         else if (mode == 0xB0)

  826.                             scene.handleCC(d2, d3);

  827.                     }

  828.                 }

  829.             }

  830. 

  831.             scene.updateSmooth();

  832.         }

  833. 

  834.         QMainWindow::timerEvent(event);

  835.     }

  836. 

  837.     void resizeEvent(QResizeEvent* event)

  838.     {

  839.         updateScreen();

  840.         QMainWindow::resizeEvent(event);

  841.     }

  842. 

  843.     void closeEvent(QCloseEvent* event)

  844.     {

  845.         saveSettings();

  846.         QMainWindow::closeEvent(event);

  847.     }

  848. 

  849. private:

  850.     int cc_x;

  851.     int cc_y;

  852.     QList<int> m_channels;

  853. 

  854.     int m_midiInTimerId;

  855. 

  856.     QSettings settings;

  857.     XYGraphicsScene scene;

  858.     Ui::XYControllerW* const ui;

  859. 

  860.     Queue qMidiInInternal;

  861. };

  862. 

  863. #include "xycontroller.moc"

  864. 

  865. // -------------------------------

  866. 

  867. int process_callback(const jack_nframes_t nframes, void*)

  868. {

  869.     void* const midiInBuffer  = jack_port_get_buffer(jMidiInPort, nframes);

  870.     void* const midiOutBuffer = jack_port_get_buffer(jMidiOutPort, nframes);

  871. 

  872.     if (! (midiInBuffer && midiOutBuffer))

  873.         return 1;

  874. 

  875.     // MIDI In

  876.     jack_midi_event_t midiEvent;

  877.     uint32_t midiEventCount = jack_midi_get_event_count(midiInBuffer);

  878. 

  879.     qMidiInData.lock();

  880. 

  881.     for (uint32_t i=0; i < midiEventCount; i++)

  882.     {

  883.         if (jack_midi_event_get(&midiEvent, midiInBuffer, i) != 0)

  884.             break;

  885. 

  886.         if (midiEvent.size == 1)

  887.             qMidiInData.put(midiEvent.buffer[0], 0, 0, false);

  888.         else if (midiEvent.size == 2)

  889.             qMidiInData.put(midiEvent.buffer[0], midiEvent.buffer[1], 0, false);

  890.         else if (midiEvent.size >= 3)

  891.             qMidiInData.put(midiEvent.buffer[0], midiEvent.buffer[1], midiEvent.buffer[2], false);

  892. 

  893.         if (qMidiInData.isFull())

  894.             break;

  895.     }

  896.     qMidiInData.unlock();

  897. 

  898.     // MIDI Out

  899.     jack_midi_clear_buffer(midiOutBuffer);

  900.     qMidiOutData.lock();

  901. 

  902.     if (! qMidiOutData.isEmpty())

  903.     {

  904.         unsigned char d1, d2, d3, data[3];

  905. 

  906.         while (qMidiOutData.get(&d1, &d2, &d3, false))

  907.         {

  908.             data[0] = d1;

  909.             data[1] = d2;

  910.             data[2] = d3;

  911.             jack_midi_event_write(midiOutBuffer, 0, data, 3);

  912.         }

  913.     }

  914.     qMidiOutData.unlock();

  915. 

  916.     return 0;

  917. }

  918. 

  919. #ifdef HAVE_JACKSESSION

  920. void session_callback(jack_session_event_t* const event, void* const arg)

  921. {

  922. #ifdef Q_OS_LINUX

  923.     QString filepath("cadence_xycontroller");

  924.     Q_UNUSED(arg);

  925. #else

  926.     QString filepath((char*)arg);

  927. #endif

  928. 

  929.     event->command_line = strdup(filepath.toUtf8().constData());

  930. 

  931.     jack_session_reply(jClient, event);

  932. 

  933.     if (event->type == JackSessionSaveAndQuit)

  934.         QApplication::instance()->quit();

  935. 

  936.     jack_session_event_free(event);

  937. }

  938. #endif

  939. 

  940. // -------------------------------

  941. 

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

  943. {

  944.     MIDI_CC_LIST__init();

  945. 

  946. #ifdef Q_OS_WIN

  947.     QApplication::setGraphicsSystem("raster");

  948. #endif

  949. 

  950.     QApplication app(argc, argv);

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

  952.     app.setApplicationVersion(VERSION);

  953.     app.setOrganizationName("Cadence");

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

  955. 

  956.     // JACK initialization

  957.     jack_status_t jStatus;

  958. #ifdef HAVE_JACKSESSION

  959.     jack_options_t jOptions = static_cast<JackOptions>(JackNoStartServer|JackSessionID);

  960. #else

  961.     jack_options_t jOptions = static_cast<JackOptions>(JackNoStartServer);

  962. #endif

  963.     jClient = jack_client_open("XY-Controller", jOptions, &jStatus);

  964. 

  965.     if (! jClient)

  966.     {

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

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

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

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

  971.         return 1;

  972.     }

  973. 

  974.     jMidiInPort  = jack_port_register(jClient, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);

  975.     jMidiOutPort = jack_port_register(jClient, "midi_out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);

  976. 

  977.     jack_set_process_callback(jClient, process_callback, nullptr);

  978. #ifdef HAVE_JACKSESSION

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

  980. #endif

  981.     jack_activate(jClient);

  982. 

  983.     // Show GUI

  984.     XYControllerW gui;

  985.     gui.show();

  986. 

  987.     // App-Loop

  988.     int ret = app.exec();

  989. 

  990.     jack_deactivate(jClient);

  991.     jack_client_close(jClient);

  992. 

  993.     return ret;

  994. }