diff --git a/app/ui/MainWindow.ui b/app/ui/MainWindow.ui
index 44aecb5..79fbee1 100644
--- a/app/ui/MainWindow.ui
+++ b/app/ui/MainWindow.ui
@@ -112,7 +112,13 @@
-
-
+
+
+
+ Name
+
+
+
diff --git a/core/include/DataSource/DataSourceItem.h b/core/include/DataSource/DataSourceItem.h
index 3b03955..9b82471 100644
--- a/core/include/DataSource/DataSourceItem.h
+++ b/core/include/DataSource/DataSourceItem.h
@@ -25,10 +25,14 @@ class SCIQLOP_CORE_EXPORT DataSourceItem {
public:
/// Key associated with the name of the item
static const QString NAME_DATA_KEY;
+ /// Key associated with the plugin of the item
+ static const QString PLUGIN_DATA_KEY;
explicit DataSourceItem(DataSourceItemType type, const QString &name);
explicit DataSourceItem(DataSourceItemType type, QVariantHash data = {});
+ std::unique_ptr clone() const;
+
/// @return the actions of the item as a vector
QVector actions() const noexcept;
@@ -64,6 +68,46 @@ public:
/// Gets all data
QVariantHash data() const noexcept;
+ /**
+ * Merge in the item the source item passed as parameter.
+ *
+ * The merge is done by adding as child of the item the complete tree represented by the source
+ * item. If a part of the tree already exists in the item (based on the name of the nodes), it
+ * is merged by completing the existing tree by items "leaves" (products, components or nodes
+ * with no child).
+ *
+ * For example, with item representing the tree:
+ * R (root node)
+ * - N1 (node)
+ * -- N11 (node)
+ * --- P1 (product)
+ * --- P2 (product)
+ * - N2 (node)
+ *
+ * and the source item representing the tree:
+ * N1 (root node)
+ * - N11 (node)
+ * -- P3 (product)
+ * - N12 (node)
+ *
+ * The leaves of the source item to merge into the item are N1/N11/P3 and N1/N12 => we therefore
+ * have the following merge result:
+ * R
+ * - N1
+ * -- N11
+ * --- P1
+ * --- P2
+ * --- P3 (added leaf)
+ * -- N12 (added leaf)
+ *
+ * @param item the source item
+ * @remarks No control is performed on products or components that are merged into the same tree
+ * part (two products or components may have the same name)
+ * @remarks the merge is made by copy (source item is not changed and still exists after the
+ * operation)
+ */
+ void merge(const DataSourceItem &item);
+
bool isRoot() const noexcept;
QString name() const noexcept;
diff --git a/core/include/DataSource/DataSourceItemAction.h b/core/include/DataSource/DataSourceItemAction.h
index 72f2a88..9bab4e3 100644
--- a/core/include/DataSource/DataSourceItemAction.h
+++ b/core/include/DataSource/DataSourceItemAction.h
@@ -35,6 +35,8 @@ public:
*/
explicit DataSourceItemAction(const QString &name, ExecuteFunction fun);
+ std::unique_ptr clone() const;
+
QString name() const noexcept;
/// Sets the data source item concerned by the action
diff --git a/core/include/DataSource/DataSourceItemMergeHelper.h b/core/include/DataSource/DataSourceItemMergeHelper.h
new file mode 100644
index 0000000..722da2c
--- /dev/null
+++ b/core/include/DataSource/DataSourceItemMergeHelper.h
@@ -0,0 +1,15 @@
+#ifndef SCIQLOP_DATASOURCEITEMMERGEHELPER_H
+#define SCIQLOP_DATASOURCEITEMMERGEHELPER_H
+
+class DataSourceItem;
+
+/**
+ * @brief The DataSourceItemMergeHelper struct is used to merge two data source items
+ * @sa DataSourceItem::merge()
+ */
+struct DataSourceItemMergeHelper {
+ /// Merges source item into dest item
+ static void merge(const DataSourceItem &source, DataSourceItem &dest);
+};
+
+#endif // SCIQLOP_DATASOURCEITEMMERGEHELPER_H
diff --git a/core/meson.build b/core/meson.build
index 11a1fb6..864624b 100644
--- a/core/meson.build
+++ b/core/meson.build
@@ -31,6 +31,7 @@ core_sources = [
'src/DataSource/DataSourceController.cpp',
'src/DataSource/DataSourceItem.cpp',
'src/DataSource/DataSourceItemAction.cpp',
+ 'src/DataSource/DataSourceItemMergeHelper.cpp',
'src/Network/NetworkController.cpp',
'src/Plugin/PluginManager.cpp',
'src/Settings/SqpSettingsDefs.cpp',
diff --git a/core/src/DataSource/DataSourceController.cpp b/core/src/DataSource/DataSourceController.cpp
index 81adfb3..a7bc3d2 100644
--- a/core/src/DataSource/DataSourceController.cpp
+++ b/core/src/DataSource/DataSourceController.cpp
@@ -12,28 +12,6 @@
Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
-namespace {
-
-/**
- * Builds the metadata of the variable that will be generated from the loading of an item
- * @param dataSourceItem the data source item from which to generate the metadata
- * @return the metadata of the variable
- */
-QVariantHash variableMetadata(const DataSourceItem &dataSourceItem)
-{
- // Variable metadata contains...
-
- // ... all metadata of the item
- auto result = dataSourceItem.data();
-
- // ... and the name of the plugin, recovered from root item
- result.insert(QStringLiteral("plugin"), dataSourceItem.rootItem().name());
-
- return result;
-}
-
-} // namespace
-
class DataSourceController::DataSourceControllerPrivate {
public:
QMutex m_WorkingMutex;
@@ -131,8 +109,7 @@ void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
auto it = impl->m_DataProviders.find(dataSourceUid);
auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
- emit variableCreationRequested(productItem.name(), variableMetadata(productItem),
- dataProvider);
+ emit variableCreationRequested(productItem.name(), productItem.data(), dataProvider);
}
else {
qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");
diff --git a/core/src/DataSource/DataSourceItem.cpp b/core/src/DataSource/DataSourceItem.cpp
index 35972b7..39d6599 100644
--- a/core/src/DataSource/DataSourceItem.cpp
+++ b/core/src/DataSource/DataSourceItem.cpp
@@ -1,9 +1,11 @@
#include
#include
+#include
#include
const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
+const QString DataSourceItem::PLUGIN_DATA_KEY = QStringLiteral("plugin");
struct DataSourceItem::DataSourceItemPrivate {
explicit DataSourceItemPrivate(DataSourceItemType type, QVariantHash data)
@@ -28,6 +30,23 @@ DataSourceItem::DataSourceItem(DataSourceItemType type, QVariantHash data)
{
}
+std::unique_ptr DataSourceItem::clone() const
+{
+ auto result = std::make_unique(impl->m_Type, impl->m_Data);
+
+ // Clones children
+ for (const auto &child : impl->m_Children) {
+ result->appendChild(std::move(child->clone()));
+ }
+
+ // Clones actions
+ for (const auto &action : impl->m_Actions) {
+ result->addAction(std::move(action->clone()));
+ }
+
+ return result;
+}
+
QVector DataSourceItem::actions() const noexcept
{
auto result = QVector{};
@@ -75,6 +94,11 @@ QVariantHash DataSourceItem::data() const noexcept
return impl->m_Data;
}
+void DataSourceItem::merge(const DataSourceItem &item)
+{
+ DataSourceItemMergeHelper::merge(item, *this);
+}
+
bool DataSourceItem::isRoot() const noexcept
{
return impl->m_Parent == nullptr;
@@ -146,7 +170,7 @@ bool DataSourceItem::operator==(const DataSourceItem &other)
if (std::tie(impl->m_Type, impl->m_Data) == std::tie(other.impl->m_Type, other.impl->m_Data)) {
// Compares contents of items' children
return std::equal(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
- std::cbegin(other.impl->m_Children),
+ std::cbegin(other.impl->m_Children), std::cend(other.impl->m_Children),
[](const auto &itemChild, const auto &otherChild) {
return *itemChild == *otherChild;
});
diff --git a/core/src/DataSource/DataSourceItemAction.cpp b/core/src/DataSource/DataSourceItemAction.cpp
index 1677091..10b233a 100644
--- a/core/src/DataSource/DataSourceItemAction.cpp
+++ b/core/src/DataSource/DataSourceItemAction.cpp
@@ -22,6 +22,11 @@ DataSourceItemAction::DataSourceItemAction(const QString &name, ExecuteFunction
{
}
+std::unique_ptr DataSourceItemAction::clone() const
+{
+ return std::make_unique(impl->m_Name, impl->m_Fun);
+}
+
QString DataSourceItemAction::name() const noexcept
{
return impl->m_Name;
diff --git a/core/src/DataSource/DataSourceItemMergeHelper.cpp b/core/src/DataSource/DataSourceItemMergeHelper.cpp
new file mode 100644
index 0000000..91e60af
--- /dev/null
+++ b/core/src/DataSource/DataSourceItemMergeHelper.cpp
@@ -0,0 +1,55 @@
+#include "DataSource/DataSourceItemMergeHelper.h"
+
+#include
+
+namespace {
+
+/**
+ * Finds in a tree an item similar to the item passed in parameter
+ * @param item the item for which to find a similar item
+ * @param root the root item of the tree
+ * @return the similar item if found, nullptr otherwise
+ */
+DataSourceItem *findSimilarItem(const DataSourceItem &item, const DataSourceItem &root)
+{
+ // An item is considered similar to the another item if:
+ // - the items are both nodes AND
+ // - the names of the items are identical
+
+ if (item.type() != DataSourceItemType::NODE) {
+ return nullptr;
+ }
+
+ DataSourceItem *result{nullptr};
+ bool found{false};
+ for (auto i = 0, count = root.childCount(); i < count && !found; ++i) {
+ auto child = root.child(i);
+
+ found = child->type() == DataSourceItemType::NODE
+ && QString::compare(child->name(), item.name(), Qt::CaseInsensitive) == 0;
+ if (found) {
+ result = child;
+ }
+ }
+
+ return result;
+}
+
+} // namespace
+
+void DataSourceItemMergeHelper::merge(const DataSourceItem &source, DataSourceItem &dest)
+{
+ // Checks if the source item can be merged into the destination item (i.e. there is a child item
+ // similar to the source item)
+ if (auto subItem = findSimilarItem(source, dest)) {
+ // If there is an item similar to the source item, applies the merge recursively
+ for (auto i = 0, count = source.childCount(); i < count; ++i) {
+ merge(*source.child(i), *subItem);
+ }
+ }
+ else {
+ // If no item is similar to the source item, the item is copied as the child of the
+ // destination item
+ dest.appendChild(source.clone());
+ }
+}
diff --git a/core/tests/DataSource/DataSourceItemBuilder.cpp b/core/tests/DataSource/DataSourceItemBuilder.cpp
new file mode 100644
index 0000000..c3ff319
--- /dev/null
+++ b/core/tests/DataSource/DataSourceItemBuilder.cpp
@@ -0,0 +1,73 @@
+#include "DataSourceItemBuilder.h"
+
+DataSourceItemBuilder &DataSourceItemBuilder::root(const QString &name)
+{
+ m_Root = std::make_shared(DataSourceItemType::NODE, name);
+ m_Items.push(m_Root.get());
+ return *this;
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::root(QVariantHash data)
+{
+ m_Root = std::make_shared(DataSourceItemType::NODE, data);
+ m_Items.push(m_Root.get());
+ return *this;
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::node(const QString &name)
+{
+ return append(DataSourceItemType::NODE, name);
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::node(QVariantHash data)
+{
+ return append(DataSourceItemType::NODE, std::move(data));
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::product(const QString &name)
+{
+ return append(DataSourceItemType::PRODUCT, name);
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::product(QVariantHash data)
+{
+ return append(DataSourceItemType::PRODUCT, std::move(data));
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::component(const QString &name)
+{
+ return append(DataSourceItemType::COMPONENT, name);
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::component(QVariantHash data)
+{
+ return append(DataSourceItemType::COMPONENT, std::move(data));
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::end()
+{
+ m_Items.pop();
+ return *this;
+}
+
+std::shared_ptr DataSourceItemBuilder::build()
+{
+ return m_Root;
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::append(DataSourceItemType type, const QString &name)
+{
+ append(type, QVariantHash{{DataSourceItem::NAME_DATA_KEY, name}});
+ return *this;
+}
+
+DataSourceItemBuilder &DataSourceItemBuilder::append(DataSourceItemType type, QVariantHash data)
+{
+ auto parentItem = m_Items.top();
+
+ auto insertIndex = parentItem->childCount();
+ parentItem->appendChild(std::make_unique(type, std::move(data)));
+
+ m_Items.push(parentItem->child(insertIndex));
+ return *this;
+}
diff --git a/core/tests/DataSource/DataSourceItemBuilder.h b/core/tests/DataSource/DataSourceItemBuilder.h
new file mode 100644
index 0000000..ce675a4
--- /dev/null
+++ b/core/tests/DataSource/DataSourceItemBuilder.h
@@ -0,0 +1,45 @@
+#ifndef SCIQLOP_DATASOURCEITEMBUILDER_H
+#define SCIQLOP_DATASOURCEITEMBUILDER_H
+
+#include
+
+#include
+#include
+
+/**
+ * @brief The DataSourceItemBuilder class aims to facilitate the creation of a DataSourceItem for unit tests
+ * @sa DataSourceItem
+ */
+class DataSourceItemBuilder {
+public:
+ /// Inits root item
+ DataSourceItemBuilder & root(const QString &name);
+ DataSourceItemBuilder & root(QVariantHash data);
+
+ /// Adds node into the current item
+ DataSourceItemBuilder & node(const QString &name);
+ DataSourceItemBuilder & node(QVariantHash data);
+
+ /// Adds product into the current item
+ DataSourceItemBuilder & product(const QString &name);
+ DataSourceItemBuilder & product(QVariantHash data);
+
+ /// Adds component into the current item
+ DataSourceItemBuilder & component(const QString &name);
+ DataSourceItemBuilder & component(QVariantHash data);
+
+ /// Closes the build of the current item
+ DataSourceItemBuilder& end();
+
+ /// Creates the DataSourceItem
+ std::shared_ptr build();
+
+private:
+ DataSourceItemBuilder& append(DataSourceItemType type, const QString &name);
+ DataSourceItemBuilder& append(DataSourceItemType type, QVariantHash data);
+
+ std::shared_ptr m_Root{nullptr};
+ std::stack m_Items;
+};
+
+#endif // SCIQLOP_DATASOURCEITEMBUILDER_H
diff --git a/core/tests/DataSource/TestDataSourceItem.cpp b/core/tests/DataSource/TestDataSourceItem.cpp
new file mode 100644
index 0000000..dd998f0
--- /dev/null
+++ b/core/tests/DataSource/TestDataSourceItem.cpp
@@ -0,0 +1,207 @@
+#include
+
+#include "DataSourceItemBuilder.h"
+
+#include
+#include
+
+#include
+
+namespace {
+
+void printItem(std::ostream &out, const DataSourceItem &item, int level = 0)
+{
+ for (auto i = 0; i < level; ++i) {
+ out << " ";
+ }
+
+ out << item.name().toStdString() << "\n";
+
+ for (auto i = 0, count = item.childCount(); i < count; ++i) {
+ printItem(out, *item.child(i), level + 1);
+ }
+}
+
+std::ostream &operator<<(std::ostream &out, const DataSourceItem &item)
+{
+ printItem(out, item, 0);
+ return out;
+}
+
+} // namespace
+
+Q_DECLARE_METATYPE(std::shared_ptr)
+
+class TestDataSourceItem : public QObject {
+ Q_OBJECT
+private slots:
+ void testMerge_data();
+ void testMerge();
+};
+
+void TestDataSourceItem::testMerge_data()
+{
+ QTest::addColumn >("source");
+ QTest::addColumn >("dest");
+ QTest::addColumn >("expectedResult");
+
+ QTest::newRow("merge (basic case)") << DataSourceItemBuilder{}
+ .root("A2")
+ .node("- B2")
+ .product("-- P2")
+ .end() // P2
+ .end() // B2
+ .end() // A2
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .product("-- P1")
+ .end() // P1
+ .end() // B1
+ .end() // A1
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .product("-- P1")
+ .end() // P1
+ .end() // B1
+ .node("- B2")
+ .product("-- P2")
+ .end() // P2
+ .end() // B2
+ .end() // A1
+ .build();
+
+ QTest::newRow("merge (some of the source and destination trees are identical)")
+ << DataSourceItemBuilder{}
+ .root("A2")
+ .node("- B1")
+ .node("-- C1")
+ .product("--- P2")
+ .end() // P2
+ .end() // C1
+ .node("-- C2")
+ .end() // C2
+ .end() // B1
+ .end() // A2
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .node("-- C1")
+ .product("--- P1")
+ .end() // P1
+ .end() // C1
+ .end() // B1
+ .end() // A1
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .node("-- C1")
+ .product("--- P1")
+ .end() // P1
+ .product("--- P2")
+ .end() // P2
+ .end() // C1
+ .node("-- C2")
+ .end() // C2
+ .end() // B1
+ .end() // A1
+ .build();
+
+ QTest::newRow("merge (products with the same name and tree are kept)")
+ << DataSourceItemBuilder{}
+ .root("A2")
+ .node("- B1")
+ .node("-- C1")
+ .product({{"name", "--- P1"}, {"from", "source"}})
+ .end() // P1
+ .end() // C1
+ .end() // B1
+ .end() // A2
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .node("-- C1")
+ .product({{"name", "--- P1"}, {"from", "dest"}})
+ .end() // P1
+ .end() // C1
+ .end() // B1
+ .end() // A1
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .node("-- C1")
+ .product({{"name", "--- P1"}, {"from", "dest"}})
+ .end() // P1 (dest)
+ .product({{"name", "--- P1"}, {"from", "source"}})
+ .end() // P1 (source)
+ .end() // C1
+ .end() // B1
+ .end() // A1
+ .build();
+
+ QTest::newRow("merge (for same nodes, metadata of dest node are kept)")
+ << DataSourceItemBuilder{}
+ .root("A2")
+ .node("- B1")
+ .node({{"name", "-- C1"}, {"from", "source"}})
+ .product("--- P2")
+ .end() // P1
+ .end() // C1
+ .end() // B1
+ .end() // A2
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .node({{"name", "-- C1"}, {"from", "dest"}})
+ .product("--- P1")
+ .end() // P1
+ .end() // C1
+ .end() // B1
+ .end() // A1
+ .build()
+ << DataSourceItemBuilder{}
+ .root("A1")
+ .node("- B1")
+ .node({{"name", "-- C1"}, {"from", "dest"}})
+ .product("--- P1")
+ .end() // P1
+ .product("--- P2")
+ .end() // P2
+ .end() // C1 (dest)
+ .end() // B1
+ .end() // A1
+ .build();
+}
+
+void TestDataSourceItem::testMerge()
+{
+ QFETCH(std::shared_ptr, source);
+ QFETCH(std::shared_ptr, dest);
+ QFETCH(std::shared_ptr, expectedResult);
+
+ // Uncomment to print trees
+ // std::cout << "source: \n" << *source << "\n";
+ // std::cout << "dest: \n" << *dest << "\n";
+
+ // Merges source in dest (not taking source root)
+ for (auto i = 0, count = source->childCount(); i < count; ++i) {
+ dest->merge(*source->child(i));
+ }
+
+ // Uncomment to print trees
+ // std::cout << "dest after merge: \n" << *dest << "\n";
+
+ // Checks merge result
+ QVERIFY(*dest == *expectedResult);
+}
+
+QTEST_MAIN(TestDataSourceItem)
+#include "TestDataSourceItem.moc"
diff --git a/core/tests/meson.build b/core/tests/meson.build
index 8a23801..ec2a714 100644
--- a/core/tests/meson.build
+++ b/core/tests/meson.build
@@ -10,6 +10,7 @@ tests = [
[['Data/TestTwoDimArrayData.cpp'],'test_2d','Two Dim Array test'],
[['Data/TestDataSeriesUtils.cpp'],'test_dataseries_util','Data series utils test'],
[['DataSource/TestDataSourceController.cpp'],'test_data_source','DataSourceController test'],
+ [['DataSource/TestDataSourceItem.cpp'],'test_data_source_item','DataSourceItem test'],
[['Variable/TestVariableCacheController.cpp'],'test_variable_cache','VariableCacheController test'],
[['Variable/TestVariable.cpp'],'test_variable','Variable test'],
[['Variable/TestVariableSync.cpp'],'test_variable_sync','Variable synchronization test']
@@ -19,7 +20,9 @@ amdatest_sources = [
'Data/DataSeriesBuilders.h',
'Data/DataSeriesBuilders.cpp',
'Data/DataSeriesTestsUtils.h',
- 'Data/DataSeriesTestsUtils.cpp'
+ 'Data/DataSeriesTestsUtils.cpp',
+ 'DataSource/DataSourceItemBuilder.h',
+ 'DataSource/DataSourceItemBuilder.cpp'
]
foreach unit_test : tests
diff --git a/gui/include/DataSource/DataSourceWidget.h b/gui/include/DataSource/DataSourceWidget.h
index 615adfd..388dbd8 100644
--- a/gui/include/DataSource/DataSourceWidget.h
+++ b/gui/include/DataSource/DataSourceWidget.h
@@ -3,6 +3,8 @@
#include
+#include
+
namespace Ui {
class DataSourceWidget;
} // Ui
@@ -29,7 +31,10 @@ public slots:
void addDataSource(DataSourceItem *dataSource) noexcept;
private:
+ void updateTreeWidget() noexcept;
+
Ui::DataSourceWidget *ui;
+ std::unique_ptr m_Root;
private slots:
/// Slot called when the filtering text has changed
diff --git a/gui/src/DataSource/DataSourceTreeWidgetItem.cpp b/gui/src/DataSource/DataSourceTreeWidgetItem.cpp
index 67bbeb1..d02d738 100644
--- a/gui/src/DataSource/DataSourceTreeWidgetItem.cpp
+++ b/gui/src/DataSource/DataSourceTreeWidgetItem.cpp
@@ -11,6 +11,41 @@ namespace {
// Column indexes
const auto NAME_COLUMN = 0;
+/**
+ * Generates the full name of an item.
+ *
+ * The full name of an item is its name possibly suffixed by the name of its plugin, in case there
+ * are items of the same name in its relatives
+ * @param item the item for which to generate the complete name
+ * @return the complete name of the item
+ */
+QString completeName(const DataSourceItem &item)
+{
+ auto name = item.name();
+
+ if (item.type() == DataSourceItemType::NODE) {
+ return name;
+ }
+
+ auto parentItem = item.parentItem();
+ if (!parentItem) {
+ return name;
+ }
+
+ // Finds in item's relatives items that have the same name
+ bool foundSameName = false;
+ for (auto i = 0, count = parentItem->childCount(); i < count && !foundSameName; ++i) {
+ auto child = parentItem->child(i);
+ foundSameName = child != &item
+ && QString::compare(child->name(), item.name(), Qt::CaseInsensitive) == 0;
+ }
+
+ // If the name of the item is not unique, it is completed by the plugin suffix
+ return foundSameName
+ ? QString{"%1 (%2)"}.arg(name, item.data(DataSourceItem::PLUGIN_DATA_KEY).toString())
+ : name;
+}
+
QIcon itemIcon(const DataSourceItem *dataSource)
{
if (dataSource) {
@@ -92,10 +127,15 @@ QString itemTooltip(const DataSourceItem *dataSource) noexcept
} // namespace
struct DataSourceTreeWidgetItem::DataSourceTreeWidgetItemPrivate {
- explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data) : m_Data{data} {}
+ explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data)
+ : m_Data{data}, m_Name{completeName(*m_Data)}
+ {
+ }
/// Model used to retrieve data source information
const DataSourceItem *m_Data;
+ /// Name displayed
+ QString m_Name;
/// Actions associated to the item. The parent of the item (QTreeWidget) takes the ownership of
/// the actions
QList m_Actions;
@@ -151,7 +191,7 @@ QVariant DataSourceTreeWidgetItem::data(int column, int role) const
if (impl->m_Data) {
switch (column) {
case NAME_COLUMN:
- return impl->m_Data->name();
+ return impl->m_Name;
default:
// No action
break;
diff --git a/gui/src/DataSource/DataSourceWidget.cpp b/gui/src/DataSource/DataSourceWidget.cpp
index 454f76b..7934df4 100644
--- a/gui/src/DataSource/DataSourceWidget.cpp
+++ b/gui/src/DataSource/DataSourceWidget.cpp
@@ -36,7 +36,11 @@ DataSourceTreeWidgetItem *createTreeWidgetItem(DataSourceItem *dataSource)
} // namespace
-DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::DataSourceWidget}
+DataSourceWidget::DataSourceWidget(QWidget *parent)
+ : QWidget{parent},
+ ui{new Ui::DataSourceWidget},
+ m_Root{
+ std::make_unique(DataSourceItemType::NODE, QStringLiteral("Sources"))}
{
ui->setupUi(this);
@@ -51,6 +55,9 @@ DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui
// Connection to filter tree
connect(ui->filterLineEdit, &QLineEdit::textChanged, this, &DataSourceWidget::filterChanged);
+
+ // First init
+ updateTreeWidget();
}
DataSourceWidget::~DataSourceWidget() noexcept
@@ -60,13 +67,29 @@ DataSourceWidget::~DataSourceWidget() noexcept
void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
{
- // Creates the item associated to the source and adds it to the tree widget. The tree widget
- // takes the ownership of the item
+ // Merges the data source (without taking its root)
if (dataSource) {
- ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
+ for (auto i = 0, count = dataSource->childCount(); i < count; ++i) {
+ m_Root->merge(*dataSource->child(i));
+ }
+
+ updateTreeWidget();
}
}
+void DataSourceWidget::updateTreeWidget() noexcept
+{
+ ui->treeWidget->clear();
+
+ auto rootItem = createTreeWidgetItem(m_Root.get());
+ ui->treeWidget->addTopLevelItem(rootItem);
+ rootItem->setExpanded(true);
+
+ // Sorts tree
+ ui->treeWidget->setSortingEnabled(true);
+ ui->treeWidget->sortByColumn(0, Qt::AscendingOrder);
+}
+
void DataSourceWidget::filterChanged(const QString &text) noexcept
{
auto validateItem = [&text](const DataSourceTreeWidgetItem &item) {
diff --git a/gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp b/gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp
index 7d47047..bb70482 100644
--- a/gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp
+++ b/gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp
@@ -223,7 +223,7 @@ VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(
void VisualizationGraphRenderingDelegate::onMouseDoubleClick(QMouseEvent *event) noexcept
{
// Opens color scale editor if color scale is double clicked
- auto colorScale = dynamic_cast(impl->m_Plot.layoutElementAt(event->pos()));
+ auto colorScale = static_cast(impl->m_Plot.layoutElementAt(event->pos()));
if (impl->m_ColorScale.m_Scale == colorScale) {
if (ColorScaleEditor{impl->m_ColorScale}.exec() == QDialog::Accepted) {
impl->m_Plot.replot();
diff --git a/plugins/amda/src/AmdaPlugin.cpp b/plugins/amda/src/AmdaPlugin.cpp
index 5ce9064..0a033a9 100644
--- a/plugins/amda/src/AmdaPlugin.cpp
+++ b/plugins/amda/src/AmdaPlugin.cpp
@@ -31,11 +31,14 @@ void associateActions(DataSourceItem &item, const QUuid &dataSourceUid)
};
const auto itemType = item.type();
- if (itemType == DataSourceItemType::PRODUCT) {
- addLoadAction(QObject::tr("Load %1 product").arg(item.name()));
- }
- else if (itemType == DataSourceItemType::COMPONENT) {
- addLoadAction(QObject::tr("Load %1 component").arg(item.name()));
+ if (itemType == DataSourceItemType::PRODUCT || itemType == DataSourceItemType::COMPONENT) {
+ // Adds plugin name to item metadata
+ item.setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
+
+ // Adds load action
+ auto actionLabel = QObject::tr(
+ itemType == DataSourceItemType::PRODUCT ? "Load %1 product" : "Load %1 component");
+ addLoadAction(actionLabel.arg(item.name()));
}
auto count = item.childCount();
diff --git a/plugins/mockplugin/src/MockPlugin.cpp b/plugins/mockplugin/src/MockPlugin.cpp
index 734200b..88e7e0a 100644
--- a/plugins/mockplugin/src/MockPlugin.cpp
+++ b/plugins/mockplugin/src/MockPlugin.cpp
@@ -25,6 +25,10 @@ std::unique_ptr createProductItem(const QVariantHash &data,
const QUuid &dataSourceUid)
{
auto result = std::make_unique(DataSourceItemType::PRODUCT, data);
+
+ // Adds plugin name to product metadata
+ result->setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
+
auto productName = data.value(DataSourceItem::NAME_DATA_KEY).toString();
// Add action to load product from DataSourceController
@@ -44,7 +48,7 @@ std::unique_ptr createDataSourceItem(const QUuid &dataSourceUid)
{
// Magnetic field products
auto magneticFieldFolder = std::make_unique(DataSourceItemType::NODE,
- QStringLiteral("Magnetic field"));
+ QStringLiteral("_Magnetic field"));
magneticFieldFolder->appendChild(
createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 10 Hz")},
{COSINUS_TYPE_KEY, "scalar"},
@@ -83,7 +87,7 @@ std::unique_ptr createDataSourceItem(const QUuid &dataSourceUid)
// Electric field products
auto electricFieldFolder = std::make_unique(DataSourceItemType::NODE,
- QStringLiteral("Electric field"));
+ QStringLiteral("_Electric field"));
// Root
auto root = std::make_unique(DataSourceItemType::NODE, DATA_SOURCE_NAME);