SessionModel.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Model/SessionModel.cpp
//! @brief     Implements class SessionModel
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Model/SessionModel.h"
#include "GUI/Model/BaseItem/SessionItem.h"
#include "GUI/Model/MakeItem/ItemFactory.h"
#include "GUI/Model/Model/SessionXML.h"
#include "GUI/Model/Sample/MaterialItem.h"
#include "GUI/Support/Data/SessionFlags.h"
#include "GUI/Support/Data/SessionItemTags.h"
#include "GUI/Util/Error.h"
#include "GUI/Util/Path.h"
#include <QColor>
#include <QFile>
#include <QMimeData>
#include <QXmlStreamWriter>
#include <utility>
 
namespace {
 
const int MaxCompression = 9;
 
//! Returns tooltip for given item.
QVariant toolTipRole(const SessionItem& item, int ncol)
{
    QString result = item.toolTip();
    if (result.isEmpty()) {
        result = item.displayName();
        if (ncol == 1 && item.value().canConvert<QString>())
            result = item.value().toString();
    }
 
    return QVariant(result);
}
 
} // namespace
 
SessionModel::SessionModel(QString model_tag, QObject* parent)
    : QAbstractItemModel(parent)
    , m_model_tag(std::move(model_tag))
{
    createRootItem();
}
 
void SessionModel::createRootItem()
{
    m_root_item = new SessionItem("ROOT_ITEM");
    m_root_item->setModel(this);
    m_root_item->registerTag("rootTag");
    m_root_item->setDefaultTag("rootTag");
}
 
SessionModel::~SessionModel()
{
    delete m_root_item;
}
 
// TODO make it relying on SessionItem::flags
 
Qt::ItemFlags SessionModel::flags(const QModelIndex& index) const
{
    Qt::ItemFlags result_flags = QAbstractItemModel::flags(index);
    if (index.isValid()) {
        result_flags |= Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
        SessionItem* item = itemForIndex(index);
        if (index.column() == SessionFlags::ITEM_VALUE && item->value().isValid()
            && item->isEditable() && item->isEnabled())
            result_flags |= Qt::ItemIsEditable;
        QVector<QString> acceptable_child_items = acceptableDefaultItemTypes(index);
        if (acceptable_child_items.contains(m_dragged_item_type))
            result_flags |= Qt::ItemIsDropEnabled;
    } else
        result_flags |= Qt::ItemIsDropEnabled;
    return result_flags;
}
 
QVariant SessionModel::data(const QModelIndex& index, int role) const
{
    ASSERT(m_root_item);
    if (!index.isValid() || index.column() < 0 || index.column() >= columnCount(QModelIndex()))
        return {};
    if (SessionItem* item = itemForIndex(index)) {
        if (role == Qt::DisplayRole || role == Qt::EditRole) {
            if (index.column() == SessionFlags::ITEM_VALUE)
                return item->value();
            if (index.column() == SessionFlags::ITEM_NAME)
                return item->itemName();
        } else if (role == Qt::ToolTipRole)
            return toolTipRole(*item, index.column());
        else if (role == Qt::ForegroundRole)
            return item->isEnabled() ? QVariant() : QColor(Qt::gray);
        else if (role == Qt::CheckStateRole && index.column() == SessionFlags::ITEM_VALUE) {
            if (item->value().type() == QVariant::Bool)
                return item->value().toBool() ? Qt::Checked : Qt::Unchecked;
        } else
            return item->roleProperty(role);
    }
    return {};
}
 
QVariant SessionModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation != Qt::Horizontal || role != Qt::DisplayRole)
        return {};
    switch (section) {
    case SessionFlags::ITEM_NAME:
        return "Name";
    case SessionFlags::ITEM_VALUE:
        return "Value";
    default:
        return {};
    }
}
 
int SessionModel::rowCount(const QModelIndex& parent) const
{
    if (parent.isValid() && parent.column() != 0)
        return 0;
    SessionItem* parent_item = itemForIndex(parent);
    return parent_item ? parent_item->numberOfChildren() : 0;
}
 
int SessionModel::columnCount(const QModelIndex& parent) const
{
    if (parent.isValid() && parent.column() != 0)
        return 0;
    return SessionFlags::MAX_COLUMNS;
}
 
QModelIndex SessionModel::index(int row, int column, const QModelIndex& parent) const
{
    ASSERT(m_root_item);
    if (row < 0 || column < 0 || column >= columnCount(QModelIndex())
        || (parent.isValid() && parent.column() != 0))
        return QModelIndex();
 
    SessionItem* parent_item = itemForIndex(parent);
 
    if (SessionItem* item = parent_item->childAt(row))
        return createIndex(row, column, item);
    return QModelIndex();
}
 
QModelIndex SessionModel::parent(const QModelIndex& child) const
{
    if (!child.isValid())
        return QModelIndex();
 
    if (SessionItem* child_item = itemForIndex(child)) {
        if (SessionItem* parent_item = child_item->parentItem()) {
            if (parent_item == m_root_item)
                return QModelIndex();
            return createIndex(parent_item->parentRow(), 0, parent_item);
        }
    }
    return QModelIndex();
}
 
bool SessionModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
    if (!index.isValid())
        return false;
 
    QModelIndex dataIndex = index;
    if (SessionItem* item = itemForIndex(dataIndex))
        if (item->setRoleProperty(role, value))
            return true;
 
    return false;
}
 
bool SessionModel::removeRows(int row, int count, const QModelIndex& parent)
{
    ASSERT(m_root_item);
    SessionItem* item = parent.isValid() ? itemForIndex(parent) : m_root_item;
    for (int i = 0; i < count; ++i)
        delete item->takeRow(row);
    return true;
}
 
QStringList SessionModel::mimeTypes() const
{
    return QStringList() << GUI::Session::XML::ItemMimeType;
}
 
QMimeData* SessionModel::mimeData(const QModelIndexList& indices) const
{
    if (indices.count() != 2)
        return nullptr;
 
    if (SessionItem* item = itemForIndex(indices.at(0))) {
        auto* mime_data = new QMimeData;
        QByteArray xml_data;
        QXmlStreamWriter writer(&xml_data);
        GUI::Session::XML::writeItemAndChildItems(&writer, item);
        mime_data->setData(GUI::Session::XML::ItemMimeType, qCompress(xml_data, MaxCompression));
        return mime_data;
    }
    return nullptr;
}
 
bool SessionModel::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row,
                                   int column, const QModelIndex& parent) const
{
    Q_UNUSED(row);
 
    if (action == Qt::IgnoreAction)
        return true;
    if (action != Qt::MoveAction || column > 0 || !data
        || !data->hasFormat(GUI::Session::XML::ItemMimeType))
        return false;
    if (!parent.isValid())
        return true;
    QVector<QString> acceptable_child_items = acceptableDefaultItemTypes(parent);
    QByteArray xml_data = qUncompress(data->data(GUI::Session::XML::ItemMimeType));
    QXmlStreamReader reader(xml_data);
    while (!reader.atEnd()) {
        reader.readNext();
        if (reader.isStartElement()) {
            if (reader.name() == GUI::Session::XML::ItemTag) {
                const QString model_type =
                    reader.attributes().value(GUI::Session::XML::ModelTypeAttribute).toString();
                return acceptable_child_items.contains(model_type);
            }
        }
    }
    return false;
}
 
bool SessionModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column,
                                const QModelIndex& parent)
{
    if (action == Qt::IgnoreAction)
        return true;
    if (action != Qt::MoveAction || column > 0 || !data
        || !data->hasFormat(GUI::Session::XML::ItemMimeType))
        return false;
    if (!canDropMimeData(data, action, row, column, parent))
        return false;
    if (SessionItem* item = itemForIndex(parent)) {
        QByteArray xml_data = qUncompress(data->data(GUI::Session::XML::ItemMimeType));
        QXmlStreamReader reader(xml_data);
        if (row == -1)
            row = item->numberOfChildren();
        beginInsertRows(parent, row, row);
        // this code block is currently not in use. The row parameter of the reader is removed
        // SessionReader::readItems(&reader, item, row);
        endInsertRows();
        return true;
    }
    return false;
}
 
QModelIndex SessionModel::indexOfItem(SessionItem* item) const
{
    if (!item || item == m_root_item || !item->parentItem())
        return QModelIndex();
    SessionItem* parent_item = item->parentItem();
    int row = parent_item->rowOfChild(item);
    return createIndex(row, 0, item);
}
 
SessionItem* SessionModel::insertNewItem(QString model_type, SessionItem* parent_item, int row,
                                         QString tag)
{
    ASSERT(m_root_item);
    if (!parent_item)
        parent_item = m_root_item;
    if (row > parent_item->numberOfChildren())
        return nullptr;
    if (parent_item != m_root_item) {
        if (tag.isEmpty())
            tag = parent_item->defaultTag();
        if (!parent_item->sessionItemTags()->isValid(tag, model_type))
            return nullptr;
    }
 
    SessionItem* new_item = GUI::Model::ItemFactory::CreateItem(model_type);
    ASSERT(new_item);
 
    parent_item->insertChild(row, new_item, tag);
 
    return new_item;
}
 
SessionItem* SessionModel::insertNewItem(QString model_type, const QModelIndex& parent_item,
                                         int row, QString tag)
{
    return insertNewItem(model_type, itemForIndex(parent_item), row, tag);
}
 
void SessionModel::removeItem(SessionItem* item)
{
    QModelIndex index = indexOfItem(item);
    if (index.isValid())
        removeRows(index.row(), 1, index.parent());
}
 
QVector<QString> SessionModel::acceptableDefaultItemTypes(const QModelIndex& parent) const
{
    QVector<QString> result;
    if (SessionItem* parent_item = itemForIndex(parent))
        result = parent_item->acceptableDefaultItemTypes();
 
    return result;
}
 
void SessionModel::clear()
{
    beginResetModel();
    delete m_root_item;
    createRootItem();
    endResetModel();
}
 
SessionItem* SessionModel::itemForIndex(const QModelIndex& index) const
{
    if (index.isValid())
        if (auto* item = static_cast<SessionItem*>(index.internalPointer()))
            return item;
 
    return m_root_item;
}
 
void SessionModel::readFrom(QXmlStreamReader* reader, MessageService* messageService)
{
    ASSERT(reader);
 
    if (reader->name() != m_model_tag)
        throw Error("SessionModel::readFrom() -> Format error in p1");
 
    beginResetModel();
    clear();
 
    GUI::Session::XML::readItems(reader, m_root_item, QString(), messageService);
    if (reader->hasError())
        throw Error(reader->errorString());
    endResetModel();
}
 
void SessionModel::writeTo(QXmlStreamWriter* writer)
{
    GUI::Session::XML::writeModel(writer, m_root_item);
}
 
//! Move given parameterized item to the new_parent at given row. If new_parent is not defined,
//! use root_item as a new parent.
 
SessionItem* SessionModel::moveItem(SessionItem* item, SessionItem* new_parent, int row,
                                    const QString& tag)
{
    if (!new_parent)
        new_parent = m_root_item;
 
    const QString tagName = tag.isEmpty() ? new_parent->defaultTag() : tag;
 
    if (!new_parent->sessionItemTags()->isValid(tagName, item->modelType()))
        return nullptr;
 
    if (item->parentItem() == new_parent) {
        // take care of indexes when moving item within same parent
        int previousIndex = item->parentItem()->getItems(tagName).indexOf(item);
        if (row == previousIndex)
            return item;
        if (previousIndex >= 0 && row > previousIndex)
            row--;
    }
 
    if (new_parent->sessionItemTags()->maximumReached(tagName)) {
        SessionItem* prev = new_parent->takeItem(0, tagName);
        m_root_item->insertChild(-1, prev);
    }
 
    // removing item from previous parent and inserting to the new one
    item->parentItem()->takeRow(item->parentItem()->rowOfChild(item));
    new_parent->insertChild(row, item, tagName);
 
    return item;
}
 
//! Copy given item to the new_parent at given row. Item intended for copying can belong to
//! another model and it will remain intact. Returns pointer to the new child.
 
SessionItem* SessionModel::copy(const SessionItem* item_to_copy, SessionItem* new_parent,
                                const QString& tag)
{
    if (!new_parent)
        new_parent = m_root_item;
 
    const QString tagName = tag.isEmpty() ? new_parent->defaultTag() : tag;
 
    QByteArray xml_data;
    QXmlStreamWriter writer(&xml_data);
    GUI::Session::XML::writeItemAndChildItems(&writer, item_to_copy);
 
    QXmlStreamReader reader(xml_data);
    GUI::Session::XML::readItems(&reader, new_parent, tagName);
 
    return new_parent->getItems(tagName).back();
}
 
void SessionModel::initFrom(SessionModel* model, SessionItem*)
{
    QByteArray byte_array;
    QXmlStreamWriter writer(&byte_array);
    writer.setAutoFormatting(true);
 
    model->writeTo(&writer);
 
    QXmlStreamReader reader(byte_array);
 
    while (!reader.atEnd()) {
        reader.readNext();
        if (reader.isStartElement())
            readFrom(&reader);
    }
}
 
SessionItem* SessionModel::rootItem() const
{
    ASSERT(m_root_item);
    return m_root_item;
}
 
QVector<SessionItem*> SessionModel::nonXMLItems() const
{
    return QVector<SessionItem*>();
}