7252848206

Committed 18 Dec 2023 07:26PM UTC coverage: 32.067% (+0.001%) from 32.066%

Build # 7252848206

Build Type

push

github

Committed by

mcallegari

Commit Message

Code style review #1427

Run Details

199 of 628 new or added lines in 101 files covered. (31.69%)

8 existing lines in 2 files now uncovered.

15169 of 47304 relevant lines covered (32.07%)

23733.74 hits per line

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

3.11

/ui/src/functionstreewidget.cpp

/*
  Q Light Controller Plus
  functionstreewidget.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 <QContextMenuEvent>
#include <QDebug>

#include "functionstreewidget.h"
#include "function.h"
#include "doc.h"

#define COL_NAME 0
#define COL_PATH 1

FunctionsTreeWidget::FunctionsTreeWidget(Doc *doc, QWidget *parent) :
    QTreeWidget(parent)
  , m_doc(doc)
{
    sortItems(COL_NAME, Qt::AscendingOrder);

    QTreeWidgetItem *root = invisibleRootItem();
    root->setFlags(root->flags() & ~Qt::ItemIsDropEnabled);

    connect(this, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
                this, SLOT(slotItemChanged(QTreeWidgetItem*)));
}

void FunctionsTreeWidget::updateTree()
{
    blockSignals(true);

    clearTree();

    foreach (Function* function, m_doc->functions())
    {
        if (function->isVisible())
            updateFunctionItem(new QTreeWidgetItem(parentItem(function)), function);
    }

    blockSignals(false);
}

void FunctionsTreeWidget::clearTree()
{
    m_foldersMap.clear();
    clear();
}

void FunctionsTreeWidget::functionNameChanged(quint32 fid)
{
    blockSignals(true);
    Function* function = m_doc->function(fid);
    if (function == NULL)
    {
        blockSignals(false);
        return;
    }

    QTreeWidgetItem* item = functionItem(function);
    if (item != NULL)
        updateFunctionItem(item, function);

    blockSignals(false);
}

QTreeWidgetItem *FunctionsTreeWidget::addFunction(quint32 fid)
{
    Function* function = m_doc->function(fid);
    if (function == NULL || function->isVisible() == false)
        return NULL;

    QTreeWidgetItem* item = functionItem(function);
    if (item != NULL)
        return item;

    blockSignals(true);
    QTreeWidgetItem* parent = parentItem(function);
    item = new QTreeWidgetItem(parent);
    updateFunctionItem(item, function);
    if (parent != NULL)
        function->setPath(parent->text(COL_PATH));
    blockSignals(false);
    return item;
}

void FunctionsTreeWidget::updateFunctionItem(QTreeWidgetItem* item, const Function* function)
{
    Q_ASSERT(item != NULL);
    Q_ASSERT(function != NULL);
    item->setText(COL_NAME, function->name());
    item->setIcon(COL_NAME, function->getIcon());
    item->setData(COL_NAME, Qt::UserRole, function->id());
    item->setData(COL_NAME, Qt::UserRole + 1, function->type());
    item->setFlags(item->flags() & ~Qt::ItemIsDropEnabled);
}

QTreeWidgetItem* FunctionsTreeWidget::parentItem(const Function* function)
{
    Q_ASSERT(function != NULL);

    if (function->isVisible() == false)
        return NULL;

    QString basePath = Function::typeToString(function->type());
    if (m_foldersMap.contains(QString(basePath + "/")) == false)
    {
        // Parent item for the given type doesn't exist yet so create one
        QTreeWidgetItem* item = new QTreeWidgetItem(this);
        item->setText(COL_NAME, basePath);
        item->setIcon(COL_NAME, function->getIcon());
        item->setData(COL_NAME, Qt::UserRole, Function::invalidId());
        item->setData(COL_NAME, Qt::UserRole + 1, function->type());
        item->setText(COL_PATH, QString(basePath + "/"));
        item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled);
        m_foldersMap[QString(basePath + "/")] = item;
    }

    QTreeWidgetItem *pItem = folderItem(function->path());

    if (pItem != NULL)
    {
        //qDebug() << "Found item for function:" << function->name() << ", path: " << function->path();
        return pItem;
    }

    return NULL;
}

quint32 FunctionsTreeWidget::itemFunctionId(const QTreeWidgetItem* item) const
{
    if (item == NULL || item->parent() == NULL)
        return Function::invalidId();
    else
    {
        QVariant var = item->data(COL_NAME, Qt::UserRole);
        if (var.isValid() == false)
            return Function::invalidId();

        return var.toUInt();
    }
}

QTreeWidgetItem* FunctionsTreeWidget::functionItem(const Function* function)
{
    Q_ASSERT(function != NULL);

    if (function->isVisible() == false)
        return NULL;

    QTreeWidgetItem* parent = parentItem(function);
    Q_ASSERT(parent != NULL);

    for (int i = 0; i < parent->childCount(); i++)
    {
        QTreeWidgetItem* item = parent->child(i);
        if (itemFunctionId(item) == function->id())
            return item;
    }

    return NULL;
}

/*********************************************************************
 * Tree folders
 *********************************************************************/

void FunctionsTreeWidget::addFolder()
{
    blockSignals(true);
    if (selectedItems().isEmpty())
    {
        blockSignals(false);
        return;
    }

    QTreeWidgetItem *item = selectedItems().first();
    if (item->text(COL_PATH).isEmpty())
        item = item->parent();

    int type = item->data(COL_NAME, Qt::UserRole + 1).toInt();

    QString fullPath = item->text(COL_PATH);
    if (fullPath.endsWith('/') == false)
        fullPath.append("/");

    QString newName = "New folder";

    int folderCount = 1;

    while (m_foldersMap.contains(fullPath + newName))
    {
        newName = "New Folder " + QString::number(folderCount++);
    }

    fullPath += newName;

    QTreeWidgetItem *folder = new QTreeWidgetItem(item);
    folder->setText(COL_NAME, newName);
    folder->setIcon(COL_NAME, QIcon(":/folder.png"));
    folder->setData(COL_NAME, Qt::UserRole, Function::invalidId());
    folder->setData(COL_NAME, Qt::UserRole + 1, type);
    folder->setText(COL_PATH, fullPath);
    folder->setFlags(folder->flags() | Qt::ItemIsDropEnabled | Qt::ItemIsEditable);

    m_foldersMap[fullPath] = folder;
    item->setExpanded(true);

    blockSignals(false);

    scrollToItem(folder, QAbstractItemView::PositionAtCenter);
}

void FunctionsTreeWidget::deleteFolder(QTreeWidgetItem *item)
{
    if (item == NULL)
        return;

    QList<QTreeWidgetItem*> childrenList;
    for (int i = 0; i < item->childCount(); i++)
        childrenList.append(item->child(i));

    QListIterator <QTreeWidgetItem*> it(childrenList);
    while (it.hasNext() == true)
    {
        QTreeWidgetItem *child = it.next();
        quint32 fid = child->data(COL_NAME, Qt::UserRole).toUInt();
        if (fid != Function::invalidId())
        {
            m_doc->deleteFunction(fid);
            delete child;
        }
        else
            deleteFolder(child);
    }

    QString name = item->text(COL_PATH);

    if (m_foldersMap.contains(name))
        m_foldersMap.remove(name);

    delete item;
}

QTreeWidgetItem *FunctionsTreeWidget::folderItem(QString name)
{
    if (selectedItems().count() > 0)
    {
        QString currFolder = selectedItems().first()->text(COL_PATH);
        if (currFolder.contains(name) && m_foldersMap.contains(currFolder))
            return m_foldersMap[currFolder];
    }

    if (m_foldersMap.contains(name))
        return m_foldersMap[name];

    if (name.endsWith('/'))
        return NULL;

    qDebug() << "Folder" << name << "doesn't exist. Creating it...";

    QTreeWidgetItem *parentNode = NULL;
    int type = Function::Undefined;
    QString fullPath;
    QStringList levelsList = name.split("/");
    foreach (QString level, levelsList)
    {
        // the first round is a category node. Just retrieve the item pointer
        // and the type, then skip it.
        if (fullPath.isEmpty())
        {
            if (m_foldersMap.contains(level + "/"))
            {
                parentNode = m_foldersMap[level + "/"];
                type = parentNode->data(COL_NAME, Qt::UserRole + 1).toInt();
            }
            fullPath = level;
            continue;
        }

        fullPath.append("/");
        fullPath.append(level);

        // create only missing levels
        if (m_foldersMap.contains(fullPath) == false)
        {
            QTreeWidgetItem *folder = new QTreeWidgetItem(parentNode);
            folder->setText(COL_NAME, level);
            folder->setIcon(COL_NAME, QIcon(":/folder.png"));
            folder->setData(COL_NAME, Qt::UserRole, Function::invalidId());
            folder->setData(COL_NAME, Qt::UserRole + 1, type);
            folder->setText(COL_PATH, fullPath);
            folder->setFlags(folder->flags() | Qt::ItemIsDropEnabled | Qt::ItemIsEditable);

            m_foldersMap[fullPath] = folder;
            parentNode = folder;
        }
        else
            parentNode = m_foldersMap[fullPath];
    }

    return m_foldersMap[name];
}

void FunctionsTreeWidget::slotItemChanged(QTreeWidgetItem *item)
{
    blockSignals(true);
    qDebug() << "[FunctionsTreeWidget] TREE item changed";
    if (item->text(COL_PATH).isEmpty())
    {
        blockSignals(false);
        return;
    }

    QTreeWidgetItem *parent = item->parent();
    if (parent != NULL)
    {
        QString fullPath = parent->text(COL_PATH);

        if (fullPath.endsWith('/') == false)
            fullPath.append("/");
        fullPath.append(item->text(COL_NAME));

        m_foldersMap.remove(item->text(COL_PATH));
        item->setText(COL_PATH, fullPath);
        m_foldersMap[fullPath] = item;
        slotUpdateChildrenPath(item);
    }
    blockSignals(false);
}

void FunctionsTreeWidget::slotUpdateChildrenPath(QTreeWidgetItem *root)
{
    if (root->childCount() == 0)
        return;
    for (int i = 0; i < root->childCount(); i++)
    {
        QTreeWidgetItem *child = root->child(i);

        // child can be a function node or another folder
        QString path = child->text(COL_PATH);
        if (path.isEmpty()) // function node
        {
            quint32 fid = child->data(COL_NAME, Qt::UserRole).toUInt();
            Function *func = m_doc->function(fid);
            if (func != NULL)
                func->setPath(root->text(COL_PATH));
        }
        else
        {
            slotItemChanged(child);
        }
    }
}

void FunctionsTreeWidget::mousePressEvent(QMouseEvent *event)
{
    QTreeWidget::mousePressEvent(event);

    m_draggedItems = selectedItems(); //itemAt(event->pos());
}


void FunctionsTreeWidget::dropEvent(QDropEvent *event)
{
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    QTreeWidgetItem *dropItem = itemAt(event->pos());
#else
    QTreeWidgetItem *dropItem = itemAt(event->position().toPoint());
#endif
    if (m_draggedItems.count() == 0 || dropItem == NULL)
        return;

    QVariant var = dropItem->data(COL_NAME, Qt::UserRole + 1);
    if (var.isValid() == false)
        return;

    int dropType = var.toInt();
    //QString folderName = dropItem->text(COL_PATH);

    foreach (QTreeWidgetItem *item, m_draggedItems)
    {
        quint32 dragFID = item->data(COL_NAME, Qt::UserRole).toUInt();
        Function *dragFunc = m_doc->function(dragFID);
        if (dragFunc != NULL && dragFunc->type() == dropType)
        {
            QTreeWidget::dropEvent(event);
            quint32 fid = item->data(COL_NAME, Qt::UserRole).toUInt();
            Function *func = m_doc->function(fid);
            if (func != NULL)
                func->setPath(dropItem->text(COL_PATH));
        }
        else
        {
            // m_draggedItem is a folder
            int dragType = item->data(COL_NAME, Qt::UserRole + 1).toInt();
            if (dragType == dropType)
                QTreeWidget::dropEvent(event);
            slotItemChanged(item);
        }
    }

    m_draggedItems.clear();
}

1	/*
2	Q Light Controller Plus
3	functionstreewidget.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 <QContextMenuEvent>
21	#include <QDebug>
22
23	#include "functionstreewidget.h"
24	#include "function.h"
25	#include "doc.h"
26
27	#define COL_NAME 0
28	#define COL_PATH 1
29
30	FunctionsTreeWidget::FunctionsTreeWidget(Doc doc, QWidget parent) :	6✔
31	QTreeWidget(parent)
32	, m_doc(doc)	6✔
33	{
34	sortItems(COL_NAME, Qt::AscendingOrder);	6✔
35
36	QTreeWidgetItem *root = invisibleRootItem();	6✔
37	root->setFlags(root->flags() & ~Qt::ItemIsDropEnabled);	6✔
38
39	connect(this, SIGNAL(itemChanged(QTreeWidgetItem*,int)),	6✔
40	this, SLOT(slotItemChanged(QTreeWidgetItem*)));
41	}	6✔
42
43	void FunctionsTreeWidget::updateTree()	×
44	{
45	blockSignals(true);	×
46
47	clearTree();	×
48
49	foreach (Function* function, m_doc->functions())	×
50	{
51	if (function->isVisible())	×
52	updateFunctionItem(new QTreeWidgetItem(parentItem(function)), function);	×
53	}
54
55	blockSignals(false);	×
56	}	×
57
58	void FunctionsTreeWidget::clearTree()	×
59	{
60	m_foldersMap.clear();	×
61	clear();	×
62	}	×
63
64	void FunctionsTreeWidget::functionNameChanged(quint32 fid)	×
65	{
66	blockSignals(true);	×
67	Function* function = m_doc->function(fid);	×
68	if (function == NULL)	×
69	{
70	blockSignals(false);	×
71	return;	×
72	}
73
74	QTreeWidgetItem* item = functionItem(function);	×
75	if (item != NULL)	×
76	updateFunctionItem(item, function);	×
77
78	blockSignals(false);	×
79	}
80
81	QTreeWidgetItem *FunctionsTreeWidget::addFunction(quint32 fid)	×
82	{
83	Function* function = m_doc->function(fid);	×
84	if (function == NULL \|\| function->isVisible() == false)	×
85	return NULL;	×
86
87	QTreeWidgetItem* item = functionItem(function);	×
88	if (item != NULL)	×
89	return item;	×
90
91	blockSignals(true);	×
92	QTreeWidgetItem* parent = parentItem(function);	×
93	item = new QTreeWidgetItem(parent);	×
94	updateFunctionItem(item, function);	×
95	if (parent != NULL)	×
96	function->setPath(parent->text(COL_PATH));	×
97	blockSignals(false);	×
98	return item;	×
99	}
100
101	void FunctionsTreeWidget::updateFunctionItem(QTreeWidgetItem* item, const Function* function)	×
102	{
103	Q_ASSERT(item != NULL);	×
104	Q_ASSERT(function != NULL);	×
105	item->setText(COL_NAME, function->name());	×
106	item->setIcon(COL_NAME, function->getIcon());	×
107	item->setData(COL_NAME, Qt::UserRole, function->id());	×
108	item->setData(COL_NAME, Qt::UserRole + 1, function->type());	×
109	item->setFlags(item->flags() & ~Qt::ItemIsDropEnabled);	×
110	}	×
111
112	QTreeWidgetItem* FunctionsTreeWidget::parentItem(const Function* function)	×
113	{
114	Q_ASSERT(function != NULL);	×
115
116	if (function->isVisible() == false)	×
117	return NULL;	×
118
119	QString basePath = Function::typeToString(function->type());	×
120	if (m_foldersMap.contains(QString(basePath + "/")) == false)	×
121	{
122	// Parent item for the given type doesn't exist yet so create one
123	QTreeWidgetItem* item = new QTreeWidgetItem(this);	×
124	item->setText(COL_NAME, basePath);	×
125	item->setIcon(COL_NAME, function->getIcon());	×
126	item->setData(COL_NAME, Qt::UserRole, Function::invalidId());	×
127	item->setData(COL_NAME, Qt::UserRole + 1, function->type());	×
128	item->setText(COL_PATH, QString(basePath + "/"));	×
129	item->setFlags(Qt::ItemIsEnabled \| Qt::ItemIsSelectable \| Qt::ItemIsDropEnabled);	×
130	m_foldersMap[QString(basePath + "/")] = item;	×
131	}
132
133	QTreeWidgetItem *pItem = folderItem(function->path());	×
134
135	if (pItem != NULL)	×
136	{
137	//qDebug() << "Found item for function:" << function->name() << ", path: " << function->path();
138	return pItem;	×
139	}
140
141	return NULL;	×
142	}
143
144	quint32 FunctionsTreeWidget::itemFunctionId(const QTreeWidgetItem* item) const	×
145	{
146	if (item == NULL \|\| item->parent() == NULL)	×
147	return Function::invalidId();	×
148	else
149	{
150	QVariant var = item->data(COL_NAME, Qt::UserRole);	×
151	if (var.isValid() == false)	×
152	return Function::invalidId();	×
153
154	return var.toUInt();	×
155	}
156	}
157
158	QTreeWidgetItem* FunctionsTreeWidget::functionItem(const Function* function)	×
159	{
160	Q_ASSERT(function != NULL);	×
161
162	if (function->isVisible() == false)	×
163	return NULL;	×
164
165	QTreeWidgetItem* parent = parentItem(function);	×
166	Q_ASSERT(parent != NULL);	×
167
168	for (int i = 0; i < parent->childCount(); i++)	×
169	{
170	QTreeWidgetItem* item = parent->child(i);	×
171	if (itemFunctionId(item) == function->id())	×
172	return item;	×
173	}
174
175	return NULL;	×
176	}
177
178	/*********************************************************************
179	* Tree folders
180	*********************************************************************/
181
182	void FunctionsTreeWidget::addFolder()	×
183	{
184	blockSignals(true);	×
185	if (selectedItems().isEmpty())	×
186	{
187	blockSignals(false);	×
188	return;	×
189	}
190
191	QTreeWidgetItem *item = selectedItems().first();	×
192	if (item->text(COL_PATH).isEmpty())	×
193	item = item->parent();	×
194
195	int type = item->data(COL_NAME, Qt::UserRole + 1).toInt();	×
196
197	QString fullPath = item->text(COL_PATH);	×
198	if (fullPath.endsWith('/') == false)	×
199	fullPath.append("/");	×
200
201	QString newName = "New folder";	×
202
203	int folderCount = 1;	×
204
205	while (m_foldersMap.contains(fullPath + newName))	×
206	{
207	newName = "New Folder " + QString::number(folderCount++);	×
208	}
209
210	fullPath += newName;	×
211
212	QTreeWidgetItem *folder = new QTreeWidgetItem(item);	×
213	folder->setText(COL_NAME, newName);	×
214	folder->setIcon(COL_NAME, QIcon(":/folder.png"));	×
215	folder->setData(COL_NAME, Qt::UserRole, Function::invalidId());	×
216	folder->setData(COL_NAME, Qt::UserRole + 1, type);	×
217	folder->setText(COL_PATH, fullPath);	×
218	folder->setFlags(folder->flags() \| Qt::ItemIsDropEnabled \| Qt::ItemIsEditable);	×
219
220	m_foldersMap[fullPath] = folder;	×
221	item->setExpanded(true);	×
222
223	blockSignals(false);	×
224
225	scrollToItem(folder, QAbstractItemView::PositionAtCenter);	×
226	}
227
228	void FunctionsTreeWidget::deleteFolder(QTreeWidgetItem *item)	×
229	{
230	if (item == NULL)	×
231	return;	×
232
233	QList<QTreeWidgetItem*> childrenList;	×
234	for (int i = 0; i < item->childCount(); i++)	×
235	childrenList.append(item->child(i));	×
236
237	QListIterator <QTreeWidgetItem*> it(childrenList);	×
238	while (it.hasNext() == true)	×
239	{
240	QTreeWidgetItem *child = it.next();	×
241	quint32 fid = child->data(COL_NAME, Qt::UserRole).toUInt();	×
242	if (fid != Function::invalidId())	×
243	{
244	m_doc->deleteFunction(fid);	×
245	delete child;	×
246	}
247	else
248	deleteFolder(child);	×
249	}
250
251	QString name = item->text(COL_PATH);	×
252
253	if (m_foldersMap.contains(name))	×
254	m_foldersMap.remove(name);	×
255
256	delete item;	×
257	}
258
259	QTreeWidgetItem *FunctionsTreeWidget::folderItem(QString name)	×
260	{
261	if (selectedItems().count() > 0)	×
262	{
263	QString currFolder = selectedItems().first()->text(COL_PATH);	×
264	if (currFolder.contains(name) && m_foldersMap.contains(currFolder))	×
265	return m_foldersMap[currFolder];	×
266	}
267
268	if (m_foldersMap.contains(name))	×
269	return m_foldersMap[name];	×
270
271	if (name.endsWith('/'))	×
272	return NULL;	×
273
274	qDebug() << "Folder" << name << "doesn't exist. Creating it...";	×
275
276	QTreeWidgetItem *parentNode = NULL;	×
277	int type = Function::Undefined;	×
278	QString fullPath;	×
279	QStringList levelsList = name.split("/");	×
NEW 280	foreach (QString level, levelsList)	×
281	{
282	// the first round is a category node. Just retrieve the item pointer
283	// and the type, then skip it.
284	if (fullPath.isEmpty())	×
285	{
286	if (m_foldersMap.contains(level + "/"))	×
287	{
288	parentNode = m_foldersMap[level + "/"];	×
289	type = parentNode->data(COL_NAME, Qt::UserRole + 1).toInt();	×
290	}
291	fullPath = level;	×
292	continue;	×
293	}
294
295	fullPath.append("/");	×
296	fullPath.append(level);	×
297
298	// create only missing levels
299	if (m_foldersMap.contains(fullPath) == false)	×
300	{
301	QTreeWidgetItem *folder = new QTreeWidgetItem(parentNode);	×
302	folder->setText(COL_NAME, level);	×
303	folder->setIcon(COL_NAME, QIcon(":/folder.png"));	×
304	folder->setData(COL_NAME, Qt::UserRole, Function::invalidId());	×
305	folder->setData(COL_NAME, Qt::UserRole + 1, type);	×
306	folder->setText(COL_PATH, fullPath);	×
307	folder->setFlags(folder->flags() \| Qt::ItemIsDropEnabled \| Qt::ItemIsEditable);	×
308
309	m_foldersMap[fullPath] = folder;	×
310	parentNode = folder;	×
311	}
312	else
313	parentNode = m_foldersMap[fullPath];	×
314	}
315
316	return m_foldersMap[name];	×
317	}
318
319	void FunctionsTreeWidget::slotItemChanged(QTreeWidgetItem *item)	×
320	{
321	blockSignals(true);	×
322	qDebug() << "[FunctionsTreeWidget] TREE item changed";	×
323	if (item->text(COL_PATH).isEmpty())	×
324	{
325	blockSignals(false);	×
326	return;	×
327	}
328
329	QTreeWidgetItem *parent = item->parent();	×
330	if (parent != NULL)	×
331	{
332	QString fullPath = parent->text(COL_PATH);	×
333
334	if (fullPath.endsWith('/') == false)	×
335	fullPath.append("/");	×
336	fullPath.append(item->text(COL_NAME));	×
337
338	m_foldersMap.remove(item->text(COL_PATH));	×
339	item->setText(COL_PATH, fullPath);	×
340	m_foldersMap[fullPath] = item;	×
341	slotUpdateChildrenPath(item);	×
342	}
343	blockSignals(false);	×
344	}
345
346	void FunctionsTreeWidget::slotUpdateChildrenPath(QTreeWidgetItem *root)	×
347	{
348	if (root->childCount() == 0)	×
349	return;	×
350	for (int i = 0; i < root->childCount(); i++)	×
351	{
352	QTreeWidgetItem *child = root->child(i);	×
353
354	// child can be a function node or another folder
355	QString path = child->text(COL_PATH);	×
356	if (path.isEmpty()) // function node	×
357	{
358	quint32 fid = child->data(COL_NAME, Qt::UserRole).toUInt();	×
359	Function *func = m_doc->function(fid);	×
360	if (func != NULL)	×
361	func->setPath(root->text(COL_PATH));	×
362	}
363	else
364	{
365	slotItemChanged(child);	×
366	}
367	}
368	}
369
370	void FunctionsTreeWidget::mousePressEvent(QMouseEvent *event)	×
371	{
372	QTreeWidget::mousePressEvent(event);	×
373
374	m_draggedItems = selectedItems(); //itemAt(event->pos());	×
375	}	×
376
377
378	void FunctionsTreeWidget::dropEvent(QDropEvent *event)	×
379	{
380	#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
381	QTreeWidgetItem *dropItem = itemAt(event->pos());	×
382	#else
383	QTreeWidgetItem *dropItem = itemAt(event->position().toPoint());
384	#endif
385	if (m_draggedItems.count() == 0 \|\| dropItem == NULL)	×
386	return;	×
387
388	QVariant var = dropItem->data(COL_NAME, Qt::UserRole + 1);	×
389	if (var.isValid() == false)	×
390	return;	×
391
392	int dropType = var.toInt();	×
393	//QString folderName = dropItem->text(COL_PATH);
394
395	foreach (QTreeWidgetItem *item, m_draggedItems)	×
396	{
397	quint32 dragFID = item->data(COL_NAME, Qt::UserRole).toUInt();	×
398	Function *dragFunc = m_doc->function(dragFID);	×
399	if (dragFunc != NULL && dragFunc->type() == dropType)	×
400	{
401	QTreeWidget::dropEvent(event);	×
402	quint32 fid = item->data(COL_NAME, Qt::UserRole).toUInt();	×
403	Function *func = m_doc->function(fid);	×
404	if (func != NULL)	×
405	func->setPath(dropItem->text(COL_PATH));	×
406	}
407	else
408	{
409	// m_draggedItem is a folder
410	int dragType = item->data(COL_NAME, Qt::UserRole + 1).toInt();	×
411	if (dragType == dropType)	×
412	QTreeWidget::dropEvent(event);	×
413	slotItemChanged(item);	×
414	}
415	}
416
417	m_draggedItems.clear();	×
418	}

mcallegari / qlcplus / 7252848206

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