HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r345:7128846c289b

Changes data source item icons (2)...

Alexandre Leroux -

r345:7128846c289b

parent child

Context file:

r345:7128846c289b

Collapse all files

gui/resources/icones/dataSourceRoot.png created 644 binary 0 0

	1	NO CONTENT: new file 100644, binary diff hidden			NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

core/include/DataSource/DataSourceItem.h +2 0

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
             class DataSourceItem {
             public:
                 /// Key associated with the name of the item
                 static const QString NAME_DATA_KEY;
                 explicit DataSourceItem(DataSourceItemType type, const QString &name);
                 explicit DataSourceItem(DataSourceItemType type, QHash<QString, QVariant> data = {});
                 /// @return the actions of the item as a vector
                 QVector<DataSourceItemAction *> actions() const noexcept;
                 /**
                  * Adds an action to the item. The item takes ownership of the action, and the action is
                  * automatically associated to the item
                  * @param action the action to add
                  */
                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to a key
                  * @param key the key to search
                  * @return the data found if key is valid, default QVariant otherwise
                  */
                 QVariant data(const QString &key) const noexcept;
+                bool isRoot() const noexcept;
                 QString name() const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
                 DataSourceItemType type() const noexcept;
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/src/DataSource/DataSourceItem.cpp +5 0

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <QVector>
             const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
             struct DataSourceItem::DataSourceItemPrivate {
                 explicit DataSourceItemPrivate(DataSourceItemType type, QHash<QString, QVariant> data)
                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                 DataSourceItemType m_Type;
                 QHash<QString, QVariant> m_Data;
                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
             DataSourceItem::DataSourceItem(DataSourceItemType type, const QString &name)
                     : DataSourceItem{type, QHash<QString, QVariant>{{NAME_DATA_KEY, name}}}
             {
             }
             DataSourceItem::DataSourceItem(DataSourceItemType type, QHash<QString, QVariant> data)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
             {
                 auto result = QVector<DataSourceItemAction *>{};
                 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
                                std::back_inserter(result), [](const auto &action) { return action.get(); });
                 return result;
             }
             void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
             {
                 action->setDataSourceItem(this);
                 impl->m_Actions.push_back(std::move(action));
             }
             void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
             {
                 child->impl->m_Parent = this;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
             QVariant DataSourceItem::data(const QString &key) const noexcept
             {
                 return impl->m_Data.value(key);
             }
+            bool DataSourceItem::isRoot() const noexcept
+            {
+                return impl->m_Parent == nullptr;
+            }
             QString DataSourceItem::name() const noexcept
             {
                 return data(NAME_DATA_KEY).toString();
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }

gui/resources/sqpguiresources.qrc +1 0

             <RCC>
                 <qresource prefix="/">
             		<file>icones/dataSourceComponent.png</file>
             		<file>icones/dataSourceNode.png</file>
             		<file>icones/dataSourceProduct.png</file>
+            		<file>icones/dataSourceRoot.png</file>
             		<file>icones/delete.png</file>
                     <file>icones/openInspector.png</file>
                     <file>icones/next.png</file>
                     <file>icones/plot.png</file>
                     <file>icones/previous.png</file>
                     <file>icones/unplot.png</file>
                 </qresource>
             </RCC>

gui/src/DataSource/DataSourceTreeWidgetItem.cpp +5 -3

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             #include <QAction>
             Q_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem, "DataSourceTreeWidgetItem")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             QIcon itemIcon(const DataSourceItem *dataSource)
             {
                 if (dataSource) {
                     auto dataSourceType = dataSource->type();
                     switch (dataSourceType) {
-                        case DataSourceItemType::NODE:
+                        case DataSourceItemType::NODE: {
-                            return QIcon{":/icones/dataSourceNode.png"};
+                            return dataSource->isRoot() ? QIcon{":/icones/dataSourceRoot.png"}
+                                                        : QIcon{":/icones/dataSourceNode.png"};
+                        }
                         case DataSourceItemType::PRODUCT:
                             return QIcon{":/icones/dataSourceProduct.png"};
                         case DataSourceItemType::COMPONENT:
                             return QIcon{":/icones/dataSourceComponent.png"};
                         default:
                             // No action
                             break;
                     }
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : unknown data source type");
                 }
                 else {
-                    qCWarning(LOG_DataSourceTreeWidgetItem())
+                    qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : the data source is null");
                 }
                 // Default cases
                 return QIcon{};
             }
             } // namespace
             struct DataSourceTreeWidgetItem::DataSourceTreeWidgetItemPrivate {
                 explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data) : m_Data{data} {}
                 /// Model used to retrieve data source information
                 const DataSourceItem *m_Data;
                 /// Actions associated to the item. The parent of the item (QTreeWidget) takes the ownership of
                 /// the actions
                 QList<QAction *> m_Actions;
             };
             DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(const DataSourceItem *data, int type)
                     : DataSourceTreeWidgetItem{nullptr, data, type}
             {
             }
             DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(QTreeWidget *parent, const DataSourceItem *data,
                                                                int type)
                     : QTreeWidgetItem{parent, type},
                       impl{spimpl::make_unique_impl<DataSourceTreeWidgetItemPrivate>(data)}
             {
                 // Sets the icon depending on the data source
                 setIcon(0, itemIcon(impl->m_Data));
                 // Generates tree actions based on the item actions
                 auto createTreeAction = [this, &parent](const auto &itemAction) {
                     auto treeAction = new QAction{itemAction->name(), parent};
                     // Executes item action when tree action is triggered
                     QObject::connect(treeAction, &QAction::triggered, itemAction,
                                      &DataSourceItemAction::execute);
                     return treeAction;
                 };
                 auto itemActions = impl->m_Data->actions();
                 std::transform(std::cbegin(itemActions), std::cend(itemActions),
                                std::back_inserter(impl->m_Actions), createTreeAction);
             }
             QVariant DataSourceTreeWidgetItem::data(int column, int role) const
             {
                 if (role == Qt::DisplayRole) {
                     if (impl->m_Data) {
                         switch (column) {
                             case NAME_COLUMN:
                                 return impl->m_Data->name();
                             default:
                                 // No action
                                 break;
                         }
                         qCWarning(LOG_DataSourceTreeWidgetItem())
                             << QObject::tr("Can't get data (unknown column %1)").arg(column);
                     }
                     else {
                         qCCritical(LOG_DataSourceTreeWidgetItem()) << QObject::tr("Can't get data (null item)");
                     }
                     return QVariant{};
                 }
                 else {
                     return QTreeWidgetItem::data(column, role);
                 }
             }
             void DataSourceTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 // Data can't be changed by edition
                 if (role != Qt::EditRole) {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
             QList<QAction *> DataSourceTreeWidgetItem::actions() const noexcept
             {
                 return impl->m_Actions;
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages