GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r319:4b46cbe03729

Handles tooltip for a data source item

Alexandre Leroux -

r319:4b46cbe03729

parent child

Context file:

r319:4b46cbe03729

Collapse all files

core/include/DataSource/DataSourceItem.h +3 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;
+                /// Gets all data
+                const QHash<QString, QVariant> &data() 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);
             }
+            const QHash<QString, QVariant> &DataSourceItem::data() const noexcept
+            {
+                return impl->m_Data;
+            }
             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/src/DataSource/DataSourceTreeWidgetItem.cpp +50 -1

             #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: {
                             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 {
                     qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : the data source is null");
                 }
                 // Default cases
                 return QIcon{};
             }
+            /// @return the tooltip text for a variant. The text depends on whether the data is a simple variant
+            /// or a list of variants
+            QString tooltipValue(const QVariant &variant) noexcept
+            {
+                // If the variant is a list of variants, the text of the tooltip is of the form: {val1, val2,
+                // ...}
+                if (variant.canConvert<QVariantList>()) {
+                    auto valueString = QStringLiteral("{");
+                    auto variantList = variant.value<QVariantList>();
+                    for (auto it = variantList.cbegin(), end = variantList.cend(); it != end; ++it) {
+                        valueString.append(it->toString());
+                        if (std::distance(it, end) != 1) {
+                            valueString.append(", ");
+                        }
+                    }
+                    valueString.append(QStringLiteral("}"));
+                    return valueString;
+                }
+                else {
+                    return variant.toString();
+                }
+            }
+            QString itemTooltip(const DataSourceItem *dataSource) noexcept
+            {
+                // The tooltip displays all item's data
+                if (dataSource) {
+                    auto result = QString{};
+                    const auto &data = dataSource->data();
+                    for (auto it = data.cbegin(), end = data.cend(); it != end; ++it) {
+                        result.append(QString{"<b>%1:</b> %2<br/>"}.arg(it.key(), tooltipValue(it.value())));
+                    }
+                    return result;
+                }
+                else {
+                    qCCritical(LOG_DataSourceTreeWidgetItem())
+                        << QObject::tr("Can't set data source tooltip : the data source is null");
+                    return QString{};
+                }
+            }
             } // 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
+                // Sets the icon and the tooltip depending on the data source
                 setIcon(0, itemIcon(impl->m_Data));
+                setToolTip(0, itemTooltip(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