mirror of https://github.com/AxioDL/amuse.git
601 lines
16 KiB
C++
601 lines
16 KiB
C++
#include "KeymapEditor.hpp"
|
|
#include "MainWindow.hpp"
|
|
#include "KeyboardWidget.hpp"
|
|
#include <QVBoxLayout>
|
|
#include <QPainter>
|
|
#include <QScrollBar>
|
|
|
|
static const int HueTable[] =
|
|
{
|
|
0, 30, 60, 80, 120, 170, 200, 240, 280, 320
|
|
};
|
|
|
|
static const int SaturationTable[] =
|
|
{
|
|
255, 255, 255, 255, 255, 127, 127, 127, 127, 127, 63, 63, 63
|
|
};
|
|
|
|
static const int ValueTable[] =
|
|
{
|
|
240, 200, 160, 120, 80, 240, 200, 160, 120, 80, 240, 200, 160
|
|
};
|
|
|
|
static const QPoint PointTable[] =
|
|
{
|
|
{21, 180},
|
|
{41, 104},
|
|
{61, 180},
|
|
{86, 104},
|
|
{101, 180},
|
|
{141, 180},
|
|
{156, 104},
|
|
{181, 180},
|
|
{201, 104},
|
|
{221, 180},
|
|
{246, 104},
|
|
{261, 180}
|
|
};
|
|
|
|
static const int RadiusTable[] =
|
|
{
|
|
14,
|
|
10,
|
|
14,
|
|
10,
|
|
14,
|
|
14,
|
|
10,
|
|
14,
|
|
10,
|
|
14,
|
|
10,
|
|
14
|
|
};
|
|
|
|
static const QColor PenColorTable[] =
|
|
{
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black
|
|
};
|
|
|
|
static const QColor NeutralColorTable[] =
|
|
{
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white,
|
|
Qt::black,
|
|
Qt::white
|
|
};
|
|
|
|
PaintButton::PaintButton(QWidget* parent)
|
|
: QPushButton(parent)
|
|
{
|
|
setIcon(QIcon(QStringLiteral(":/icons/IconPaintbrush.svg")));
|
|
setIconSize(QSize(26, 26));
|
|
setFixedSize(46, 46);
|
|
setToolTip(tr("Activate brush to apply values to keys"));
|
|
}
|
|
|
|
KeymapEditor* KeymapView::getEditor() const
|
|
{
|
|
return qobject_cast<KeymapEditor*>(parentWidget()->parentWidget()->parentWidget());
|
|
}
|
|
|
|
void KeymapView::loadData(ProjectModel::KeymapNode* node)
|
|
{
|
|
m_node = node;
|
|
}
|
|
|
|
void KeymapView::unloadData()
|
|
{
|
|
m_node.reset();
|
|
std::fill(std::begin(m_keyPalettes), std::end(m_keyPalettes), -1);
|
|
}
|
|
|
|
ProjectModel::INode* KeymapView::currentNode() const
|
|
{
|
|
return m_node.get();
|
|
}
|
|
|
|
void KeymapView::drawKey(QPainter& painter, const QRect& octaveRect, qreal penWidth,
|
|
const QColor* keyPalette, int o, int k) const
|
|
{
|
|
int keyIdx = o * 12 + k;
|
|
int keyPalIdx = m_keyPalettes[keyIdx];
|
|
painter.setPen(QPen(PenColorTable[k], penWidth));
|
|
painter.setBrush(keyPalIdx < 0 ? NeutralColorTable[k] : keyPalette[keyPalIdx]);
|
|
painter.drawEllipse(PointTable[k] + octaveRect.topLeft(), RadiusTable[k], RadiusTable[k]);
|
|
painter.setTransform(QTransform().translate(
|
|
PointTable[k].x() + octaveRect.left() - 13, PointTable[k].y() + octaveRect.top() - 20).rotate(-90.0));
|
|
painter.drawStaticText(QPointF{}, m_keyTexts[keyIdx]);
|
|
painter.setTransform(QTransform());
|
|
}
|
|
|
|
void KeymapView::paintEvent(QPaintEvent* ev)
|
|
{
|
|
QPainter painter(this);
|
|
painter.setRenderHint(QPainter::Antialiasing);
|
|
|
|
const QColor* keyPalette = getEditor()->m_paintPalette;
|
|
|
|
qreal deviceRatio = devicePixelRatioF();
|
|
qreal penWidth = std::max(std::floor(deviceRatio), 1.0) / deviceRatio;
|
|
|
|
painter.setFont(m_keyFont);
|
|
int kbY = height() / 2 - 100;
|
|
for (int o = 0; o < 10; ++o)
|
|
{
|
|
QRect thisRect(o * 280, kbY, 280, 200);
|
|
if (ev->rect().intersects(thisRect))
|
|
{
|
|
m_octaveRenderer.render(&painter, thisRect);
|
|
for (int k = 0; k < 12; ++k)
|
|
drawKey(painter, thisRect, penWidth, keyPalette, o, k);
|
|
}
|
|
}
|
|
QRect thisRect(2800, kbY, 202, 200);
|
|
if (ev->rect().intersects(thisRect))
|
|
{
|
|
m_lastOctaveRenderer.render(&painter, thisRect);
|
|
for (int k = 0; k < 8; ++k)
|
|
drawKey(painter, thisRect, penWidth, keyPalette, 10, k);
|
|
}
|
|
}
|
|
|
|
void KeymapView::mousePressEvent(QMouseEvent* ev)
|
|
{
|
|
mouseMoveEvent(ev);
|
|
}
|
|
|
|
int KeymapView::getKey(const QPoint& localPos) const
|
|
{
|
|
QPointF localPoint = m_widgetToSvg.map(localPos);
|
|
for (int i = 0; i < 5; ++i)
|
|
if (m_sharp[i].contains(localPoint))
|
|
return SharpKeyNumbers[i];
|
|
for (int i = 0; i < 7; ++i)
|
|
if (m_natural[i].contains(localPoint))
|
|
return NaturalKeyNumbers[i];
|
|
return -1;
|
|
}
|
|
|
|
void KeymapView::mouseMoveEvent(QMouseEvent* ev)
|
|
{
|
|
int octave = ev->x() / 280;
|
|
int key = getKey(ev->pos() - QPoint(octave * 280, height() / 2 - 100));
|
|
if (octave >= 0 && key >= 0)
|
|
getEditor()->touchKey(octave * 12 + key, ev->modifiers() & Qt::ShiftModifier);
|
|
}
|
|
|
|
void KeymapView::wheelEvent(QWheelEvent* event)
|
|
{
|
|
if (QScrollArea* scroll = qobject_cast<QScrollArea*>(parentWidget()->parentWidget()))
|
|
{
|
|
/* Send wheel event directly to the scroll bar */
|
|
QApplication::sendEvent(scroll->horizontalScrollBar(), event);
|
|
}
|
|
}
|
|
|
|
KeymapView::KeymapView(QWidget* parent)
|
|
: QWidget(parent), m_octaveRenderer(QStringLiteral(":/bg/keyboard.svg")),
|
|
m_lastOctaveRenderer(QStringLiteral(":/bg/keyboard_last.svg"))
|
|
{
|
|
setMinimumWidth(3002);
|
|
|
|
int k = 0;
|
|
for (int i = 0; i < 11; ++i)
|
|
for (int j = 0; j < 12 && k < 128; ++j)
|
|
m_keyTexts[k++].setText(QStringLiteral("%1%2").arg(KeyStrings[j]).arg(i - 1));
|
|
m_keyFont.setPointSize(12);
|
|
std::fill(std::begin(m_keyPalettes), std::end(m_keyPalettes), -1);
|
|
|
|
for (int i = 0; i < 7; ++i)
|
|
if (m_octaveRenderer.elementExists(NaturalKeyNames[i]))
|
|
m_natural[i] = m_octaveRenderer.matrixForElement(NaturalKeyNames[i]).
|
|
mapRect(m_octaveRenderer.boundsOnElement(NaturalKeyNames[i]));
|
|
|
|
for (int i = 0; i < 5; ++i)
|
|
if (m_octaveRenderer.elementExists(SharpKeyNames[i]))
|
|
m_sharp[i] = m_octaveRenderer.matrixForElement(SharpKeyNames[i]).
|
|
mapRect(m_octaveRenderer.boundsOnElement(SharpKeyNames[i]));
|
|
|
|
m_widgetToSvg = RectToRect(QRect(0, 0, 280, 200), m_octaveRenderer.viewBoxF());
|
|
}
|
|
|
|
KeymapEditor* KeymapControls::getEditor() const
|
|
{
|
|
return qobject_cast<KeymapEditor*>(parentWidget());
|
|
}
|
|
|
|
void KeymapControls::setPaintIdx(int idx)
|
|
{
|
|
QPalette palette = m_paintButton->palette();
|
|
if (idx < 0)
|
|
{
|
|
palette.setColor(QPalette::Background, QWidget::palette().color(QPalette::Background));
|
|
palette.setColor(QPalette::Button, QWidget::palette().color(QPalette::Button));
|
|
}
|
|
else
|
|
{
|
|
const QColor* keyPalette = getEditor()->m_paintPalette;
|
|
palette.setColor(QPalette::Background, keyPalette[idx]);
|
|
palette.setColor(QPalette::Button, keyPalette[idx].darker(300));
|
|
}
|
|
m_paintButton->setPalette(palette);
|
|
}
|
|
|
|
void KeymapControls::setKeymap(const amuse::Keymap& km)
|
|
{
|
|
m_enableUpdate = false;
|
|
int idx = m_macro->collection()->indexOfId(km.macro.id);
|
|
m_macro->setCurrentIndex(idx + 1);
|
|
m_transpose->setValue(km.transpose);
|
|
if (km.pan == -128)
|
|
{
|
|
m_pan->setDisabled(true);
|
|
m_pan->setValue(true);
|
|
m_surround->setChecked(true);
|
|
}
|
|
else
|
|
{
|
|
m_pan->setEnabled(true);
|
|
m_pan->setValue(km.pan);
|
|
m_surround->setChecked(false);
|
|
}
|
|
m_prioOffset->setValue(km.prioOffset);
|
|
m_enableUpdate = true;
|
|
}
|
|
|
|
void KeymapControls::loadData(ProjectModel::KeymapNode* node)
|
|
{
|
|
m_enableUpdate = false;
|
|
m_macro->setCollection(g_MainWindow->projectModel()->getGroupNode(node)->
|
|
getCollectionOfType(ProjectModel::INode::Type::SoundMacro));
|
|
m_macro->setDisabled(false);
|
|
m_transpose->setDisabled(false);
|
|
m_transpose->setValue(0);
|
|
m_pan->setDisabled(false);
|
|
m_pan->setValue(64);
|
|
m_surround->setDisabled(false);
|
|
m_surround->setChecked(false);
|
|
m_prioOffset->setDisabled(false);
|
|
m_prioOffset->setValue(0);
|
|
m_paintButton->setDisabled(false);
|
|
m_paintButton->setPalette(palette());
|
|
m_enableUpdate = true;
|
|
}
|
|
|
|
void KeymapControls::unloadData()
|
|
{
|
|
m_enableUpdate = false;
|
|
m_macro->setCollection(nullptr);
|
|
m_macro->setDisabled(true);
|
|
m_transpose->setDisabled(true);
|
|
m_pan->setDisabled(true);
|
|
m_surround->setDisabled(true);
|
|
m_prioOffset->setDisabled(true);
|
|
m_paintButton->setDisabled(true);
|
|
m_paintButton->setPalette(palette());
|
|
m_enableUpdate = true;
|
|
}
|
|
|
|
void KeymapControls::controlChanged()
|
|
{
|
|
if (m_enableUpdate)
|
|
{
|
|
amuse::Keymap km;
|
|
km.macro.id = m_macro->currentIndex() == 0 ? amuse::SoundMacroId{} :
|
|
m_macro->collection()->idOfIndex(m_macro->currentIndex() - 1);
|
|
km.transpose = int8_t(m_transpose->value());
|
|
km.pan = int8_t(m_pan->value());
|
|
if (m_surround->isChecked())
|
|
{
|
|
km.pan = -128;
|
|
m_pan->setDisabled(true);
|
|
}
|
|
else
|
|
{
|
|
m_pan->setEnabled(true);
|
|
}
|
|
km.prioOffset = int8_t(m_prioOffset->value());
|
|
getEditor()->touchControl(km);
|
|
}
|
|
}
|
|
|
|
void KeymapControls::paintButtonPressed()
|
|
{
|
|
KeymapEditor* editor = getEditor();
|
|
if (!editor->m_inPaint)
|
|
{
|
|
editor->setCursor(QCursor(QPixmap(QStringLiteral(":/icons/IconPaintbrush.svg")), 2, 30));
|
|
editor->m_inPaint = true;
|
|
m_paintButton->setDown(true);
|
|
}
|
|
else
|
|
{
|
|
editor->unsetCursor();
|
|
editor->m_inPaint = false;
|
|
m_paintButton->setDown(false);
|
|
}
|
|
}
|
|
|
|
KeymapControls::KeymapControls(QWidget* parent)
|
|
: QFrame(parent)
|
|
{
|
|
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
|
|
setFixedHeight(100);
|
|
setFrameShape(QFrame::StyledPanel);
|
|
setFrameShadow(QFrame::Sunken);
|
|
setBackgroundRole(QPalette::Base);
|
|
setAutoFillBackground(true);
|
|
|
|
QPalette palette = QWidget::palette();
|
|
palette.setColor(QPalette::Base, palette.color(QPalette::Background));
|
|
|
|
QHBoxLayout* mainLayout = new QHBoxLayout;
|
|
|
|
QGridLayout* leftLayout = new QGridLayout;
|
|
|
|
leftLayout->addWidget(new QLabel(tr("SoundMacro")), 0, 0);
|
|
m_macro = new FieldProjectNode;
|
|
m_macro->setDisabled(true);
|
|
connect(m_macro, SIGNAL(currentIndexChanged(int)), this, SLOT(controlChanged()));
|
|
leftLayout->addWidget(m_macro, 1, 0);
|
|
|
|
leftLayout->addWidget(new QLabel(tr("Transpose")), 0, 1);
|
|
m_transpose = new QSpinBox;
|
|
m_transpose->setPalette(palette);
|
|
m_transpose->setDisabled(true);
|
|
m_transpose->setRange(-128, 127);
|
|
m_transpose->setToolTip(tr("Offset resulting MIDI note"));
|
|
connect(m_transpose, SIGNAL(valueChanged(int)), this, SLOT(controlChanged()));
|
|
leftLayout->addWidget(m_transpose, 1, 1);
|
|
|
|
leftLayout->addWidget(new QLabel(tr("Pan")), 0, 2);
|
|
m_pan = new QSpinBox;
|
|
m_pan->setPalette(palette);
|
|
m_pan->setDisabled(true);
|
|
m_pan->setRange(-127, 127);
|
|
m_pan->setToolTip(tr("Set initial pan"));
|
|
connect(m_pan, SIGNAL(valueChanged(int)), this, SLOT(controlChanged()));
|
|
leftLayout->addWidget(m_pan, 1, 2);
|
|
|
|
leftLayout->addWidget(new QLabel(tr("Surround")), 0, 3);
|
|
m_surround = new QCheckBox;
|
|
m_surround->setPalette(palette);
|
|
m_surround->setDisabled(true);
|
|
m_surround->setToolTip(tr("Initially play through surround channels"));
|
|
connect(m_surround, SIGNAL(stateChanged(int)), this, SLOT(controlChanged()));
|
|
leftLayout->addWidget(m_surround, 1, 3);
|
|
|
|
leftLayout->addWidget(new QLabel(tr("Prio Offset")), 0, 4);
|
|
m_prioOffset = new QSpinBox;
|
|
m_prioOffset->setPalette(palette);
|
|
m_prioOffset->setDisabled(true);
|
|
m_prioOffset->setRange(-128, 127);
|
|
m_prioOffset->setToolTip(tr("Offset resulting priority"));
|
|
connect(m_prioOffset, SIGNAL(valueChanged(int)), this, SLOT(controlChanged()));
|
|
leftLayout->addWidget(m_prioOffset, 1, 4);
|
|
|
|
leftLayout->setColumnMinimumWidth(0, 200);
|
|
leftLayout->setColumnMinimumWidth(1, 75);
|
|
leftLayout->setColumnMinimumWidth(2, 75);
|
|
leftLayout->setColumnMinimumWidth(3, 50);
|
|
leftLayout->setColumnMinimumWidth(4, 75);
|
|
leftLayout->setRowMinimumHeight(0, 22);
|
|
leftLayout->setRowMinimumHeight(1, 37);
|
|
leftLayout->setContentsMargins(10, 6, 0, 14);
|
|
|
|
QVBoxLayout* rightLayout = new QVBoxLayout;
|
|
|
|
m_paintButton = new PaintButton;
|
|
m_paintButton->setDisabled(true);
|
|
connect(m_paintButton, SIGNAL(pressed()), this, SLOT(paintButtonPressed()));
|
|
rightLayout->addWidget(m_paintButton);
|
|
rightLayout->setContentsMargins(0, 0, 10, 0);
|
|
|
|
mainLayout->addLayout(leftLayout);
|
|
mainLayout->addStretch(1);
|
|
mainLayout->addLayout(rightLayout);
|
|
setLayout(mainLayout);
|
|
}
|
|
|
|
void KeymapEditor::_touch()
|
|
{
|
|
if (m_controlKeymap.macro.id == 0xffff)
|
|
m_controls->setPaintIdx(-1);
|
|
else
|
|
m_controls->setPaintIdx(getConfigIdx(m_controlKeymap.configKey()));
|
|
}
|
|
|
|
void KeymapEditor::touchKey(int key, bool bulk)
|
|
{
|
|
if (m_inPaint)
|
|
{
|
|
if (bulk)
|
|
{
|
|
uint64_t refKey = (*m_kmView->m_node->m_obj)[key].configKey();
|
|
for (int i = 0; i < 128; ++i)
|
|
{
|
|
amuse::Keymap& km = (*m_kmView->m_node->m_obj)[i];
|
|
if (km.configKey() != refKey)
|
|
continue;
|
|
if (km.macro.id != 0xffff)
|
|
deallocateConfigIdx(km.configKey());
|
|
km = m_controlKeymap;
|
|
if (km.macro.id == 0xffff)
|
|
m_kmView->m_keyPalettes[i] = -1;
|
|
else
|
|
m_kmView->m_keyPalettes[i] = allocateConfigIdx(km.configKey());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
amuse::Keymap& km = (*m_kmView->m_node->m_obj)[key];
|
|
if (km.macro.id != 0xffff)
|
|
deallocateConfigIdx(km.configKey());
|
|
km = m_controlKeymap;
|
|
if (km.macro.id == 0xffff)
|
|
m_kmView->m_keyPalettes[key] = -1;
|
|
else
|
|
m_kmView->m_keyPalettes[key] = allocateConfigIdx(km.configKey());
|
|
}
|
|
|
|
m_kmView->update();
|
|
}
|
|
else
|
|
{
|
|
amuse::Keymap& km = (*m_kmView->m_node->m_obj)[key];
|
|
m_controlKeymap = km;
|
|
m_controls->setKeymap(km);
|
|
_touch();
|
|
}
|
|
}
|
|
|
|
void KeymapEditor::touchControl(const amuse::Keymap& km)
|
|
{
|
|
m_controlKeymap = km;
|
|
_touch();
|
|
}
|
|
|
|
int KeymapEditor::allocateConfigIdx(uint64_t key)
|
|
{
|
|
auto search = m_configToIdx.find(key);
|
|
if (search != m_configToIdx.end())
|
|
{
|
|
++search->second.second;
|
|
return search->second.first;
|
|
}
|
|
for (int i = 0; i < 129; ++i)
|
|
if (!m_idxBitmap[i])
|
|
{
|
|
m_configToIdx[key] = std::make_pair(i, 1);
|
|
m_idxBitmap.set(i);
|
|
return i;
|
|
}
|
|
Q_UNREACHABLE();
|
|
}
|
|
|
|
void KeymapEditor::deallocateConfigIdx(uint64_t key)
|
|
{
|
|
auto search = m_configToIdx.find(key);
|
|
if (search != m_configToIdx.end())
|
|
{
|
|
--search->second.second;
|
|
if (search->second.second == 0)
|
|
{
|
|
m_idxBitmap.reset(search->second.first);
|
|
m_configToIdx.erase(search);
|
|
}
|
|
return;
|
|
}
|
|
Q_UNREACHABLE();
|
|
}
|
|
|
|
int KeymapEditor::getConfigIdx(uint64_t key) const
|
|
{
|
|
auto search = m_configToIdx.find(key);
|
|
if (search != m_configToIdx.end())
|
|
return search->second.first;
|
|
for (int i = 0; i < 129; ++i)
|
|
if (!m_idxBitmap[i])
|
|
return i;
|
|
Q_UNREACHABLE();
|
|
}
|
|
|
|
bool KeymapEditor::loadData(ProjectModel::KeymapNode* node)
|
|
{
|
|
if (m_kmView->m_node.get() != node)
|
|
{
|
|
m_configToIdx.clear();
|
|
m_idxBitmap.reset();
|
|
|
|
for (int i = 0; i < 128; ++i)
|
|
{
|
|
amuse::Keymap& km = (*node->m_obj)[i];
|
|
if (km.macro.id == 0xffff)
|
|
m_kmView->m_keyPalettes[i] = -1;
|
|
else
|
|
m_kmView->m_keyPalettes[i] = allocateConfigIdx(km.configKey());
|
|
}
|
|
|
|
m_controlKeymap = amuse::Keymap();
|
|
m_kmView->loadData(node);
|
|
m_controls->loadData(node);
|
|
}
|
|
|
|
m_inPaint = false;
|
|
m_controls->m_paintButton->setDown(false);
|
|
unsetCursor();
|
|
|
|
return true;
|
|
}
|
|
|
|
void KeymapEditor::unloadData()
|
|
{
|
|
m_configToIdx.clear();
|
|
m_idxBitmap.reset();
|
|
m_kmView->unloadData();
|
|
m_controls->unloadData();
|
|
|
|
m_inPaint = false;
|
|
m_controls->m_paintButton->setDown(false);
|
|
unsetCursor();
|
|
}
|
|
|
|
ProjectModel::INode* KeymapEditor::currentNode() const
|
|
{
|
|
return m_kmView->currentNode();
|
|
}
|
|
|
|
void KeymapEditor::keyPressEvent(QKeyEvent* event)
|
|
{
|
|
if (event->key() == Qt::Key_Escape)
|
|
{
|
|
if (m_inPaint)
|
|
{
|
|
m_inPaint = false;
|
|
m_controls->m_paintButton->setDown(false);
|
|
unsetCursor();
|
|
}
|
|
}
|
|
}
|
|
|
|
KeymapEditor::KeymapEditor(QWidget* parent)
|
|
: EditorWidget(parent), m_scrollArea(new QScrollArea),
|
|
m_kmView(new KeymapView), m_controls(new KeymapControls)
|
|
{
|
|
|
|
int k = 0;
|
|
for (int i = 0; i < 13; ++i)
|
|
for (int j = 0; j < 10 && k < 129; ++j)
|
|
m_paintPalette[k++].setHsv(HueTable[j], SaturationTable[i], ValueTable[i]);
|
|
|
|
m_scrollArea->setWidget(m_kmView);
|
|
m_scrollArea->setWidgetResizable(true);
|
|
|
|
QVBoxLayout* layout = new QVBoxLayout;
|
|
layout->setContentsMargins(QMargins());
|
|
layout->setSpacing(1);
|
|
layout->addWidget(m_scrollArea);
|
|
layout->addWidget(m_controls);
|
|
setLayout(layout);
|
|
}
|