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

0.0

/ui/src/virtualconsole/vcxypadpreset.cpp

/*
  Q Light Controller Plus
  vcxypadpreset.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 <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QDebug>

#include "vcxypadpreset.h"
#include "vcwidget.h"
#include "function.h"

VCXYPadPreset::VCXYPadPreset(quint8 id)
    : m_id(id)
    , m_name(QString())
    , m_dmxPos(QPointF())
    , m_funcID(Function::invalidId())
{

}

VCXYPadPreset::VCXYPadPreset(const VCXYPadPreset &other)
{
    *this = other;
}

VCXYPadPreset::~VCXYPadPreset()
{
}

QString VCXYPadPreset::getColor() const
{
    switch(m_type)
    {
        case EFX: return ("#BBBB8D"); break;
        case Scene: return ("#BB8E8E"); break;
        case FixtureGroup: return ("#95BB95"); break;
        case Position:
        default:
            return ("#BBBBBB");
        break;
    }
}

void VCXYPadPreset::setFunctionID(quint32 id)
{
    m_funcID = id;
}

quint32 VCXYPadPreset::functionID() const
{
    return m_funcID;
}

void VCXYPadPreset::setPosition(QPointF pos)
{
    m_dmxPos = pos;
}

QPointF VCXYPadPreset::position() const
{
    return m_dmxPos;
}

void VCXYPadPreset::setFixtureGroup(QList<GroupHead> heads)
{
    m_fxGroup = heads;
}

QList<GroupHead> VCXYPadPreset::fixtureGroup() const
{
    return m_fxGroup;
}

VCXYPadPreset &VCXYPadPreset::operator=(const VCXYPadPreset &vcpp)
{
    if (this != &vcpp)
    {
        m_id = vcpp.m_id;
        m_type = vcpp.m_type;
        m_name = vcpp.m_name;
        m_dmxPos = vcpp.m_dmxPos;
        m_funcID = vcpp.m_funcID;
        m_fxGroup = vcpp.m_fxGroup;
        m_keySequence = vcpp.m_keySequence;

        if (vcpp.m_inputSource != NULL)
        {
            m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(vcpp.m_inputSource->universe(),
                                                   vcpp.m_inputSource->channel()));

            m_inputSource->setFeedbackValue(QLCInputFeedback::LowerValue, vcpp.m_inputSource->feedbackValue(QLCInputFeedback::LowerValue));
            m_inputSource->setFeedbackValue(QLCInputFeedback::UpperValue, vcpp.m_inputSource->feedbackValue(QLCInputFeedback::UpperValue));
        }
    }
    return *this;
}

bool VCXYPadPreset::operator<(const VCXYPadPreset &right) const
{
    return m_id < right.m_id;
}

bool VCXYPadPreset::compare(const VCXYPadPreset *left, const VCXYPadPreset *right)
{
    return *left < *right;
}

QString VCXYPadPreset::typeToString(VCXYPadPreset::PresetType type)
{
    if (type == EFX)
        return "EFX";
    else if (type == Scene)
        return "Scene";
    else if (type == FixtureGroup)
        return "FixtureGroup";

    return "Position";
}

VCXYPadPreset::PresetType VCXYPadPreset::stringToType(QString str)
{
    if (str == "EFX")
        return EFX;
    else if (str == "Scene")
        return Scene;
    else if (str == "FixtureGroup")
        return FixtureGroup;

    return Position;
}

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

bool VCXYPadPreset::loadXML(QXmlStreamReader &root)
{
    if (root.name() != KXMLQLCVCXYPadPreset)
    {
        qWarning() << Q_FUNC_INFO << "Matrix control node not found";
        return false;
    }

    if (root.attributes().hasAttribute(KXMLQLCVCXYPadPresetID) == false)
    {
        qWarning() << Q_FUNC_INFO << "XYPad Preset ID not found";
        return false;
    }

    m_id = root.attributes().value(KXMLQLCVCXYPadPresetID).toString().toUInt();

    QPointF pos;
    bool hasPosition = false;

    /* Children */
    while (root.readNextStartElement())
    {
        if (root.name() == KXMLQLCVCXYPadPresetType)
        {
            m_type = stringToType(root.readElementText());
        }
        else if (root.name() == KXMLQLCVCXYPadPresetName)
        {
            m_name = root.readElementText();
        }
        else if (root.name() == KXMLQLCVCXYPadPresetFuncID)
        {
            setFunctionID(root.readElementText().toUInt());
        }
        else if (root.name() == KXMLQLCVCXYPadPresetXPos)
        {
            pos.setX(QString(root.readElementText()).toFloat());
            hasPosition = true;
        }
        else if (root.name() == KXMLQLCVCXYPadPresetYPos)
        {
            pos.setY(QString(root.readElementText()).toFloat());
            hasPosition = true;
        }
        else if (root.name() == KXMLQLCVCXYPadPresetFixture)
        {
            quint32 fxID = Fixture::invalidId();
            int head = -1;
            QXmlStreamAttributes attrs = root.attributes();

            if (attrs.hasAttribute(KXMLQLCVCXYPadPresetFixtureID))
                fxID = attrs.value(KXMLQLCVCXYPadPresetFixtureID).toString().toUInt();
            if (attrs.hasAttribute(KXMLQLCVCXYPadPresetFixtureHead))
                head = attrs.value(KXMLQLCVCXYPadPresetFixtureHead).toString().toInt();

            if (fxID != Fixture::invalidId() && head != -1)
                m_fxGroup.append(GroupHead(fxID, head));
            root.skipCurrentElement();
        }
        else if (root.name() == KXMLQLCVCWidgetInput)
        {
            m_inputSource = VCWidget::getXMLInput(root);
            root.skipCurrentElement();
        }
        else if (root.name() == KXMLQLCVCWidgetKey)
        {
            m_keySequence = VCWidget::stripKeySequence(QKeySequence(root.readElementText()));
        }
        else
        {
            qWarning() << Q_FUNC_INFO << "Unknown VCMatrixControl tag:" << root.name().toString();
            root.skipCurrentElement();
        }
    }

    if (hasPosition)
        m_dmxPos = pos;

    return true;
}

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

    doc->writeStartElement(KXMLQLCVCXYPadPreset);
    doc->writeAttribute(KXMLQLCVCXYPadPresetID, QString::number(m_id));

    /* Preset type */
    doc->writeTextElement(KXMLQLCVCXYPadPresetType, typeToString(m_type));
    /* Preset name */
    doc->writeTextElement(KXMLQLCVCXYPadPresetName, m_name);

    if (m_type == EFX || m_type == Scene)
    {
        doc->writeTextElement(KXMLQLCVCXYPadPresetFuncID, QString::number(m_funcID));
    }
    else if (m_type == Position)
    {
        doc->writeTextElement(KXMLQLCVCXYPadPresetXPos, QString::number(m_dmxPos.x()));
        doc->writeTextElement(KXMLQLCVCXYPadPresetYPos, QString::number(m_dmxPos.y()));
    }
    else if (m_type == FixtureGroup)
    {
        foreach (GroupHead gh, fixtureGroup())
        {
            doc->writeStartElement(KXMLQLCVCXYPadPresetFixture);
            doc->writeAttribute(KXMLQLCVCXYPadPresetFixtureID, QString::number(gh.fxi));
            doc->writeAttribute(KXMLQLCVCXYPadPresetFixtureHead, QString::number(gh.head));
            doc->writeEndElement();
        }
    }

    /* External input source */
    if (!m_inputSource.isNull() && m_inputSource->isValid())
        VCWidget::saveXMLInput(doc, m_inputSource);

    /* Key sequence */
    if (m_keySequence.isEmpty() == false)
        doc->writeTextElement(KXMLQLCVCWidgetKey, m_keySequence.toString());

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

    return true;
}



1	/*
2	Q Light Controller Plus
3	vcxypadpreset.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 <QXmlStreamReader>
21	#include <QXmlStreamWriter>
22	#include <QDebug>
23
24	#include "vcxypadpreset.h"
25	#include "vcwidget.h"
26	#include "function.h"
27
28	VCXYPadPreset::VCXYPadPreset(quint8 id)	×
29	: m_id(id)	×
30	, m_name(QString())	×
31	, m_dmxPos(QPointF())	×
32	, m_funcID(Function::invalidId())	×
33	{
34
35	}	×
36
37	VCXYPadPreset::VCXYPadPreset(const VCXYPadPreset &other)	×
38	{
39	*this = other;	×
40	}	×
41
42	VCXYPadPreset::~VCXYPadPreset()	×
43	{
44	}	×
45
46	QString VCXYPadPreset::getColor() const	×
47	{
48	switch(m_type)	×
49	{
50	case EFX: return ("#BBBB8D"); break;	×
51	case Scene: return ("#BB8E8E"); break;	×
52	case FixtureGroup: return ("#95BB95"); break;	×
53	case Position:	×
54	default:
55	return ("#BBBBBB");	×
56	break;
57	}
58	}
59
60	void VCXYPadPreset::setFunctionID(quint32 id)	×
61	{
62	m_funcID = id;	×
63	}	×
64
65	quint32 VCXYPadPreset::functionID() const	×
66	{
67	return m_funcID;	×
68	}
69
70	void VCXYPadPreset::setPosition(QPointF pos)	×
71	{
72	m_dmxPos = pos;	×
73	}	×
74
75	QPointF VCXYPadPreset::position() const	×
76	{
77	return m_dmxPos;	×
78	}
79
80	void VCXYPadPreset::setFixtureGroup(QList<GroupHead> heads)	×
81	{
82	m_fxGroup = heads;	×
83	}	×
84
85	QList<GroupHead> VCXYPadPreset::fixtureGroup() const	×
86	{
87	return m_fxGroup;	×
88	}
89
90	VCXYPadPreset &VCXYPadPreset::operator=(const VCXYPadPreset &vcpp)	×
91	{
92	if (this != &vcpp)	×
93	{
94	m_id = vcpp.m_id;	×
95	m_type = vcpp.m_type;	×
96	m_name = vcpp.m_name;	×
97	m_dmxPos = vcpp.m_dmxPos;	×
98	m_funcID = vcpp.m_funcID;	×
99	m_fxGroup = vcpp.m_fxGroup;	×
100	m_keySequence = vcpp.m_keySequence;	×
101
102	if (vcpp.m_inputSource != NULL)	×
103	{
104	m_inputSource = QSharedPointer<QLCInputSource>(new QLCInputSource(vcpp.m_inputSource->universe(),	×
105	vcpp.m_inputSource->channel()));	×
106
107	m_inputSource->setFeedbackValue(QLCInputFeedback::LowerValue, vcpp.m_inputSource->feedbackValue(QLCInputFeedback::LowerValue));	×
108	m_inputSource->setFeedbackValue(QLCInputFeedback::UpperValue, vcpp.m_inputSource->feedbackValue(QLCInputFeedback::UpperValue));	×
109	}
110	}
111	return *this;	×
112	}
113
114	bool VCXYPadPreset::operator<(const VCXYPadPreset &right) const	×
115	{
116	return m_id < right.m_id;	×
117	}
118
119	bool VCXYPadPreset::compare(const VCXYPadPreset left, const VCXYPadPreset right)	×
120	{
121	return left < right;	×
122	}
123
124	QString VCXYPadPreset::typeToString(VCXYPadPreset::PresetType type)	×
125	{
126	if (type == EFX)	×
127	return "EFX";	×
128	else if (type == Scene)	×
129	return "Scene";	×
130	else if (type == FixtureGroup)	×
131	return "FixtureGroup";	×
132
133	return "Position";	×
134	}
135
136	VCXYPadPreset::PresetType VCXYPadPreset::stringToType(QString str)	×
137	{
138	if (str == "EFX")	×
139	return EFX;	×
140	else if (str == "Scene")	×
141	return Scene;	×
142	else if (str == "FixtureGroup")	×
143	return FixtureGroup;	×
144
145	return Position;	×
146	}
147
148	/************************************************************************
149	* Load & Save
150	***********************************************************************/
151
152	bool VCXYPadPreset::loadXML(QXmlStreamReader &root)	×
153	{
154	if (root.name() != KXMLQLCVCXYPadPreset)	×
155	{
156	qWarning() << Q_FUNC_INFO << "Matrix control node not found";	×
157	return false;	×
158	}
159
160	if (root.attributes().hasAttribute(KXMLQLCVCXYPadPresetID) == false)	×
161	{
162	qWarning() << Q_FUNC_INFO << "XYPad Preset ID not found";	×
163	return false;	×
164	}
165
166	m_id = root.attributes().value(KXMLQLCVCXYPadPresetID).toString().toUInt();	×
167
168	QPointF pos;	×
169	bool hasPosition = false;	×
170
171	/* Children */
172	while (root.readNextStartElement())	×
173	{
174	if (root.name() == KXMLQLCVCXYPadPresetType)	×
175	{
176	m_type = stringToType(root.readElementText());	×
177	}
178	else if (root.name() == KXMLQLCVCXYPadPresetName)	×
179	{
180	m_name = root.readElementText();	×
181	}
182	else if (root.name() == KXMLQLCVCXYPadPresetFuncID)	×
183	{
184	setFunctionID(root.readElementText().toUInt());	×
185	}
186	else if (root.name() == KXMLQLCVCXYPadPresetXPos)	×
187	{
188	pos.setX(QString(root.readElementText()).toFloat());	×
189	hasPosition = true;	×
190	}
191	else if (root.name() == KXMLQLCVCXYPadPresetYPos)	×
192	{
193	pos.setY(QString(root.readElementText()).toFloat());	×
194	hasPosition = true;	×
195	}
196	else if (root.name() == KXMLQLCVCXYPadPresetFixture)	×
197	{
198	quint32 fxID = Fixture::invalidId();	×
199	int head = -1;	×
200	QXmlStreamAttributes attrs = root.attributes();	×
201
202	if (attrs.hasAttribute(KXMLQLCVCXYPadPresetFixtureID))	×
203	fxID = attrs.value(KXMLQLCVCXYPadPresetFixtureID).toString().toUInt();	×
204	if (attrs.hasAttribute(KXMLQLCVCXYPadPresetFixtureHead))	×
205	head = attrs.value(KXMLQLCVCXYPadPresetFixtureHead).toString().toInt();	×
206
207	if (fxID != Fixture::invalidId() && head != -1)	×
208	m_fxGroup.append(GroupHead(fxID, head));	×
209	root.skipCurrentElement();	×
210	}	×
211	else if (root.name() == KXMLQLCVCWidgetInput)	×
212	{
213	m_inputSource = VCWidget::getXMLInput(root);	×
214	root.skipCurrentElement();	×
215	}
216	else if (root.name() == KXMLQLCVCWidgetKey)	×
217	{
218	m_keySequence = VCWidget::stripKeySequence(QKeySequence(root.readElementText()));	×
219	}
220	else
221	{
222	qWarning() << Q_FUNC_INFO << "Unknown VCMatrixControl tag:" << root.name().toString();	×
223	root.skipCurrentElement();	×
224	}
225	}
226
227	if (hasPosition)	×
228	m_dmxPos = pos;	×
229
230	return true;	×
231	}
232
233	bool VCXYPadPreset::saveXML(QXmlStreamWriter *doc)	×
234	{
235	Q_ASSERT(doc != NULL);	×
236
237	doc->writeStartElement(KXMLQLCVCXYPadPreset);	×
238	doc->writeAttribute(KXMLQLCVCXYPadPresetID, QString::number(m_id));	×
239
240	/* Preset type */
241	doc->writeTextElement(KXMLQLCVCXYPadPresetType, typeToString(m_type));	×
242	/* Preset name */
243	doc->writeTextElement(KXMLQLCVCXYPadPresetName, m_name);	×
244
245	if (m_type == EFX \|\| m_type == Scene)	×
246	{
247	doc->writeTextElement(KXMLQLCVCXYPadPresetFuncID, QString::number(m_funcID));	×
248	}
249	else if (m_type == Position)	×
250	{
251	doc->writeTextElement(KXMLQLCVCXYPadPresetXPos, QString::number(m_dmxPos.x()));	×
252	doc->writeTextElement(KXMLQLCVCXYPadPresetYPos, QString::number(m_dmxPos.y()));	×
253	}
254	else if (m_type == FixtureGroup)	×
255	{
256	foreach (GroupHead gh, fixtureGroup())	×
257	{
258	doc->writeStartElement(KXMLQLCVCXYPadPresetFixture);	×
259	doc->writeAttribute(KXMLQLCVCXYPadPresetFixtureID, QString::number(gh.fxi));	×
260	doc->writeAttribute(KXMLQLCVCXYPadPresetFixtureHead, QString::number(gh.head));	×
261	doc->writeEndElement();	×
262	}	×
263	}
264
265	/* External input source */
266	if (!m_inputSource.isNull() && m_inputSource->isValid())	×
267	VCWidget::saveXMLInput(doc, m_inputSource);	×
268
269	/* Key sequence */
270	if (m_keySequence.isEmpty() == false)	×
271	doc->writeTextElement(KXMLQLCVCWidgetKey, m_keySequence.toString());	×
272
273	/* End the <Preset> tag */
274	doc->writeEndElement();	×
275
276	return true;	×
277	}
278
279

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