void FixtureConsole::enableExternalInput(bool enable)
{
if (enable == true && m_externalInputEnabled == false)
{
connect(_app->inputMap(),
SIGNAL(inputValueChanged(quint32,
quint32,
uchar)),
this, SLOT(slotInputValueChanged(quint32,
quint32,
uchar)));
m_externalInputEnabled = true;
}
else if (enable == false && m_externalInputEnabled == true)
{
disconnect(_app->inputMap(),
SIGNAL(inputValueChanged(quint32,
quint32,
uchar)),
this,
SLOT(slotInputValueChanged(quint32,
quint32,
uchar)));
m_externalInputEnabled = false;
}
}
void VCPropertiesEditor::slotAutoDetectGrandMasterInputToggled(bool checked)
{
if (checked == true)
{
connect(m_inputMap, SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotGrandMasterInputValueChanged(quint32,quint32)));
}
else
{
disconnect(m_inputMap, SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotGrandMasterInputValueChanged(quint32,quint32)));
}
}
void VCMatrixProperties::slotAutoDetectSliderInputToggled(bool checked)
{
if (checked == true)
{
connect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotSliderInputValueChanged(quint32,quint32)));
}
else
{
disconnect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotSliderInputValueChanged(quint32,quint32)));
}
}
void VCCueListProperties::slotPlaybackAutoDetectInputToggled(bool checked)
{
if (checked == true)
{
connect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotPlaybackInputValueChanged(quint32,quint32)));
}
else
{
disconnect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotPlaybackInputValueChanged(quint32,quint32)));
}
}
void VCSliderProperties::slotAutoDetectInputToggled(bool checked)
{
if (checked == true)
{
connect(m_inputMap, SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotInputValueChanged(quint32,quint32)));
}
else
{
disconnect(m_inputMap, SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotInputValueChanged(quint32,quint32)));
}
}
void VCCueListProperties::slotCF2AutoDetectInputToggled(bool checked)
{
m_cf1AutoDetectInputButton->setChecked(false);
if (checked == true)
{
connect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotCF2InputValueChanged(quint32,quint32)));
}
else
{
disconnect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotCF2InputValueChanged(quint32,quint32)));
}
}
void InputPatch::slotValueChanged(quint32 input, quint32 channel, uchar value, const QString& key)
{
// In case we have several lines connected from the same plugin, emit only
// such values that belong to this particular patch.
if (input == m_input)
emit inputValueChanged(m_inputUniverse, channel, value, key);
}
void InputSelectionWidget::slotAutoDetectInputToggled(bool checked)
{
if (checked == true)
{
connect(m_doc->inputOutputMap(),
SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotInputValueChanged(quint32,quint32)));
}
else
{
disconnect(m_doc->inputOutputMap(),
SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotInputValueChanged(quint32,quint32)));
}
emit autoDetectToggled(checked);
}
void InputSelectionWidget::slotInputValueChanged(quint32 universe, quint32 channel)
{
if (m_emitOdd == true && m_signalsReceived % 2)
{
emit inputValueChanged(universe, (m_widgetPage << 16) | channel);
m_signalsReceived++;
return;
}
m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(universe, (m_widgetPage << 16) | channel));
updateInputSource();
m_signalsReceived++;
if (m_emitOdd == false)
emit inputValueChanged(universe, (m_widgetPage << 16) | channel);
}
void VCPropertiesEditor::slotAutoDetectHoldInputToggled(bool checked)
{
if (checked == true)
{
if (m_autoDetectFadeInputButton->isChecked() == true)
m_autoDetectFadeInputButton->toggle();
connect(m_inputMap, SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotHoldInputValueChanged(quint32,quint32)));
}
else
{
disconnect(m_inputMap, SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotHoldInputValueChanged(quint32,quint32)));
}
}
void InputSelectionWidget::slotChooseInputClicked()
{
SelectInputChannel sic(this, m_doc->inputOutputMap());
if (sic.exec() == QDialog::Accepted)
{
m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(sic.universe(), sic.channel()));
updateInputSource();
emit inputValueChanged(sic.universe(), sic.channel());
}
}
void InputPatch::slotValueChanged(quint32 universe, quint32 input, quint32 channel,
uchar value, const QString& key)
{
// In case we have several lines connected to the same plugin, emit only
// such values that belong to this particular patch.
if (input == m_pluginLine)
{
if (universe == UINT_MAX || (universe != UINT_MAX && universe == m_universe))
emit inputValueChanged(m_universe, channel, value, key);
}
}
void InputMap::slotValueChanged(QLCInPlugin* plugin, quint32 input,
quint32 channel, uchar value)
{
for (quint32 i = 0; i < m_universes; i++)
{
if (m_patch[i]->plugin() == plugin &&
m_patch[i]->input() == input)
{
emit inputValueChanged(i, channel, value);
}
}
}
void InputMap::slotValueChanged(QLCInPlugin* plugin, t_input input,
t_input_channel channel, t_input_value value)
{
for (t_input_universe i = 0; i < m_universes; i++)
{
if (m_patch[i]->plugin() == plugin &&
m_patch[i]->input() == input)
{
emit inputValueChanged(i, channel, value);
}
}
}
void QLCInputSource::updateInputValue(uchar value)
{
QMutexLocker locker(&m_mutex);
if (m_workingMode == Encoder)
{
if (value < m_inputValue)
m_sensitivity = -qAbs(m_sensitivity);
else if (value > m_inputValue)
m_sensitivity = qAbs(m_sensitivity);
m_inputValue = CLAMP(m_inputValue + m_sensitivity, 0, UCHAR_MAX);
locker.unlock();
emit inputValueChanged(m_universe, m_channel, m_inputValue);
}
else if (m_emitExtraPressRelease == true)
{
emit inputValueChanged(m_universe, m_channel, m_upper);
emit inputValueChanged(m_universe, m_channel, m_lower);
}
else
m_inputValue = value;
}
void InputMap::slotValueChanged(quint32 input, quint32 channel, uchar value)
{
QLCInPlugin* plugin = qobject_cast<QLCInPlugin*> (QObject::sender());
if (plugin == NULL)
return;
for (quint32 i = 0; i < m_universes; i++)
{
if (m_patch[i]->plugin() == plugin &&
m_patch[i]->input() == input)
{
emit inputValueChanged(i, channel, value);
}
}
}
InputManager::InputManager(QWidget* parent, Qt::WindowFlags flags)
: QWidget(parent, flags)
{
/* Create a new layout for this widget */
new QVBoxLayout(this);
/* Toolbar */
m_toolbar = new QToolBar(tr("Input Manager"), this);
m_toolbar->addAction(QIcon(":/edit.png"), tr("Edit Mapping"),
this, SLOT(slotEditClicked()));
layout()->addWidget(m_toolbar);
/* Tree */
m_tree = new QTreeWidget(this);
layout()->addWidget(m_tree);
m_tree->setRootIsDecorated(false);
m_tree->setItemsExpandable(false);
m_tree->setSortingEnabled(false);
m_tree->setAllColumnsShowFocus(true);
m_tree->header()->setResizeMode(QHeaderView::ResizeToContents);
QStringList columns;
columns << tr("Universe") << tr("Plugin") << tr("Input") << tr("Profile")
<< tr("Editor universe");
m_tree->setHeaderLabels(columns);
connect(m_tree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
this, SLOT(slotEditClicked()));
/* Timer that clears the input data icon after a while */
m_timer = new QTimer(this);
m_timer->setSingleShot(true);
connect(m_timer, SIGNAL(timeout()), this, SLOT(slotTimerTimeout()));
/* Listen to input map's input data signals */
connect(_app->inputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotInputValueChanged(quint32,quint32,uchar)));
/* Listen to document changes */
connect(_app, SIGNAL(documentChanged(Doc*)),
this, SLOT(slotDocumentChanged(Doc*)));
/* Use the initial document */
slotDocumentChanged(_app->doc());
/* Listen to plugin configuration changes */
connect(_app->inputMap(), SIGNAL(pluginConfigurationChanged(const QString&)),
this, SLOT(slotPluginConfigurationChanged()));
}
void QLCInputSource::run()
{
qDebug() << Q_FUNC_INFO << "Thread started for universe" << m_universe << "channel" << m_channel;
uchar inputValueCopy = m_inputValue;
double dValue = m_outputValue;
uchar lastOutputValue = m_outputValue;
bool movementOn = false;
while (m_running == true)
{
msleep(50);
QMutexLocker locker(&m_mutex);
if (lastOutputValue != m_outputValue)
dValue = m_outputValue;
if (inputValueCopy != m_inputValue || movementOn == true)
{
movementOn = false;
inputValueCopy = m_inputValue;
double moveAmount = 127 - inputValueCopy;
if (moveAmount != 0)
{
dValue -= (moveAmount / m_sensitivity);
dValue = CLAMP(dValue, 0, 255);
uchar newDmxValue = uchar(dValue);
qDebug() << "double value:" << dValue << "uchar val:" << newDmxValue;
if (newDmxValue != m_outputValue)
emit inputValueChanged(m_universe, m_channel, newDmxValue);
movementOn = true;
}
lastOutputValue = m_outputValue;
}
}
}
VirtualConsole::VirtualConsole(QQuickView *view, Doc *doc,
ContextManager *ctxManager, QObject *parent)
: PreviewContext(view, doc, "VC", parent)
, m_editMode(false)
, m_contextManager(ctxManager)
, m_selectedPage(0)
, m_latestWidgetId(0)
, m_inputDetectionEnabled(false)
, m_autoDetectionWidget(NULL)
, m_autoDetectionSource(NULL)
, m_autoDetectionKey(QKeySequence())
, m_autoDetectionKeyId(UINT_MAX)
{
Q_ASSERT(doc != NULL);
setContextResource("qrc:/VirtualConsole.qml");
setContextTitle(tr("Virtual Console"));
for (int i = 0; i < DEFAULT_VC_PAGES_NUMBER; i++)
{
VCPage *page = new VCPage(view, m_doc, this, i, this);
QQmlEngine::setObjectOwnership(page, QQmlEngine::CppOwnership);
m_contextManager->registerContext(page->previewContext());
m_pages.append(page);
}
qmlRegisterType<VCWidget>("com.qlcplus.classes", 1, 0, "VCWidget");
qmlRegisterType<VCFrame>("com.qlcplus.classes", 1, 0, "VCFrame");
qmlRegisterType<VCPage>("com.qlcplus.classes", 1, 0, "VCPage");
qmlRegisterType<VCButton>("com.qlcplus.classes", 1, 0, "VCButton");
qmlRegisterType<VCLabel>("com.qlcplus.classes", 1, 0, "VCLabel");
qmlRegisterType<VCSlider>("com.qlcplus.classes", 1, 0, "VCSlider");
qmlRegisterType<VCClock>("com.qlcplus.classes", 1, 0, "VCClock");
qmlRegisterType<VCClockSchedule>("com.qlcplus.classes", 1, 0, "VCClockSchedule");
connect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar,QString)),
this, SLOT(slotInputValueChanged(quint32,quint32,uchar)));
}
VCXYPadProperties::VCXYPadProperties(VCXYPad* xypad, Doc* doc)
: QDialog(xypad)
, m_xypad(xypad)
, m_doc(doc)
{
Q_ASSERT(doc != NULL);
Q_ASSERT(xypad != NULL);
setupUi(this);
// IDs 0-15 are reserved for XYPad base controls
m_lastAssignedID = 15;
QAction* action = new QAction(this);
action->setShortcut(QKeySequence(QKeySequence::Close));
connect(action, SIGNAL(triggered(bool)), this, SLOT(reject()));
addAction(action);
/********************************************************************
* General page
********************************************************************/
m_nameEdit->setText(m_xypad->caption());
if (m_xypad->invertedAppearance() == true)
m_YInvertedRadio->setChecked(true);
m_panInputWidget = new InputSelectionWidget(m_doc, this);
m_panInputWidget->setTitle(tr("Pan / Horizontal Axis"));
m_panInputWidget->setKeyInputVisibility(false);
m_panInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::panInputSourceId));
m_panInputWidget->setWidgetPage(m_xypad->page());
m_panInputWidget->emitOddValues(true);
m_panInputWidget->show();
m_extInputLayout->addWidget(m_panInputWidget);
connect(m_panInputWidget, SIGNAL(autoDetectToggled(bool)),
this, SLOT(slotPanAutoDetectToggled(bool)));
connect(m_panInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),
this, SLOT(slotPanInputValueChanged(quint32,quint32)));
m_tiltInputWidget = new InputSelectionWidget(m_doc, this);
m_tiltInputWidget->setTitle(tr("Tilt / Vertical Axis"));
m_tiltInputWidget->setKeyInputVisibility(false);
m_tiltInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::tiltInputSourceId));
m_tiltInputWidget->setWidgetPage(m_xypad->page());
m_tiltInputWidget->emitOddValues(true);
m_tiltInputWidget->show();
m_extInputLayout->addWidget(m_tiltInputWidget);
connect(m_tiltInputWidget, SIGNAL(autoDetectToggled(bool)),
this, SLOT(slotTiltAutoDetectToggled(bool)));
connect(m_tiltInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),
this, SLOT(slotTiltInputValueChanged(quint32,quint32)));
m_widthInputWidget = new InputSelectionWidget(m_doc, this);
m_widthInputWidget->setTitle(tr("Width"));
m_widthInputWidget->setKeyInputVisibility(false);
m_widthInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::widthInputSourceId));
m_widthInputWidget->setWidgetPage(m_xypad->page());
m_widthInputWidget->show();
m_sizeInputLayout->addWidget(m_widthInputWidget);
m_heightInputWidget = new InputSelectionWidget(m_doc, this);
m_heightInputWidget->setTitle(tr("Height"));
m_heightInputWidget->setKeyInputVisibility(false);
m_heightInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::heightInputSourceId));
m_heightInputWidget->setWidgetPage(m_xypad->page());
m_heightInputWidget->show();
m_sizeInputLayout->addWidget(m_heightInputWidget);
/********************************************************************
* Fixtures page
********************************************************************/
slotSelectionChanged(NULL);
fillFixturesTree();
connect(m_percentageRadio, SIGNAL(clicked(bool)),
this, SLOT(slotPercentageRadioChecked()));
connect(m_degreesRadio, SIGNAL(clicked(bool)),
this, SLOT(slotDegreesRadioChecked()));
connect(m_dmxRadio, SIGNAL(clicked(bool)),
this, SLOT(slotDMXRadioChecked()));
/********************************************************************
* Presets page
********************************************************************/
m_presetInputWidget = new InputSelectionWidget(m_doc, this);
m_presetInputWidget->setCustomFeedbackVisibility(true);
m_presetInputWidget->setWidgetPage(m_xypad->page());
m_presetInputWidget->show();
m_presetInputLayout->addWidget(m_presetInputWidget);
connect(m_presetInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),
this, SLOT(slotInputValueChanged(quint32,quint32)));
connect(m_presetInputWidget, SIGNAL(keySequenceChanged(QKeySequence)),
this, SLOT(slotKeySequenceChanged(QKeySequence)));
connect(m_addPositionButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddPositionClicked()));
connect(m_addEfxButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddEFXClicked()));
connect(m_addSceneButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddSceneClicked()));
connect(m_addFxGroupButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddFixtureGroupClicked()));
connect(m_removePresetButton, SIGNAL(clicked()),
this, SLOT(slotRemovePresetClicked()));
connect(m_moveUpPresetButton, SIGNAL(clicked()),
this, SLOT(slotMoveUpPresetClicked()));
connect(m_moveDownPresetButton, SIGNAL(clicked()),
this, SLOT(slotMoveDownPresetClicked()));
connect(m_presetNameEdit, SIGNAL(textEdited(QString const&)),
this, SLOT(slotPresetNameEdited(QString const&)));
connect(m_presetsTree, SIGNAL(itemClicked(QTreeWidgetItem*,int)),
this, SLOT(slotPresetSelectionChanged()));
m_xyArea = new VCXYPadArea(this);
//m_xyArea->setFixedSize(140, 140);
m_xyArea->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_xyArea->setMode(Doc::Operate);
m_presetLayout->addWidget(m_xyArea);
connect(m_xyArea, SIGNAL(positionChanged(QPointF)),
this, SLOT(slotXYPadPositionChanged(QPointF)));
foreach(const VCXYPadPreset *preset, m_xypad->presets())
{
m_presetList.append(new VCXYPadPreset(*preset));
if (preset->m_id > m_lastAssignedID)
m_lastAssignedID = preset->m_id;
}
updatePresetsTree();
QSettings settings;
QVariant var = settings.value(SETTINGS_GEOMETRY);
if (var.isValid() == true)
restoreGeometry(var.toByteArray());
AppUtil::ensureWidgetIsVisible(this);
m_doc->masterTimer()->registerDMXSource(this, "XYPadCfg");
}
VCMatrixProperties::VCMatrixProperties(VCMatrix* matrix, Doc* doc)
: QDialog(matrix)
, m_doc(doc)
{
Q_ASSERT(matrix != NULL);
Q_ASSERT(doc != NULL);
setupUi(this);
m_lastAssignedID = 0;
/* Matrix text and function */
m_matrix = matrix;
m_nameEdit->setText(m_matrix->caption());
slotSetFunction(m_matrix->function());
if (m_matrix->instantChanges())
m_instantCheck->setChecked(true);
/* Matrix connections */
connect(m_attachFunction, SIGNAL(clicked()), this, SLOT(slotAttachFunction()));
connect(m_detachFunction, SIGNAL(clicked()), this, SLOT(slotSetFunction()));
/* Slider external input */
m_sliderInputSource = m_matrix->inputSource();
updateSliderInputSource();
connect(m_autoDetectInputButton, SIGNAL(toggled(bool)),
this, SLOT(slotAutoDetectSliderInputToggled(bool)));
connect(m_chooseInputButton, SIGNAL(clicked()),
this, SLOT(slotChooseSliderInputClicked()));
/* Visibility */
quint32 visibilityMask = m_matrix->visibilityMask();
if (visibilityMask & VCMatrix::ShowSlider) m_sliderCheck->setChecked(true);
if (visibilityMask & VCMatrix::ShowLabel) m_labelCheck->setChecked(true);
if (visibilityMask & VCMatrix::ShowStartColorButton) m_startColorButtonCheck->setChecked(true);
if (visibilityMask & VCMatrix::ShowEndColorButton) m_endColorButtonCheck->setChecked(true);
if (visibilityMask & VCMatrix::ShowPresetCombo) m_presetComboCheck->setChecked(true);
/* Custom controls */
foreach(const VCMatrixControl *control, m_matrix->customControls())
{
m_controls.append(new VCMatrixControl(*control));
if (control->m_id > m_lastAssignedID)
m_lastAssignedID = control->m_id;
}
m_controlsTree->setSelectionMode(QAbstractItemView::SingleSelection);
updateTree();
connect(m_controlsTree, SIGNAL(itemClicked(QTreeWidgetItem*,int)),
this, SLOT(slotTreeSelectionChanged()));
connect(m_addStartColorButton, SIGNAL(clicked()),
this, SLOT(slotAddStartColorClicked()));
connect(m_addStartColorKnobsButton, SIGNAL(clicked()),
this, SLOT(slotAddStartColorKnobsClicked()));
connect(m_addEndColorButton, SIGNAL(clicked()),
this, SLOT(slotAddEndColorClicked()));
connect(m_addEndColorKnobsButton, SIGNAL(clicked()),
this, SLOT(slotAddEndColorKnobsClicked()));
connect(m_addEndColorResetButton, SIGNAL(clicked()),
this, SLOT(slotAddEndColorResetClicked()));
connect(m_addPresetButton, SIGNAL(clicked()),
this, SLOT(slotAddAnimationClicked()));
connect(m_addTextButton, SIGNAL(clicked()),
this, SLOT(slotAddTextClicked()));
connect(m_removeButton, SIGNAL(clicked()),
this, SLOT(slotRemoveClicked()));
m_presetInputWidget = new InputSelectionWidget(m_doc, this);
m_presetInputWidget->setCustomFeedbackVisibility(true);
m_presetInputWidget->setWidgetPage(m_matrix->page());
m_presetInputWidget->show();
m_presetInputLayout->addWidget(m_presetInputWidget);
connect(m_presetInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),
this, SLOT(slotInputValueChanged(quint32,quint32)));
connect(m_presetInputWidget, SIGNAL(keySequenceChanged(QKeySequence)),
this, SLOT(slotKeySequenceChanged(QKeySequence)));
}
InputOutputManager::InputOutputManager(QWidget* parent, Doc* doc)
: QWidget(parent)
, m_doc(doc)
, m_editor(NULL)
{
Q_ASSERT(s_instance == NULL);
s_instance = this;
Q_ASSERT(doc != NULL);
m_inputMap = doc->inputMap();
m_outputMap = doc->outputMap();
/* Create a new layout for this widget */
new QVBoxLayout(this);
layout()->setContentsMargins(0, 0, 0, 0);
layout()->setSpacing(0);
m_splitter = new QSplitter(Qt::Horizontal, this);
layout()->addWidget(m_splitter);
/* Tree */
m_tree = new QTreeWidget(this);
m_splitter->addWidget(m_tree);
m_tree->setRootIsDecorated(false);
m_tree->setItemsExpandable(false);
m_tree->setSortingEnabled(false);
m_tree->setAllColumnsShowFocus(true);
QWidget* gcontainer = new QWidget(this);
m_splitter->addWidget(gcontainer);
gcontainer->setLayout(new QVBoxLayout);
gcontainer->layout()->setContentsMargins(0, 0, 0, 0);
QStringList columns;
columns << tr("Universe") << tr("Input") << tr("Output") << tr("Feedback") << tr("Profile");
m_tree->setHeaderLabels(columns);
connect(m_tree, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
this, SLOT(slotCurrentItemChanged()));
/* Timer that clears the input data icon after a while */
m_icon = QIcon(":/input.png");
m_timer = new QTimer(this);
m_timer->setSingleShot(true);
connect(m_timer, SIGNAL(timeout()), this, SLOT(slotTimerTimeout()));
/* Listen to input map's input data signals */
connect(m_inputMap, SIGNAL(inputValueChanged(quint32,quint32,uchar)),
this, SLOT(slotInputValueChanged(quint32,quint32,uchar)));
/* Listen to plugin configuration changes */
connect(m_inputMap, SIGNAL(pluginConfigurationChanged(const QString&)),
this, SLOT(updateTree()));
updateTree();
m_tree->setCurrentItem(m_tree->topLevelItem(0));
//slotCurrentItemChanged();
QSettings settings;
QVariant var = settings.value(SETTINGS_SPLITTER);
if (var.isValid() == true)
m_splitter->restoreState(var.toByteArray());
}
GrandMasterSlider::GrandMasterSlider(QWidget* parent, InputOutputMap *ioMap)
: QFrame(parent)
, m_ioMap(ioMap)
{
Q_ASSERT(ioMap != NULL);
//setFrameStyle(QFrame::Panel | QFrame::Sunken);
setStyleSheet("QFrame { background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #D6D2D0, stop: 1 #AFACAB); "
"border: 1px solid gray; border-radius: 4px; }");
setSizePolicy(QSizePolicy::Maximum, QSizePolicy::MinimumExpanding);
setMinimumSize(QSize(40, 100));
setMaximumSize(QSize(40, USHRT_MAX));
new QVBoxLayout(this);
layout()->setMargin(2);
m_valueLabel = new QLabel(this);
m_valueLabel->setAlignment(Qt::AlignHCenter);
m_valueLabel->setStyleSheet("QFrame { background-color: transparent; border: 0px; border-radius: 0px; }");
layout()->addWidget(m_valueLabel);
m_slider = new ClickAndGoSlider(this);
m_slider->setRange(0, UCHAR_MAX);
m_slider->setStyleSheet(
"QSlider::groove:vertical { background: transparent; width: 28px; } "
"QSlider::handle:vertical { "
"background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #A81919, stop:0.45 #DB2020, stop:0.50 #000, stop:0.55 #DB2020, stop:1 #A81919);"
"border: 1px solid #5c5c5c;"
"border-radius: 4px; margin: 0 -1px; height: 20px; }"
"QSlider::handle:vertical:hover {"
"background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #DB2020, stop:0.45 #F51C1C, stop:0.50 #fff, stop:0.55 #F51C1C, stop:1 #DB2020);"
"border: 1px solid #000; }"
"QSlider::add-page:vertical { background: QLinearGradient( x1: 0, y1: 0, x2: 1, y2: 0, stop: 0 #78d, stop: 1 #97CDEC );"
"border: 1px solid #5288A7; margin: 0 11px; }"
"QSlider::sub-page:vertical { background: QLinearGradient( x1: 0, y1: 0, x2: 1, y2: 0, stop: 0 #888, stop: 1 #ddd );"
"border: 1px solid #8E8A86; margin: 0 11px; }"
"QSlider::handle:vertical:disabled { background: QLinearGradient(x1:0, y1:0, x2:0, y2:1, stop:0 #ddd, stop:0.45 #888, stop:0.50 #444, stop:0.55 #888, stop:1 #999);"
"border: 1px solid #666; }"
);
m_slider->setMinimumSize(QSize(30, 50));
m_slider->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::MinimumExpanding);
layout()->addWidget(m_slider);
layout()->setAlignment(m_slider, Qt::AlignHCenter);
m_slider->setValue(255);
connect(m_slider, SIGNAL(valueChanged(int)),
this, SLOT(slotValueChanged(int)));
m_nameLabel = new QLabel(this);
m_nameLabel->setWordWrap(true);
m_nameLabel->setAlignment(Qt::AlignHCenter);
m_nameLabel->setText(tr("GM"));
layout()->addWidget(m_nameLabel);
/* Listen to GM value changes */
connect(m_ioMap, SIGNAL(grandMasterValueChanged(uchar)),
this, SLOT(slotGrandMasterValueChanged(uchar)));
connect(m_ioMap, SIGNAL(grandMasterValueModeChanged(GrandMaster::ValueMode)),
this, SLOT(slotGrandMasterValueModeChanged(GrandMaster::ValueMode)));
/* External input connection */
connect(m_ioMap, SIGNAL(inputValueChanged(quint32, quint32, uchar)),
this, SLOT(slotInputValueChanged(quint32, quint32, uchar)));
updateTooltip();
updateDisplayValue();
}