|
|
/*------------------------------------------------------------------------------
|
|
|
* -- This file is a part of SciQLop
|
|
|
* -- Copyright (C) 2019, Plasma Physics Laboratory - CNRS
|
|
|
* --
|
|
|
* -- This program 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 3 of the License, or
|
|
|
* -- (at your option) any later version.
|
|
|
* --
|
|
|
* -- This program 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 this program; if not, write to the Free Software
|
|
|
* -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
* -------------------------------------------------------------------------------*/
|
|
|
/*-- Author : Alexis Jeandet
|
|
|
* -- Mail : alexis.jeandet@lpp.polytechnique.fr
|
|
|
* -- alexis.jeandet@member.fsf.org
|
|
|
* ----------------------------------------------------------------------------*/
|
|
|
// https://doc.qt.io/qt-5/qtwidgets-itemviews-simpletreemodel-example.html
|
|
|
|
|
|
#include "DataSource/datasources.h"
|
|
|
|
|
|
inline std::unique_ptr<DataSourceItem> make_folder_item(const QString& name)
|
|
|
{
|
|
|
return std::make_unique<DataSourceItem>(DataSourceItemType::NODE, name);
|
|
|
}
|
|
|
|
|
|
template<typename T>
|
|
|
DataSourceItem* make_path_items(const T& path_list_begin,
|
|
|
const T& path_list_end, DataSourceItem* root)
|
|
|
{
|
|
|
std::for_each(path_list_begin, path_list_end,
|
|
|
[&root](const auto& folder_name) mutable {
|
|
|
auto folder_ptr = root->findItem(folder_name);
|
|
|
if(folder_ptr == nullptr)
|
|
|
{
|
|
|
auto folder = make_folder_item(folder_name);
|
|
|
folder_ptr = folder.get();
|
|
|
root->appendChild(std::move(folder));
|
|
|
}
|
|
|
root = folder_ptr;
|
|
|
});
|
|
|
return root;
|
|
|
}
|
|
|
|
|
|
inline std::unique_ptr<DataSourceItem>
|
|
|
make_product_item(const QVariantHash& metaData, const QUuid& dataSourceUid,
|
|
|
const QString& DATA_SOURCE_NAME, DataSources* dc)
|
|
|
{
|
|
|
auto result =
|
|
|
std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, metaData);
|
|
|
|
|
|
// Adds plugin name to product metadata
|
|
|
result->setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
|
|
|
result->setData(DataSourceItem::ID_DATA_KEY,
|
|
|
metaData.value(DataSourceItem::NAME_DATA_KEY));
|
|
|
|
|
|
auto productName = metaData.value(DataSourceItem::NAME_DATA_KEY).toString();
|
|
|
|
|
|
// Add action to load product from DataSourceController
|
|
|
// result->addAction(std::make_unique<DataSourceItemAction>(
|
|
|
// QObject::tr("Load %1 product").arg(productName),
|
|
|
// [productName, dataSourceUid, dc](DataSourceItem& item) {
|
|
|
// if(dc) { dc->loadProductItem(dataSourceUid, item); }
|
|
|
// }));
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
QVariant DataSources::data(const QModelIndex& index, int role) const
|
|
|
{
|
|
|
if(!index.isValid()) return QVariant();
|
|
|
if(role != Qt::DisplayRole) return QVariant();
|
|
|
DataSourceItem* item = static_cast<DataSourceItem*>(index.internalPointer());
|
|
|
return item->name();
|
|
|
}
|
|
|
|
|
|
int DataSources::columnCount(const QModelIndex& parent) const
|
|
|
{
|
|
|
(void)parent;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int DataSources::rowCount(const QModelIndex& parent) const
|
|
|
{
|
|
|
DataSourceItem* parentItem;
|
|
|
if(parent.column() > 0) return 0;
|
|
|
if(!parent.isValid())
|
|
|
parentItem = _root;
|
|
|
else
|
|
|
parentItem = static_cast<DataSourceItem*>(parent.internalPointer());
|
|
|
return parentItem->childCount();
|
|
|
}
|
|
|
|
|
|
QModelIndex DataSources::parent(const QModelIndex& index) const
|
|
|
{
|
|
|
if(!index.isValid()) return QModelIndex();
|
|
|
DataSourceItem* childItem =
|
|
|
static_cast<DataSourceItem*>(index.internalPointer());
|
|
|
DataSourceItem* parentItem = childItem->parentItem();
|
|
|
if(parentItem == _root) return QModelIndex();
|
|
|
return createIndex(parentItem->index(), 0, parentItem);
|
|
|
}
|
|
|
|
|
|
QModelIndex DataSources::index(int row, int column,
|
|
|
const QModelIndex& parent) const
|
|
|
{
|
|
|
if(!hasIndex(row, column, parent)) return QModelIndex();
|
|
|
DataSourceItem* parentItem;
|
|
|
if(!parent.isValid())
|
|
|
parentItem = _root;
|
|
|
else
|
|
|
parentItem = static_cast<DataSourceItem*>(parent.internalPointer());
|
|
|
DataSourceItem* childItem = parentItem->child(row);
|
|
|
if(childItem) return createIndex(row, column, childItem);
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
void DataSources::addDataSourceItem(
|
|
|
const QUuid& providerUid, const QString& path,
|
|
|
const QMap<QString, QString>& metaData) noexcept
|
|
|
{
|
|
|
auto path_list = path.split('/', QString::SkipEmptyParts);
|
|
|
auto name = *(std::cend(path_list) - 1);
|
|
|
auto path_item =
|
|
|
make_path_items(std::cbegin(path_list), std::cend(path_list) - 1, _root);
|
|
|
QVariantHash meta_data{{DataSourceItem::NAME_DATA_KEY, name}};
|
|
|
for(auto& key : metaData.keys())
|
|
|
{
|
|
|
meta_data[key] = metaData[key];
|
|
|
}
|
|
|
path_item->appendChild(
|
|
|
make_product_item(meta_data, providerUid, "test", this));
|
|
|
}
|
|
|
|
|
|
void DataSources::addProvider(IDataProvider* provider) noexcept
|
|
|
{
|
|
|
_DataProviders.insert(
|
|
|
{provider->id(), std::unique_ptr<IDataProvider>{provider}});
|
|
|
}
|
|
|
|
