14492056933

Committed 16 Apr 2025 11:53AM UTC coverage: 31.851% (-0.002%) from 31.853%

Build # 14492056933

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1725 from Jurrie/bugfix/Correctly_name_SonicPulse_LED_Bar_10

Correctly name 'SonicPulse LED Bar 10'

Run Details

14673 of 46068 relevant lines covered (31.85%)

26455.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/ui/src/virtualconsole/vcmatrixproperties.cpp

/*
  Q Light Controller Plus
  vcmatrixproperties.cpp

  Copyright (c) Massimo Callegari

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0.txt

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

#include <QColorDialog>
#include <QInputDialog>
#include <QTreeWidget>
#include <QMap>

#include "vcmatrixpresetselection.h"
#include "inputselectionwidget.h"
#include "vcmatrixproperties.h"
#include "selectinputchannel.h"
#include "functionselection.h"
#include "inputpatch.h"
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 #include "rgbscript.h"
#else
 #include "rgbscriptv4.h"
#endif

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::ShowColor1Button) m_mtxColor1ButtonCheck->setChecked(true);
    if (visibilityMask & VCMatrix::ShowColor2Button) m_mtxColor2ButtonCheck->setChecked(true);
    if (visibilityMask & VCMatrix::ShowColor3Button) m_mtxColor3ButtonCheck->setChecked(true);
    if (visibilityMask & VCMatrix::ShowColor4Button) m_mtxColor4ButtonCheck->setChecked(true);
    if (visibilityMask & VCMatrix::ShowColor5Button) m_mtxColor5ButtonCheck->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();
    slotColorComboActivated();

    connect(m_controlsTree, SIGNAL(itemClicked(QTreeWidgetItem*,int)),
            this, SLOT(slotTreeSelectionChanged()));

    connect(m_colorsCombo, SIGNAL(activated(int)),
            this, SLOT(slotColorComboActivated()));
    connect(m_addColorButton, SIGNAL(clicked()),
            this, SLOT(slotAddColorClicked()));
    connect(m_addColorKnobsButton, SIGNAL(clicked()),
            this, SLOT(slotAddColorKnobsClicked()));
    connect(m_addColorResetButton, SIGNAL(clicked()),
            this, SLOT(slotAddColorResetClicked()));

    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)));
}

VCMatrixProperties::~VCMatrixProperties()
{
    foreach (VCMatrixControl* control, m_controls)
        delete control;

    delete m_presetInputWidget;
}

/*********************************************************************
 * RGB Matrix attachment
 *********************************************************************/

void VCMatrixProperties::slotAttachFunction()
{
    FunctionSelection fs(this, m_doc);
    fs.setMultiSelection(false);
    fs.setFilter(Function::RGBMatrixType);
    fs.disableFilters(Function::SceneType | Function::ChaserType | Function::EFXType |
                      Function::ShowType | Function::ScriptType | Function::CollectionType |
                      Function::AudioType | Function::VideoType);

    if (fs.exec() == QDialog::Accepted && fs.selection().size() > 0)
        slotSetFunction(fs.selection().first());
}

void VCMatrixProperties::slotSetFunction(quint32 fid)
{
    m_function = fid;
    Function* func = m_doc->function(m_function);

    if (func == NULL)
    {
        m_functionEdit->setText(tr("No function"));
    }
    else
    {
        m_functionEdit->setText(func->name());
        if (m_nameEdit->text().simplified().contains(QString::number(m_matrix->id())))
            m_nameEdit->setText(func->name());
    }
}

/*********************************************************************
 * Slider External input
 *********************************************************************/

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 VCMatrixProperties::slotSliderInputValueChanged(quint32 universe, quint32 channel)
{
    m_sliderInputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(universe, (m_matrix->page() << 16) | channel));
    updateSliderInputSource();
}

void VCMatrixProperties::slotChooseSliderInputClicked()
{
    SelectInputChannel sic(this, m_doc->inputOutputMap());
    if (sic.exec() == QDialog::Accepted)
    {
        m_sliderInputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(sic.universe(), sic.channel()));
        updateSliderInputSource();
    }
}

void VCMatrixProperties::updateSliderInputSource()
{
    QString uniName;
    QString chName;

    if (m_doc->inputOutputMap()->inputSourceNames(m_sliderInputSource, uniName, chName) == false)
    {
        uniName = KInputNone;
        chName = KInputNone;
    }

    m_inputUniverseEdit->setText(uniName);
    m_inputChannelEdit->setText(chName);
}

/*********************************************************************
 * Custom controls
 *********************************************************************/

void VCMatrixProperties::updateTree()
{
    m_controlsTree->blockSignals(true);
    m_controlsTree->clear();
    foreach (VCMatrixControl *control, m_controls)
    {
        QTreeWidgetItem *item = new QTreeWidgetItem(m_controlsTree);
        item->setData(0, Qt::UserRole, control->m_id);

        switch(control->m_type)
        {
            case VCMatrixControl::Color1:
                item->setIcon(0, QIcon(":/color.png"));
                item->setText(0, tr("Color 1"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color1Knob:
                item->setIcon(0, QIcon(":/knob.png"));
                item->setText(0, tr("Color 1 Knob"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color1Reset:
            break;
            case VCMatrixControl::Color2:
                item->setIcon(0, QIcon(":/color.png"));
                item->setText(0, tr("Color 2"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color2Knob:
                item->setIcon(0, QIcon(":/knob.png"));
                item->setText(0, tr("Color 2 Knob"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color2Reset:
                item->setIcon(0, QIcon(":/fileclose.png"));
                item->setText(0, tr("Color 2 Reset"));
            break;
            case VCMatrixControl::Color3:
                item->setIcon(0, QIcon(":/color.png"));
                item->setText(0, tr("Color 3"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color3Knob:
                item->setIcon(0, QIcon(":/knob.png"));
                item->setText(0, tr("Color 3 Knob"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color3Reset:
                item->setIcon(0, QIcon(":/fileclose.png"));
                item->setText(0, tr("Color 3 Reset"));
            break;
            case VCMatrixControl::Color4:
                item->setIcon(0, QIcon(":/color.png"));
                item->setText(0, tr("Color 4"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color4Knob:
                item->setIcon(0, QIcon(":/knob.png"));
                item->setText(0, tr("Color 4 Knob"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color4Reset:
                item->setIcon(0, QIcon(":/fileclose.png"));
                item->setText(0, tr("Color 4 Reset"));
            break;
            case VCMatrixControl::Color5:
                item->setIcon(0, QIcon(":/color.png"));
                item->setText(0, tr("Color 5"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color5Knob:
                item->setIcon(0, QIcon(":/knob.png"));
                item->setText(0, tr("Color 5 Knob"));
                item->setText(1, control->m_color.name());
                item->setBackground(1, QBrush(control->m_color));
            break;
            case VCMatrixControl::Color5Reset:
                item->setIcon(0, QIcon(":/fileclose.png"));
                item->setText(0, tr("Color 5 Reset"));
            break;
            case VCMatrixControl::Animation:
            {
                item->setIcon(0, QIcon(":/script.png"));
                item->setText(0, tr("Animation"));
                QString presetName = control->m_resource;
                if (!control->m_properties.isEmpty())
                {
                    presetName += " (";
                    QMapIterator<QString, QString> it(control->m_properties);
                    while (it.hasNext())
                    {
                        it.next();
                        presetName += it.value();
                        if (it.hasNext())
                            presetName += ",";
                    }
                    presetName += ")";
                }
                item->setText(1, presetName);
            }
            break;
            case VCMatrixControl::Image:
            break;
            case VCMatrixControl::Text:
                item->setIcon(0, QIcon(":/fonts.png"));
                item->setText(0, tr("Text"));
                item->setText(1, control->m_resource);
            break;
        }
    }
    m_controlsTree->resizeColumnToContents(0);
    m_controlsTree->blockSignals(false);
}

VCMatrixControl *VCMatrixProperties::getSelectedControl()
{
    if (m_controlsTree->selectedItems().isEmpty())
        return NULL;

    QTreeWidgetItem * item = m_controlsTree->selectedItems().first();
    if (item != NULL)
    {
        quint8 ctlID = item->data(0, Qt::UserRole).toUInt();
        foreach (VCMatrixControl *control, m_controls)
        {
            if (control->m_id == ctlID)
                return control;
        }
    }

    Q_ASSERT(false);
    return NULL;
}

QList<QColor> VCMatrixProperties::rgbColorList()
{
    QList<QColor> colors;
    colors.append(QColor(Qt::red));
    colors.append(QColor(Qt::green));
    colors.append(QColor(Qt::blue));
    return colors;
}

void VCMatrixProperties::addControl(VCMatrixControl *control)
{
    m_controls.append(control);
}

void VCMatrixProperties::removeControl(quint8 id)
{
    for (int i = 0; i < m_controls.count(); i++)
    {
        if (m_controls.at(i)->m_id == id)
        {
            m_controls.removeAt(i);
            return;
        }
    }
}

void VCMatrixProperties::slotAddColorClicked()
{
    QColor col = QColorDialog::getColor();
    if (col.isValid() == true)
    {
        VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);
        newControl->m_type = VCMatrixControl::ControlType(int(VCMatrixControl::Color1) + m_colorsCombo->currentIndex());
        newControl->m_color = col;
        addControl(newControl);
        updateTree();
    }
}

void VCMatrixProperties::slotAddColorKnobsClicked()
{
    foreach (QColor col, VCMatrixProperties::rgbColorList())
    {
        VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);
        newControl->m_type = VCMatrixControl::ControlType(int(VCMatrixControl::Color1Knob) + m_colorsCombo->currentIndex());
        newControl->m_color = col;
        addControl(newControl);
    }
    updateTree();
}

void VCMatrixProperties::slotAddColorResetClicked()
{
    VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);
    newControl->m_type = VCMatrixControl::ControlType(int(VCMatrixControl::Color1Reset) + m_colorsCombo->currentIndex());
    addControl(newControl);
    updateTree();
}

void VCMatrixProperties::slotAddAnimationClicked()
{
    VCMatrixPresetSelection ps(m_doc, this);

    if (ps.exec() == QDialog::Accepted)
    {
        VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);
        newControl->m_type = VCMatrixControl::Animation;
        newControl->m_resource = ps.selectedPreset();
        newControl->m_properties = ps.customizedProperties();
        addControl(newControl);
        updateTree();
    }
}

void VCMatrixProperties::slotAddTextClicked()
{
    bool ok;
    QString text = QInputDialog::getText(this, tr("Enter a text"),
                                      tr("Text"), QLineEdit::Normal,
                                      "Q Light Controller+", &ok);
    if (ok && !text.isEmpty())
    {
        VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);
        newControl->m_type = VCMatrixControl::Text;
        newControl->m_resource = text;
        addControl(newControl);
        updateTree();
    }
}

void VCMatrixProperties::slotRemoveClicked()
{
    if (m_controlsTree->selectedItems().isEmpty())
        return;
    QTreeWidgetItem *selItem = m_controlsTree->selectedItems().first();
    quint8 ctlID = selItem->data(0, Qt::UserRole).toUInt();

    {
        // For R/G/B Knobs:
        // Remove the two others
        VCMatrixControl *control = getSelectedControl();
        if (control != NULL)
        {
            if (control->m_type == VCMatrixControl::Color1Knob
                    || control->m_type == VCMatrixControl::Color2Knob
                    || control->m_type == VCMatrixControl::Color3Knob
                    || control->m_type == VCMatrixControl::Color4Knob
                    || control->m_type == VCMatrixControl::Color5Knob)
            {
                if (control->m_color == Qt::red)
                {
                    removeControl(ctlID + 1);
                    removeControl(ctlID + 2);
                }
                else if (control->m_color == Qt::green)
                {
                    removeControl(ctlID - 1);
                    removeControl(ctlID + 1);
                }
                else if (control->m_color == Qt::blue)
                {
                    removeControl(ctlID - 2);
                    removeControl(ctlID - 1);
                }
                else
                {
                    Q_ASSERT(false);
                }
            }
        }
    }

    removeControl(ctlID);
    updateTree();
}

void VCMatrixProperties::slotInputValueChanged(quint32 universe, quint32 channel)
{
    Q_UNUSED(universe);
    Q_UNUSED(channel);

    VCMatrixControl *preset = getSelectedControl();

    if (preset != NULL) {
        preset->m_inputSource = m_presetInputWidget->inputSource();
    }
}

void VCMatrixProperties::slotKeySequenceChanged(QKeySequence key)
{
    VCMatrixControl *preset = getSelectedControl();

    if (preset != NULL)
        preset->m_keySequence = key;
}


void VCMatrixProperties::slotTreeSelectionChanged()
{
    VCMatrixControl *control = getSelectedControl();

    if (control != NULL)
    {
        m_presetInputWidget->setInputSource(control->m_inputSource);
        m_presetInputWidget->setKeySequence(control->m_keySequence.toString(QKeySequence::NativeText));
        if (control->widgetType() == VCMatrixControl::Button)
        {
            m_presetInputWidget->setCustomFeedbackVisibility(true);
            m_presetInputWidget->setKeyInputVisibility(true);
        }
        else
        {
            m_presetInputWidget->setCustomFeedbackVisibility(false);
            m_presetInputWidget->setKeyInputVisibility(false);
        }
    }
}

void VCMatrixProperties::slotColorComboActivated()
{
    if (m_colorsCombo->currentIndex() == 0)
        m_addColorResetButton->setEnabled(false);
    else
        m_addColorResetButton->setEnabled(true);
}

void VCMatrixProperties::accept()
{
    m_matrix->setCaption(m_nameEdit->text());
    m_matrix->setFunction(m_function);
    if (m_instantCheck->isChecked())
        m_matrix->setInstantChanges(true);
    else
        m_matrix->setInstantChanges(false);

    /* External input */
    m_matrix->setInputSource(m_sliderInputSource);

    /* Visibility */
    quint32 visibilityMask = 0;
    if (m_sliderCheck->isChecked()) visibilityMask |= VCMatrix::ShowSlider;
    if (m_labelCheck->isChecked()) visibilityMask |= VCMatrix::ShowLabel;
    if (m_mtxColor1ButtonCheck->isChecked()) visibilityMask |= VCMatrix::ShowColor1Button;
    if (m_mtxColor2ButtonCheck->isChecked()) visibilityMask |= VCMatrix::ShowColor2Button;
    if (m_mtxColor3ButtonCheck->isChecked()) visibilityMask |= VCMatrix::ShowColor3Button;
    if (m_mtxColor4ButtonCheck->isChecked()) visibilityMask |= VCMatrix::ShowColor4Button;
    if (m_mtxColor5ButtonCheck->isChecked()) visibilityMask |= VCMatrix::ShowColor5Button;
    if (m_presetComboCheck->isChecked()) visibilityMask |= VCMatrix::ShowPresetCombo;
    m_matrix->setVisibilityMask(visibilityMask);

    /* Controls */
    m_matrix->resetCustomControls();
    for (int i = 0; i < m_controls.count(); i++)
        m_matrix->addCustomControl(*m_controls.at(i));

    /* Close dialog */
    QDialog::accept();
}

1	/*
2	Q Light Controller Plus
3	vcmatrixproperties.cpp
4
5	Copyright (c) Massimo Callegari
6
7	Licensed under the Apache License, Version 2.0 (the "License");
8	you may not use this file except in compliance with the License.
9	You may obtain a copy of the License at
10
11	http://www.apache.org/licenses/LICENSE-2.0.txt
12
13	Unless required by applicable law or agreed to in writing, software
14	distributed under the License is distributed on an "AS IS" BASIS,
15	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	See the License for the specific language governing permissions and
17	limitations under the License.
18	*/
19
20	#include <QColorDialog>
21	#include <QInputDialog>
22	#include <QTreeWidget>
23	#include <QMap>
24
25	#include "vcmatrixpresetselection.h"
26	#include "inputselectionwidget.h"
27	#include "vcmatrixproperties.h"
28	#include "selectinputchannel.h"
29	#include "functionselection.h"
30	#include "inputpatch.h"
31	#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
32	#include "rgbscript.h"
33	#else
34	#include "rgbscriptv4.h"
35	#endif
36
37	VCMatrixProperties::VCMatrixProperties(VCMatrix* matrix, Doc* doc)	×
38	: QDialog(matrix)
39	, m_doc(doc)	×
40	{
41	Q_ASSERT(matrix != NULL);
42	Q_ASSERT(doc != NULL);
43
44	setupUi(this);	×
45
46	m_lastAssignedID = 0;	×
47
48	/* Matrix text and function */
49	m_matrix = matrix;	×
50	m_nameEdit->setText(m_matrix->caption());	×
51	slotSetFunction(m_matrix->function());	×
52
53	if (m_matrix->instantChanges())	×
54	m_instantCheck->setChecked(true);	×
55
56	/* Matrix connections */
57	connect(m_attachFunction, SIGNAL(clicked()), this, SLOT(slotAttachFunction()));	×
58	connect(m_detachFunction, SIGNAL(clicked()), this, SLOT(slotSetFunction()));	×
59
60	/* Slider external input */
61	m_sliderInputSource = m_matrix->inputSource();	×
62	updateSliderInputSource();	×
63
64	connect(m_autoDetectInputButton, SIGNAL(toggled(bool)),	×
65	this, SLOT(slotAutoDetectSliderInputToggled(bool)));
66	connect(m_chooseInputButton, SIGNAL(clicked()),	×
67	this, SLOT(slotChooseSliderInputClicked()));
68
69	/* Visibility */
70	quint32 visibilityMask = m_matrix->visibilityMask();	×
71	if (visibilityMask & VCMatrix::ShowSlider) m_sliderCheck->setChecked(true);	×
72	if (visibilityMask & VCMatrix::ShowLabel) m_labelCheck->setChecked(true);	×
73	if (visibilityMask & VCMatrix::ShowColor1Button) m_mtxColor1ButtonCheck->setChecked(true);	×
74	if (visibilityMask & VCMatrix::ShowColor2Button) m_mtxColor2ButtonCheck->setChecked(true);	×
75	if (visibilityMask & VCMatrix::ShowColor3Button) m_mtxColor3ButtonCheck->setChecked(true);	×
76	if (visibilityMask & VCMatrix::ShowColor4Button) m_mtxColor4ButtonCheck->setChecked(true);	×
77	if (visibilityMask & VCMatrix::ShowColor5Button) m_mtxColor5ButtonCheck->setChecked(true);	×
78	if (visibilityMask & VCMatrix::ShowPresetCombo) m_presetComboCheck->setChecked(true);	×
79
80	/* Custom controls */
81	foreach (const VCMatrixControl *control, m_matrix->customControls())	×
82	{
83	m_controls.append(new VCMatrixControl(*control));	×
84	if (control->m_id > m_lastAssignedID)	×
85	m_lastAssignedID = control->m_id;	×
86	}
87
88	m_controlsTree->setSelectionMode(QAbstractItemView::SingleSelection);	×
89
90	updateTree();	×
91	slotColorComboActivated();	×
92
93	connect(m_controlsTree, SIGNAL(itemClicked(QTreeWidgetItem*,int)),	×
94	this, SLOT(slotTreeSelectionChanged()));
95
96	connect(m_colorsCombo, SIGNAL(activated(int)),	×
97	this, SLOT(slotColorComboActivated()));
98	connect(m_addColorButton, SIGNAL(clicked()),	×
99	this, SLOT(slotAddColorClicked()));
100	connect(m_addColorKnobsButton, SIGNAL(clicked()),	×
101	this, SLOT(slotAddColorKnobsClicked()));
102	connect(m_addColorResetButton, SIGNAL(clicked()),	×
103	this, SLOT(slotAddColorResetClicked()));
104
105	connect(m_addPresetButton, SIGNAL(clicked()),	×
106	this, SLOT(slotAddAnimationClicked()));
107	connect(m_addTextButton, SIGNAL(clicked()),	×
108	this, SLOT(slotAddTextClicked()));
109
110	connect(m_removeButton, SIGNAL(clicked()),	×
111	this, SLOT(slotRemoveClicked()));
112
113	m_presetInputWidget = new InputSelectionWidget(m_doc, this);	×
114	m_presetInputWidget->setCustomFeedbackVisibility(true);	×
115	m_presetInputWidget->setWidgetPage(m_matrix->page());	×
116	m_presetInputWidget->show();	×
117	m_presetInputLayout->addWidget(m_presetInputWidget);	×
118
119	connect(m_presetInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),	×
120	this, SLOT(slotInputValueChanged(quint32,quint32)));
121	connect(m_presetInputWidget, SIGNAL(keySequenceChanged(QKeySequence)),	×
122	this, SLOT(slotKeySequenceChanged(QKeySequence)));
123	}	×
124
125	VCMatrixProperties::~VCMatrixProperties()	×
126	{
127	foreach (VCMatrixControl* control, m_controls)	×
128	delete control;	×
129
130	delete m_presetInputWidget;	×
131	}	×
132
133	/*********************************************************************
134	* RGB Matrix attachment
135	*********************************************************************/
136
137	void VCMatrixProperties::slotAttachFunction()	×
138	{
139	FunctionSelection fs(this, m_doc);	×
140	fs.setMultiSelection(false);	×
141	fs.setFilter(Function::RGBMatrixType);	×
142	fs.disableFilters(Function::SceneType \| Function::ChaserType \| Function::EFXType \|	×
143	Function::ShowType \| Function::ScriptType \| Function::CollectionType \|
144	Function::AudioType \| Function::VideoType);
145
146	if (fs.exec() == QDialog::Accepted && fs.selection().size() > 0)	×
147	slotSetFunction(fs.selection().first());	×
148	}	×
149
150	void VCMatrixProperties::slotSetFunction(quint32 fid)	×
151	{
152	m_function = fid;	×
153	Function* func = m_doc->function(m_function);	×
154
155	if (func == NULL)	×
156	{
157	m_functionEdit->setText(tr("No function"));	×
158	}
159	else
160	{
161	m_functionEdit->setText(func->name());	×
162	if (m_nameEdit->text().simplified().contains(QString::number(m_matrix->id())))	×
163	m_nameEdit->setText(func->name());	×
164	}
165	}	×
166
167	/*********************************************************************
168	* Slider External input
169	*********************************************************************/
170
171	void VCMatrixProperties::slotAutoDetectSliderInputToggled(bool checked)	×
172	{
173	if (checked == true)	×
174	{
175	connect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),	×
176	this, SLOT(slotSliderInputValueChanged(quint32,quint32)));
177	}
178	else
179	{
180	disconnect(m_doc->inputOutputMap(), SIGNAL(inputValueChanged(quint32,quint32,uchar)),	×
181	this, SLOT(slotSliderInputValueChanged(quint32,quint32)));
182	}
183	}	×
184
185	void VCMatrixProperties::slotSliderInputValueChanged(quint32 universe, quint32 channel)	×
186	{
187	m_sliderInputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(universe, (m_matrix->page() << 16) \| channel));	×
188	updateSliderInputSource();	×
189	}	×
190
191	void VCMatrixProperties::slotChooseSliderInputClicked()	×
192	{
193	SelectInputChannel sic(this, m_doc->inputOutputMap());	×
194	if (sic.exec() == QDialog::Accepted)	×
195	{
196	m_sliderInputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(sic.universe(), sic.channel()));	×
197	updateSliderInputSource();	×
198	}
199	}	×
200
201	void VCMatrixProperties::updateSliderInputSource()	×
202	{
203	QString uniName;
204	QString chName;
205
206	if (m_doc->inputOutputMap()->inputSourceNames(m_sliderInputSource, uniName, chName) == false)	×
207	{
208	uniName = KInputNone;	×
209	chName = KInputNone;	×
210	}
211
212	m_inputUniverseEdit->setText(uniName);	×
213	m_inputChannelEdit->setText(chName);	×
214	}	×
215
216	/*********************************************************************
217	* Custom controls
218	*********************************************************************/
219
220	void VCMatrixProperties::updateTree()	×
221	{
222	m_controlsTree->blockSignals(true);	×
223	m_controlsTree->clear();	×
224	foreach (VCMatrixControl *control, m_controls)	×
225	{
226	QTreeWidgetItem *item = new QTreeWidgetItem(m_controlsTree);	×
227	item->setData(0, Qt::UserRole, control->m_id);	×
228
229	switch(control->m_type)	×
230	{
231	case VCMatrixControl::Color1:	×
232	item->setIcon(0, QIcon(":/color.png"));	×
233	item->setText(0, tr("Color 1"));	×
234	item->setText(1, control->m_color.name());	×
235	item->setBackground(1, QBrush(control->m_color));	×
236	break;	×
237	case VCMatrixControl::Color1Knob:	×
238	item->setIcon(0, QIcon(":/knob.png"));	×
239	item->setText(0, tr("Color 1 Knob"));	×
240	item->setText(1, control->m_color.name());	×
241	item->setBackground(1, QBrush(control->m_color));	×
242	break;	×
243	case VCMatrixControl::Color1Reset:
244	break;
245	case VCMatrixControl::Color2:	×
246	item->setIcon(0, QIcon(":/color.png"));	×
247	item->setText(0, tr("Color 2"));	×
248	item->setText(1, control->m_color.name());	×
249	item->setBackground(1, QBrush(control->m_color));	×
250	break;	×
251	case VCMatrixControl::Color2Knob:	×
252	item->setIcon(0, QIcon(":/knob.png"));	×
253	item->setText(0, tr("Color 2 Knob"));	×
254	item->setText(1, control->m_color.name());	×
255	item->setBackground(1, QBrush(control->m_color));	×
256	break;	×
257	case VCMatrixControl::Color2Reset:	×
258	item->setIcon(0, QIcon(":/fileclose.png"));	×
259	item->setText(0, tr("Color 2 Reset"));	×
260	break;	×
261	case VCMatrixControl::Color3:	×
262	item->setIcon(0, QIcon(":/color.png"));	×
263	item->setText(0, tr("Color 3"));	×
264	item->setText(1, control->m_color.name());	×
265	item->setBackground(1, QBrush(control->m_color));	×
266	break;	×
267	case VCMatrixControl::Color3Knob:	×
268	item->setIcon(0, QIcon(":/knob.png"));	×
269	item->setText(0, tr("Color 3 Knob"));	×
270	item->setText(1, control->m_color.name());	×
271	item->setBackground(1, QBrush(control->m_color));	×
272	break;	×
273	case VCMatrixControl::Color3Reset:	×
274	item->setIcon(0, QIcon(":/fileclose.png"));	×
275	item->setText(0, tr("Color 3 Reset"));	×
276	break;	×
277	case VCMatrixControl::Color4:	×
278	item->setIcon(0, QIcon(":/color.png"));	×
279	item->setText(0, tr("Color 4"));	×
280	item->setText(1, control->m_color.name());	×
281	item->setBackground(1, QBrush(control->m_color));	×
282	break;	×
283	case VCMatrixControl::Color4Knob:	×
284	item->setIcon(0, QIcon(":/knob.png"));	×
285	item->setText(0, tr("Color 4 Knob"));	×
286	item->setText(1, control->m_color.name());	×
287	item->setBackground(1, QBrush(control->m_color));	×
288	break;	×
289	case VCMatrixControl::Color4Reset:	×
290	item->setIcon(0, QIcon(":/fileclose.png"));	×
291	item->setText(0, tr("Color 4 Reset"));	×
292	break;	×
293	case VCMatrixControl::Color5:	×
294	item->setIcon(0, QIcon(":/color.png"));	×
295	item->setText(0, tr("Color 5"));	×
296	item->setText(1, control->m_color.name());	×
297	item->setBackground(1, QBrush(control->m_color));	×
298	break;	×
299	case VCMatrixControl::Color5Knob:	×
300	item->setIcon(0, QIcon(":/knob.png"));	×
301	item->setText(0, tr("Color 5 Knob"));	×
302	item->setText(1, control->m_color.name());	×
303	item->setBackground(1, QBrush(control->m_color));	×
304	break;	×
305	case VCMatrixControl::Color5Reset:	×
306	item->setIcon(0, QIcon(":/fileclose.png"));	×
307	item->setText(0, tr("Color 5 Reset"));	×
308	break;	×
309	case VCMatrixControl::Animation:	×
310	{
311	item->setIcon(0, QIcon(":/script.png"));	×
312	item->setText(0, tr("Animation"));	×
313	QString presetName = control->m_resource;
314	if (!control->m_properties.isEmpty())	×
315	{
316	presetName += " (";	×
317	QMapIterator<QString, QString> it(control->m_properties);	×
318	while (it.hasNext())	×
319	{
320	it.next();	×
321	presetName += it.value();
322	if (it.hasNext())	×
323	presetName += ",";	×
324	}
325	presetName += ")";	×
326	}
327	item->setText(1, presetName);	×
328	}	×
329	break;	×
330	case VCMatrixControl::Image:
331	break;
332	case VCMatrixControl::Text:	×
333	item->setIcon(0, QIcon(":/fonts.png"));	×
334	item->setText(0, tr("Text"));	×
335	item->setText(1, control->m_resource);	×
336	break;
337	}
338	}
339	m_controlsTree->resizeColumnToContents(0);	×
340	m_controlsTree->blockSignals(false);	×
341	}	×
342
343	VCMatrixControl *VCMatrixProperties::getSelectedControl()	×
344	{
345	if (m_controlsTree->selectedItems().isEmpty())	×
346	return NULL;
347
348	QTreeWidgetItem * item = m_controlsTree->selectedItems().first();	×
349	if (item != NULL)	×
350	{
351	quint8 ctlID = item->data(0, Qt::UserRole).toUInt();	×
352	foreach (VCMatrixControl *control, m_controls)	×
353	{
354	if (control->m_id == ctlID)	×
355	return control;
356	}
357	}
358
359	Q_ASSERT(false);
360	return NULL;
361	}
362
363	QList<QColor> VCMatrixProperties::rgbColorList()	×
364	{
365	QList<QColor> colors;
366	colors.append(QColor(Qt::red));	×
367	colors.append(QColor(Qt::green));	×
368	colors.append(QColor(Qt::blue));	×
369	return colors;	×
370	}	×
371
372	void VCMatrixProperties::addControl(VCMatrixControl *control)	×
373	{
374	m_controls.append(control);	×
375	}	×
376
377	void VCMatrixProperties::removeControl(quint8 id)	×
378	{
379	for (int i = 0; i < m_controls.count(); i++)	×
380	{
381	if (m_controls.at(i)->m_id == id)	×
382	{
383	m_controls.removeAt(i);	×
384	return;	×
385	}
386	}
387	}
388
389	void VCMatrixProperties::slotAddColorClicked()	×
390	{
391	QColor col = QColorDialog::getColor();	×
392	if (col.isValid() == true)	×
393	{
394	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
395	newControl->m_type = VCMatrixControl::ControlType(int(VCMatrixControl::Color1) + m_colorsCombo->currentIndex());	×
396	newControl->m_color = col;	×
397	addControl(newControl);	×
398	updateTree();	×
399	}
400	}	×
401
402	void VCMatrixProperties::slotAddColorKnobsClicked()	×
403	{
404	foreach (QColor col, VCMatrixProperties::rgbColorList())	×
405	{
406	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
407	newControl->m_type = VCMatrixControl::ControlType(int(VCMatrixControl::Color1Knob) + m_colorsCombo->currentIndex());	×
408	newControl->m_color = col;	×
409	addControl(newControl);	×
410	}
411	updateTree();	×
412	}	×
413
414	void VCMatrixProperties::slotAddColorResetClicked()	×
415	{
416	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
417	newControl->m_type = VCMatrixControl::ControlType(int(VCMatrixControl::Color1Reset) + m_colorsCombo->currentIndex());	×
418	addControl(newControl);	×
419	updateTree();	×
420	}	×
421
422	void VCMatrixProperties::slotAddAnimationClicked()	×
423	{
424	VCMatrixPresetSelection ps(m_doc, this);	×
425
426	if (ps.exec() == QDialog::Accepted)	×
427	{
428	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
429	newControl->m_type = VCMatrixControl::Animation;	×
430	newControl->m_resource = ps.selectedPreset();	×
431	newControl->m_properties = ps.customizedProperties();	×
432	addControl(newControl);	×
433	updateTree();	×
434	}
435	}	×
436
437	void VCMatrixProperties::slotAddTextClicked()	×
438	{
439	bool ok;
440	QString text = QInputDialog::getText(this, tr("Enter a text"),	×
441	tr("Text"), QLineEdit::Normal,	×
442	"Q Light Controller+", &ok);	×
443	if (ok && !text.isEmpty())	×
444	{
445	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
446	newControl->m_type = VCMatrixControl::Text;	×
447	newControl->m_resource = text;	×
448	addControl(newControl);	×
449	updateTree();	×
450	}
451	}	×
452
453	void VCMatrixProperties::slotRemoveClicked()	×
454	{
455	if (m_controlsTree->selectedItems().isEmpty())	×
456	return;
457	QTreeWidgetItem *selItem = m_controlsTree->selectedItems().first();	×
458	quint8 ctlID = selItem->data(0, Qt::UserRole).toUInt();	×
459
460	{
461	// For R/G/B Knobs:
462	// Remove the two others
463	VCMatrixControl *control = getSelectedControl();	×
464	if (control != NULL)	×
465	{
466	if (control->m_type == VCMatrixControl::Color1Knob	×
467	\|\| control->m_type == VCMatrixControl::Color2Knob
468	\|\| control->m_type == VCMatrixControl::Color3Knob
469	\|\| control->m_type == VCMatrixControl::Color4Knob
470	\|\| control->m_type == VCMatrixControl::Color5Knob)	×
471	{
472	if (control->m_color == Qt::red)	×
473	{
474	removeControl(ctlID + 1);	×
475	removeControl(ctlID + 2);	×
476	}
477	else if (control->m_color == Qt::green)	×
478	{
479	removeControl(ctlID - 1);	×
480	removeControl(ctlID + 1);	×
481	}
482	else if (control->m_color == Qt::blue)	×
483	{
484	removeControl(ctlID - 2);	×
485	removeControl(ctlID - 1);	×
486	}
487	else
488	{
489	Q_ASSERT(false);
490	}
491	}
492	}
493	}
494
495	removeControl(ctlID);	×
496	updateTree();	×
497	}
498
499	void VCMatrixProperties::slotInputValueChanged(quint32 universe, quint32 channel)	×
500	{
501	Q_UNUSED(universe);
502	Q_UNUSED(channel);
503
504	VCMatrixControl *preset = getSelectedControl();	×
505
506	if (preset != NULL) {	×
507	preset->m_inputSource = m_presetInputWidget->inputSource();	×
508	}
509	}	×
510
511	void VCMatrixProperties::slotKeySequenceChanged(QKeySequence key)	×
512	{
513	VCMatrixControl *preset = getSelectedControl();	×
514
515	if (preset != NULL)	×
516	preset->m_keySequence = key;	×
517	}	×
518
519
520	void VCMatrixProperties::slotTreeSelectionChanged()	×
521	{
522	VCMatrixControl *control = getSelectedControl();	×
523
524	if (control != NULL)	×
525	{
526	m_presetInputWidget->setInputSource(control->m_inputSource);	×
527	m_presetInputWidget->setKeySequence(control->m_keySequence.toString(QKeySequence::NativeText));	×
528	if (control->widgetType() == VCMatrixControl::Button)	×
529	{
530	m_presetInputWidget->setCustomFeedbackVisibility(true);	×
531	m_presetInputWidget->setKeyInputVisibility(true);	×
532	}
533	else
534	{
535	m_presetInputWidget->setCustomFeedbackVisibility(false);	×
536	m_presetInputWidget->setKeyInputVisibility(false);	×
537	}
538	}
539	}	×
540
541	void VCMatrixProperties::slotColorComboActivated()	×
542	{
543	if (m_colorsCombo->currentIndex() == 0)	×
544	m_addColorResetButton->setEnabled(false);	×
545	else
546	m_addColorResetButton->setEnabled(true);	×
547	}	×
548
549	void VCMatrixProperties::accept()	×
550	{
551	m_matrix->setCaption(m_nameEdit->text());	×
552	m_matrix->setFunction(m_function);	×
553	if (m_instantCheck->isChecked())	×
554	m_matrix->setInstantChanges(true);	×
555	else
556	m_matrix->setInstantChanges(false);	×
557
558	/* External input */
559	m_matrix->setInputSource(m_sliderInputSource);	×
560
561	/* Visibility */
562	quint32 visibilityMask = 0;
563	if (m_sliderCheck->isChecked()) visibilityMask \|= VCMatrix::ShowSlider;	×
564	if (m_labelCheck->isChecked()) visibilityMask \|= VCMatrix::ShowLabel;	×
565	if (m_mtxColor1ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor1Button;	×
566	if (m_mtxColor2ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor2Button;	×
567	if (m_mtxColor3ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor3Button;	×
568	if (m_mtxColor4ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor4Button;	×
569	if (m_mtxColor5ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor5Button;	×
570	if (m_presetComboCheck->isChecked()) visibilityMask \|= VCMatrix::ShowPresetCombo;	×
571	m_matrix->setVisibilityMask(visibilityMask);	×
572
573	/* Controls */
574	m_matrix->resetCustomControls();	×
575	for (int i = 0; i < m_controls.count(); i++)	×
576	m_matrix->addCustomControl(*m_controls.at(i));	×
577
578	/* Close dialog */
579	QDialog::accept();	×
580	}	×

mcallegari / qlcplus / 14492056933

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous