|
|
#include "Catalogue/CatalogueTreeModel.h"
|
|
|
#include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
|
|
|
|
|
|
#include <QMimeData>
|
|
|
#include <memory>
|
|
|
|
|
|
#include <Common/MimeTypesDef.h>
|
|
|
|
|
|
struct CatalogueTreeModel::CatalogueTreeModelPrivate {
|
|
|
std::unique_ptr<CatalogueAbstractTreeItem> m_RootItem = nullptr;
|
|
|
|
|
|
CatalogueTreeModelPrivate() : m_RootItem{std::make_unique<CatalogueAbstractTreeItem>()} {}
|
|
|
};
|
|
|
|
|
|
CatalogueTreeModel::CatalogueTreeModel(QObject *parent)
|
|
|
: QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueTreeModelPrivate>()}
|
|
|
{
|
|
|
}
|
|
|
|
|
|
QModelIndex CatalogueTreeModel::addTopLevelItem(CatalogueAbstractTreeItem *item)
|
|
|
{
|
|
|
auto nbTopLevelItems = impl->m_RootItem->children().count();
|
|
|
beginInsertRows(QModelIndex(), nbTopLevelItems, nbTopLevelItems);
|
|
|
impl->m_RootItem->addChild(item);
|
|
|
endInsertRows();
|
|
|
|
|
|
emit dataChanged(QModelIndex(), QModelIndex());
|
|
|
|
|
|
return index(nbTopLevelItems, 0);
|
|
|
}
|
|
|
|
|
|
QVector<CatalogueAbstractTreeItem *> CatalogueTreeModel::topLevelItems() const
|
|
|
{
|
|
|
return impl->m_RootItem->children();
|
|
|
}
|
|
|
|
|
|
void CatalogueTreeModel::addChildItem(CatalogueAbstractTreeItem *child,
|
|
|
const QModelIndex &parentIndex)
|
|
|
{
|
|
|
auto parentItem = item(parentIndex);
|
|
|
int c = parentItem->children().count();
|
|
|
beginInsertRows(parentIndex, c, c);
|
|
|
parentItem->addChild(child);
|
|
|
endInsertRows();
|
|
|
|
|
|
emit dataChanged(parentIndex, parentIndex);
|
|
|
}
|
|
|
|
|
|
CatalogueAbstractTreeItem *CatalogueTreeModel::item(const QModelIndex &index) const
|
|
|
{
|
|
|
return static_cast<CatalogueAbstractTreeItem *>(index.internalPointer());
|
|
|
}
|
|
|
|
|
|
QModelIndex CatalogueTreeModel::indexOf(CatalogueAbstractTreeItem *item, int column) const
|
|
|
{
|
|
|
auto parentItem = item->parent();
|
|
|
if (!parentItem) {
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
auto row = parentItem->children().indexOf(item);
|
|
|
return createIndex(row, column, item);
|
|
|
}
|
|
|
|
|
|
QModelIndex CatalogueTreeModel::index(int row, int column, const QModelIndex &parent) const
|
|
|
{
|
|
|
if (column > 0) {
|
|
|
int a = 0;
|
|
|
}
|
|
|
|
|
|
if (!hasIndex(row, column, parent)) {
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
CatalogueAbstractTreeItem *parentItem = nullptr;
|
|
|
|
|
|
if (!parent.isValid()) {
|
|
|
parentItem = impl->m_RootItem.get();
|
|
|
}
|
|
|
else {
|
|
|
parentItem = item(parent);
|
|
|
}
|
|
|
|
|
|
auto childItem = parentItem->children().value(row);
|
|
|
if (childItem) {
|
|
|
return createIndex(row, column, childItem);
|
|
|
}
|
|
|
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
|
|
|
QModelIndex CatalogueTreeModel::parent(const QModelIndex &index) const
|
|
|
{
|
|
|
if (!index.isValid()) {
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
auto childItem = item(index);
|
|
|
auto parentItem = childItem->parent();
|
|
|
|
|
|
if (parentItem == nullptr || parentItem->parent() == nullptr) {
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
auto row = parentItem->parent()->children().indexOf(parentItem);
|
|
|
return createIndex(row, 0, parentItem);
|
|
|
}
|
|
|
|
|
|
int CatalogueTreeModel::rowCount(const QModelIndex &parent) const
|
|
|
{
|
|
|
CatalogueAbstractTreeItem *parentItem = nullptr;
|
|
|
|
|
|
if (!parent.isValid()) {
|
|
|
parentItem = impl->m_RootItem.get();
|
|
|
}
|
|
|
else {
|
|
|
parentItem = item(parent);
|
|
|
}
|
|
|
|
|
|
return parentItem->children().count();
|
|
|
}
|
|
|
|
|
|
int CatalogueTreeModel::columnCount(const QModelIndex &parent) const
|
|
|
{
|
|
|
return (int)Column::Count;
|
|
|
}
|
|
|
|
|
|
Qt::ItemFlags CatalogueTreeModel::flags(const QModelIndex &index) const
|
|
|
{
|
|
|
auto treeItem = item(index);
|
|
|
if (treeItem) {
|
|
|
return treeItem->flags(index.column());
|
|
|
}
|
|
|
|
|
|
return Qt::NoItemFlags;
|
|
|
}
|
|
|
|
|
|
QVariant CatalogueTreeModel::data(const QModelIndex &index, int role) const
|
|
|
{
|
|
|
auto treeItem = item(index);
|
|
|
if (treeItem) {
|
|
|
return treeItem->data(index.column(), role);
|
|
|
}
|
|
|
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
bool CatalogueTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
|
|
|
{
|
|
|
auto treeItem = item(index);
|
|
|
if (treeItem) {
|
|
|
auto result = treeItem->setData(index.column(), role, value);
|
|
|
|
|
|
if (result && index.column() == (int)Column::Name) {
|
|
|
emit itemRenamed(index);
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
bool CatalogueTreeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
|
|
|
int column, const QModelIndex &parent) const
|
|
|
{
|
|
|
auto draggedIndex = parent;
|
|
|
auto draggedItem = item(draggedIndex);
|
|
|
if (draggedItem) {
|
|
|
return draggedItem->canDropMimeData(data, action);
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
bool CatalogueTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row,
|
|
|
int column, const QModelIndex &parent)
|
|
|
{
|
|
|
bool result = false;
|
|
|
|
|
|
auto draggedIndex = parent;
|
|
|
auto draggedItem = item(draggedIndex);
|
|
|
if (draggedItem) {
|
|
|
result = draggedItem->dropMimeData(data, action);
|
|
|
if (result) {
|
|
|
emit itemDropped(draggedIndex);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
Qt::DropActions CatalogueTreeModel::supportedDropActions() const
|
|
|
{
|
|
|
return Qt::CopyAction | Qt::MoveAction;
|
|
|
}
|
|
|
|
|
|
QStringList CatalogueTreeModel::mimeTypes() const
|
|
|
{
|
|
|
return {MIME_TYPE_EVENT_LIST};
|
|
|
}
|
|
|
|
