|
|
#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;
|
|
|
|
|
|
/**
|
|
|
* 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) {
|
|
|
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}, 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<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 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);
|
|
|
|
|
|
// Sets the flags of the items
|
|
|
auto flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
|
|
|
if (data->type() == DataSourceItemType::COMPONENT
|
|
|
|| data->type() == DataSourceItemType::PRODUCT) {
|
|
|
flags |= Qt::ItemIsDragEnabled;
|
|
|
}
|
|
|
|
|
|
setFlags(flags);
|
|
|
}
|
|
|
|
|
|
const DataSourceItem *DataSourceTreeWidgetItem::data() const
|
|
|
{
|
|
|
return impl->m_Data;
|
|
|
}
|
|
|
|
|
|
QVariant DataSourceTreeWidgetItem::data(int column, int role) const
|
|
|
{
|
|
|
if (role == Qt::DisplayRole) {
|
|
|
if (impl->m_Data) {
|
|
|
switch (column) {
|
|
|
case NAME_COLUMN:
|
|
|
return impl->m_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;
|
|
|
}
|
|
|
|
