jsontreemodel.cpp

Go to the documentation of this file.

#include <QtGui>
#include <list>
#include "jsontreemodel.h"
 
using nlohmann::json;
using namespace nlohmann::detail;
 
JsonTreeModel::JsonTreeModel(const QStringList &headers, const nlohmann::json &data,
                     QObject *parent)
    : QAbstractItemModel(parent)
{
    QVector<QVariant> rootData;
    foreach (QString header, headers)
        rootData << header;
 
    rootItem = new JsonTreeItem(rootData);
    setupModelData(data, rootItem);
}
 
JsonTreeModel::~JsonTreeModel()
{
    delete rootItem;
}
 
int JsonTreeModel::columnCount(const QModelIndex & /* parent */) const
{
    return rootItem->columnCount();
}
 
QVariant JsonTreeModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid())
        return QVariant();
 
    if (role != Qt::DisplayRole && role != Qt::EditRole)
        return QVariant();
 
    JsonTreeItem *item = getItem(index);
 
    return item->data(index.column());
}
 
Qt::ItemFlags JsonTreeModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return 0;
 
    return Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
 
JsonTreeItem *JsonTreeModel::getItem(const QModelIndex &index) const
{
    if (index.isValid()) {
        JsonTreeItem *item = static_cast<JsonTreeItem*>(index.internalPointer());
        if (item) return item;
    }
    return rootItem;
}
 
QVariant JsonTreeModel::headerData(int section, Qt::Orientation orientation,
                               int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
        return rootItem->data(section);
 
    return QVariant();
}
 
QModelIndex JsonTreeModel::index(int row, int column, const QModelIndex &parent) const
{
    if (parent.isValid() && parent.column() != 0)
        return QModelIndex();
 
    JsonTreeItem *parentItem = getItem(parent);
 
    JsonTreeItem *childItem = parentItem->child(row);
    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
 
bool JsonTreeModel::insertColumns(int position, int columns, const QModelIndex &parent)
{
    bool success;
 
    beginInsertColumns(parent, position, position + columns - 1);
    success = rootItem->insertColumns(position, columns);
    endInsertColumns();
 
    return success;
}
 
bool JsonTreeModel::insertRows(int position, int rows, const QModelIndex &parent)
{
    JsonTreeItem *parentItem = getItem(parent);
    bool success;
 
    beginInsertRows(parent, position, position + rows - 1);
    success = parentItem->insertChildren(position, rows, rootItem->columnCount());
    endInsertRows();
 
    return success;
}
 
QModelIndex JsonTreeModel::parent(const QModelIndex &index) const
{
    if (!index.isValid())
        return QModelIndex();
 
    JsonTreeItem *childItem = getItem(index);
    JsonTreeItem *parentItem = childItem->parent();
 
    if (parentItem == rootItem)
        return QModelIndex();
 
    return createIndex(parentItem->childNumber(), 0, parentItem);
}
 
bool JsonTreeModel::removeColumns(int position, int columns, const QModelIndex &parent)
{
    bool success;
 
    beginRemoveColumns(parent, position, position + columns - 1);
    success = rootItem->removeColumns(position, columns);
    endRemoveColumns();
 
    if (rootItem->columnCount() == 0)
        removeRows(0, rowCount());
 
    return success;
}
 
bool JsonTreeModel::removeRows(int position, int rows, const QModelIndex &parent)
{
    JsonTreeItem *parentItem = getItem(parent);
    bool success = true;
 
    beginRemoveRows(parent, position, position + rows - 1);
    success = parentItem->removeChildren(position, rows);
    endRemoveRows();
 
    return success;
}
 
int JsonTreeModel::rowCount(const QModelIndex &parent) const
{
    JsonTreeItem *parentItem = getItem(parent);
 
    return parentItem->childCount();
}
 
bool JsonTreeModel::setData(const QModelIndex &index, const QVariant &value,
                        int role)
{
    if (role != Qt::EditRole)
        return false;
 
    JsonTreeItem *item = getItem(index);
    bool result = item->setData(index.column(), value);
 
    if (result)
        emit dataChanged(index, index);
 
    return result;
}
 
bool JsonTreeModel::setHeaderData(int section, Qt::Orientation orientation,
                              const QVariant &value, int role)
{
    if (role != Qt::EditRole || orientation != Qt::Horizontal)
        return false;
 
    bool result = rootItem->setData(section, value);
 
    if (result)
        emit headerDataChanged(orientation, section, section);
 
    return result;
}
 
void JsonTreeModel::setupModelData(const nlohmann::json &lines, JsonTreeItem *parent)
{
    nlohmann::json* data = (nlohmann::json*)&lines;
    //QList<JsonTreeItem*> parents;
    QVector<QVariant> columnData;
    //parents << parent;
 
    /*
    JsonTreeItem *parent1 = parents.last();
    parent1->insertChildren(parent1->childCount(), 1, 2);
    parent1->child(parent1->childCount() - 1)->setData(0, QVariant(tr("A")));
    parent1->child(parent1->childCount() - 1)->setData(1, QVariant(tr("fdsfs")));
 
    JsonTreeItem *parent2 = parents.last()->child(0);
    parent2->insertChildren(parent2->childCount(), 1, 2);
    parent2->child(parent2->childCount() - 1)->setData(0, QVariant(tr("B")));
    parent2->child(parent2->childCount() - 1)->setData(1, QVariant(tr("fdsfs")));
    */
 
    int len = data->size();
    nlohmann::json::iterator dataIt = data->begin();
 
    for (int i = 0; i < len; i++)
    {
        std::string keyStr;
        auto key = dataIt.key();
        auto vType = data->type();
        QVariant keyIndex, keyData, keyType;
        if (vType == value_t::array )
        {
            QString arrayIndex("");
            arrayIndex.append(QString().sprintf("%i", i));
            keyIndex = QVariant(arrayIndex);
            keyData = QVariant(tr(dataIt->dump().c_str()));
            keyType = QVariant(getTypeString(dataIt.value().type()));
        }
        else
        {
            // key = data->at(i);
            keyIndex = QVariant(tr(key.c_str()));
            if (dataIt.value().type() != value_t::object ) {
                keyData = QVariant(tr(dataIt->dump().c_str()));
            }
            else {
                keyData = QVariant("");
            }
            keyType = QVariant(getTypeString(dataIt.value().type()));
        }
 
        columnData.clear();
        columnData.push_back(keyIndex);
        columnData.push_back(keyData);
        columnData.push_back(keyType);
 
        JsonTreeItem *parent1 = parent;
        parent1->insertChildren(parent1->childCount(), 1, rootItem->columnCount());
        for (int column = 0; column < columnData.size(); ++column)
            parent1->child(parent1->childCount() - 1)->setData(column, columnData[column]);
 
        if (data->type() == value_t::array)
        {
            if (dataIt.value().type() == value_t::array || dataIt.value().type() == value_t::object)
            {
                setupModelData(dataIt.value(), parent1->child(parent1->childCount() - 1));
            }
        }
        else
        {
            if (dataIt.value().type() == value_t::array || dataIt.value().type() == value_t::object)
            {
                setupModelData(dataIt.value(), parent1->child(parent1->childCount() - 1));
            }
        }
 
        dataIt++;
    }
}
 
JsonTreeItem *JsonTreeModel::getRootItem()
{
    return rootItem;
}
 
QString JsonTreeModel::getTypeString(value_t vType)
{
    QString typeString;
    switch (vType)
    {
    case value_t::array:
        typeString = tr("array");
        break;
    case value_t::boolean:
        typeString = tr("boolean");
        break;
    case value_t::number_integer:
        typeString = tr("integer");
        break;
    case value_t::null:
        typeString = tr("null");
        break;
    case value_t::object:
        typeString = tr("object");
        break;
    case value_t::number_float:
        typeString = tr("double");
        break;
    case value_t::string:
        typeString = tr("string");
        break;
    case value_t::number_unsigned:
        typeString = tr("unsigned integer");
        break;
    defalut:
        typeString = tr("type error");
    }
    return typeString;
}