19144422256

Committed 06 Nov 2025 05:33PM UTC coverage: 34.256% (-0.1%) from 34.358%

Build # 19144422256

Build Type

push

github

Committed by

mcallegari

Commit Message

Back to 5.1.0 debug

Run Details

17718 of 51723 relevant lines covered (34.26%)

19528.23 hits per line

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

37.01

/ui/src/inputselectionwidget.cpp

/*
  Q Light Controller Plus
  inputselectionwidget.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 <QDebug>

#include "customfeedbackdialog.h"
#include "inputselectionwidget.h"
#include "selectinputchannel.h"
#include "qlcinputchannel.h"
#include "qlcinputsource.h"
#include "assignhotkey.h"
#include "inputpatch.h"
#include "doc.h"

InputSelectionWidget::InputSelectionWidget(Doc *doc, QWidget *parent)
    : QWidget(parent)
    , m_doc(doc)
    , m_widgetPage(0)
    , m_emitOdd(false)
    , m_supportMonitoring(false)
    , m_signalsReceived(0)
{
    Q_ASSERT(doc != NULL);

    setupUi(this);

    m_customFbButton->setVisible(false);

    connect(m_attachKey, SIGNAL(clicked()), this, SLOT(slotAttachKey()));
    connect(m_detachKey, SIGNAL(clicked()), this, SLOT(slotDetachKey()));

    connect(m_autoDetectInputButton, SIGNAL(toggled(bool)),
            this, SLOT(slotAutoDetectInputToggled(bool)));
    connect(m_chooseInputButton, SIGNAL(clicked()),
            this, SLOT(slotChooseInputClicked()));

    connect(m_customFbButton, SIGNAL(clicked(bool)),
            this, SLOT(slotCustomFeedbackClicked()));
}

InputSelectionWidget::~InputSelectionWidget()
{
}

void InputSelectionWidget::setKeyInputVisibility(bool visible)
{
    m_keyInputGroup->setVisible(visible);
}

void InputSelectionWidget::setCustomFeedbackVisibility(bool visible)
{
    m_customFbButton->setVisible(visible);
}

void InputSelectionWidget::setMonitoringSupport(bool enable)
{
    m_supportMonitoring = enable;
}

void InputSelectionWidget::setTitle(QString title)
{
    m_extInputGroup->setTitle(title);
}

void InputSelectionWidget::setWidgetPage(int page)
{
    m_widgetPage = page;
}

bool InputSelectionWidget::isAutoDetecting()
{
   return m_autoDetectInputButton->isChecked();
}

void InputSelectionWidget::stopAutoDetection()
{
    if (m_autoDetectInputButton->isChecked())
        m_autoDetectInputButton->toggle();
}

void InputSelectionWidget::emitOddValues(bool enable)
{
    m_emitOdd = enable;
}

void InputSelectionWidget::setKeySequence(const QKeySequence &keySequence)
{
    m_keySequence = QKeySequence(keySequence);
    m_keyEdit->setText(m_keySequence.toString(QKeySequence::NativeText));
}

QKeySequence InputSelectionWidget::keySequence() const
{
    return m_keySequence;
}

void InputSelectionWidget::setInputSource(const QSharedPointer<QLCInputSource> &source)
{
    m_inputSource = source;
    updateInputSource();
}

QSharedPointer<QLCInputSource> InputSelectionWidget::inputSource() const
{
    return m_inputSource;
}

void InputSelectionWidget::slotAttachKey()
{
    AssignHotKey ahk(this, m_keySequence);
    if (ahk.exec() == QDialog::Accepted)
    {
        setKeySequence(QKeySequence(ahk.keySequence()));
        emit keySequenceChanged(m_keySequence);
    }
}

void InputSelectionWidget::slotDetachKey()
{
    setKeySequence(QKeySequence());
    emit keySequenceChanged(m_keySequence);
}

void InputSelectionWidget::slotAutoDetectInputToggled(bool checked)
{
    if (checked == true)
    {
        connect(m_doc->inputOutputMap(),
                SIGNAL(inputValueChanged(quint32,quint32,uchar)),
                this, SLOT(slotInputValueChanged(quint32,quint32)));
    }
    else
    {
        disconnect(m_doc->inputOutputMap(),
                   SIGNAL(inputValueChanged(quint32,quint32,uchar)),
                   this, SLOT(slotInputValueChanged(quint32,quint32)));
    }
    emit autoDetectToggled(checked);
}

void InputSelectionWidget::slotInputValueChanged(quint32 universe, quint32 channel)
{
    if (m_emitOdd == true && m_signalsReceived % 2)
    {
        emit inputValueChanged(universe, (m_widgetPage << 16) | channel);
        m_signalsReceived++;
        return;
    }

    m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(universe, (m_widgetPage << 16) | channel));
    updateInputSource();
    m_signalsReceived++;

    if (m_emitOdd == false)
        emit inputValueChanged(universe, (m_widgetPage << 16) | channel);
}

void InputSelectionWidget::slotChooseInputClicked()
{
    SelectInputChannel sic(this, m_doc->inputOutputMap());
    if (sic.exec() == QDialog::Accepted)
    {
        uchar lowerValue = 0;
        uchar upperValue = 0;
        uchar monitorValue = 0;
        QVariant extraLowerParams;
        QVariant extraUpperParams;
        QVariant extraMonitorParams;
        if (!m_inputSource.isNull())
        {
            lowerValue = m_inputSource->feedbackValue(QLCInputFeedback::LowerValue);
            upperValue = m_inputSource->feedbackValue(QLCInputFeedback::UpperValue);
            monitorValue = m_inputSource->feedbackValue(QLCInputFeedback::MonitorValue);
            extraLowerParams = m_inputSource->feedbackExtraParams(QLCInputFeedback::LowerValue);
            extraUpperParams = m_inputSource->feedbackExtraParams(QLCInputFeedback::UpperValue);
            extraMonitorParams = m_inputSource->feedbackExtraParams(QLCInputFeedback::MonitorValue);
        }
        m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(sic.universe(), (m_widgetPage << 16) | sic.channel()));
        if (!m_inputSource.isNull())
        {
            if (lowerValue != m_inputSource->feedbackValue(QLCInputFeedback::LowerValue))
                m_inputSource->setFeedbackValue(QLCInputFeedback::LowerValue, lowerValue);
            if (upperValue != m_inputSource->feedbackValue(QLCInputFeedback::UpperValue))
                m_inputSource->setFeedbackValue(QLCInputFeedback::UpperValue, upperValue);
            if (monitorValue != m_inputSource->feedbackValue(QLCInputFeedback::MonitorValue))
                m_inputSource->setFeedbackValue(QLCInputFeedback::MonitorValue, monitorValue);
            if (extraLowerParams.isValid())
                m_inputSource->setFeedbackExtraParams(QLCInputFeedback::LowerValue, extraLowerParams);
            if (extraUpperParams.isValid())
                m_inputSource->setFeedbackExtraParams(QLCInputFeedback::UpperValue, extraUpperParams);
            if (extraMonitorParams.isValid())
                m_inputSource->setFeedbackExtraParams(QLCInputFeedback::MonitorValue, extraMonitorParams);
        }
        updateInputSource();
        emit inputValueChanged(sic.universe(), (m_widgetPage << 16) | sic.channel());
    }
}

void InputSelectionWidget::slotCustomFeedbackClicked()
{
    CustomFeedbackDialog cfDialog(m_doc, m_inputSource, this);
    cfDialog.setMonitoringVisibility(m_supportMonitoring);
    cfDialog.exec();
}

void InputSelectionWidget::updateInputSource()
{
    QString uniName;
    QString chName;

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

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

1	/*
2	Q Light Controller Plus
3	inputselectionwidget.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 <QDebug>
21
22	#include "customfeedbackdialog.h"
23	#include "inputselectionwidget.h"
24	#include "selectinputchannel.h"
25	#include "qlcinputchannel.h"
26	#include "qlcinputsource.h"
27	#include "assignhotkey.h"
28	#include "inputpatch.h"
29	#include "doc.h"
30
31	InputSelectionWidget::InputSelectionWidget(Doc doc, QWidget parent)	4✔
32	: QWidget(parent)
33	, m_doc(doc)	4✔
34	, m_widgetPage(0)	4✔
35	, m_emitOdd(false)	4✔
36	, m_supportMonitoring(false)	4✔
37	, m_signalsReceived(0)	4✔
38	{
39	Q_ASSERT(doc != NULL);	4✔
40
41	setupUi(this);	4✔
42
43	m_customFbButton->setVisible(false);	4✔
44
45	connect(m_attachKey, SIGNAL(clicked()), this, SLOT(slotAttachKey()));	4✔
46	connect(m_detachKey, SIGNAL(clicked()), this, SLOT(slotDetachKey()));	4✔
47
48	connect(m_autoDetectInputButton, SIGNAL(toggled(bool)),	4✔
49	this, SLOT(slotAutoDetectInputToggled(bool)));
50	connect(m_chooseInputButton, SIGNAL(clicked()),	4✔
51	this, SLOT(slotChooseInputClicked()));
52
53	connect(m_customFbButton, SIGNAL(clicked(bool)),	4✔
54	this, SLOT(slotCustomFeedbackClicked()));
55	}	4✔
56
57	InputSelectionWidget::~InputSelectionWidget()	8✔
58	{
59	}	8✔
60
61	void InputSelectionWidget::setKeyInputVisibility(bool visible)	×
62	{
63	m_keyInputGroup->setVisible(visible);	×
64	}	×
65
66	void InputSelectionWidget::setCustomFeedbackVisibility(bool visible)	4✔
67	{
68	m_customFbButton->setVisible(visible);	4✔
69	}	4✔
70
71	void InputSelectionWidget::setMonitoringSupport(bool enable)	×
72	{
73	m_supportMonitoring = enable;	×
74	}	×
75
76	void InputSelectionWidget::setTitle(QString title)	3✔
77	{
78	m_extInputGroup->setTitle(title);	3✔
79	}	3✔
80
81	void InputSelectionWidget::setWidgetPage(int page)	4✔
82	{
83	m_widgetPage = page;	4✔
84	}	4✔
85
86	bool InputSelectionWidget::isAutoDetecting()	×
87	{
88	return m_autoDetectInputButton->isChecked();	×
89	}
90
91	void InputSelectionWidget::stopAutoDetection()	×
92	{
93	if (m_autoDetectInputButton->isChecked())	×
94	m_autoDetectInputButton->toggle();	×
95	}	×
96
97	void InputSelectionWidget::emitOddValues(bool enable)	×
98	{
99	m_emitOdd = enable;	×
100	}	×
101
102	void InputSelectionWidget::setKeySequence(const QKeySequence &keySequence)	3✔
103	{
104	m_keySequence = QKeySequence(keySequence);	3✔
105	m_keyEdit->setText(m_keySequence.toString(QKeySequence::NativeText));	3✔
106	}	3✔
107
108	QKeySequence InputSelectionWidget::keySequence() const	3✔
109	{
110	return m_keySequence;	3✔
111	}
112
113	void InputSelectionWidget::setInputSource(const QSharedPointer<QLCInputSource> &source)	3✔
114	{
115	m_inputSource = source;	3✔
116	updateInputSource();	3✔
117	}	3✔
118
119	QSharedPointer<QLCInputSource> InputSelectionWidget::inputSource() const	3✔
120	{
121	return m_inputSource;	3✔
122	}
123
124	void InputSelectionWidget::slotAttachKey()	×
125	{
126	AssignHotKey ahk(this, m_keySequence);	×
127	if (ahk.exec() == QDialog::Accepted)	×
128	{
129	setKeySequence(QKeySequence(ahk.keySequence()));	×
130	emit keySequenceChanged(m_keySequence);	×
131	}
132	}	×
133
134	void InputSelectionWidget::slotDetachKey()	×
135	{
136	setKeySequence(QKeySequence());	×
137	emit keySequenceChanged(m_keySequence);	×
138	}	×
139
140	void InputSelectionWidget::slotAutoDetectInputToggled(bool checked)	×
141	{
142	if (checked == true)	×
143	{
144	connect(m_doc->inputOutputMap(),	×
145	SIGNAL(inputValueChanged(quint32,quint32,uchar)),
146	this, SLOT(slotInputValueChanged(quint32,quint32)));
147	}
148	else
149	{
150	disconnect(m_doc->inputOutputMap(),	×
151	SIGNAL(inputValueChanged(quint32,quint32,uchar)),
152	this, SLOT(slotInputValueChanged(quint32,quint32)));
153	}
154	emit autoDetectToggled(checked);	×
155	}	×
156
157	void InputSelectionWidget::slotInputValueChanged(quint32 universe, quint32 channel)	×
158	{
159	if (m_emitOdd == true && m_signalsReceived % 2)	×
160	{
161	emit inputValueChanged(universe, (m_widgetPage << 16) \| channel);	×
162	m_signalsReceived++;	×
163	return;	×
164	}
165
166	m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(universe, (m_widgetPage << 16) \| channel));	×
167	updateInputSource();	×
168	m_signalsReceived++;	×
169
170	if (m_emitOdd == false)	×
171	emit inputValueChanged(universe, (m_widgetPage << 16) \| channel);	×
172	}
173
174	void InputSelectionWidget::slotChooseInputClicked()	×
175	{
176	SelectInputChannel sic(this, m_doc->inputOutputMap());	×
177	if (sic.exec() == QDialog::Accepted)	×
178	{
179	uchar lowerValue = 0;	×
180	uchar upperValue = 0;	×
181	uchar monitorValue = 0;	×
182	QVariant extraLowerParams;	×
183	QVariant extraUpperParams;	×
184	QVariant extraMonitorParams;	×
185	if (!m_inputSource.isNull())	×
186	{
187	lowerValue = m_inputSource->feedbackValue(QLCInputFeedback::LowerValue);	×
188	upperValue = m_inputSource->feedbackValue(QLCInputFeedback::UpperValue);	×
189	monitorValue = m_inputSource->feedbackValue(QLCInputFeedback::MonitorValue);	×
190	extraLowerParams = m_inputSource->feedbackExtraParams(QLCInputFeedback::LowerValue);	×
191	extraUpperParams = m_inputSource->feedbackExtraParams(QLCInputFeedback::UpperValue);	×
192	extraMonitorParams = m_inputSource->feedbackExtraParams(QLCInputFeedback::MonitorValue);	×
193	}
194	m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(sic.universe(), (m_widgetPage << 16) \| sic.channel()));	×
195	if (!m_inputSource.isNull())	×
196	{
197	if (lowerValue != m_inputSource->feedbackValue(QLCInputFeedback::LowerValue))	×
198	m_inputSource->setFeedbackValue(QLCInputFeedback::LowerValue, lowerValue);	×
199	if (upperValue != m_inputSource->feedbackValue(QLCInputFeedback::UpperValue))	×
200	m_inputSource->setFeedbackValue(QLCInputFeedback::UpperValue, upperValue);	×
201	if (monitorValue != m_inputSource->feedbackValue(QLCInputFeedback::MonitorValue))	×
202	m_inputSource->setFeedbackValue(QLCInputFeedback::MonitorValue, monitorValue);	×
203	if (extraLowerParams.isValid())	×
204	m_inputSource->setFeedbackExtraParams(QLCInputFeedback::LowerValue, extraLowerParams);	×
205	if (extraUpperParams.isValid())	×
206	m_inputSource->setFeedbackExtraParams(QLCInputFeedback::UpperValue, extraUpperParams);	×
207	if (extraMonitorParams.isValid())	×
208	m_inputSource->setFeedbackExtraParams(QLCInputFeedback::MonitorValue, extraMonitorParams);	×
209	}
210	updateInputSource();	×
211	emit inputValueChanged(sic.universe(), (m_widgetPage << 16) \| sic.channel());	×
212	}	×
213	}	×
214
215	void InputSelectionWidget::slotCustomFeedbackClicked()	×
216	{
217	CustomFeedbackDialog cfDialog(m_doc, m_inputSource, this);	×
218	cfDialog.setMonitoringVisibility(m_supportMonitoring);	×
219	cfDialog.exec();	×
220	}	×
221
222	void InputSelectionWidget::updateInputSource()	3✔
223	{
224	QString uniName;	3✔
225	QString chName;	3✔
226
227	if (!m_inputSource \|\| m_doc->inputOutputMap()->inputSourceNames(m_inputSource, uniName, chName) == false)	3✔
228	{
229	uniName = KInputNone;	3✔
230	chName = KInputNone;	3✔
231	}
232
233	m_inputUniverseEdit->setText(uniName);	3✔
234	m_inputChannelEdit->setText(chName);	3✔
235	}	3✔

mcallegari / qlcplus / 19144422256

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