18357067171

Committed 08 Oct 2025 08:16PM UTC coverage: 34.26% (+2.2%) from 32.066%

Build # 18357067171

Build Type

push

github

Committed by

mcallegari

Commit Message

Merge branch 'master' into filedialog

Run Details

1282 of 4424 new or added lines in 152 files covered. (28.98%)

1342 existing lines in 152 files now uncovered.

17704 of 51675 relevant lines covered (34.26%)

19430.31 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);	×
NEW 73	if (visibilityMask & VCMatrix::ShowColor1Button) m_mtxColor1ButtonCheck->setChecked(true);	×
NEW 74	if (visibilityMask & VCMatrix::ShowColor2Button) m_mtxColor2ButtonCheck->setChecked(true);	×
NEW 75	if (visibilityMask & VCMatrix::ShowColor3Button) m_mtxColor3ButtonCheck->setChecked(true);	×
NEW 76	if (visibilityMask & VCMatrix::ShowColor4Button) m_mtxColor4ButtonCheck->setChecked(true);	×
NEW 77	if (visibilityMask & VCMatrix::ShowColor5Button) m_mtxColor5ButtonCheck->setChecked(true);	×
UNCOV 78	if (visibilityMask & VCMatrix::ShowPresetCombo) m_presetComboCheck->setChecked(true);	×
79
80	/* Custom controls */
NEW 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;	×
UNCOV 86	}	×
87
88	m_controlsTree->setSelectionMode(QAbstractItemView::SingleSelection);	×
89
90	updateTree();	×
NEW 91	slotColorComboActivated();	×
92
93	connect(m_controlsTree, SIGNAL(itemClicked(QTreeWidgetItem*,int)),	×
94	this, SLOT(slotTreeSelectionChanged()));
95
NEW 96	connect(m_colorsCombo, SIGNAL(activated(int)),	×
97	this, SLOT(slotColorComboActivated()));
NEW 98	connect(m_addColorButton, SIGNAL(clicked()),	×
99	this, SLOT(slotAddColorClicked()));
NEW 100	connect(m_addColorKnobsButton, SIGNAL(clicked()),	×
101	this, SLOT(slotAddColorKnobsClicked()));
NEW 102	connect(m_addColorResetButton, SIGNAL(clicked()),	×
103	this, SLOT(slotAddColorResetClicked()));
104
UNCOV 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();	×
NEW 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	{
NEW 231	case VCMatrixControl::Color1:	×
NEW 232	item->setIcon(0, QIcon(":/color.png"));	×
NEW 233	item->setText(0, tr("Color 1"));	×
NEW 234	item->setText(1, control->m_color.name());	×
NEW 235	item->setBackground(1, QBrush(control->m_color));	×
NEW 236	break;	×
NEW 237	case VCMatrixControl::Color1Knob:	×
NEW 238	item->setIcon(0, QIcon(":/knob.png"));	×
NEW 239	item->setText(0, tr("Color 1 Knob"));	×
NEW 240	item->setText(1, control->m_color.name());	×
NEW 241	item->setBackground(1, QBrush(control->m_color));	×
NEW 242	break;	×
NEW 243	case VCMatrixControl::Color1Reset:	×
NEW 244	break;	×
NEW 245	case VCMatrixControl::Color2:	×
NEW 246	item->setIcon(0, QIcon(":/color.png"));	×
NEW 247	item->setText(0, tr("Color 2"));	×
NEW 248	item->setText(1, control->m_color.name());	×
NEW 249	item->setBackground(1, QBrush(control->m_color));	×
NEW 250	break;	×
NEW 251	case VCMatrixControl::Color2Knob:	×
NEW 252	item->setIcon(0, QIcon(":/knob.png"));	×
NEW 253	item->setText(0, tr("Color 2 Knob"));	×
NEW 254	item->setText(1, control->m_color.name());	×
NEW 255	item->setBackground(1, QBrush(control->m_color));	×
NEW 256	break;	×
NEW 257	case VCMatrixControl::Color2Reset:	×
NEW 258	item->setIcon(0, QIcon(":/fileclose.png"));	×
NEW 259	item->setText(0, tr("Color 2 Reset"));	×
NEW 260	break;	×
NEW 261	case VCMatrixControl::Color3:	×
NEW 262	item->setIcon(0, QIcon(":/color.png"));	×
NEW 263	item->setText(0, tr("Color 3"));	×
NEW 264	item->setText(1, control->m_color.name());	×
NEW 265	item->setBackground(1, QBrush(control->m_color));	×
NEW 266	break;	×
NEW 267	case VCMatrixControl::Color3Knob:	×
NEW 268	item->setIcon(0, QIcon(":/knob.png"));	×
NEW 269	item->setText(0, tr("Color 3 Knob"));	×
NEW 270	item->setText(1, control->m_color.name());	×
NEW 271	item->setBackground(1, QBrush(control->m_color));	×
NEW 272	break;	×
NEW 273	case VCMatrixControl::Color3Reset:	×
NEW 274	item->setIcon(0, QIcon(":/fileclose.png"));	×
NEW 275	item->setText(0, tr("Color 3 Reset"));	×
NEW 276	break;	×
NEW 277	case VCMatrixControl::Color4:	×
278	item->setIcon(0, QIcon(":/color.png"));	×
NEW 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;	×
NEW 283	case VCMatrixControl::Color4Knob:	×
284	item->setIcon(0, QIcon(":/knob.png"));	×
NEW 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;	×
NEW 289	case VCMatrixControl::Color4Reset:	×
NEW 290	item->setIcon(0, QIcon(":/fileclose.png"));	×
NEW 291	item->setText(0, tr("Color 4 Reset"));	×
NEW 292	break;	×
NEW 293	case VCMatrixControl::Color5:	×
294	item->setIcon(0, QIcon(":/color.png"));	×
NEW 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;	×
NEW 299	case VCMatrixControl::Color5Knob:	×
300	item->setIcon(0, QIcon(":/knob.png"));	×
NEW 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;	×
NEW 305	case VCMatrixControl::Color5Reset:	×
306	item->setIcon(0, QIcon(":/fileclose.png"));	×
NEW 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 += " (";	×
NEW 317	QMapIterator<QString, QString> it(control->m_properties);	×
NEW 318	while (it.hasNext())	×
319	{
320	it.next();	×
321	presetName += it.value();	×
322	if (it.hasNext())	×
323	presetName += ",";	×
324	}
325	presetName += ")";	×
UNCOV 326	}	×
327	item->setText(1, presetName);	×
UNCOV 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	}
UNCOV 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();	×
NEW 352	foreach (VCMatrixControl *control, m_controls)	×
353	{
354	if (control->m_id == ctlID)	×
355	return control;	×
UNCOV 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;	×
UNCOV 370	}	×
371
372	void VCMatrixProperties::addControl(VCMatrixControl *control)	×
373	{
374	m_controls.append(control);	×
375	}	×
376
377	void VCMatrixProperties::removeControl(quint8 id)	×
378	{
NEW 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
NEW 389	void VCMatrixProperties::slotAddColorClicked()	×
390	{
391	QColor col = QColorDialog::getColor();	×
392	if (col.isValid() == true)	×
393	{
394	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
NEW 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
NEW 402	void VCMatrixProperties::slotAddColorKnobsClicked()	×
403	{
404	foreach (QColor col, VCMatrixProperties::rgbColorList())	×
405	{
406	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
NEW 407	newControl->m_type = VCMatrixControl::ControlType(int(VCMatrixControl::Color1Knob) + m_colorsCombo->currentIndex());	×
408	newControl->m_color = col;	×
409	addControl(newControl);	×
UNCOV 410	}	×
411	updateTree();	×
412	}	×
413
NEW 414	void VCMatrixProperties::slotAddColorResetClicked()	×
415	{
416	VCMatrixControl *newControl = new VCMatrixControl(++m_lastAssignedID);	×
NEW 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	{
NEW 466	if (control->m_type == VCMatrixControl::Color1Knob	×
NEW 467	\|\| control->m_type == VCMatrixControl::Color2Knob	×
NEW 468	\|\| control->m_type == VCMatrixControl::Color3Knob	×
NEW 469	\|\| control->m_type == VCMatrixControl::Color4Knob	×
NEW 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
NEW 541	void VCMatrixProperties::slotColorComboActivated()	×
542	{
NEW 543	if (m_colorsCombo->currentIndex() == 0)	×
NEW 544	m_addColorResetButton->setEnabled(false);	×
545	else
NEW 546	m_addColorResetButton->setEnabled(true);	×
NEW 547	}	×
548
UNCOV 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;	×
NEW 565	if (m_mtxColor1ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor1Button;	×
NEW 566	if (m_mtxColor2ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor2Button;	×
NEW 567	if (m_mtxColor3ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor3Button;	×
NEW 568	if (m_mtxColor4ButtonCheck->isChecked()) visibilityMask \|= VCMatrix::ShowColor4Button;	×
NEW 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 / 18357067171

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