FitParameterModel.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Model/FitParameterModel.cpp
//! @brief     Implements class FitParameterAbsModel
//!
//! @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/Model/Model/FitParameterModel.h"
#include "GUI/Model/Job/FitParameterContainerItem.h"
#include "GUI/Model/Job/FitParameterItem.h"
#include "GUI/Model/Job/FitParameterLinkItem.h"
#include "GUI/Model/Model/FitParameterHelper.h"
#include "GUI/Model/Model/JobModel.h"
#include "GUI/Model/Model/ModelPath.h"
#include "GUI/Model/Model/SessionXML.h"
#include "GUI/Util/Error.h"
#include <QColor>
#include <QMimeData>
 
#include <boost/polymorphic_cast.hpp>
 
using boost::polymorphic_downcast;
 
#include <optional>
 
FitParameterModel::FitParameterModel(FitParameterContainerItem* fitParContainer, QObject* parent)
    : QAbstractItemModel(parent)
    , m_parameterContainer(fitParContainer)
{
    addColumn(COL_NAME, "Name", "Name of fit parameter");
    addColumn(COL_TYPE, "Type", "Fit parameter limits type");
    addColumn(COL_VALUE, "Value", "Starting value of fit parameter");
    addColumn(COL_MIN, "Min", "Lower bound on fit parameter value");
    addColumn(COL_MAX, "Max", "Upper bound on fit parameter value");
 
    connectModel(fitParContainer->model());
 
    m_parameterContainer->mapper()->setOnItemDestroy(
        [this](SessionItem* parentItem) {
            if (parentItem != m_parameterContainer) {
                throw Error("FitParameterModel::FitParameterModel() -> Error. "
                            "Wrong item reported.");
            }
            m_parameterContainer = nullptr;
        },
        this);
}
 
FitParameterModel::~FitParameterModel()
{
    if (m_parameterContainer)
        m_parameterContainer->mapper()->unsubscribe(this);
}
 
Qt::ItemFlags FitParameterModel::flags(const QModelIndex& index) const
{
    if (!m_parameterContainer)
        return Qt::NoItemFlags;
 
    Qt::ItemFlags result = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
    if (SessionItem* item = itemForIndex(index)) {
        if (item->isEditable() && index.column() != COL_NAME)
            result |= Qt::ItemIsEditable;
        if (item->parentItem()->hasModelType<FitParameterLinkItem>() && index.column() == COL_NAME)
            result |= Qt::ItemIsDragEnabled;
        const bool allow_one_fit_parameter_to_have_more_than_one_link = true;
        if (allow_one_fit_parameter_to_have_more_than_one_link) {
            // drop is allowed to fit parameter container, and, to FitParameterItem itself.
            // (i.e. we can have more than one link in single FitParameterItem)
            if (item->hasModelType<FitParameterItem>()
                || item->hasModelType<FitParameterContainerItem>()) {
                result |= Qt::ItemIsDropEnabled;
            }
        } else {
            // drop is allowed only to fit parameter container
            // (i.e. only one link is allowed in FitParameterItem)
            if (item->hasModelType<FitParameterContainerItem>())
                result |= Qt::ItemIsDropEnabled;
        }
    }
    return result;
}
 
QModelIndex FitParameterModel::index(int row, int column, const QModelIndex& parent) const
{
    if (!m_parameterContainer || row < 0 || column < 0 || column >= columnCount(QModelIndex())
        || (parent.isValid() && parent.column() != COL_NAME))
        return QModelIndex();
 
    SessionItem* parent_item = itemForIndex(parent);
    ASSERT(parent_item);
 
    if (parent_item->hasModelType<FitParameterContainerItem>()) {
        QVector<FitParameterItem*> fitParamItems =
            polymorphic_downcast<FitParameterContainerItem*>(parent_item)->fitParameterItems();
        if (row < fitParamItems.size()) {
            FitParameterItem* fitParItem = fitParamItems[row];
            SessionItem* itemToPack = nullptr;
            switch (column) {
            case COL_NAME:
                itemToPack = fitParItem;
                break;
            case COL_TYPE:
                itemToPack = fitParItem->typeItem();
                break;
            case COL_VALUE:
                itemToPack = fitParItem->startValueItem();
                break;
            case COL_MIN:
                itemToPack = fitParItem->minimumItem();
                break;
            case COL_MAX:
                itemToPack = fitParItem->maximumItem();
                break;
            default:
                itemToPack = nullptr;
            }
            return createIndex(row, column, itemToPack);
        }
    } else if (parent_item->hasModelType<FitParameterItem>() && column == COL_NAME) {
        QVector<FitParameterLinkItem*> links =
            polymorphic_downcast<FitParameterItem*>(parent_item)->linkItems();
        if (row < links.size()) {
            if (FitParameterLinkItem* linkItem = links.at(row))
                return createIndex(row, column, linkItem->linkItem());
        }
    }
    return QModelIndex();
}
 
QModelIndex FitParameterModel::parent(const QModelIndex& child) const
{
    if (!m_parameterContainer)
        return QModelIndex();
 
    if (!child.isValid())
        return QModelIndex();
 
    if (SessionItem* child_item = itemForIndex(child)) {
        if (SessionItem* parent_item = child_item->parentItem()) {
            if (!isValidSourceItem(parent_item))
                return QModelIndex();
            if (parent_item->hasModelType<FitParameterLinkItem>()) {
                SessionItem* fitPar = parent_item->parentItem();
                if (!isValidSourceItem(fitPar))
                    return QModelIndex();
                return createIndex(fitPar->parentRow(), 0, fitPar);
            }
        }
    }
    return QModelIndex();
}
 
int FitParameterModel::rowCount(const QModelIndex& parent) const
{
    if (!m_parameterContainer)
        return 0;
 
    if (parent.isValid() && parent.column() != COL_NAME)
        return 0;
 
    SessionItem* parent_item = itemForIndex(parent);
    if (parent_item != m_parameterContainer && !isValidSourceItem(parent_item))
        return 0;
 
    if (parent_item->hasModelType<FitParameterContainerItem>())
        return parent_item->numberOfChildren();
    if (parent_item->hasModelType<FitParameterItem>())
        return polymorphic_downcast<FitParameterItem*>(parent_item)->linkItems().size();
    return 0;
}
 
int FitParameterModel::columnCount(const QModelIndex& parent) const
{
    if (!m_parameterContainer)
        return 0;
 
    if (parent.isValid() && parent.column() != COL_NAME)
        return 0;
 
    if (!parent.isValid())
        return NUM_COLUMNS;
 
    if (parent.isValid()) {
        if (SessionItem* parentItem = itemForIndex(parent)) {
            if (parentItem->hasModelType<FitParameterItem>())
                return !polymorphic_downcast<FitParameterItem*>(parentItem)->linkItems().empty();
        }
    }
    return 0;
}
 
QVariant FitParameterModel::data(const QModelIndex& index, int role) const
{
    if (!m_parameterContainer)
        return QVariant();
 
    if (!index.isValid() || index.column() < 0 || index.column() >= NUM_COLUMNS)
        return QVariant();
 
    if (SessionItem* item = itemForIndex(index)) {
        if (role == Qt::DisplayRole || role == Qt::EditRole) {
            if (item->hasModelType<FitParameterItem>())
                return item->displayName();
            if (const auto* linkItem = dynamic_cast<FitParameterLinkItem*>(item->parentItem()))
                return linkItem->title();
            return item->value();
        }
        if (role == Qt::ForegroundRole && !item->isEditable())
            return QVariant(QColor(Qt::gray));
        if (role == Qt::ToolTipRole && item->hasModelType<FitParameterLinkItem>())
            return item->value();
    }
    return QVariant();
}
 
bool FitParameterModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
    if (!m_parameterContainer)
        return false;
 
    if (!index.isValid())
        return false;
    if (SessionItem* item = itemForIndex(index)) {
        if (role == Qt::EditRole) {
            item->setValue(value);
            emit dataChanged(index, index);
            return true;
        }
    }
    return false;
}
 
QStringList FitParameterModel::mimeTypes() const
{
    QStringList types;
    types << GUI::Session::XML::LinkMimeType;
    return types;
}
 
QMimeData* FitParameterModel::mimeData(const QModelIndexList& indexes) const
{
    auto* mimeData = new QMimeData();
    QModelIndex index = indexes.first();
    if (index.isValid()) {
        if (SessionItem* item = itemForIndex(index)) {
            QString path = item->value().toString();
            auto* parameterItem = FitParameterHelper::getParameterItem(m_parameterContainer, path);
            QByteArray data;
            data.setNum(reinterpret_cast<qlonglong>(parameterItem));
            mimeData->setData(GUI::Session::XML::LinkMimeType, data);
        }
    }
    return mimeData;
}
 
bool FitParameterModel::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row,
                                        int column, const QModelIndex& parent) const
{
    Q_UNUSED(data);
    Q_UNUSED(action);
    Q_UNUSED(row);
    bool drop_is_possible(false);
    if (parent.isValid())
        drop_is_possible = true;
    if (!parent.isValid() && row == -1 && column == -1)
        drop_is_possible = true;
    return drop_is_possible;
}
 
bool FitParameterModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row,
                                     int column, const QModelIndex& parent)
{
    Q_UNUSED(action);
    Q_UNUSED(row);
    Q_UNUSED(column);
 
    if (parent.isValid()) {
        if (SessionItem* fitParItem = itemForIndex(parent)) {
            ASSERT(fitParItem->hasModelType<FitParameterItem>());
            ParameterItem* parItem = reinterpret_cast<ParameterItem*>(
                data->data(GUI::Session::XML::LinkMimeType).toULongLong());
            ASSERT(parItem);
            m_parameterContainer->addToFitParameter(parItem, fitParItem->displayName());
        }
    } else {
        ParameterItem* parItem = reinterpret_cast<ParameterItem*>(
            data->data(GUI::Session::XML::LinkMimeType).toULongLong());
        ASSERT(parItem);
        m_parameterContainer->createFitParameter(parItem);
    }
    return true;
}
 
QVariant FitParameterModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role == Qt::DisplayRole && orientation == Qt::Horizontal)
        return m_columnNames.value(section);
    if (role == Qt::ToolTipRole)
        return m_columnToolTips.value(section);
    return QVariant();
}
 
void FitParameterModel::onSourceDataChanged(const QModelIndex& topLeft,
                                            const QModelIndex& bottomRight,
                                            const QVector<int>& roles)
{
    Q_UNUSED(bottomRight);
 
    auto* sourceModel = qobject_cast<JobModel*>(sender());
    ASSERT(sourceModel);
    SessionItem* sourceItem = sourceModel->itemForIndex(topLeft);
 
    QModelIndex itemIndex = indexOfItem(sourceItem);
 
    if (itemIndex.isValid())
        emit dataChanged(itemIndex, itemIndex, roles);
}
 
void FitParameterModel::onSourceRowsRemoved(const QModelIndex& parent, int first, int last)
{
    Q_UNUSED(parent);
    Q_UNUSED(first);
    Q_UNUSED(last);
    beginResetModel();
    endResetModel();
}
 
void FitParameterModel::onSourceAboutToBeReset()
{
    if (!m_parameterContainer)
        return;
    beginResetModel();
    endResetModel();
}
 
void FitParameterModel::connectModel(QAbstractItemModel* sourceModel, bool isConnect) const
{
    ASSERT(sourceModel);
    if (isConnect) {
        connect(sourceModel, &QAbstractItemModel::dataChanged, this,
                &FitParameterModel::onSourceDataChanged);
        connect(sourceModel, &QAbstractItemModel::rowsRemoved, this,
                &FitParameterModel::onSourceRowsRemoved);
        connect(sourceModel, &QAbstractItemModel::modelAboutToBeReset, this,
                &FitParameterModel::onSourceAboutToBeReset);
    } else {
        disconnect(sourceModel, &QAbstractItemModel::dataChanged, this,
                   &FitParameterModel::onSourceDataChanged);
        disconnect(sourceModel, &QAbstractItemModel::rowsRemoved, this,
                   &FitParameterModel::onSourceRowsRemoved);
        disconnect(sourceModel, &QAbstractItemModel::modelAboutToBeReset, this,
                   &FitParameterModel::onSourceAboutToBeReset);
    }
}
 
void FitParameterModel::addColumn(FitParameterModel::EColumn id, const QString& name,
                                  const QString& tooltip)
{
    m_columnNames[id] = name;
    m_columnToolTips[id] = tooltip;
}
 
QModelIndex FitParameterModel::indexOfItem(SessionItem* item) const
{
    if (!m_parameterContainer)
        return QModelIndex();
 
    if (SessionItem* parent_item = item->parentItem()) {
        if (parent_item->hasModelType<FitParameterContainerItem>()) {
            if (item->hasModelType<FitParameterItem>())
                return createIndex(item->parentRow(), 0, item);
        } else if (parent_item->hasModelType<FitParameterItem>()) {
            auto* fitParam = polymorphic_downcast<FitParameterItem*>(parent_item);
            std::optional<int> col;
            if (item == fitParam->typeItem())
                col = COL_TYPE;
            else if (item == fitParam->startValueItem())
                col = COL_VALUE;
            else if (item == fitParam->minimumItem())
                col = COL_MIN;
            else if (item == fitParam->maximumItem())
                col = COL_MAX;
            if (col)
                return createIndex(parent_item->parentRow(), col.value(), item);
        } else if (parent_item->hasModelType<FitParameterLinkItem>()) {
            QVector<FitParameterLinkItem*> links =
                polymorphic_downcast<FitParameterItem*>(parent_item->parentItem())->linkItems();
            int index = links.indexOf(polymorphic_downcast<FitParameterLinkItem*>(parent_item));
            return createIndex(index, 0, item);
        }
    }
    return QModelIndex();
}
 
SessionItem* FitParameterModel::itemForIndex(const QModelIndex& index) const
{
    if (!m_parameterContainer)
        return nullptr;
 
    if (index.isValid()) {
        auto* item = static_cast<SessionItem*>(index.internalPointer());
        if (item) {
            if (!isValidSourceItem(item))
                return nullptr;
            return item;
        }
    }
    return m_parameterContainer;
}
 
SessionModel* FitParameterModel::sourceModel() const
{
    ASSERT(m_parameterContainer);
    return m_parameterContainer->model();
}
 
//! Returns true if given item still exists in source model
bool FitParameterModel::isValidSourceItem(SessionItem* item) const
{
    if (item == m_parameterContainer)
        return true;
    if (sourceModel()
        && GUI::Model::Path::isValidItem(sourceModel(), item, m_parameterContainer->index()))
        return true;
    return false;
}