openrw/rwviewer/models/DFFFramesTreeModel.cpp

#include "DFFFramesTreeModel.hpp"
#include <data/Clump.hpp>
#include <data/Skeleton.hpp>

DFFFramesTreeModel::DFFFramesTreeModel(Clump* m, Skeleton* skel,
                                       QObject* parent)
    : QAbstractItemModel(parent), model(m), skeleton(skel) {
}

int DFFFramesTreeModel::columnCount(const QModelIndex& parent) const {
    return 1;
}

int DFFFramesTreeModel::rowCount(const QModelIndex& parent) const {
    ModelFrame* f = static_cast<ModelFrame*>(parent.internalPointer());
    if (f) {
        return f->getChildren().size();
    }

    if (parent.row() == -1) {
        return 1;
    }

    return 0;
}

QModelIndex DFFFramesTreeModel::index(int row, int column,
                                      const QModelIndex& parent) const {
    if (parent.row() == -1 && parent.column() == -1) {
        return createIndex(row, column, model->frames[model->rootFrameIdx]);
    }
    ModelFrame* f = static_cast<ModelFrame*>(parent.internalPointer());
    ModelFrame* p = f->getChildren()[row];
    return createIndex(row, column, p);
}

QModelIndex DFFFramesTreeModel::parent(const QModelIndex& child) const {
    ModelFrame* c = static_cast<ModelFrame*>(child.internalPointer());
    if (c->getParent()) {
        auto cp = c->getParent();
        if (cp->getParent()) {
            for (size_t i = 0; i < cp->getParent()->getChildren().size(); ++i) {
                if (cp->getParent()->getChildren()[i] == c->getParent()) {
                    return createIndex(i, 0, c->getParent());
                }
            }
        } else {
            return createIndex(0, 0, cp);
        }
    }
    return QModelIndex();
}

QVariant DFFFramesTreeModel::data(const QModelIndex& index, int role) const {
    ModelFrame* f = static_cast<ModelFrame*>(index.internalPointer());
    if (role == Qt::DisplayRole) {
        if (index.column() == 0) {
            return QString(f->getName().c_str());
        }
    } else if (role == Qt::CheckStateRole) {
        if (index.column() == 0) {
            if (skeleton) {
                return skeleton->getData(f->getIndex()).enabled ? Qt::Checked
                                                                : Qt::Unchecked;
            }
        }
    }
    return QVariant();
}

bool DFFFramesTreeModel::setData(const QModelIndex& index,
                                 const QVariant& value, int role) {
    if (!index.isValid()) {
        return false;
    }

    ModelFrame* f = static_cast<ModelFrame*>(index.internalPointer());

    if (role == Qt::CheckStateRole) {
        if (index.column() == 0 && skeleton) {
            if ((Qt::CheckState)value.toInt() == Qt::Checked) {
                skeleton->setEnabled(f, true);
            } else {
                skeleton->setEnabled(f, false);
            }
            return true;
        }
    }

    return false;
}

Qt::ItemFlags DFFFramesTreeModel::flags(const QModelIndex& index) const {
    if (!index.isValid()) {
        return 0;
    }

    Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;

    if (index.column() == 0 && skeleton) {
        flags |= Qt::ItemIsUserCheckable;
    }

    return flags;
}

QVariant DFFFramesTreeModel::headerData(int section,
                                        Qt::Orientation orientation,
                                        int role) const {
    if (orientation == Qt::Horizontal) {
        if (role == Qt::DisplayRole) {
            return "Name";
        }
    }
    return QVariant();
}