2021-09-06 12:54:28 -04:00
|
|
|
#include "multiverseitem.h"
|
|
|
|
#include "multiversemodel.h"
|
|
|
|
#include "qsacnnode.h"
|
|
|
|
|
|
|
|
#include <QMetaEnum>
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::MultiverseModel
|
|
|
|
* @param parent
|
|
|
|
* @param node
|
|
|
|
*/
|
|
|
|
MultiverseModel::MultiverseModel(QObject *parent, QSacnNode *node)
|
|
|
|
: QAbstractItemModel(parent)
|
|
|
|
, node_(node)
|
|
|
|
, rootItem_(new MultiverseItem())
|
|
|
|
{
|
|
|
|
QMetaEnum e = QMetaEnum::fromType<MultiverseModel::Catagory>();
|
|
|
|
for (int k = 0; k < e.keyCount(); k++)
|
|
|
|
{
|
|
|
|
auto item = new MultiverseItem(rootItem_);
|
|
|
|
item->setOverrideData(QString(e.key(k)));
|
|
|
|
auto idx = MultiverseModel::index(k, 0, QModelIndex());
|
|
|
|
categoryIndexes.insert(static_cast<MultiverseModel::Catagory>
|
|
|
|
(e.value(k)), idx);
|
|
|
|
}
|
|
|
|
|
2021-09-07 09:15:11 -04:00
|
|
|
connect(node, &QSacnNode::discoveryUpdates,
|
|
|
|
this, &MultiverseModel::doDiscovery);
|
2021-09-06 12:54:28 -04:00
|
|
|
connect(node, &QSacnNode::subscribing,
|
|
|
|
this, &MultiverseModel::doSubscription);
|
2021-09-08 13:28:49 -04:00
|
|
|
connect(node, &QSacnNode::unsubscribing,
|
|
|
|
this, &MultiverseModel::doUnsubscribe);
|
2021-09-06 12:54:28 -04:00
|
|
|
connect(node, &QSacnNode::creating,
|
|
|
|
this, &MultiverseModel::doCreation);
|
2021-09-08 13:28:49 -04:00
|
|
|
connect(node, &QSacnNode::terminating,
|
|
|
|
this, &MultiverseModel::doTerminate);
|
2021-09-06 12:54:28 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::~MultiverseModel
|
|
|
|
*/
|
|
|
|
MultiverseModel::~MultiverseModel()
|
|
|
|
{
|
|
|
|
delete rootItem_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::root
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
MultiverseItem * MultiverseModel::root()
|
|
|
|
{
|
|
|
|
return rootItem_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::getItem
|
|
|
|
* @param index
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
MultiverseItem * MultiverseModel::getItem(const QModelIndex &index) const
|
|
|
|
{
|
|
|
|
if (index.isValid())
|
|
|
|
{
|
|
|
|
auto item = static_cast<MultiverseItem*>(index.internalPointer());
|
|
|
|
if (item)
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
return rootItem_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::headerData
|
|
|
|
* @param section
|
|
|
|
* @param orientation
|
|
|
|
* @param role
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
QVariant MultiverseModel::headerData(int section, Qt::Orientation orientation,
|
|
|
|
int role) const
|
|
|
|
{
|
|
|
|
if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
|
|
|
|
switch (static_cast<Column>(section)) {
|
|
|
|
case Universe:
|
2021-09-08 09:55:38 -04:00
|
|
|
return tr("Universe");
|
2021-09-06 12:54:28 -04:00
|
|
|
case Priority:
|
2021-09-08 09:55:38 -04:00
|
|
|
return tr("Priority");
|
|
|
|
case Channels:
|
|
|
|
return tr("Channels");
|
2022-11-24 11:31:51 -05:00
|
|
|
case SourceName:
|
|
|
|
return tr("Source Name");
|
2021-09-06 12:54:28 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return QVariant();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::index
|
|
|
|
* @param row
|
|
|
|
* @param column
|
|
|
|
* @param parent
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
QModelIndex MultiverseModel::index(int row, int column,
|
|
|
|
const QModelIndex &parent) const
|
|
|
|
{
|
|
|
|
if (parent.isValid() && parent.column() != 0)
|
|
|
|
return QModelIndex();
|
|
|
|
|
|
|
|
MultiverseItem *parentItem = getItem(parent);
|
|
|
|
if (!parentItem)
|
|
|
|
return QModelIndex();
|
|
|
|
|
|
|
|
auto childItem = parentItem->child(row);
|
|
|
|
if (childItem)
|
|
|
|
return createIndex(row, column, childItem);
|
|
|
|
|
|
|
|
return QModelIndex();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::parent
|
|
|
|
* @param index
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
QModelIndex MultiverseModel::parent(const QModelIndex &index) const
|
|
|
|
{
|
|
|
|
if (!checkIndex(index, CheckIndexOption::IndexIsValid |
|
|
|
|
CheckIndexOption::DoNotUseParent))
|
|
|
|
return QModelIndex();
|
|
|
|
|
|
|
|
auto childItem = getItem(index);
|
|
|
|
auto parentItem = childItem ? childItem->parentItem() : nullptr;
|
|
|
|
|
|
|
|
if (parentItem == rootItem_ || !parentItem)
|
|
|
|
return QModelIndex();
|
|
|
|
|
|
|
|
return createIndex(parentItem->row(), 0, parentItem);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::rowCount
|
|
|
|
* @param parent
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
int MultiverseModel::rowCount(const QModelIndex &parent) const
|
|
|
|
{
|
|
|
|
auto parentItem = getItem(parent);
|
|
|
|
return parentItem ? parentItem->childCount() : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::columnCount
|
|
|
|
* @param parent
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
int MultiverseModel::columnCount(const QModelIndex &parent) const
|
|
|
|
{
|
|
|
|
Q_UNUSED(parent);
|
|
|
|
return QMetaEnum::fromType<Column>().keyCount();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::data
|
|
|
|
* @param index
|
|
|
|
* @param role
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
QVariant MultiverseModel::data(const QModelIndex &index, int role) const
|
|
|
|
{
|
|
|
|
if (!checkIndex(index, CheckIndexOption::IndexIsValid))
|
|
|
|
return QVariant();
|
|
|
|
|
|
|
|
return getItem(index)->data(index.column(), role);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-11-18 11:32:07 -05:00
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::setData
|
|
|
|
* @param index
|
|
|
|
* @param value
|
|
|
|
* @param role
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
bool MultiverseModel::setData(const QModelIndex &index, const QVariant &value, int role)
|
|
|
|
{
|
|
|
|
if (!checkIndex(index, CheckIndexOption::IndexIsValid))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (getItem(index)->setData(index.column(), value, role))
|
|
|
|
{
|
|
|
|
emit dataChanged(index, index, QVector<int>() << role);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-06 12:54:28 -04:00
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::flags
|
|
|
|
* @param index
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
Qt::ItemFlags MultiverseModel::flags(const QModelIndex &index) const
|
|
|
|
{
|
|
|
|
if (!checkIndex(index, CheckIndexOption::IndexIsValid))
|
|
|
|
return Qt::NoItemFlags;
|
|
|
|
|
|
|
|
auto item = getItem(index);
|
|
|
|
|
|
|
|
if (!item)
|
|
|
|
return Qt::NoItemFlags;
|
|
|
|
|
|
|
|
return item->flags(index.column(), QAbstractItemModel::flags(index));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::insert
|
|
|
|
* @param universe
|
|
|
|
* @param parent
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
void MultiverseModel::insert(const QModelIndex &parent,
|
2021-09-10 11:47:48 -04:00
|
|
|
QSacnUniverse* universe,
|
2021-09-06 12:54:28 -04:00
|
|
|
discoveredUniverse *discovery)
|
|
|
|
{
|
|
|
|
auto item = getItem(parent);
|
2021-09-08 09:37:32 -04:00
|
|
|
beginInsertRows(parent, item->childCount(), item->childCount());
|
2021-09-08 12:47:40 -04:00
|
|
|
auto child = new MultiverseItem(item, universe, discovery);
|
2021-09-10 11:47:48 -04:00
|
|
|
endInsertRows();
|
2021-09-10 11:49:36 -04:00
|
|
|
auto index = QPersistentModelIndex(createIndex(item->childCount() - 1, 0,
|
|
|
|
child));
|
2021-09-10 11:47:48 -04:00
|
|
|
|
2021-09-10 16:05:09 -04:00
|
|
|
auto refreshRow = [this] (QPersistentModelIndex index) {
|
|
|
|
auto begin = index.sibling(index.row(), 0);
|
|
|
|
auto end = begin.siblingAtColumn(columnCount() - 1);
|
|
|
|
emit dataChanged(begin, end);
|
|
|
|
};
|
|
|
|
|
2021-09-08 12:47:40 -04:00
|
|
|
connect(universe, &QSacnUniverse::changed,
|
2021-09-10 16:05:09 -04:00
|
|
|
this, [refreshRow, index](){ refreshRow(index); });
|
2021-09-10 12:00:50 -04:00
|
|
|
|
|
|
|
connect(universe, &QSacnUniverse::sourceListChanged,
|
2021-09-10 16:05:09 -04:00
|
|
|
this, [this, universe, child, index, refreshRow]() {
|
|
|
|
// remove the old children
|
2021-09-10 12:00:50 -04:00
|
|
|
beginRemoveRows(index, 0, child->childCount() - 1);
|
|
|
|
child->removeChildren();
|
|
|
|
endRemoveRows();
|
|
|
|
|
2021-09-10 16:05:09 -04:00
|
|
|
// add the new children
|
2021-09-10 12:00:50 -04:00
|
|
|
beginInsertRows(index, 0, universe->sources().size() - 1);
|
|
|
|
child->createChildren();
|
|
|
|
endInsertRows();
|
2021-09-10 16:05:09 -04:00
|
|
|
|
|
|
|
// refresh row of new child when data arrives
|
|
|
|
for (int i = 0; i < child->childCount(); i++)
|
|
|
|
{
|
|
|
|
auto grandchild = child->child(i);
|
|
|
|
auto index = QPersistentModelIndex(createIndex(i, 0, grandchild));
|
|
|
|
auto data = grandchild->data(Column::Universe, Qt::EditRole);
|
|
|
|
if (data.metaType().id() != qMetaTypeId<QSacnUniverse*>())
|
|
|
|
return;
|
|
|
|
auto universe = data.value<QSacnUniverse*>();
|
|
|
|
connect(universe, &QSacnUniverse::changed,
|
|
|
|
this, [refreshRow, index](){ refreshRow(index); });
|
|
|
|
}
|
2021-09-10 12:00:50 -04:00
|
|
|
});
|
2021-09-06 12:54:28 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-08 13:28:49 -04:00
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::remove
|
|
|
|
* @param parent
|
|
|
|
* @param data
|
|
|
|
*/
|
|
|
|
void MultiverseModel::remove(const QModelIndex &parent, const QVariant &data)
|
|
|
|
{
|
|
|
|
auto item = static_cast<MultiverseItem*>(parent.internalPointer());
|
|
|
|
auto row = item->childRow(Column::Universe, data);
|
|
|
|
if (row < 0)
|
|
|
|
return;
|
|
|
|
auto child = item->child(row);
|
|
|
|
if (!child)
|
|
|
|
return;
|
|
|
|
beginRemoveRows(parent, row, row);
|
|
|
|
item->removeChild(child);
|
|
|
|
endRemoveRows();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-07 09:15:11 -04:00
|
|
|
void MultiverseModel::doDiscovery()
|
|
|
|
{
|
2021-09-07 09:39:45 -04:00
|
|
|
auto parentIndex = categoryIndexes.value(MultiverseModel::Discovery);
|
|
|
|
auto parent = static_cast<MultiverseItem*>(parentIndex.internalPointer());
|
2021-09-07 09:15:11 -04:00
|
|
|
|
2021-09-08 09:37:32 -04:00
|
|
|
beginRemoveRows(parentIndex, 0, parent->childCount() - 1);
|
2021-09-07 11:18:49 -04:00
|
|
|
parent->removeChildren();
|
2021-09-07 09:39:45 -04:00
|
|
|
endRemoveRows();
|
2021-09-07 09:15:11 -04:00
|
|
|
|
2021-09-08 09:37:32 -04:00
|
|
|
beginInsertRows(parentIndex, 0, node_->discovered.size() - 1);
|
2021-09-07 11:17:52 -04:00
|
|
|
for (auto& discovery : node_->discovered)
|
|
|
|
new MultiverseItem(parent, nullptr, discovery.get());
|
2021-09-07 09:39:45 -04:00
|
|
|
endInsertRows();
|
2021-09-06 15:09:45 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-06 12:54:28 -04:00
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::doSubscription
|
|
|
|
* @param universe
|
|
|
|
*/
|
|
|
|
void MultiverseModel::doSubscription(QSacnUniverse* universe)
|
|
|
|
{
|
|
|
|
auto parentIndex = categoryIndexes.value(MultiverseModel::Receiver);
|
|
|
|
insert(parentIndex, universe);
|
|
|
|
}
|
|
|
|
|
2021-09-08 13:28:49 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::doUnsubscribe
|
|
|
|
* @param universe
|
|
|
|
*/
|
|
|
|
void MultiverseModel::doUnsubscribe(QSacnUniverse* universe)
|
|
|
|
{
|
|
|
|
auto parentIndex = categoryIndexes.value(MultiverseModel::Receiver);
|
|
|
|
remove(parentIndex, QVariant::fromValue(universe));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-06 12:54:28 -04:00
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::doCreation
|
|
|
|
* @param universe
|
|
|
|
*/
|
|
|
|
void MultiverseModel::doCreation(QSacnUniverse* universe)
|
|
|
|
{
|
|
|
|
auto parentIndex = categoryIndexes.value(MultiverseModel::Source);
|
|
|
|
insert(parentIndex, universe);
|
|
|
|
}
|
2021-09-08 13:28:49 -04:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief MultiverseModel::doTerminate
|
|
|
|
* @param universe
|
|
|
|
*/
|
2021-09-10 11:47:48 -04:00
|
|
|
void MultiverseModel::doTerminate(QSacnUniverse *universe)
|
2021-09-08 13:28:49 -04:00
|
|
|
{
|
|
|
|
auto parentIndex = categoryIndexes.value(MultiverseModel::Source);
|
|
|
|
remove(parentIndex, QVariant::fromValue(universe));
|
|
|
|
}
|