7079218641

Committed 03 Dec 2023 08:32PM UTC coverage: 32.001% (+0.03%) from 31.976%

Build # 7079218641

Build Type

push

github

Committed by

mcallegari

Commit Message

engine: fix Show test unit

Run Details

15134 of 47293 relevant lines covered (32.0%)

23492.55 hits per line

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

85.42

/engine/src/showfunction.cpp

/*
  Q Light Controller Plus
  showfunction.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 "showfunction.h"
#include "function.h"
#include "doc.h"

#define KXMLShowFunctionID "ID"
#define KXMLShowFunctionStartTime "StartTime"
#define KXMLShowFunctionDuration "Duration"
#define KXMLShowFunctionColor "Color"
#define KXMLShowFunctionLocked "Locked"

ShowFunction::ShowFunction(quint32 id, QObject *parent)
    : QObject(parent)
    , m_id(id)
    , m_functionId(Function::invalidId())
    , m_startTime(UINT_MAX)
    , m_duration(0)
    , m_color(QColor())
    , m_locked(false)
    , m_intensityOverrideId(-1)
{
}

quint32 ShowFunction::id()
{
    return m_id;
}

void ShowFunction::setFunctionID(quint32 id)
{
    if (id == m_functionId)
        return;

    m_functionId = id;
    emit functionIDChanged();
}

quint32 ShowFunction::functionID() const
{
    return m_functionId;
}

void ShowFunction::setStartTime(quint32 time)
{
    if (time == m_startTime)
        return;

    m_startTime = time;
    emit startTimeChanged();
}

quint32 ShowFunction::startTime() const
{
    return m_startTime;
}

void ShowFunction::setDuration(quint32 duration)
{
    if (duration == m_duration)
        return;

    m_duration = duration;
    emit durationChanged();
}

quint32 ShowFunction::duration() const
{
    return m_duration;
}

quint32 ShowFunction::duration(const Doc *doc) const
{
    if (m_duration)
        return m_duration;

    if (doc == NULL)
        return 0;

    Function *f = doc->function(m_functionId);
    if (f == NULL)
        return 0;

    return f->totalDuration();
}

void ShowFunction::setColor(QColor color)
{
    if (color == m_color)
        return;

    m_color = color;
    emit colorChanged();
}

QColor ShowFunction::color() const
{
    return m_color;
}

QColor ShowFunction::defaultColor(Function::Type type)
{
    switch (type)
    {
        case Function::ChaserType:    return QColor(85, 107, 128);
        case Function::AudioType:     return QColor(96, 128, 83);
        case Function::RGBMatrixType: return QColor(101, 155, 155);
        case Function::EFXType:       return QColor(128, 60, 60);
        case Function::VideoType:     return QColor(147, 140, 20);
        default: return QColor(100, 100, 100);
    }
}

void ShowFunction::setLocked(bool locked)
{
    if (locked == m_locked)
        return;

    m_locked = locked;
    emit lockedChanged();
}

bool ShowFunction::isLocked() const
{
    return m_locked;
}

int ShowFunction::intensityOverrideId() const
{
    return m_intensityOverrideId;
}

void ShowFunction::setIntensityOverrideId(int id)
{
    m_intensityOverrideId = id;
}

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

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

    QXmlStreamAttributes attrs = root.attributes();

    if (attrs.hasAttribute(KXMLShowFunctionID))
        setFunctionID(attrs.value(KXMLShowFunctionID).toString().toUInt());
    if (attrs.hasAttribute(KXMLShowFunctionStartTime))
        setStartTime(attrs.value(KXMLShowFunctionStartTime).toString().toUInt());
    if (attrs.hasAttribute(KXMLShowFunctionDuration))
        setDuration(attrs.value(KXMLShowFunctionDuration).toString().toUInt());
    if (attrs.hasAttribute(KXMLShowFunctionColor))
        setColor(QColor(attrs.value(KXMLShowFunctionColor).toString()));
    if (attrs.hasAttribute(KXMLShowFunctionLocked))
        setLocked(true);

    root.skipCurrentElement();

    return true;
}

bool ShowFunction::saveXML(QXmlStreamWriter *doc, quint32 trackId) const
{
    Q_ASSERT(doc != NULL);

    /* Main tag */
    doc->writeStartElement(KXMLShowFunction);

    /* Attributes */
    if (trackId != UINT_MAX)
    {
        doc->writeAttribute(KXMLShowFunctionUid, QString::number(m_id));
        doc->writeAttribute(KXMLShowFunctionTrackId, QString::number(trackId));
    }
    doc->writeAttribute(KXMLShowFunctionID, QString::number(functionID()));
    doc->writeAttribute(KXMLShowFunctionStartTime, QString::number(startTime()));
    if (m_duration)
        doc->writeAttribute(KXMLShowFunctionDuration, QString::number(m_duration));
    if (color().isValid())
        doc->writeAttribute(KXMLShowFunctionColor, color().name());
    if (isLocked())
        doc->writeAttribute(KXMLShowFunctionLocked, QString::number(m_locked));

    doc->writeEndElement();

    return true;
}

1	/*
2	Q Light Controller Plus
3	showfunction.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 "showfunction.h"
25	#include "function.h"
26	#include "doc.h"
27
28	#define KXMLShowFunctionID "ID"
29	#define KXMLShowFunctionStartTime "StartTime"
30	#define KXMLShowFunctionDuration "Duration"
31	#define KXMLShowFunctionColor "Color"
32	#define KXMLShowFunctionLocked "Locked"
33
34	ShowFunction::ShowFunction(quint32 id, QObject *parent)	13✔
35	: QObject(parent)
36	, m_id(id)
37	, m_functionId(Function::invalidId())	26✔
38	, m_startTime(UINT_MAX)
39	, m_duration(0)
40	, m_color(QColor())
41	, m_locked(false)
42	, m_intensityOverrideId(-1)	13✔
43	{
44	}	13✔
45
46	quint32 ShowFunction::id()	12✔
47	{
48	return m_id;	12✔
49	}
50
51	void ShowFunction::setFunctionID(quint32 id)	13✔
52	{
53	if (id == m_functionId)	13✔
54	return;	×
55
56	m_functionId = id;	13✔
57	emit functionIDChanged();	13✔
58	}
59
60	quint32 ShowFunction::functionID() const	34✔
61	{
62	return m_functionId;	34✔
63	}
64
65	void ShowFunction::setStartTime(quint32 time)	6✔
66	{
67	if (time == m_startTime)	6✔
68	return;	×
69
70	m_startTime = time;	6✔
71	emit startTimeChanged();	6✔
72	}
73
74	quint32 ShowFunction::startTime() const	11✔
75	{
76	return m_startTime;	11✔
77	}
78
79	void ShowFunction::setDuration(quint32 duration)	7✔
80	{
81	if (duration == m_duration)	7✔
82	return;	×
83
84	m_duration = duration;	7✔
85	emit durationChanged();	7✔
86	}
87
88	quint32 ShowFunction::duration() const	6✔
89	{
90	return m_duration;	6✔
91	}
92
93	quint32 ShowFunction::duration(const Doc *doc) const	4✔
94	{
95	if (m_duration)	4✔
96	return m_duration;	4✔
97
98	if (doc == NULL)	×
99	return 0;	×
100
101	Function *f = doc->function(m_functionId);	×
102	if (f == NULL)	×
103	return 0;	×
104
105	return f->totalDuration();	×
106	}
107
108	void ShowFunction::setColor(QColor color)	6✔
109	{
110	if (color == m_color)	6✔
111	return;	1✔
112
113	m_color = color;	5✔
114	emit colorChanged();	5✔
115	}
116
117	QColor ShowFunction::color() const	11✔
118	{
119	return m_color;	11✔
120	}
121
122	QColor ShowFunction::defaultColor(Function::Type type)	8✔
123	{
124	switch (type)	8✔
125	{
126	case Function::ChaserType: return QColor(85, 107, 128);	1✔
127	case Function::AudioType: return QColor(96, 128, 83);	1✔
128	case Function::RGBMatrixType: return QColor(101, 155, 155);	1✔
129	case Function::EFXType: return QColor(128, 60, 60);	1✔
130	case Function::VideoType: return QColor(147, 140, 20);	1✔
131	default: return QColor(100, 100, 100);	3✔
132	}
133	}
134
135	void ShowFunction::setLocked(bool locked)	5✔
136	{
137	if (locked == m_locked)	5✔
138	return;	×
139
140	m_locked = locked;	5✔
141	emit lockedChanged();	5✔
142	}
143
144	bool ShowFunction::isLocked() const	7✔
145	{
146	return m_locked;	7✔
147	}
148
149	int ShowFunction::intensityOverrideId() const	2✔
150	{
151	return m_intensityOverrideId;	2✔
152	}
153
154	void ShowFunction::setIntensityOverrideId(int id)	2✔
155	{
156	m_intensityOverrideId = id;	2✔
157	}	2✔
158
159	/************************************************************************
160	* Load & Save
161	***********************************************************************/
162
163	bool ShowFunction::loadXML(QXmlStreamReader &root)	2✔
164	{
165	if (root.name() != KXMLShowFunction)	2✔
166	{
167	qWarning() << Q_FUNC_INFO << "ShowFunction node not found";	×
168	return false;	×
169	}
170
171	QXmlStreamAttributes attrs = root.attributes();	2✔
172
173	if (attrs.hasAttribute(KXMLShowFunctionID))	2✔
174	setFunctionID(attrs.value(KXMLShowFunctionID).toString().toUInt());	2✔
175	if (attrs.hasAttribute(KXMLShowFunctionStartTime))	2✔
176	setStartTime(attrs.value(KXMLShowFunctionStartTime).toString().toUInt());	1✔
177	if (attrs.hasAttribute(KXMLShowFunctionDuration))	2✔
178	setDuration(attrs.value(KXMLShowFunctionDuration).toString().toUInt());	2✔
179	if (attrs.hasAttribute(KXMLShowFunctionColor))	2✔
180	setColor(QColor(attrs.value(KXMLShowFunctionColor).toString()));	1✔
181	if (attrs.hasAttribute(KXMLShowFunctionLocked))	2✔
182	setLocked(true);	1✔
183
184	root.skipCurrentElement();	2✔
185
186	return true;	2✔
187	}
188
189	bool ShowFunction::saveXML(QXmlStreamWriter *doc, quint32 trackId) const	2✔
190	{
191	Q_ASSERT(doc != NULL);	2✔
192
193	/* Main tag */
194	doc->writeStartElement(KXMLShowFunction);	2✔
195
196	/* Attributes */
197	if (trackId != UINT_MAX)	2✔
198	{
199	doc->writeAttribute(KXMLShowFunctionUid, QString::number(m_id));	×
200	doc->writeAttribute(KXMLShowFunctionTrackId, QString::number(trackId));	×
201	}
202	doc->writeAttribute(KXMLShowFunctionID, QString::number(functionID()));	2✔
203	doc->writeAttribute(KXMLShowFunctionStartTime, QString::number(startTime()));	2✔
204	if (m_duration)	2✔
205	doc->writeAttribute(KXMLShowFunctionDuration, QString::number(m_duration));	1✔
206	if (color().isValid())	2✔
207	doc->writeAttribute(KXMLShowFunctionColor, color().name());	1✔
208	if (isLocked())	2✔
209	doc->writeAttribute(KXMLShowFunctionLocked, QString::number(m_locked));	1✔
210
211	doc->writeEndElement();	2✔
212
213	return true;	2✔
214	}

mcallegari / qlcplus / 7079218641

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