13633248611

Committed 03 Mar 2025 02:31PM UTC coverage: 31.871% (+0.4%) from 31.5%

Build # 13633248611

Build Type

push

github

Committed by

web-flow

Commit Message

actions: add chrpath to profile

Run Details

14689 of 46089 relevant lines covered (31.87%)

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

mcallegari / qlcplus / 13633248611

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