TreeModel.cpp

Go to the documentation of this file.

 
#include "Base/TreeModel.h"
 
#include <QModelIndex>
#include <QStringList>
#include <QVariant>
 
#include "Base/TreeItem.h"
 
TreeModel::TreeModel(QObject* parent) : QAbstractItemModel(parent)
{
    //_modelType = TREE_MODEL;
    QList<QVariant> rootData;
    rootData << "1"
             << "2"
             << "3";
    _rootItem = new TreeItem(rootData, nullptr);
    // setupModelData(data, _rootItem);
}
 
TreeModel::~TreeModel()
{
    delete _rootItem;
}
 
QModelIndex TreeModel::index(int row, int column,
                             const QModelIndex& parent) const
{
    if (!hasIndex(row, column, parent))
    {
        return QModelIndex();
    }
 
    TreeItem* parentItem;
 
    if (!parent.isValid())
    {
        parentItem = _rootItem;
    }
    else
    {
        parentItem = static_cast<TreeItem*>(parent.internalPointer());
    }
 
    TreeItem* childItem = parentItem->child(row);
    if (childItem)
    {
        return createIndex(row, column, childItem);
    }
 
    return QModelIndex();
}
 
QModelIndex TreeModel::parent(const QModelIndex& index) const
{
    if (!index.isValid())
    {
        return QModelIndex();
    }
 
    auto* childItem = static_cast<TreeItem*>(index.internalPointer());
    TreeItem* parentItem = childItem->parentItem();
 
    if (parentItem == _rootItem)
    {
        return QModelIndex();
    }
 
    return createIndex(parentItem->row(), 0, parentItem);
}
 
int TreeModel::rowCount(const QModelIndex& parent) const
{
    TreeItem* parentItem;
    if (parent.column() > 0)
    {
        return 0;
    }
 
    if (!parent.isValid())
    {
        parentItem = _rootItem;
    }
    else
    {
        parentItem = static_cast<TreeItem*>(parent.internalPointer());
    }
 
    return parentItem->childCount();
}
 
int TreeModel::columnCount(const QModelIndex& parent) const
{
    if (parent.isValid())
    {
        return static_cast<TreeItem*>(parent.internalPointer())->columnCount();
    }
 
    return _rootItem->columnCount();
}
 
void TreeModel::updateData() {}
QVariant TreeModel::data(const QModelIndex& index, int role) const
{
    if (!index.isValid())
    {
        return QVariant();
    }
 
    if (role == Qt::EditRole || role == Qt::DisplayRole)
    {
        auto* item = static_cast<TreeItem*>(index.internalPointer());
 
        return item->data(index.column());
    }
 
    return QVariant();
}
 
bool TreeModel::setData(const QModelIndex& index, const QVariant& value,
                        int role /* = Qt::EditRole */)
{
    if (!index.isValid())
    {
        return false;
    }
 
    if (role == Qt::EditRole)
    {
        auto* item = static_cast<TreeItem*>(index.internalPointer());
        item->setData(index.column(), value);
        return true;
    }
    return false;
}
Qt::ItemFlags TreeModel::flags(const QModelIndex& index) const
{
    if (!index.isValid())
    {
        return Qt::NoItemFlags;
    }
 
    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
 
TreeItem* TreeModel::getItem(const QModelIndex& index) const
{
    if (index.isValid())
    {
        auto* item = static_cast<TreeItem*>(index.internalPointer());
        if (item)
        {
            return item;
        }
    }
    return _rootItem;
}
 
QVariant TreeModel::headerData(int section, Qt::Orientation orientation,
                               int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
    {
        return _rootItem->data(section);
    }
 
    return QVariant();
}
 
bool TreeModel::removeRows(int position, int count, const QModelIndex& parent)
{
    TreeItem* parentItem = getItem(parent);
    bool success = true;
 
    beginRemoveRows(parent, position, position + count - 1);
    success = parentItem->removeChildren(position, count);
    endRemoveRows();
 
    return success;
}
 
void TreeModel::setupModelData(const QStringList& lines, TreeItem* parent)
{
    QList<TreeItem*> parents;
    QList<int> indentations;
    parents << parent;
    indentations << 0;
 
    int number = 0;
 
    while (number < lines.count())
    {
        int position = 0;
        while (position < lines[number].length())
        {
            if (lines[number].mid(position, 1) != " ")
            {
                break;
            }
            position++;
        }
 
        QString lineData = lines[number].mid(position).trimmed();
 
        if (!lineData.isEmpty())
        {
            // Read the column data from the rest of the line.
            QStringList columnStrings =
                lineData.split("\t", Qt::SkipEmptyParts);
            QList<QVariant> columnData;
            for (int column = 0; column < columnStrings.count(); ++column)
            {
                columnData << columnStrings[column];
            }
 
            if (position > indentations.last())
            {
                // The last child of the current parent is now the new parent
                // unless the current parent has no children.
 
                if (parents.last()->childCount() > 0)
                {
                    parents << parents.last()->child(
                        parents.last()->childCount() - 1);
                    indentations << position;
                }
            }
            else
            {
                while (position < indentations.last() && parents.count() > 0)
                {
                    parents.pop_back();
                    indentations.pop_back();
                }
            }
 
            // Append a new item to the current parent's list of children.
            parents.last()->appendChild(
                new TreeItem(columnData, parents.last()));
        }
 
        number++;
    }
}
 
TreeItem* TreeModel::rootItem() const
{
    return _rootItem;
}