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

78.42

/engine/src/qlcinputchannel.cpp

/*
  Q Light Controller
  qlcinputchannel.cpp

  Copyright (c) Heikki Junnila

  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 <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QString>
#include <QDebug>
#include <QIcon>

#include "qlcinputchannel.h"

/****************************************************************************
 * Initialization
 ****************************************************************************/

QLCInputChannel::QLCInputChannel()
    : m_type(Button)
    , m_movementType(Absolute)
    , m_movementSensitivity(20)
    , m_sendExtraPress(false)
    , m_lowerValue(0)
    , m_upperValue(UCHAR_MAX)
    , m_lowerChannel(-1)
{
}

QLCInputChannel *QLCInputChannel::createCopy()
{
    QLCInputChannel *copy = new QLCInputChannel();
    copy->setName(this->name());
    copy->setType(this->type());
    copy->setMovementType(this->movementType());
    copy->setMovementSensitivity(this->movementSensitivity());
    copy->setSendExtraPress(this->sendExtraPress());
    copy->setLowerChannel(this->lowerChannel());
    copy->setRange(this->lowerValue(), this->upperValue());

    return copy;
}

QLCInputChannel::~QLCInputChannel()
{
}

/****************************************************************************
 * Type
 ****************************************************************************/

void QLCInputChannel::setType(Type type)
{
    if (type == m_type)
        return;

    m_type = type;
    if (type == Encoder)
        m_movementSensitivity = 1;
    else
        m_movementSensitivity = 20;

    emit typeChanged();
}

QLCInputChannel::Type QLCInputChannel::type() const
{
    return m_type;
}

QString QLCInputChannel::typeToString(Type type)
{
    switch (type)
    {
        case Button:
            return KXMLQLCInputChannelButton;
        case Knob:
            return KXMLQLCInputChannelKnob;
        case Encoder:
            return KXMLQLCInputChannelEncoder;
        case Slider:
            return KXMLQLCInputChannelSlider;
        case NextPage:
            return KXMLQLCInputChannelPageUp;
        case PrevPage:
            return KXMLQLCInputChannelPageDown;
        case PageSet:
            return KXMLQLCInputChannelPageSet;
        default:
            return KXMLQLCInputChannelNone;
        }
}

QString QLCInputChannel::typeString()
{
    return typeToString(type());
}

QLCInputChannel::Type QLCInputChannel::stringToType(const QString& type)
{
    if (type == KXMLQLCInputChannelButton)
        return Button;
    else if (type == KXMLQLCInputChannelKnob)
        return Knob;
    else if (type == KXMLQLCInputChannelEncoder)
        return Encoder;
    else if (type == KXMLQLCInputChannelSlider)
        return Slider;
    else if (type == KXMLQLCInputChannelPageUp)
        return NextPage;
    else if (type == KXMLQLCInputChannelPageDown)
        return PrevPage;
    else if (type == KXMLQLCInputChannelPageSet)
        return PageSet;
    else
        return NoType;
}

QStringList QLCInputChannel::types()
{
    QStringList list;
    list << KXMLQLCInputChannelSlider;
    list << KXMLQLCInputChannelKnob;
    list << KXMLQLCInputChannelEncoder;
    list << KXMLQLCInputChannelButton;
    list << KXMLQLCInputChannelPageUp;
    list << KXMLQLCInputChannelPageDown;
    list << KXMLQLCInputChannelPageSet;
    return list;
}

QIcon QLCInputChannel::typeToIcon(Type type)
{
    return QIcon(iconResource(type));
}

QIcon QLCInputChannel::stringToIcon(const QString& str)
{
    return typeToIcon(stringToType(str));
}

QString QLCInputChannel::iconResource(Type type, bool svg)
{
    QString prefix = svg ? "qrc" : "";
    QString ext = svg ? "svg" : "png";

    switch(type)
    {
        case Button: return QString("%1:/button.%2").arg(prefix, ext);
        case Knob: return QString("%1:/knob.%2").arg(prefix, ext);
        case Encoder: return QString("%1:/knob.%2").arg(prefix, ext);
        case Slider: return QString("%1:/slider.%2").arg(prefix, ext);
        case PrevPage: return QString("%1:/forward.%2").arg(prefix, ext);
        case NextPage: return QString("%1:/back.%2").arg(prefix, ext);
        case PageSet: return QString("%1:/star.%2").arg(prefix, ext);
        default: return QString();
    }

    return QString("%1:/other.%2").arg(prefix, ext);
}

QIcon QLCInputChannel::icon() const
{
    return typeToIcon(type());
}

/****************************************************************************
 * Name
 ****************************************************************************/

void QLCInputChannel::setName(const QString& name)
{
    if (name == m_name)
        return;

    m_name = name;

    emit nameChanged();
}

QString QLCInputChannel::name() const
{
    return m_name;
}

/*********************************************************************
 * Slider/Knob movement behaviour specific methods
 *********************************************************************/

QLCInputChannel::MovementType QLCInputChannel::movementType() const
{
    return m_movementType;
}

void QLCInputChannel::setMovementType(QLCInputChannel::MovementType type)
{
    m_movementType = type;
}

int QLCInputChannel::movementSensitivity() const
{
    return m_movementSensitivity;
}

void QLCInputChannel::setMovementSensitivity(int value)
{
    m_movementSensitivity = value;
}

/*********************************************************************
 * Button behaviour specific methods
 *********************************************************************/

void QLCInputChannel::setSendExtraPress(bool enable)
{
    if (enable == m_sendExtraPress)
        return;

    m_sendExtraPress = enable;
    emit sendExtraPressChanged();
}

bool QLCInputChannel::sendExtraPress() const
{
    return m_sendExtraPress;
}

void QLCInputChannel::setRange(uchar lower, uchar upper)
{
    setLowerValue(lower);
    setUpperValue(upper);
}

uchar QLCInputChannel::lowerValue() const
{
    return m_lowerValue;
}

void QLCInputChannel::setLowerValue(const uchar value)
{
    if (value == m_lowerValue)
        return;
    
    m_lowerValue = value;
    emit lowerValueChanged();
}

uchar QLCInputChannel::upperValue() const
{
    return m_upperValue;
}

void QLCInputChannel::setUpperValue(const uchar value)
{
    if (value == m_upperValue)
        return;
    
    m_upperValue = value;
    emit upperValueChanged();
}

int QLCInputChannel::lowerChannel() const
{
    return m_lowerChannel;
}

void QLCInputChannel::setLowerChannel(const int channel)
{
    if (channel == m_lowerChannel)
        return;
    
    m_lowerChannel = channel;
    emit midiChannelChanged();
}

/****************************************************************************
 * Load & Save
 ****************************************************************************/

bool QLCInputChannel::loadXML(QXmlStreamReader &root)
{
    if (root.isStartElement() == false || root.name() != KXMLQLCInputChannel)
    {
        qWarning() << Q_FUNC_INFO << "Channel node not found";
        return false;
    }

    while (root.readNextStartElement())
    {
        if (root.name() == KXMLQLCInputChannelName)
        {
            setName(root.readElementText());
        }
        else if (root.name() == KXMLQLCInputChannelType)
        {
            setType(stringToType(root.readElementText()));
        }
        else if (root.name() == KXMLQLCInputChannelExtraPress)
        {
            root.readElementText();
            setSendExtraPress(true);
        }
        else if (root.name() == KXMLQLCInputChannelMovement)
        {
            if (root.attributes().hasAttribute(KXMLQLCInputChannelSensitivity))
                setMovementSensitivity(root.attributes().value(KXMLQLCInputChannelSensitivity).toString().toInt());

            if (root.readElementText() == KXMLQLCInputChannelRelative)
                setMovementType(Relative);
        }
        else if (root.name() == KXMLQLCInputChannelFeedback)
        {
            QXmlStreamAttributes attrs = root.attributes();
            uchar min = 0, max = UCHAR_MAX;
            int fbChannel = -1;

            if (attrs.hasAttribute(KXMLQLCInputChannelLowerValue))
                min = uchar(attrs.value(KXMLQLCInputChannelLowerValue).toString().toUInt());
            if (attrs.hasAttribute(KXMLQLCInputChannelUpperValue))
                max = uchar(attrs.value(KXMLQLCInputChannelUpperValue).toString().toUInt());
            if (attrs.hasAttribute(KXMLQLCInputChannelMidiChannel))
                fbChannel = attrs.value(KXMLQLCInputChannelMidiChannel).toInt();

            setRange(min, max);
            setLowerChannel(fbChannel);
            root.skipCurrentElement();
        }
        else
        {
            qWarning() << Q_FUNC_INFO << "Unknown input channel tag" << root.name();
            root.skipCurrentElement();
        }
    }

    return true;
}

bool QLCInputChannel::saveXML(QXmlStreamWriter *doc, quint32 channelNumber) const
{
    if (doc == NULL || doc->device() == NULL)
        return false;

    doc->writeStartElement(KXMLQLCInputChannel);
    doc->writeAttribute(KXMLQLCInputChannelNumber,
                        QString("%1").arg(channelNumber));

    doc->writeTextElement(KXMLQLCInputChannelName, m_name);
    doc->writeTextElement(KXMLQLCInputChannelType, typeToString(m_type));
    if (sendExtraPress() == true)
        doc->writeTextElement(KXMLQLCInputChannelExtraPress, "True");

    /* Save only slider's relative movement */
    if ((type() == Slider || type() == Knob) && movementType() == Relative)
    {
        doc->writeStartElement(KXMLQLCInputChannelMovement);
        doc->writeAttribute(KXMLQLCInputChannelSensitivity, QString::number(movementSensitivity()));
        doc->writeCharacters(KXMLQLCInputChannelRelative);
        doc->writeEndElement();
    }
    else if (type() == Encoder)
    {
        doc->writeStartElement(KXMLQLCInputChannelMovement);
        doc->writeAttribute(KXMLQLCInputChannelSensitivity, QString::number(movementSensitivity()));
        doc->writeEndElement();
    }
    else if (type() == Button && (lowerValue() != 0 || upperValue() != UCHAR_MAX))
    {
        doc->writeStartElement(KXMLQLCInputChannelFeedback);
        if (lowerValue() != 0)
            doc->writeAttribute(KXMLQLCInputChannelLowerValue, QString::number(lowerValue()));
        if (upperValue() != UCHAR_MAX)
            doc->writeAttribute(KXMLQLCInputChannelUpperValue, QString::number(upperValue()));
        if (lowerChannel() != -1)
            doc->writeAttribute(KXMLQLCInputChannelMidiChannel, QString::number(lowerChannel()));
        doc->writeEndElement();
    }

    doc->writeEndElement();
    return true;
}

1	/*
2	Q Light Controller
3	qlcinputchannel.cpp
4
5	Copyright (c) Heikki Junnila
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 <QXmlStreamReader>
21	#include <QXmlStreamWriter>
22	#include <QString>
23	#include <QDebug>
24	#include <QIcon>
25
26	#include "qlcinputchannel.h"
27
28	/****************************************************************************
29	* Initialization
30	****************************************************************************/
31
32	QLCInputChannel::QLCInputChannel()	12,458✔
33	: m_type(Button)	12,458✔
34	, m_movementType(Absolute)	12,458✔
35	, m_movementSensitivity(20)	12,458✔
36	, m_sendExtraPress(false)	12,458✔
37	, m_lowerValue(0)	12,458✔
38	, m_upperValue(UCHAR_MAX)	12,458✔
39	, m_lowerChannel(-1)	12,458✔
40	{
41	}	12,458✔
42
43	QLCInputChannel *QLCInputChannel::createCopy()	10✔
44	{
45	QLCInputChannel *copy = new QLCInputChannel();	10✔
46	copy->setName(this->name());	10✔
47	copy->setType(this->type());	10✔
48	copy->setMovementType(this->movementType());	10✔
49	copy->setMovementSensitivity(this->movementSensitivity());	10✔
50	copy->setSendExtraPress(this->sendExtraPress());	10✔
51	copy->setLowerChannel(this->lowerChannel());	10✔
52	copy->setRange(this->lowerValue(), this->upperValue());	10✔
53
54	return copy;	10✔
55	}
56
57	QLCInputChannel::~QLCInputChannel()	8,178✔
58	{
59	}	8,178✔
60
61	/****************************************************************************
62	* Type
63	****************************************************************************/
64
65	void QLCInputChannel::setType(Type type)	12,437✔
66	{
67	if (type == m_type)	12,437✔
68	return;
69
70	m_type = type;	4,893✔
71	if (type == Encoder)	4,893✔
72	m_movementSensitivity = 1;	112✔
73	else
74	m_movementSensitivity = 20;	4,781✔
75
76	emit typeChanged();	4,893✔
77	}
78
79	QLCInputChannel::Type QLCInputChannel::type() const	807✔
80	{
81	return m_type;	807✔
82	}
83
84	QString QLCInputChannel::typeToString(Type type)	12✔
85	{
86	switch (type)	12✔
87	{
88	case Button:	4✔
89	return KXMLQLCInputChannelButton;	4✔
90	case Knob:	2✔
91	return KXMLQLCInputChannelKnob;	2✔
92	case Encoder:	1✔
93	return KXMLQLCInputChannelEncoder;	1✔
94	case Slider:	1✔
95	return KXMLQLCInputChannelSlider;	1✔
96	case NextPage:	1✔
97	return KXMLQLCInputChannelPageUp;	1✔
98	case PrevPage:	1✔
99	return KXMLQLCInputChannelPageDown;	1✔
100	case PageSet:	1✔
101	return KXMLQLCInputChannelPageSet;	1✔
102	default:	1✔
103	return KXMLQLCInputChannelNone;	1✔
104	}
105	}
106
107	QString QLCInputChannel::typeString()	×
108	{
109	return typeToString(type());	×
110	}
111
112	QLCInputChannel::Type QLCInputChannel::stringToType(const QString& type)	12,426✔
113	{
114	if (type == KXMLQLCInputChannelButton)	12,426✔
115	return Button;
116	else if (type == KXMLQLCInputChannelKnob)	4,889✔
117	return Knob;
118	else if (type == KXMLQLCInputChannelEncoder)	2,971✔
119	return Encoder;
120	else if (type == KXMLQLCInputChannelSlider)	2,859✔
121	return Slider;
122	else if (type == KXMLQLCInputChannelPageUp)	23✔
123	return NextPage;
124	else if (type == KXMLQLCInputChannelPageDown)	13✔
125	return PrevPage;
126	else if (type == KXMLQLCInputChannelPageSet)	3✔
127	return PageSet;
128	else
129	return NoType;	2✔
130	}
131
132	QStringList QLCInputChannel::types()	1✔
133	{
134	QStringList list;
135	list << KXMLQLCInputChannelSlider;	2✔
136	list << KXMLQLCInputChannelKnob;	2✔
137	list << KXMLQLCInputChannelEncoder;	2✔
138	list << KXMLQLCInputChannelButton;	2✔
139	list << KXMLQLCInputChannelPageUp;	2✔
140	list << KXMLQLCInputChannelPageDown;	2✔
141	list << KXMLQLCInputChannelPageSet;	2✔
142	return list;	1✔
143	}
144
145	QIcon QLCInputChannel::typeToIcon(Type type)	×
146	{
147	return QIcon(iconResource(type));	×
148	}
149
150	QIcon QLCInputChannel::stringToIcon(const QString& str)	×
151	{
152	return typeToIcon(stringToType(str));	×
153	}
154
155	QString QLCInputChannel::iconResource(Type type, bool svg)	×
156	{
157	QString prefix = svg ? "qrc" : "";	×
158	QString ext = svg ? "svg" : "png";	×
159
160	switch(type)	×
161	{
162	case Button: return QString("%1:/button.%2").arg(prefix, ext);	×
163	case Knob: return QString("%1:/knob.%2").arg(prefix, ext);	×
164	case Encoder: return QString("%1:/knob.%2").arg(prefix, ext);	×
165	case Slider: return QString("%1:/slider.%2").arg(prefix, ext);	×
166	case PrevPage: return QString("%1:/forward.%2").arg(prefix, ext);	×
167	case NextPage: return QString("%1:/back.%2").arg(prefix, ext);	×
168	case PageSet: return QString("%1:/star.%2").arg(prefix, ext);	×
169	default: return QString();
170	}
171
172	return QString("%1:/other.%2").arg(prefix, ext);
173	}	×
174
175	QIcon QLCInputChannel::icon() const	×
176	{
177	return typeToIcon(type());	×
178	}
179
180	/****************************************************************************
181	* Name
182	****************************************************************************/
183
184	void QLCInputChannel::setName(const QString& name)	12,444✔
185	{
186	if (name == m_name)	12,444✔
187	return;
188
189	m_name = name;	12,444✔
190
191	emit nameChanged();	12,444✔
192	}
193
194	QString QLCInputChannel::name() const	35✔
195	{
196	return m_name;	35✔
197	}
198
199	/*********************************************************************
200	* Slider/Knob movement behaviour specific methods
201	*********************************************************************/
202
203	QLCInputChannel::MovementType QLCInputChannel::movementType() const	11✔
204	{
205	return m_movementType;	11✔
206	}
207
208	void QLCInputChannel::setMovementType(QLCInputChannel::MovementType type)	13✔
209	{
210	m_movementType = type;	13✔
211	}	13✔
212
213	int QLCInputChannel::movementSensitivity() const	10✔
214	{
215	return m_movementSensitivity;	10✔
216	}
217
218	void QLCInputChannel::setMovementSensitivity(int value)	124✔
219	{
220	m_movementSensitivity = value;	124✔
221	}	124✔
222
223	/*********************************************************************
224	* Button behaviour specific methods
225	*********************************************************************/
226
227	void QLCInputChannel::setSendExtraPress(bool enable)	79✔
228	{
229	if (enable == m_sendExtraPress)	79✔
230	return;
231
232	m_sendExtraPress = enable;	69✔
233	emit sendExtraPressChanged();	69✔
234	}
235
236	bool QLCInputChannel::sendExtraPress() const	14✔
237	{
238	return m_sendExtraPress;	14✔
239	}
240
241	void QLCInputChannel::setRange(uchar lower, uchar upper)	619✔
242	{
243	setLowerValue(lower);	619✔
244	setUpperValue(upper);	619✔
245	}	619✔
246
247	uchar QLCInputChannel::lowerValue() const	13✔
248	{
249	return m_lowerValue;	13✔
250	}
251
252	void QLCInputChannel::setLowerValue(const uchar value)	619✔
253	{
254	if (value == m_lowerValue)	619✔
255	return;
256
257	m_lowerValue = value;	366✔
258	emit lowerValueChanged();	366✔
259	}
260
261	uchar QLCInputChannel::upperValue() const	13✔
262	{
263	return m_upperValue;	13✔
264	}
265
266	void QLCInputChannel::setUpperValue(const uchar value)	619✔
267	{
268	if (value == m_upperValue)	619✔
269	return;
270
271	m_upperValue = value;	606✔
272	emit upperValueChanged();	606✔
273	}
274
275	int QLCInputChannel::lowerChannel() const	10✔
276	{
277	return m_lowerChannel;	10✔
278	}
279
280	void QLCInputChannel::setLowerChannel(const int channel)	619✔
281	{
282	if (channel == m_lowerChannel)	619✔
283	return;
284
285	m_lowerChannel = channel;	192✔
286	emit midiChannelChanged();	192✔
287	}
288
289	/****************************************************************************
290	* Load & Save
291	****************************************************************************/
292
293	bool QLCInputChannel::loadXML(QXmlStreamReader &root)	12,418✔
294	{
295	if (root.isStartElement() == false \|\| root.name() != KXMLQLCInputChannel)	24,836✔
296	{
297	qWarning() << Q_FUNC_INFO << "Channel node not found";	×
298	return false;	×
299	}
300
301	while (root.readNextStartElement())	38,046✔
302	{
303	if (root.name() == KXMLQLCInputChannelName)	51,256✔
304	{
305	setName(root.readElementText());	12,418✔
306	}
307	else if (root.name() == KXMLQLCInputChannelType)	26,420✔
308	{
309	setType(stringToType(root.readElementText()));	12,418✔
310	}
311	else if (root.name() == KXMLQLCInputChannelExtraPress)	1,584✔
312	{
313	root.readElementText();	69✔
314	setSendExtraPress(true);	69✔
315	}
316	else if (root.name() == KXMLQLCInputChannelMovement)	1,446✔
317	{
318	if (root.attributes().hasAttribute(KXMLQLCInputChannelSensitivity))	114✔
319	setMovementSensitivity(root.attributes().value(KXMLQLCInputChannelSensitivity).toString().toInt());	114✔
320
321	if (root.readElementText() == KXMLQLCInputChannelRelative)	114✔
322	setMovementType(Relative);	3✔
323	}
324	else if (root.name() == KXMLQLCInputChannelFeedback)	1,218✔
325	{
326	QXmlStreamAttributes attrs = root.attributes();	609✔
327	uchar min = 0, max = UCHAR_MAX;
328	int fbChannel = -1;
329
330	if (attrs.hasAttribute(KXMLQLCInputChannelLowerValue))	609✔
331	min = uchar(attrs.value(KXMLQLCInputChannelLowerValue).toString().toUInt());	366✔
332	if (attrs.hasAttribute(KXMLQLCInputChannelUpperValue))	609✔
333	max = uchar(attrs.value(KXMLQLCInputChannelUpperValue).toString().toUInt());	606✔
334	if (attrs.hasAttribute(KXMLQLCInputChannelMidiChannel))	609✔
335	fbChannel = attrs.value(KXMLQLCInputChannelMidiChannel).toInt();	192✔
336
337	setRange(min, max);	609✔
338	setLowerChannel(fbChannel);	609✔
339	root.skipCurrentElement();	609✔
340	}
341	else
342	{
343	qWarning() << Q_FUNC_INFO << "Unknown input channel tag" << root.name();	×
344	root.skipCurrentElement();	×
345	}
346	}
347
348	return true;
349	}
350
351	bool QLCInputChannel::saveXML(QXmlStreamWriter *doc, quint32 channelNumber) const	4✔
352	{
353	if (doc == NULL \|\| doc->device() == NULL)	4✔
354	return false;	×
355
356	doc->writeStartElement(KXMLQLCInputChannel);	4✔
357	doc->writeAttribute(KXMLQLCInputChannelNumber,	4✔
358	QString("%1").arg(channelNumber));	12✔
359
360	doc->writeTextElement(KXMLQLCInputChannelName, m_name);	4✔
361	doc->writeTextElement(KXMLQLCInputChannelType, typeToString(m_type));	4✔
362	if (sendExtraPress() == true)	4✔
363	doc->writeTextElement(KXMLQLCInputChannelExtraPress, "True");	×
364
365	/* Save only slider's relative movement */
366	if ((type() == Slider \|\| type() == Knob) && movementType() == Relative)	4✔
367	{
368	doc->writeStartElement(KXMLQLCInputChannelMovement);	×
369	doc->writeAttribute(KXMLQLCInputChannelSensitivity, QString::number(movementSensitivity()));	×
370	doc->writeCharacters(KXMLQLCInputChannelRelative);	×
371	doc->writeEndElement();	×
372	}
373	else if (type() == Encoder)	4✔
374	{
375	doc->writeStartElement(KXMLQLCInputChannelMovement);	×
376	doc->writeAttribute(KXMLQLCInputChannelSensitivity, QString::number(movementSensitivity()));	×
377	doc->writeEndElement();	×
378	}
379	else if (type() == Button && (lowerValue() != 0 \|\| upperValue() != UCHAR_MAX))	4✔
380	{
381	doc->writeStartElement(KXMLQLCInputChannelFeedback);	×
382	if (lowerValue() != 0)	×
383	doc->writeAttribute(KXMLQLCInputChannelLowerValue, QString::number(lowerValue()));	×
384	if (upperValue() != UCHAR_MAX)	×
385	doc->writeAttribute(KXMLQLCInputChannelUpperValue, QString::number(upperValue()));	×
386	if (lowerChannel() != -1)	×
387	doc->writeAttribute(KXMLQLCInputChannelMidiChannel, QString::number(lowerChannel()));	×
388	doc->writeEndElement();	×
389	}
390
391	doc->writeEndElement();	4✔
392	return true;	4✔
393	}

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