YShuvakin/VkuMonitor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First implementation

Browse Source
This commit is contained in:
Yury Shuvakin
2024-07-03 19:11:29 +09:00
parent 25a3a8ac11
commit d708fc3499
153 changed files with 17687 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
cpp/window/SetupDialog/SetupDialogTreeModel.cpp Normal file
View File

@@ -0,0 +1,263 @@
/*
Copyright (c) 2015, 2016 Hubert Denkmair <hubert@denkmair.de>
This file is part of cangaroo.
cangaroo is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
cangaroo is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with cangaroo. If not, see <http://www.gnu.org/licenses/>.
*/
#include "SetupDialogTreeModel.h"
SetupDialogTreeModel::SetupDialogTreeModel(Backend *backend, QObject *parent)
: QAbstractItemModel(parent),
_backend(backend),
_rootItem(0)
{
}
SetupDialogTreeModel::~SetupDialogTreeModel()
{
if (_rootItem) {
delete _rootItem;
}
}
QVariant SetupDialogTreeModel::data(const QModelIndex &index, int role) const
{
SetupDialogTreeItem *item = static_cast<SetupDialogTreeItem*>(index.internalPointer());
if (item) {
if (role==Qt::DisplayRole) {
return item->dataDisplayRole(index);
}
}
return QVariant();
}
QVariant SetupDialogTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
(void) orientation;
if (role==Qt::DisplayRole) {
switch (section) {
case column_device: return "Device";
case column_driver: return "Driver";
case column_bitrate: return "Bitrate";
case column_filename: return "Filename";
case column_path: return "Path";
default: return "";
}
} else {
return QVariant();
}
}
QModelIndex SetupDialogTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if (!hasIndex(row, column, parent)) {
return QModelIndex();
} else {
SetupDialogTreeItem *parentItem = itemOrRoot(parent);
SetupDialogTreeItem *childItem = parentItem->child(row);
return childItem ? createIndex(row, column, childItem) : QModelIndex();
}
}
QModelIndex SetupDialogTreeModel::parent(const QModelIndex &index) const
{
if (!index.isValid()) { return QModelIndex(); }
SetupDialogTreeItem *childItem = static_cast<SetupDialogTreeItem*>(index.internalPointer());
SetupDialogTreeItem *parentItem = childItem->getParentItem();
return (parentItem == _rootItem) ? QModelIndex() : createIndex(parentItem->row(), 0, parentItem);
}
int SetupDialogTreeModel::rowCount(const QModelIndex &parent) const
{
int retval = 0;
if (parent.column() <= 0) {
SetupDialogTreeItem *item = itemOrRoot(parent);
if (item) {
retval = item->getChildCount();
}
}
return retval;
}
int SetupDialogTreeModel::columnCount(const QModelIndex &parent) const
{
(void) parent;
return column_count;
}
QModelIndex SetupDialogTreeModel::indexOfItem(const SetupDialogTreeItem *item) const
{
return createIndex(item->row(), 0, (void*)item);
}
SetupDialogTreeItem *SetupDialogTreeModel::addNetwork()
{
QString s;
int i=0;
while (true) {
s = QString("Network %1").arg(++i);
if (_rootItem->setup->getNetworkByName(s)==0) {
break;
}
}
beginInsertRows(QModelIndex(), _rootItem->getChildCount(), _rootItem->getChildCount());
MeasurementNetwork *network = _rootItem->setup->createNetwork();
network->setName(s);
SetupDialogTreeItem *item = loadNetwork(_rootItem, *network);
endInsertRows();
return item;
}
void SetupDialogTreeModel::deleteNetwork(const QModelIndex &index)
{
SetupDialogTreeItem *item = static_cast<SetupDialogTreeItem*>(index.internalPointer());
beginRemoveRows(index.parent(), index.row(), index.row());
_rootItem->removeChild(item);
_rootItem->setup->removeNetwork(item->network);
endRemoveRows();
}
SetupDialogTreeItem *SetupDialogTreeModel::addCanDb(const QModelIndex &parent, pCanDb db)
{
SetupDialogTreeItem *parentItem = static_cast<SetupDialogTreeItem*>(parent.internalPointer());
if (!parentItem) { return 0; }
SetupDialogTreeItem *item = 0;
if (parentItem->network) {
beginInsertRows(parent, rowCount(parent), rowCount(parent));
parentItem->network->addCanDb(db);
item = loadCanDb(*parentItem, db);
endInsertRows();
}
return item;
}
void SetupDialogTreeModel::deleteCanDb(const QModelIndex &index)
{
SetupDialogTreeItem *item = static_cast<SetupDialogTreeItem*>(index.internalPointer());
if (!item) { return; }
SetupDialogTreeItem *parentItem = item->getParentItem();
if (parentItem && parentItem->network && parentItem->network->_canDbs.contains(item->candb)) {
parentItem->network->_canDbs.removeAll(item->candb);
beginRemoveRows(index.parent(), item->row(), item->row());
item->getParentItem()->removeChild(item);
endRemoveRows();
}
}
SetupDialogTreeItem *SetupDialogTreeModel::addInterface(const QModelIndex &parent, CanInterfaceId &interface)
{
SetupDialogTreeItem *parentItem = static_cast<SetupDialogTreeItem*>(parent.internalPointer());
if (!parentItem) { return 0; }
SetupDialogTreeItem *item = 0;
if (parentItem && parentItem->network) {
beginInsertRows(parent, parentItem->getChildCount(), parentItem->getChildCount());
MeasurementInterface *mi = parentItem->network->addCanInterface(interface);
item = loadMeasurementInterface(*parentItem, mi);
endInsertRows();
}
return item;
}
void SetupDialogTreeModel::deleteInterface(const QModelIndex &index)
{
SetupDialogTreeItem *item = static_cast<SetupDialogTreeItem*>(index.internalPointer());
if (!item) { return; }
SetupDialogTreeItem *parentItem = item->getParentItem();
if (parentItem && parentItem->network && parentItem->network->interfaces().contains(item->intf)) {
parentItem->network->removeInterface(item->intf);
beginRemoveRows(index.parent(), item->row(), item->row());
item->getParentItem()->removeChild(item);
endRemoveRows();
}
}
SetupDialogTreeItem *SetupDialogTreeModel::itemOrRoot(const QModelIndex &index) const
{
return index.isValid() ? static_cast<SetupDialogTreeItem*>(index.internalPointer()) : _rootItem;
}
SetupDialogTreeItem *SetupDialogTreeModel::loadMeasurementInterface(SetupDialogTreeItem &parent, MeasurementInterface *intf)
{
SetupDialogTreeItem *item = new SetupDialogTreeItem(SetupDialogTreeItem::type_interface, _backend, &parent);
item->intf = intf;
parent.appendChild(item);
return item;
}
SetupDialogTreeItem *SetupDialogTreeModel::loadCanDb(SetupDialogTreeItem &parent, pCanDb &db)
{
SetupDialogTreeItem *item = new SetupDialogTreeItem(SetupDialogTreeItem::type_candb, _backend, &parent);
item->candb = db;
parent.appendChild(item);
return item;
}
SetupDialogTreeItem *SetupDialogTreeModel::loadNetwork(SetupDialogTreeItem *root, MeasurementNetwork &network)
{
SetupDialogTreeItem *item_network = new SetupDialogTreeItem(SetupDialogTreeItem::type_network, _backend, root);
item_network->network = &network;
SetupDialogTreeItem *item_intf_root = new SetupDialogTreeItem(SetupDialogTreeItem::type_interface_root, _backend, item_network);
item_intf_root->network = &network;
item_network->appendChild(item_intf_root);
SetupDialogTreeItem *item_candb_root = new SetupDialogTreeItem(SetupDialogTreeItem::type_candb_root, _backend, item_network);
item_candb_root->network = &network;
item_network->appendChild(item_candb_root);
foreach (MeasurementInterface *intf, network.interfaces()) {
loadMeasurementInterface(*item_intf_root, intf);
}
foreach (pCanDb candb, network._canDbs) {
loadCanDb(*item_candb_root, candb);
}
root->appendChild(item_network);
return item_network;
}
void SetupDialogTreeModel::load(MeasurementSetup &setup)
{
SetupDialogTreeItem *_newRoot = new SetupDialogTreeItem(SetupDialogTreeItem::type_root, 0);
_newRoot->setup = &setup;
foreach (MeasurementNetwork *network, setup.getNetworks()) {
loadNetwork(_newRoot, *network);
}
beginResetModel();
SetupDialogTreeItem *_oldRoot = _rootItem;
_rootItem = _newRoot;
delete _oldRoot;
endResetModel();
}