RealDataTreeModel.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Import/RealDataTreeModel.cpp
//! @brief     Implements class RealDataTreeModel
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2021
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/View/Import/RealDataTreeModel.h"
#include "GUI/Application/ApplicationSettings.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Model/RealDataModel.h"
#include <QApplication>
#include <QtCore>
#include <QtGui>
 
RealDataTreeModel::RealDataTreeModel(QObject* parent, RealDataModel* model)
    : QAbstractItemModel(parent)
    , m_model(model)
    , m_visibleRanks({1, 2})
{
    for (auto rank : m_visibleRanks)
        m_items[rank - 1] = model->realDataItems(rank);
 
    updateSubscriptions();
 
    connect(m_model, &RealDataModel::modelAboutToBeReset, this, &RealDataTreeModel::clear,
            Qt::UniqueConnection);
}
 
void RealDataTreeModel::setVisibleRanks(QSet<int> visibleRanks)
{
    if (m_visibleRanks == visibleRanks)
        return;
 
    m_visibleRanks = visibleRanks;
 
    beginResetModel();
    for (auto rank : m_visibleRanks)
        m_items[rank - 1] = m_model->realDataItems(rank);
    endResetModel();
 
    updateSubscriptions();
}
 
void RealDataTreeModel::refreshAfterModelChange()
{
    for (auto rank : m_visibleRanks) {
        if (!m_items[rank - 1].isEmpty()) {
            beginRemoveRows(indexOfHeadline(rank), 0, m_items[rank - 1].size() - 1);
            m_items[rank - 1] = m_model->realDataItems(rank);
            endRemoveRows();
        }
    }
 
    updateSubscriptions();
}
 
void RealDataTreeModel::clear()
{
    beginResetModel();
    m_items[0].clear();
    m_items[1].clear();
    endResetModel();
    updateSubscriptions();
}
 
void RealDataTreeModel::removeItem(RealDataItem* item)
{
    QModelIndex index = indexForItem(item);
    if (!index.isValid())
        return;
 
    if (item->dataLoader())
        item->dataLoader()->disconnect(this);
 
    const int rank = item->isSpecularData() ? 1 : 2;
    if (m_visibleRanks.contains(rank)) {
        const int rowOfItem = m_items[rank - 1].indexOf(item);
        beginRemoveRows(indexOfHeadline(rank), rowOfItem, rowOfItem);
        m_items[rank - 1].removeAll(item);
        m_model->remove(item);
        endRemoveRows();
    }
}
 
RealDataItem* RealDataTreeModel::insertSpecularDataItem()
{
    return insertDataItem(1);
}
 
RealDataItem* RealDataTreeModel::insertIntensityDataItem()
{
    return insertDataItem(2);
}
 
RealDataItem* RealDataTreeModel::insertDataItem(int rank)
{
    auto* newItem = m_model->insertDataItem(rank);
    if (!m_visibleRanks.contains(rank))
        return newItem;
 
    const int rowOfItem = m_model->realDataItems(rank).indexOf(newItem);
    beginInsertRows(indexOfHeadline(rank), rowOfItem, rowOfItem);
    m_items[rank - 1] = m_model->realDataItems(rank);
    endInsertRows();
    updateSubscriptions();
    return newItem;
}
 
RealDataItem* RealDataTreeModel::topMostItem() const
{
    if (!m_items[0].isEmpty() && m_visibleRanks.contains(1))
        return m_items[0].first();
    if (!m_items[1].isEmpty() && m_visibleRanks.contains(2))
        return m_items[1].first();
    return nullptr;
}
 
QModelIndex RealDataTreeModel::indexOfHeadline(int rank) const
{
    if (!m_visibleRanks.contains(rank))
        return QModelIndex();
 
    if (rank == 1)
        return createIndex(0, 0, nullptr);
 
    if (rank == 2) {
        const bool has1D = m_visibleRanks.contains(1);
        return createIndex(has1D ? 1 : 0, 0, nullptr);
    }
 
    return QModelIndex();
}
 
QModelIndex RealDataTreeModel::index(int row, int column, const QModelIndex& parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();
 
    if (!parent.isValid())
        return createIndex(row, column, nullptr);
 
    for (auto rank : m_visibleRanks)
        if (parent == indexOfHeadline(rank))
            return createIndex(row, column, m_items[rank - 1][row]);
 
    return QModelIndex();
}
 
QModelIndex RealDataTreeModel::parent(const QModelIndex& index) const
{
    if (!index.isValid())
        return QModelIndex();
 
    if (index.internalPointer() == nullptr) // index is headline => no parent
        return QModelIndex();
 
    if (itemForIndex(index)->isSpecularData())
        return indexOfHeadline(1);
 
    return indexOfHeadline(2);
}
 
int RealDataTreeModel::columnCount(const QModelIndex& /*parent*/) const
{
    return 1;
}
 
int RealDataTreeModel::rowCount(const QModelIndex& parent) const
{
    if (!parent.isValid())
        return m_visibleRanks.size();
 
    // parent is a headline
    for (int rank : m_visibleRanks)
        if (parent == indexOfHeadline(rank))
            return m_items[rank - 1].size();
 
    return 0;
}
 
QVariant RealDataTreeModel::data(const QModelIndex& index, int role) const
{
    if (isHeadline(index)) {
        QString title = (index == indexOfHeadline(1)) ? "1D Data" : "2D Data";
        if (m_visibleRanks.size() < 2)
            title = "Data";
 
        switch (role) {
        case Qt::DisplayRole:
            return title;
 
        case Qt::FontRole: {
            QFont f(QApplication::font());
            f.setPointSize(f.pointSize() * 1.5);
            f.setBold(true);
            return f;
        }
 
        case Qt::SizeHintRole: {
            QFont f(QApplication::font());
            f.setPointSize(f.pointSize() * 1.5);
            f.setBold(true);
            QSize s = QFontMetrics(f).boundingRect(title).size();
            return QSize(s.width() * 2, s.height() * 2);
        }
 
        case Qt::TextAlignmentRole:
            return QVariant(Qt::AlignLeft | Qt::AlignVCenter);
 
        case Qt::BackgroundRole:
            return appSettings->styleSheetPalette().headlineBackground;
 
        case Qt::ForegroundRole:
            return appSettings->styleSheetPalette().headlineText;
 
        default:
            return QVariant();
        }
    }
 
    auto* const item = itemForIndex(index);
 
    if (role == Qt::ToolTipRole)
        return QString();
 
    if (role == Qt::DecorationRole) {
        if (item->isSpecularData())
            return item->hasImportErrors() ? QIcon(":/images/warning_16x16.png")
                                           : QIcon(":/images/1D_OK.png");
        return QIcon(":/images/2D_OK.png");
    }
 
    if (role == Qt::DisplayRole) {
        const auto numErrors =
            (item->dataLoader() != nullptr) ? item->dataLoader()->numErrors() : 0;
 
        if (numErrors == 0)
            return item->dataName();
        if (numErrors == 1)
            return item->dataName() + " (1 parser warning)";
        return item->dataName() + QString(" (%1 parser warnings)").arg(numErrors);
    }
 
    if (role == Qt::EditRole)
        return item->dataName();
 
    return QVariant();
}
 
Qt::ItemFlags RealDataTreeModel::flags(const QModelIndex& index) const
{
    if (isHeadline(index) || !index.isValid())
        return Qt::NoItemFlags;
 
    auto f = QAbstractItemModel::flags(index);
    f |= Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
 
    if (index.column() == 0) // col 0 contains name of the data entry
        f |= Qt::ItemIsEditable;
 
    return f;
}
 
bool RealDataTreeModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
    if (!index.isValid())
        return false;
 
    if (role == Qt::EditRole && index.column() == 0) {
        itemForIndex(index)->setDataName(value.toString());
        emit dataChanged(index, index);
        return true;
    }
 
    return false;
}
 
RealDataItem* RealDataTreeModel::itemForIndex(const QModelIndex& index) const
{
    if (!index.isValid())
        return nullptr;
 
    return reinterpret_cast<RealDataItem*>(index.internalPointer());
}
 
QModelIndex RealDataTreeModel::indexForItem(RealDataItem* item) const
{
    if (item == nullptr)
        return QModelIndex();
 
    const int rank = item->isSpecularData() ? 1 : 2;
    if (m_visibleRanks.contains(rank))
        if (auto index = m_items[rank - 1].indexOf(item); index >= 0)
            return createIndex(index, 0, item);
 
    return QModelIndex();
}
 
bool RealDataTreeModel::isHeadline(const QModelIndex& index) const
{
    if (!index.isValid())
        return false;
 
    return index.internalPointer() == nullptr;
}
 
void RealDataTreeModel::updateSubscriptions()
{
    for (auto* item : m_items[0])
        connect(item, &RealDataItem::importContentsProcessed, this,
                [=]() { onContentsProcessed(item); });
 
    for (auto* item : m_items[1])
        connect(item, &RealDataItem::importContentsProcessed, this,
                [=]() { onContentsProcessed(item); });
}
 
void RealDataTreeModel::onContentsProcessed(RealDataItem* item)
{
    QModelIndex index = indexForItem(item);
    emit dataChanged(index, index);
}