6683238402

Committed 29 Oct 2023 12:10PM UTC coverage: 28.07%. Remained the same

Build # 6683238402

Build Type

push

github

Committed by

mcallegari

Commit Message

engine: fix build

Run Details

15385 of 54809 relevant lines covered (28.07%)

20267.63 hits per line

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

0.0

/ui/src/dmxdumpfactory.cpp

/*
  Q Light Controller Plus
  dmxdumpfactory.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 <QTreeWidgetItem>
#include <QTreeWidget>
#include <QDebug>

#include "dmxdumpfactoryproperties.h"
#include "fixturetreewidget.h"
#include "functionselection.h"
#include "virtualconsole.h"
#include "dmxdumpfactory.h"
#include "universe.h"
#include "function.h"
#include "vcwidget.h"
#include "vcbutton.h"
#include "vcslider.h"
#include "chaser.h"
#include "scene.h"
#include "doc.h"

#define KColumnName  0
#define KColumnType  1
#define KColumnID    2

#define KColumnTargetName 0
#define KColumnTargetID   1

DmxDumpFactory::DmxDumpFactory(Doc *doc, DmxDumpFactoryProperties *props, QWidget *parent)
    : QDialog(parent)
    , m_doc(doc)
    , m_properties(props)
    , m_selectedSceneID(Function::invalidId())
{
    Q_ASSERT(doc != NULL);

    setupUi(this);

    quint32 treeFlags = FixtureTreeWidget::ChannelType |
                        FixtureTreeWidget::ChannelSelection;

    m_fixturesTree = new FixtureTreeWidget(m_doc, treeFlags, this);
    m_fixturesTree->setIconSize(QSize(24, 24));
    m_fixturesTree->setSortingEnabled(false);

    m_treeLayout->addWidget(m_fixturesTree);
    m_fixturesTree->setChannelsMask(m_properties->channelsMask());

    m_fixturesTree->updateTree();

    if (m_properties->selectedTarget() == DmxDumpFactoryProperties::VCButton)
        m_buttonRadio->setChecked(true);
    else if (m_properties->selectedTarget() == DmxDumpFactoryProperties::VCSlider)
        m_sliderRadio->setChecked(true);
    else
        slotUpdateChasersTree();

    m_dumpAllRadio->setText(tr("Dump all channels (%1 Universes, %2 Fixtures, %3 Channels)")
                            .arg(m_fixturesTree->universeCount()).arg(m_fixturesTree->fixturesCount()).arg(m_fixturesTree->channelsCount()));

    m_sceneName->setText(tr("New Scene From Live %1").arg(m_doc->nextFunctionID()));
    if (m_properties->dumpChannelsMode() == true)
        m_dumpAllRadio->setChecked(true);
    else
        m_dumpSelectedRadio->setChecked(true);

    if(m_properties->nonZeroValuesMode() == true)
        m_nonZeroCheck->setChecked(true);

    connect(m_sceneButton, SIGNAL(clicked(bool)),
            this, SLOT(slotSelectSceneButtonClicked()));
}

DmxDumpFactory::~DmxDumpFactory()
{
}

void DmxDumpFactory::slotUpdateChasersTree()
{
    m_addtoTree->clear();
    foreach(Function *f, m_doc->functionsByType(Function::ChaserType))
    {
        Chaser *chaser = qobject_cast<Chaser*>(f);
        QTreeWidgetItem *item = new QTreeWidgetItem(m_addtoTree);
        item->setText(KColumnTargetName, chaser->name());
        item->setText(KColumnTargetID, QString::number(chaser->id()));
        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
        if (m_properties->isChaserSelected(chaser->id()))
            item->setCheckState(KColumnName, Qt::Checked);
        else
            item->setCheckState(KColumnName, Qt::Unchecked);
    }
}

void DmxDumpFactory::slotUpdateButtons()
{
    updateWidgetsTree(VCWidget::ButtonWidget);
}

void DmxDumpFactory::slotUpdateSliders()
{
    updateWidgetsTree(VCWidget::SliderWidget);
}

void DmxDumpFactory::slotSelectSceneButtonClicked()
{
    FunctionSelection fs(this, m_doc);
    fs.setMultiSelection(false);
    fs.setFilter(Function::SceneType, true);

    if (fs.exec() == QDialog::Accepted && fs.selection().size() > 0)
    {
        m_selectedSceneID = fs.selection().first();
        Scene *scene = qobject_cast<Scene*>(m_doc->function(m_selectedSceneID));
        if (scene == NULL)
            return;

        m_sceneName->setText(scene->name());
        m_dumpSelectedRadio->setChecked(true);
        QByteArray chMask = m_properties->channelsMask();
        chMask.fill(0);

        foreach(SceneValue scv, scene->values())
        {
            Fixture *fxi = m_doc->fixture(scv.fxi);
            if (fxi == NULL)
                continue;
            quint32 absAddress = fxi->universeAddress() + scv.channel;
            if (chMask.length() > (int)absAddress)
                chMask[absAddress] = 1;
        }
        m_properties->setChannelsMask(chMask);
        m_fixturesTree->setChannelsMask(chMask);
        m_fixturesTree->updateTree();
    }
}

QList<VCWidget *> DmxDumpFactory::getChildren(VCWidget *obj, int type)
{
    QList<VCWidget *> list;
    if (obj == NULL)
        return list;
    QListIterator <VCWidget*> it(obj->findChildren<VCWidget*>());
    while (it.hasNext() == true)
    {
        VCWidget* child = it.next();
        qDebug() << Q_FUNC_INFO << "append: " << child->caption();
        if (type == child->type())
            list.append(child);
    }
    return list;
}

void DmxDumpFactory::updateWidgetsTree(int type)
{
    m_addtoTree->clear();
    VCFrame *contents = VirtualConsole::instance()->contents();
    QList<VCWidget *> widgetsList = getChildren((VCWidget *)contents, type);

    foreach (QObject *object, widgetsList)
    {
        VCWidget *widget = qobject_cast<VCWidget *>(object);

        QTreeWidgetItem *item = new QTreeWidgetItem(m_addtoTree);
        item->setText(KColumnTargetName, widget->caption());
        item->setIcon(KColumnTargetName, VCWidget::typeToIcon(widget->type()));
        item->setText(KColumnTargetID, QString::number(widget->id()));
        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
        item->setCheckState(KColumnName, Qt::Unchecked);
    }
}

void DmxDumpFactory::slotDumpModeChanged(bool mode)
{
    if (mode == true)
        m_fixturesTree->setEnabled(false);
    else
        m_fixturesTree->setEnabled(true);
    m_properties->setDumpChannelsMode(mode);
}

void DmxDumpFactory::slotDumpNonZeroChanged(bool active)
{
    m_properties->setNonZeroValuesMode(active);
}

void DmxDumpFactory::accept()
{
    QByteArray dumpMask = m_properties->channelsMask();
    QList<Universe*> ua = m_doc->inputOutputMap()->claimUniverses();

    QByteArray preGMValues(ua.size() * UNIVERSE_SIZE, 0); //= ua->preGMValues();

    for (int i = 0; i < ua.count(); ++i)
    {
        const int offset = i * UNIVERSE_SIZE;
        preGMValues.replace(offset, UNIVERSE_SIZE, ua.at(i)->preGMValues());
        if (ua.at(i)->passthrough())
        {
            for (int j = 0; j < UNIVERSE_SIZE; ++j)
            {
                const int ofs = offset + j;
                preGMValues[ofs] =
                    static_cast<char>(ua.at(i)->applyPassthrough(j, static_cast<uchar>(preGMValues[ofs])));
            }
        }
    }

    m_doc->inputOutputMap()->releaseUniverses(false);

    Scene *newScene = NULL;
    if (m_selectedSceneID != Function::invalidId())
        newScene = qobject_cast<Scene*>(m_doc->function(m_selectedSceneID));

    for (int t = 0; t < m_fixturesTree->topLevelItemCount(); t++)
    {
        QTreeWidgetItem *uniItem = m_fixturesTree->topLevelItem(t);
        if (newScene == NULL && (m_dumpAllRadio->isChecked() ||
             uniItem->checkState(KColumnName) != Qt::Unchecked))
                newScene = new Scene(m_doc);
        //int uni = uniItem->text(KColumnID).toInt();
        for (int f = 0; f < uniItem->childCount(); f++)
        {
            QTreeWidgetItem *fixItem = uniItem->child(f);
            quint32 fxID = fixItem->data(KColumnName, PROP_ID).toUInt();
            Fixture *fxi = m_doc->fixture(fxID);
            if (fxi != NULL)
            {
                quint32 baseAddress = fxi->universeAddress();
                for (int c = 0; c < fixItem->childCount(); c++)
                {
                    QTreeWidgetItem *chanItem = fixItem->child(c);
                    quint32 channel = chanItem->data(KColumnName, PROP_CHANNEL).toUInt();

                    if (m_dumpAllRadio->isChecked())
                    {
                        dumpMask[baseAddress + channel] = 1;
                        uchar value = preGMValues.at(baseAddress + channel);
                        if (m_nonZeroCheck->isChecked() == false ||
                           (m_nonZeroCheck->isChecked() == true && value > 0))
                        {
                            SceneValue sv = SceneValue(fxID, channel, value);
                            newScene->setValue(sv);
                        }
                    }
                    else
                    {
                        //qDebug() << "Fix: " << fxID << "chan:" << channel << "addr:" << (baseAddress + channel);
                        if (chanItem->checkState(KColumnName) == Qt::Checked)
                        {
                            dumpMask[baseAddress + channel] = 1;
                            uchar value = preGMValues.at(baseAddress + channel);
                            if (m_nonZeroCheck->isChecked() == false ||
                               (m_nonZeroCheck->isChecked() == true && value > 0))
                            {
                                SceneValue sv = SceneValue(fxID, channel, value);
                                newScene->setValue(sv);
                            }
                        }
                        else
                            dumpMask[baseAddress + channel] = 0;
                    }
                }
            }
        }
    }
    /** If the Scene is valid, add it to QLC+ functions */
    if (newScene != NULL)
    {
        bool addedToDoc = false;

        if (m_selectedSceneID != Function::invalidId() &&
            m_doc->function(m_selectedSceneID) != NULL)
        {
            addedToDoc = true;
        }
        else
        {
            newScene->setName(m_sceneName->text());
            addedToDoc = m_doc->addFunction(newScene);
        }
        if (addedToDoc == true)
        {
            quint32 sceneID = newScene->id();
            /** Now add the Scene to the selected Chasers */
            for (int tc = 0; tc < m_addtoTree->topLevelItemCount(); tc++)
            {
                QTreeWidgetItem *targetItem = m_addtoTree->topLevelItem(tc);
                quint32 targetID = targetItem->text(KColumnTargetID).toUInt();
                if (targetItem->checkState(KColumnTargetName) == Qt::Checked)
                {
                    if (m_chaserRadio->isChecked())
                    {
                        Chaser *chaser = qobject_cast<Chaser*>(m_doc->function(targetID));
                        if (chaser != NULL)
                        {
                            ChaserStep chsStep(sceneID);
                            chaser->addStep(chsStep);
                            m_properties->addChaserID(targetID);
                        }
                    }
                    else if (m_buttonRadio->isChecked())
                    {
                        VCButton *button = qobject_cast<VCButton*>(VirtualConsole::instance()->widget(targetID));
                        if (button != NULL)
                        {
                            button->setFunction(newScene->id());
                            button->setCaption(newScene->name());
                        }
                    }
                    else if (m_sliderRadio->isChecked())
                    {
                        VCSlider *slider = qobject_cast<VCSlider*>(VirtualConsole::instance()->widget(targetID));
                        if (slider != NULL)
                        {
                            slider->setPlaybackFunction(newScene->id());
                            slider->setCaption(newScene->name());
                        }
                    }
                }
                else
                    m_properties->removeChaserID(targetID);
            }
        }
    }

    m_properties->setChannelsMask(dumpMask);
    if (m_chaserRadio->isChecked())
        m_properties->setSelectedTarget(DmxDumpFactoryProperties::Chaser);
    else if (m_buttonRadio->isChecked())
        m_properties->setSelectedTarget(DmxDumpFactoryProperties::VCButton);
    else if (m_sliderRadio->isChecked())
        m_properties->setSelectedTarget(DmxDumpFactoryProperties::VCSlider);

    /* Close dialog */
    QDialog::accept();
}

1	/*
2	Q Light Controller Plus
3	dmxdumpfactory.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 <QTreeWidgetItem>
21	#include <QTreeWidget>
22	#include <QDebug>
23
24	#include "dmxdumpfactoryproperties.h"
25	#include "fixturetreewidget.h"
26	#include "functionselection.h"
27	#include "virtualconsole.h"
28	#include "dmxdumpfactory.h"
29	#include "universe.h"
30	#include "function.h"
31	#include "vcwidget.h"
32	#include "vcbutton.h"
33	#include "vcslider.h"
34	#include "chaser.h"
35	#include "scene.h"
36	#include "doc.h"
37
38	#define KColumnName 0
39	#define KColumnType 1
40	#define KColumnID 2
41
42	#define KColumnTargetName 0
43	#define KColumnTargetID 1
44
45	DmxDumpFactory::DmxDumpFactory(Doc doc, DmxDumpFactoryProperties props, QWidget *parent)	×
46	: QDialog(parent)
47	, m_doc(doc)
48	, m_properties(props)
49	, m_selectedSceneID(Function::invalidId())	×
50	{
51	Q_ASSERT(doc != NULL);	×
52
53	setupUi(this);	×
54
55	quint32 treeFlags = FixtureTreeWidget::ChannelType \|	×
56	FixtureTreeWidget::ChannelSelection;
57
58	m_fixturesTree = new FixtureTreeWidget(m_doc, treeFlags, this);	×
59	m_fixturesTree->setIconSize(QSize(24, 24));	×
60	m_fixturesTree->setSortingEnabled(false);	×
61
62	m_treeLayout->addWidget(m_fixturesTree);	×
63	m_fixturesTree->setChannelsMask(m_properties->channelsMask());	×
64
65	m_fixturesTree->updateTree();	×
66
67	if (m_properties->selectedTarget() == DmxDumpFactoryProperties::VCButton)	×
68	m_buttonRadio->setChecked(true);	×
69	else if (m_properties->selectedTarget() == DmxDumpFactoryProperties::VCSlider)	×
70	m_sliderRadio->setChecked(true);	×
71	else
72	slotUpdateChasersTree();	×
73
74	m_dumpAllRadio->setText(tr("Dump all channels (%1 Universes, %2 Fixtures, %3 Channels)")	×
75	.arg(m_fixturesTree->universeCount()).arg(m_fixturesTree->fixturesCount()).arg(m_fixturesTree->channelsCount()));	×
76
77	m_sceneName->setText(tr("New Scene From Live %1").arg(m_doc->nextFunctionID()));	×
78	if (m_properties->dumpChannelsMode() == true)	×
79	m_dumpAllRadio->setChecked(true);	×
80	else
81	m_dumpSelectedRadio->setChecked(true);	×
82
83	if(m_properties->nonZeroValuesMode() == true)	×
84	m_nonZeroCheck->setChecked(true);	×
85
86	connect(m_sceneButton, SIGNAL(clicked(bool)),	×
87	this, SLOT(slotSelectSceneButtonClicked()));
88	}	×
89
90	DmxDumpFactory::~DmxDumpFactory()	×
91	{
92	}	×
93
94	void DmxDumpFactory::slotUpdateChasersTree()	×
95	{
96	m_addtoTree->clear();	×
97	foreach(Function *f, m_doc->functionsByType(Function::ChaserType))	×
98	{
99	Chaser chaser = qobject_cast<Chaser>(f);	×
100	QTreeWidgetItem *item = new QTreeWidgetItem(m_addtoTree);	×
101	item->setText(KColumnTargetName, chaser->name());	×
102	item->setText(KColumnTargetID, QString::number(chaser->id()));	×
103	item->setFlags(item->flags() \| Qt::ItemIsUserCheckable);	×
104	if (m_properties->isChaserSelected(chaser->id()))	×
105	item->setCheckState(KColumnName, Qt::Checked);	×
106	else
107	item->setCheckState(KColumnName, Qt::Unchecked);	×
108	}
109	}	×
110
111	void DmxDumpFactory::slotUpdateButtons()	×
112	{
113	updateWidgetsTree(VCWidget::ButtonWidget);	×
114	}	×
115
116	void DmxDumpFactory::slotUpdateSliders()	×
117	{
118	updateWidgetsTree(VCWidget::SliderWidget);	×
119	}	×
120
121	void DmxDumpFactory::slotSelectSceneButtonClicked()	×
122	{
123	FunctionSelection fs(this, m_doc);	×
124	fs.setMultiSelection(false);	×
125	fs.setFilter(Function::SceneType, true);	×
126
127	if (fs.exec() == QDialog::Accepted && fs.selection().size() > 0)	×
128	{
129	m_selectedSceneID = fs.selection().first();	×
130	Scene scene = qobject_cast<Scene>(m_doc->function(m_selectedSceneID));	×
131	if (scene == NULL)	×
132	return;	×
133
134	m_sceneName->setText(scene->name());	×
135	m_dumpSelectedRadio->setChecked(true);	×
136	QByteArray chMask = m_properties->channelsMask();	×
137	chMask.fill(0);	×
138
139	foreach(SceneValue scv, scene->values())	×
140	{
141	Fixture *fxi = m_doc->fixture(scv.fxi);	×
142	if (fxi == NULL)	×
143	continue;	×
144	quint32 absAddress = fxi->universeAddress() + scv.channel;	×
145	if (chMask.length() > (int)absAddress)	×
146	chMask[absAddress] = 1;	×
147	}
148	m_properties->setChannelsMask(chMask);	×
149	m_fixturesTree->setChannelsMask(chMask);	×
150	m_fixturesTree->updateTree();	×
151	}
152	}
153
154	QList<VCWidget > DmxDumpFactory::getChildren(VCWidget obj, int type)	×
155	{
156	QList<VCWidget *> list;	×
157	if (obj == NULL)	×
158	return list;	×
159	QListIterator <VCWidget> it(obj->findChildren<VCWidget>());	×
160	while (it.hasNext() == true)	×
161	{
162	VCWidget* child = it.next();	×
163	qDebug() << Q_FUNC_INFO << "append: " << child->caption();	×
164	if (type == child->type())	×
165	list.append(child);	×
166	}
167	return list;	×
168	}
169
170	void DmxDumpFactory::updateWidgetsTree(int type)	×
171	{
172	m_addtoTree->clear();	×
173	VCFrame *contents = VirtualConsole::instance()->contents();	×
174	QList<VCWidget > widgetsList = getChildren((VCWidget )contents, type);	×
175
176	foreach (QObject *object, widgetsList)	×
177	{
178	VCWidget widget = qobject_cast<VCWidget >(object);	×
179
180	QTreeWidgetItem *item = new QTreeWidgetItem(m_addtoTree);	×
181	item->setText(KColumnTargetName, widget->caption());	×
182	item->setIcon(KColumnTargetName, VCWidget::typeToIcon(widget->type()));	×
183	item->setText(KColumnTargetID, QString::number(widget->id()));	×
184	item->setFlags(item->flags() \| Qt::ItemIsUserCheckable);	×
185	item->setCheckState(KColumnName, Qt::Unchecked);	×
186	}
187	}	×
188
189	void DmxDumpFactory::slotDumpModeChanged(bool mode)	×
190	{
191	if (mode == true)	×
192	m_fixturesTree->setEnabled(false);	×
193	else
194	m_fixturesTree->setEnabled(true);	×
195	m_properties->setDumpChannelsMode(mode);	×
196	}	×
197
198	void DmxDumpFactory::slotDumpNonZeroChanged(bool active)	×
199	{
200	m_properties->setNonZeroValuesMode(active);	×
201	}	×
202
203	void DmxDumpFactory::accept()	×
204	{
205	QByteArray dumpMask = m_properties->channelsMask();	×
206	QList<Universe*> ua = m_doc->inputOutputMap()->claimUniverses();	×
207
208	QByteArray preGMValues(ua.size() * UNIVERSE_SIZE, 0); //= ua->preGMValues();	×
209
210	for (int i = 0; i < ua.count(); ++i)	×
211	{
212	const int offset = i * UNIVERSE_SIZE;	×
213	preGMValues.replace(offset, UNIVERSE_SIZE, ua.at(i)->preGMValues());	×
214	if (ua.at(i)->passthrough())	×
215	{
216	for (int j = 0; j < UNIVERSE_SIZE; ++j)	×
217	{
218	const int ofs = offset + j;	×
219	preGMValues[ofs] =	×
220	static_cast<char>(ua.at(i)->applyPassthrough(j, static_cast<uchar>(preGMValues[ofs])));	×
221	}
222	}
223	}
224
225	m_doc->inputOutputMap()->releaseUniverses(false);	×
226
227	Scene *newScene = NULL;	×
228	if (m_selectedSceneID != Function::invalidId())	×
229	newScene = qobject_cast<Scene*>(m_doc->function(m_selectedSceneID));	×
230
231	for (int t = 0; t < m_fixturesTree->topLevelItemCount(); t++)	×
232	{
233	QTreeWidgetItem *uniItem = m_fixturesTree->topLevelItem(t);	×
234	if (newScene == NULL && (m_dumpAllRadio->isChecked() \|\|	×
235	uniItem->checkState(KColumnName) != Qt::Unchecked))	×
236	newScene = new Scene(m_doc);	×
237	//int uni = uniItem->text(KColumnID).toInt();
238	for (int f = 0; f < uniItem->childCount(); f++)	×
239	{
240	QTreeWidgetItem *fixItem = uniItem->child(f);	×
241	quint32 fxID = fixItem->data(KColumnName, PROP_ID).toUInt();	×
242	Fixture *fxi = m_doc->fixture(fxID);	×
243	if (fxi != NULL)	×
244	{
245	quint32 baseAddress = fxi->universeAddress();	×
246	for (int c = 0; c < fixItem->childCount(); c++)	×
247	{
248	QTreeWidgetItem *chanItem = fixItem->child(c);	×
249	quint32 channel = chanItem->data(KColumnName, PROP_CHANNEL).toUInt();	×
250
251	if (m_dumpAllRadio->isChecked())	×
252	{
253	dumpMask[baseAddress + channel] = 1;	×
254	uchar value = preGMValues.at(baseAddress + channel);	×
255	if (m_nonZeroCheck->isChecked() == false \|\|	×
256	(m_nonZeroCheck->isChecked() == true && value > 0))	×
257	{
258	SceneValue sv = SceneValue(fxID, channel, value);	×
259	newScene->setValue(sv);	×
260	}
261	}
262	else
263	{
264	//qDebug() << "Fix: " << fxID << "chan:" << channel << "addr:" << (baseAddress + channel);
265	if (chanItem->checkState(KColumnName) == Qt::Checked)	×
266	{
267	dumpMask[baseAddress + channel] = 1;	×
268	uchar value = preGMValues.at(baseAddress + channel);	×
269	if (m_nonZeroCheck->isChecked() == false \|\|	×
270	(m_nonZeroCheck->isChecked() == true && value > 0))	×
271	{
272	SceneValue sv = SceneValue(fxID, channel, value);	×
273	newScene->setValue(sv);	×
274	}
275	}
276	else
277	dumpMask[baseAddress + channel] = 0;	×
278	}
279	}
280	}
281	}
282	}
283	/** If the Scene is valid, add it to QLC+ functions */
284	if (newScene != NULL)	×
285	{
286	bool addedToDoc = false;	×
287
288	if (m_selectedSceneID != Function::invalidId() &&	×
289	m_doc->function(m_selectedSceneID) != NULL)	×
290	{
291	addedToDoc = true;	×
292	}
293	else
294	{
295	newScene->setName(m_sceneName->text());	×
296	addedToDoc = m_doc->addFunction(newScene);	×
297	}
298	if (addedToDoc == true)	×
299	{
300	quint32 sceneID = newScene->id();	×
301	/** Now add the Scene to the selected Chasers */
302	for (int tc = 0; tc < m_addtoTree->topLevelItemCount(); tc++)	×
303	{
304	QTreeWidgetItem *targetItem = m_addtoTree->topLevelItem(tc);	×
305	quint32 targetID = targetItem->text(KColumnTargetID).toUInt();	×
306	if (targetItem->checkState(KColumnTargetName) == Qt::Checked)	×
307	{
308	if (m_chaserRadio->isChecked())	×
309	{
310	Chaser chaser = qobject_cast<Chaser>(m_doc->function(targetID));	×
311	if (chaser != NULL)	×
312	{
313	ChaserStep chsStep(sceneID);	×
314	chaser->addStep(chsStep);	×
315	m_properties->addChaserID(targetID);	×
316	}
317	}
318	else if (m_buttonRadio->isChecked())	×
319	{
320	VCButton button = qobject_cast<VCButton>(VirtualConsole::instance()->widget(targetID));	×
321	if (button != NULL)	×
322	{
323	button->setFunction(newScene->id());	×
324	button->setCaption(newScene->name());	×
325	}
326	}
327	else if (m_sliderRadio->isChecked())	×
328	{
329	VCSlider slider = qobject_cast<VCSlider>(VirtualConsole::instance()->widget(targetID));	×
330	if (slider != NULL)	×
331	{
332	slider->setPlaybackFunction(newScene->id());	×
333	slider->setCaption(newScene->name());	×
334	}
335	}
336	}
337	else
338	m_properties->removeChaserID(targetID);	×
339	}
340	}
341	}
342
343	m_properties->setChannelsMask(dumpMask);	×
344	if (m_chaserRadio->isChecked())	×
345	m_properties->setSelectedTarget(DmxDumpFactoryProperties::Chaser);	×
346	else if (m_buttonRadio->isChecked())	×
347	m_properties->setSelectedTarget(DmxDumpFactoryProperties::VCButton);	×
348	else if (m_sliderRadio->isChecked())	×
349	m_properties->setSelectedTarget(DmxDumpFactoryProperties::VCSlider);	×
350
351	/* Close dialog */
352	QDialog::accept();	×
353	}	×

mcallegari / qlcplus / 6683238402

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