6810307726

Committed 09 Nov 2023 10:11AM UTC coverage: 28.086% (+0.02%) from 28.067%

Build # 6810307726

Build Type

Pull #1477

github

Committed by

web-flow

Commit Message

Merge c8f4c4dcb into 56a703a42

Pull Request Pull Request #1477: Webaccess cuelist side fader

Run Details

8 of 39 new or added lines in 1 file covered. (20.51%)

279 existing lines in 9 files now uncovered.

15420 of 54903 relevant lines covered (28.09%)

20284.04 hits per line

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

97.73

/ui/src/virtualconsole/vcproperties.cpp

/*
  Q Light Controller Plus
  vcproperties.cpp

  Copyright (c) Heikki Junnila
                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 <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QWidget>
#include <QDebug>

#include "inputoutputmap.h"
#include "vcproperties.h"
#include "qlcchannel.h"

/*****************************************************************************
 * Properties Initialization
 *****************************************************************************/

VCProperties::VCProperties()
    : m_size(QSize(1920, 1080))
    , m_gmChannelMode(GrandMaster::Intensity)
    , m_gmValueMode(GrandMaster::Reduce)
    , m_gmSliderMode(GrandMaster::Normal)
    , m_gmInputUniverse(InputOutputMap::invalidUniverse())
    , m_gmInputChannel(QLCChannel::invalid())
{
}

VCProperties::VCProperties(const VCProperties& properties)
    : m_size(properties.m_size)
    , m_gmChannelMode(properties.m_gmChannelMode)
    , m_gmValueMode(properties.m_gmValueMode)
    , m_gmSliderMode(properties.m_gmSliderMode)
    , m_gmInputUniverse(properties.m_gmInputUniverse)
    , m_gmInputChannel(properties.m_gmInputChannel)
{
}

VCProperties::~VCProperties()
{
}

VCProperties &VCProperties::operator=(const VCProperties &props)
{
    if (this != &props)
    {
        m_size = props.m_size;
        m_gmChannelMode = props.m_gmChannelMode;
        m_gmValueMode = props.m_gmValueMode;
        m_gmSliderMode = props.m_gmSliderMode;
        m_gmInputUniverse = props.m_gmInputUniverse;
        m_gmInputChannel = props.m_gmInputChannel;
    }

    return *this;
}

/*****************************************************************************
 * Size
 *****************************************************************************/

void VCProperties::setSize(const QSize& size)
{
    m_size = size;
}

QSize VCProperties::size() const
{
    return m_size;
}

/*****************************************************************************
 * Grand Master
 *****************************************************************************/

void VCProperties::setGrandMasterChannelMode(GrandMaster::ChannelMode mode)
{
    m_gmChannelMode = mode;
}

GrandMaster::ChannelMode VCProperties::grandMasterChannelMode() const
{
    return m_gmChannelMode;
}

void VCProperties::setGrandMasterValueMode(GrandMaster::ValueMode mode)
{
    m_gmValueMode = mode;
}

GrandMaster::ValueMode VCProperties::grandMasterValueMode() const
{
    return m_gmValueMode;
}

void VCProperties::setGrandMasterSliderMode(GrandMaster::SliderMode mode)
{
    m_gmSliderMode = mode;
}

GrandMaster::SliderMode VCProperties::grandMasterSlideMode() const
{
    return m_gmSliderMode;
}

void VCProperties::setGrandMasterInputSource(quint32 universe, quint32 channel)
{
    m_gmInputUniverse = universe;
    m_gmInputChannel = channel;
}

quint32 VCProperties::grandMasterInputUniverse() const
{
    return m_gmInputUniverse;
}

quint32 VCProperties::grandMasterInputChannel() const
{
    return m_gmInputChannel;
}

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

bool VCProperties::loadXML(QXmlStreamReader &root)
{
    if (root.name() != KXMLQLCVCProperties)
    {
        qWarning() << Q_FUNC_INFO << "Virtual console properties node not found";
        return false;
    }

    QString str;
    while (root.readNextStartElement())
    {
        if (root.name() == KXMLQLCVCPropertiesSize)
        {
            QSize sz;

            /* Width */
            str = root.attributes().value(KXMLQLCVCPropertiesSizeWidth).toString();
            if (str.isEmpty() == false)
                sz.setWidth(str.toInt());

            /* Height */
            str = root.attributes().value(KXMLQLCVCPropertiesSizeHeight).toString();
            if (str.isEmpty() == false)
                sz.setHeight(str.toInt());

            /* Set size if both are valid */
            if (sz.isValid() == true)
                setSize(sz);
            root.skipCurrentElement();
        }
        else if (root.name() == KXMLQLCVCPropertiesGrandMaster)
        {
            QXmlStreamAttributes attrs = root.attributes();

            str = attrs.value(KXMLQLCVCPropertiesGrandMasterChannelMode).toString();
            setGrandMasterChannelMode(GrandMaster::stringToChannelMode(str));

            str = attrs.value(KXMLQLCVCPropertiesGrandMasterValueMode).toString();
            setGrandMasterValueMode(GrandMaster::stringToValueMode(str));

            if (attrs.hasAttribute(KXMLQLCVCPropertiesGrandMasterSliderMode))
            {
                str = attrs.value(KXMLQLCVCPropertiesGrandMasterSliderMode).toString();
                setGrandMasterSliderMode(GrandMaster::stringToSliderMode(str));
            }

            QXmlStreamReader::TokenType tType = root.readNext();
            if (tType == QXmlStreamReader::Characters)
                tType = root.readNext();

            // check if there is a Input tag defined
            if (tType == QXmlStreamReader::StartElement)
            {
                if (root.name() == KXMLQLCVCPropertiesInput)
                {
                    quint32 universe = InputOutputMap::invalidUniverse();
                    quint32 channel = QLCChannel::invalid();
                    /* External input */
                    if (loadXMLInput(root, &universe, &channel) == true)
                        setGrandMasterInputSource(universe, channel);
                }
                root.skipCurrentElement();
            }
        }
        else
        {
            qWarning() << Q_FUNC_INFO << "Unknown virtual console property tag:"
                       << root.name().toString();
            root.skipCurrentElement();
        }
    }

    return true;
}

bool VCProperties::saveXML(QXmlStreamWriter *doc) const
{
    Q_ASSERT(doc != NULL);

    /* Properties entry */
    doc->writeStartElement(KXMLQLCVCProperties);

    /* Size */
    doc->writeStartElement(KXMLQLCVCPropertiesSize);
    doc->writeAttribute(KXMLQLCVCPropertiesSizeWidth, QString::number(size().width()));
    doc->writeAttribute(KXMLQLCVCPropertiesSizeHeight, QString::number(size().height()));
    doc->writeEndElement();

    /***********************
     * Grand Master slider *
     ***********************/
    doc->writeStartElement(KXMLQLCVCPropertiesGrandMaster);

    /* Channel mode */
    doc->writeAttribute(KXMLQLCVCPropertiesGrandMasterChannelMode,
                     GrandMaster::channelModeToString(m_gmChannelMode));

    /* Value mode */
    doc->writeAttribute(KXMLQLCVCPropertiesGrandMasterValueMode,
                     GrandMaster::valueModeToString(m_gmValueMode));

    /* Slider mode */
    doc->writeAttribute(KXMLQLCVCPropertiesGrandMasterSliderMode,
                     GrandMaster::sliderModeToString(m_gmSliderMode));

    /* Grand Master external input */
    if (m_gmInputUniverse != InputOutputMap::invalidUniverse() &&
        m_gmInputChannel != QLCChannel::invalid())
    {
        doc->writeStartElement(KXMLQLCVCPropertiesInput);
        doc->writeAttribute(KXMLQLCVCPropertiesInputUniverse,
                            QString("%1").arg(m_gmInputUniverse));
        doc->writeAttribute(KXMLQLCVCPropertiesInputChannel,
                            QString("%1").arg(m_gmInputChannel));
        doc->writeEndElement();
    }
    /* End the <GrandMaster> tag */
    doc->writeEndElement();

    /* End the <Properties> tag */
    doc->writeEndElement();

    return true;
}

bool VCProperties::loadXMLInput(QXmlStreamReader &root, quint32* universe, quint32* channel)
{
    /* External input */
    if (root.name() != KXMLQLCVCPropertiesInput)
        return false;

    QXmlStreamAttributes attrs = root.attributes();

    /* Universe */
    QString str = attrs.value(KXMLQLCVCPropertiesInputUniverse).toString();
    if (str.isEmpty() == false)
        *universe = str.toUInt();
    else
        *universe = InputOutputMap::invalidUniverse();

    /* Channel */
    str = attrs.value(KXMLQLCVCPropertiesInputChannel).toString();
    if (str.isEmpty() == false)
        *channel = str.toUInt();
    else
        *channel = QLCChannel::invalid();

    root.skipCurrentElement();

    /* Verdict */
    if (*universe != InputOutputMap::invalidUniverse() &&
        *channel != QLCChannel::invalid())
    {
        return true;
    }
    else
    {
        return false;
    }
}

1	/*
2	Q Light Controller Plus
3	vcproperties.cpp
4
5	Copyright (c) Heikki Junnila
6	Massimo Callegari
7
8	Licensed under the Apache License, Version 2.0 (the "License");
9	you may not use this file except in compliance with the License.
10	You may obtain a copy of the License at
11
12	http://www.apache.org/licenses/LICENSE-2.0.txt
13
14	Unless required by applicable law or agreed to in writing, software
15	distributed under the License is distributed on an "AS IS" BASIS,
16	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17	See the License for the specific language governing permissions and
18	limitations under the License.
19	*/
20
21	#include <QXmlStreamReader>
22	#include <QXmlStreamWriter>
23	#include <QWidget>
24	#include <QDebug>
25
26	#include "inputoutputmap.h"
27	#include "vcproperties.h"
28	#include "qlcchannel.h"
29
30	/*****************************************************************************
31	* Properties Initialization
32	*****************************************************************************/
33
34	VCProperties::VCProperties()	83✔
35	: m_size(QSize(1920, 1080))
36	, m_gmChannelMode(GrandMaster::Intensity)
37	, m_gmValueMode(GrandMaster::Reduce)
38	, m_gmSliderMode(GrandMaster::Normal)
39	, m_gmInputUniverse(InputOutputMap::invalidUniverse())	166✔
40	, m_gmInputChannel(QLCChannel::invalid())	83✔
41	{
42	}	83✔
43
44	VCProperties::VCProperties(const VCProperties& properties)	156✔
45	: m_size(properties.m_size)
46	, m_gmChannelMode(properties.m_gmChannelMode)	156✔
47	, m_gmValueMode(properties.m_gmValueMode)	156✔
48	, m_gmSliderMode(properties.m_gmSliderMode)	156✔
49	, m_gmInputUniverse(properties.m_gmInputUniverse)	156✔
50	, m_gmInputChannel(properties.m_gmInputChannel)	156✔
51	{
52	}	156✔
53
54	VCProperties::~VCProperties()	239✔
55	{
56	}	239✔
57
58	VCProperties &VCProperties::operator=(const VCProperties &props)	4✔
59	{
60	if (this != &props)	4✔
61	{
62	m_size = props.m_size;	4✔
63	m_gmChannelMode = props.m_gmChannelMode;	4✔
64	m_gmValueMode = props.m_gmValueMode;	4✔
65	m_gmSliderMode = props.m_gmSliderMode;	4✔
66	m_gmInputUniverse = props.m_gmInputUniverse;	4✔
67	m_gmInputChannel = props.m_gmInputChannel;	4✔
68	}
69
70	return *this;	4✔
71	}
72
73	/*****************************************************************************
74	* Size
75	*****************************************************************************/
76
77	void VCProperties::setSize(const QSize& size)	3✔
78	{
79	m_size = size;	3✔
80	}	3✔
81
82	QSize VCProperties::size() const	81✔
83	{
84	return m_size;	81✔
85	}
86
87	/*****************************************************************************
88	* Grand Master
89	*****************************************************************************/
90
91	void VCProperties::setGrandMasterChannelMode(GrandMaster::ChannelMode mode)	79✔
92	{
93	m_gmChannelMode = mode;	79✔
94	}	79✔
95
96	GrandMaster::ChannelMode VCProperties::grandMasterChannelMode() const	3✔
97	{
98	return m_gmChannelMode;	3✔
99	}
100
101	void VCProperties::setGrandMasterValueMode(GrandMaster::ValueMode mode)	79✔
102	{
103	m_gmValueMode = mode;	79✔
104	}	79✔
105
106	GrandMaster::ValueMode VCProperties::grandMasterValueMode() const	3✔
107	{
108	return m_gmValueMode;	3✔
109	}
110
111	void VCProperties::setGrandMasterSliderMode(GrandMaster::SliderMode mode)	1✔
112	{
113	m_gmSliderMode = mode;	1✔
114	}	1✔
115
UNCOV 116	GrandMaster::SliderMode VCProperties::grandMasterSlideMode() const	×
117	{
118	return m_gmSliderMode;	×
119	}
120
121	void VCProperties::setGrandMasterInputSource(quint32 universe, quint32 channel)	78✔
122	{
123	m_gmInputUniverse = universe;	78✔
124	m_gmInputChannel = channel;	78✔
125	}	78✔
126
127	quint32 VCProperties::grandMasterInputUniverse() const	78✔
128	{
129	return m_gmInputUniverse;	78✔
130	}
131
132	quint32 VCProperties::grandMasterInputChannel() const	78✔
133	{
134	return m_gmInputChannel;	78✔
135	}
136
137	/*****************************************************************************
138	* Load & Save
139	*****************************************************************************/
140
141	bool VCProperties::loadXML(QXmlStreamReader &root)	4✔
142	{
143	if (root.name() != KXMLQLCVCProperties)	4✔
144	{
145	qWarning() << Q_FUNC_INFO << "Virtual console properties node not found";	1✔
146	return false;	1✔
147	}
148
149	QString str;	3✔
150	while (root.readNextStartElement())	11✔
151	{
152	if (root.name() == KXMLQLCVCPropertiesSize)	8✔
153	{
154	QSize sz;	3✔
155
156	/* Width */
157	str = root.attributes().value(KXMLQLCVCPropertiesSizeWidth).toString();	3✔
158	if (str.isEmpty() == false)	3✔
159	sz.setWidth(str.toInt());	3✔
160
161	/* Height */
162	str = root.attributes().value(KXMLQLCVCPropertiesSizeHeight).toString();	3✔
163	if (str.isEmpty() == false)	3✔
164	sz.setHeight(str.toInt());	3✔
165
166	/* Set size if both are valid */
167	if (sz.isValid() == true)	3✔
168	setSize(sz);	3✔
169	root.skipCurrentElement();	3✔
170	}
171	else if (root.name() == KXMLQLCVCPropertiesGrandMaster)	5✔
172	{
173	QXmlStreamAttributes attrs = root.attributes();	6✔
174
175	str = attrs.value(KXMLQLCVCPropertiesGrandMasterChannelMode).toString();	3✔
176	setGrandMasterChannelMode(GrandMaster::stringToChannelMode(str));	3✔
177
178	str = attrs.value(KXMLQLCVCPropertiesGrandMasterValueMode).toString();	3✔
179	setGrandMasterValueMode(GrandMaster::stringToValueMode(str));	3✔
180
181	if (attrs.hasAttribute(KXMLQLCVCPropertiesGrandMasterSliderMode))	3✔
182	{
183	str = attrs.value(KXMLQLCVCPropertiesGrandMasterSliderMode).toString();	1✔
184	setGrandMasterSliderMode(GrandMaster::stringToSliderMode(str));	1✔
185	}
186
187	QXmlStreamReader::TokenType tType = root.readNext();	3✔
188	if (tType == QXmlStreamReader::Characters)	3✔
UNCOV 189	tType = root.readNext();	×
190
191	// check if there is a Input tag defined
192	if (tType == QXmlStreamReader::StartElement)	3✔
193	{
194	if (root.name() == KXMLQLCVCPropertiesInput)	2✔
195	{
196	quint32 universe = InputOutputMap::invalidUniverse();	2✔
197	quint32 channel = QLCChannel::invalid();	2✔
198	/* External input */
199	if (loadXMLInput(root, &universe, &channel) == true)	2✔
200	setGrandMasterInputSource(universe, channel);	2✔
201	}
202	root.skipCurrentElement();	2✔
203	}
204	}
205	else
206	{
207	qWarning() << Q_FUNC_INFO << "Unknown virtual console property tag:"	2✔
208	<< root.name().toString();	2✔
209	root.skipCurrentElement();	2✔
210	}
211	}
212
213	return true;	3✔
214	}
215
216	bool VCProperties::saveXML(QXmlStreamWriter *doc) const	1✔
217	{
218	Q_ASSERT(doc != NULL);	1✔
219
220	/* Properties entry */
221	doc->writeStartElement(KXMLQLCVCProperties);	1✔
222
223	/* Size */
224	doc->writeStartElement(KXMLQLCVCPropertiesSize);	1✔
225	doc->writeAttribute(KXMLQLCVCPropertiesSizeWidth, QString::number(size().width()));	1✔
226	doc->writeAttribute(KXMLQLCVCPropertiesSizeHeight, QString::number(size().height()));	1✔
227	doc->writeEndElement();	1✔
228
229	/***********************
230	* Grand Master slider *
231	***********************/
232	doc->writeStartElement(KXMLQLCVCPropertiesGrandMaster);	1✔
233
234	/* Channel mode */
235	doc->writeAttribute(KXMLQLCVCPropertiesGrandMasterChannelMode,	1✔
236	GrandMaster::channelModeToString(m_gmChannelMode));	2✔
237
238	/* Value mode */
239	doc->writeAttribute(KXMLQLCVCPropertiesGrandMasterValueMode,	1✔
240	GrandMaster::valueModeToString(m_gmValueMode));	2✔
241
242	/* Slider mode */
243	doc->writeAttribute(KXMLQLCVCPropertiesGrandMasterSliderMode,	1✔
244	GrandMaster::sliderModeToString(m_gmSliderMode));	2✔
245
246	/* Grand Master external input */
247	if (m_gmInputUniverse != InputOutputMap::invalidUniverse() &&	2✔
248	m_gmInputChannel != QLCChannel::invalid())	1✔
249	{
250	doc->writeStartElement(KXMLQLCVCPropertiesInput);	1✔
251	doc->writeAttribute(KXMLQLCVCPropertiesInputUniverse,	1✔
252	QString("%1").arg(m_gmInputUniverse));	2✔
253	doc->writeAttribute(KXMLQLCVCPropertiesInputChannel,	1✔
254	QString("%1").arg(m_gmInputChannel));	2✔
255	doc->writeEndElement();	1✔
256	}
257	/* End the <GrandMaster> tag */
258	doc->writeEndElement();	1✔
259
260	/* End the <Properties> tag */
261	doc->writeEndElement();	1✔
262
263	return true;	1✔
264	}
265
266	bool VCProperties::loadXMLInput(QXmlStreamReader &root, quint32* universe, quint32* channel)	5✔
267	{
268	/* External input */
269	if (root.name() != KXMLQLCVCPropertiesInput)	5✔
270	return false;	1✔
271
272	QXmlStreamAttributes attrs = root.attributes();	8✔
273
274	/* Universe */
275	QString str = attrs.value(KXMLQLCVCPropertiesInputUniverse).toString();	12✔
276	if (str.isEmpty() == false)	4✔
277	*universe = str.toUInt();	3✔
278	else
279	*universe = InputOutputMap::invalidUniverse();	1✔
280
281	/* Channel */
282	str = attrs.value(KXMLQLCVCPropertiesInputChannel).toString();	4✔
283	if (str.isEmpty() == false)	4✔
284	*channel = str.toUInt();	3✔
285	else
286	*channel = QLCChannel::invalid();	1✔
287
288	root.skipCurrentElement();	4✔
289
290	/* Verdict */
291	if (*universe != InputOutputMap::invalidUniverse() &&	7✔
292	*channel != QLCChannel::invalid())	3✔
293	{
294	return true;	3✔
295	}
296	else
297	{
298	return false;	1✔
299	}
300	}

mcallegari / qlcplus / 6810307726

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