FitParameterWidget.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Fit/FitParameterWidget.cpp
//! @brief     Implements class FitParameterWidget
//!
//! @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/View/Fit/FitParameterWidget.h"
#include "GUI/Model/Job/FitParameterContainerItem.h"
#include "GUI/Model/Job/FitParameterItem.h"
#include "GUI/Model/Job/FitParameterLinkItem.h"
#include "GUI/Model/Job/FitSuiteItem.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Model/Job/ParameterTreeItems.h"
#include "GUI/Model/Model/FitParameterHelper.h"
#include "GUI/Model/Model/FitParameterModel.h"
#include "GUI/Model/Model/JobModel.h"
#include "GUI/View/Common/CustomEventFilters.h"
#include "GUI/View/Fit/FitParameterDelegate.h"
#include "GUI/View/Fit/ParameterTuningWidget.h"
#include "GUI/View/Info/OverlayLabelController.h"
#include "GUI/View/Tool/mainwindow_constants.h"
#include <QAction>
#include <QMenu>
#include <QTreeView>
#include <QVBoxLayout>
 
#include <boost/polymorphic_cast.hpp>
 
using boost::polymorphic_downcast;
 
FitParameterWidget::FitParameterWidget(QWidget* parent)
    : SessionItemWidget(parent)
    , m_treeView(new QTreeView)
    , m_tuningWidget(nullptr)
    , m_createFitParAction(nullptr)
    , m_removeFromFitParAction(nullptr)
    , m_removeFitParAction(nullptr)
    , m_fitParameterModel(nullptr)
    , m_keyboardFilter(new DeleteEventFilter(this))
    , m_infoLabel(new OverlayLabelController(this))
{
    auto* layout = new QVBoxLayout(this);
    layout->addWidget(m_treeView);
    layout->setMargin(0);
    layout->setSpacing(0);
    init_actions();
 
    m_treeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
    m_treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
    m_treeView->setContextMenuPolicy(Qt::CustomContextMenu);
    m_treeView->setItemDelegate(new FitParameterDelegate(this));
    m_treeView->setDragEnabled(true);
    m_treeView->setDragDropMode(QAbstractItemView::DragDrop);
    m_treeView->installEventFilter(m_keyboardFilter);
    m_treeView->setAlternatingRowColors(true);
    m_treeView->setStyleSheet("alternate-background-color: #EFF0F1;");
 
    connect(m_treeView, &QTreeView::customContextMenuRequested, this,
            &FitParameterWidget::onFitParameterTreeContextMenu);
 
    m_infoLabel->setArea(m_treeView);
    m_infoLabel->setText("Drop parameter(s) to fit here");
}
 
//! Sets ParameterTuningWidget to be able to provide it with context menu and steer
//! its behaviour in the course of fit settings or fit running
 
void FitParameterWidget::setParameterTuningWidget(ParameterTuningWidget* tuningWidget)
{
    if (tuningWidget == m_tuningWidget)
        return;
 
    if (m_tuningWidget)
        disconnect(m_tuningWidget, &ParameterTuningWidget::itemContextMenuRequest, this,
                   &FitParameterWidget::onTuningWidgetContextMenu);
 
    m_tuningWidget = tuningWidget;
    if (!m_tuningWidget)
        return;
 
    connect(m_tuningWidget, &ParameterTuningWidget::itemContextMenuRequest, this,
            &FitParameterWidget::onTuningWidgetContextMenu, Qt::UniqueConnection);
    connect(m_tuningWidget, &QObject::destroyed, [this] { m_tuningWidget = nullptr; });
}
 
//! Creates context menu for ParameterTuningWidget
 
void FitParameterWidget::onTuningWidgetContextMenu(const QPoint& point)
{
    QMenu menu;
 
    if (jobItem()->getStatus() == JobStatus::Fitting) {
        setActionsEnabled(false);
        return;
    }
 
    m_removeFromFitParAction->setEnabled(canRemoveFromFitParameters());
    m_createFitParAction->setEnabled(canCreateFitParameter());
 
    menu.addAction(m_createFitParAction);
    QMenu* addToFitParMenu = menu.addMenu("Add to existing fit parameter");
    addToFitParMenu->setEnabled(true);
 
    const bool allow_one_fit_parameter_to_have_more_than_one_link = true;
    if (allow_one_fit_parameter_to_have_more_than_one_link) {
        QStringList fitParNames = jobItem()->fitParameterContainerItem()->fitParameterNames();
        if (fitParNames.isEmpty() || !canCreateFitParameter())
            addToFitParMenu->setEnabled(false);
        for (int i = 0; i < fitParNames.count(); ++i) {
            auto* action = new QAction(QString("to ").append(fitParNames.at(i)), addToFitParMenu);
            connect(action, &QAction::triggered, [=] { onAddToFitParAction(i); });
            addToFitParMenu->addAction(action);
        }
    }
    menu.addSeparator();
    menu.addAction(m_removeFromFitParAction);
 
    menu.exec(point);
    setActionsEnabled(true);
}
 
//! Creates context menu for the tree with fit parameters
 
void FitParameterWidget::onFitParameterTreeContextMenu(const QPoint& point)
{
    if (jobItem()->getStatus() == JobStatus::Fitting) {
        setActionsEnabled(false);
        return;
    }
    if (jobItem()->fitParameterContainerItem()->isEmpty())
        return;
 
    QMenu menu;
    menu.addAction(m_removeFitParAction);
    menu.exec(m_treeView->viewport()->mapToGlobal(point));
    setActionsEnabled(true);
}
 
//! Propagates selection form the tree with fit parameters to the tuning widget
 
void FitParameterWidget::onFitParametersSelectionChanged(const QItemSelection& selection)
{
    if (selection.indexes().isEmpty())
        return;
 
    for (auto index : selection.indexes()) {
        m_tuningWidget->selectionModel()->clearSelection();
        SessionItem* item = m_fitParameterModel->itemForIndex(index);
        if (item->parentItem()->hasModelType<FitParameterLinkItem>()) {
            QString link = polymorphic_downcast<FitParameterLinkItem*>(item->parentItem())->link();
            m_tuningWidget->makeSelected(
                jobItem()->parameterContainerItem()->findParameterItem(link));
        }
    }
}
 
//! Creates fit parameters for all selected ParameterItem's in tuning widget
 
void FitParameterWidget::onCreateFitParAction()
{
    for (auto* item : m_tuningWidget->getSelectedParameters())
        if (!jobItem()->fitParameterContainerItem()->fitParameterItem(item))
            jobItem()->fitParameterContainerItem()->createFitParameter(item);
}
 
//! All ParameterItem's selected in tuning widget will be removed from link section of
//! corresponding fitParameterItem.
 
void FitParameterWidget::onRemoveFromFitParAction()
{
    for (auto* item : m_tuningWidget->getSelectedParameters())
        jobItem()->fitParameterContainerItem()->removeLink(item);
}
 
//! All selected FitParameterItem's of FitParameterItemLink's will be removed
 
void FitParameterWidget::onRemoveFitParAction()
{
    FitParameterContainerItem* container = jobItem()->fitParameterContainerItem();
 
    // retrieve both, selected FitParameterItem and FitParameterItemLink
    const auto linksToRemove = selectedFitParameterLinks();
 
    for (const auto& link : linksToRemove)
        for (auto* fitParItem : container->fitParameterItems())
            fitParItem->removeLink(link);
 
    QVector<FitParameterItem*> itemsToRemove = selectedFitParameters();
    //  By uncommenting line below, removing link from fit parameter will lead to fit parameter
    // removal too (if it doesn't have other links)
    //  QVector<FitParameterItem *> itemsToRemove = selectedFitParameters()+emptyFitParameters();
 
    for (auto* item : itemsToRemove)
        container->model()->removeRow(item->index().row(), item->index().parent());
}
 
//! Add all selected parameters to fitParameter with given index
 
void FitParameterWidget::onAddToFitParAction(int ipar)
{
    const QString fitParName = jobItem()->fitParameterContainerItem()->fitParameterNames().at(ipar);
    for (auto* item : m_tuningWidget->getSelectedParameters())
        jobItem()->fitParameterContainerItem()->addToFitParameter(item, fitParName);
}
 
void FitParameterWidget::onFitParameterModelChange()
{
    spanParameters();
    updateInfoLabel();
}
 
void FitParameterWidget::subscribeToItem()
{
    init_fit_model();
}
 
void FitParameterWidget::init_actions()
{
    m_createFitParAction = new QAction("Create fit parameter", this);
    connect(m_createFitParAction, &QAction::triggered, this,
            &FitParameterWidget::onCreateFitParAction);
 
    m_removeFromFitParAction = new QAction("Remove from fit parameters", this);
    connect(m_removeFromFitParAction, &QAction::triggered, this,
            &FitParameterWidget::onRemoveFromFitParAction);
 
    m_removeFitParAction = new QAction("Remove fit parameter", this);
    connect(m_removeFitParAction, &QAction::triggered, this,
            &FitParameterWidget::onRemoveFitParAction);
 
    connect(m_keyboardFilter, &DeleteEventFilter::removeItem, this,
            &FitParameterWidget::onRemoveFitParAction);
}
 
//! Initializes FitParameterModel and its tree.
 
void FitParameterWidget::init_fit_model()
{
    m_treeView->setModel(nullptr);
 
    delete m_fitParameterModel;
    m_fitParameterModel = new FitParameterModel(jobItem()->fitParameterContainerItem(),
                                                jobItem()->fitParameterContainerItem()->model());
    m_treeView->setModel(m_fitParameterModel);
 
    connect(m_fitParameterModel, &FitParameterModel::dataChanged, this,
            &FitParameterWidget::onFitParameterModelChange);
    connect(m_fitParameterModel, &FitParameterModel::modelReset, this,
            &FitParameterWidget::onFitParameterModelChange);
 
    onFitParameterModelChange();
    connectFitParametersSelection(true);
}
 
//! Returns true if tuning widget contains selected ParameterItem's which can be used to create
//! a fit parameter (i.e. it is not linked with some fit parameter already).
 
bool FitParameterWidget::canCreateFitParameter()
{
    QVector<ParameterItem*> selected = m_tuningWidget->getSelectedParameters();
    for (auto* item : selected) {
        if (jobItem()->fitParameterContainerItem()->fitParameterItem(item) == nullptr)
            return true;
    }
    return false;
}
 
//! Returns true if tuning widget contains selected ParameterItem's which can be removed from
//! fit parameters.
 
bool FitParameterWidget::canRemoveFromFitParameters()
{
    QVector<ParameterItem*> selected = m_tuningWidget->getSelectedParameters();
    for (auto* item : selected) {
        if (jobItem()->fitParameterContainerItem()->fitParameterItem(item))
            return true;
    }
    return false;
}
 
//! Enables/disables all context menu actions.
 
void FitParameterWidget::setActionsEnabled(bool value)
{
    m_createFitParAction->setEnabled(value);
    m_removeFromFitParAction->setEnabled(value);
    m_removeFitParAction->setEnabled(value);
}
 
//! Returns list of FitParameterItem's currently selected in FitParameterItem tree
 
QVector<FitParameterItem*> FitParameterWidget::selectedFitParameters()
{
    QVector<FitParameterItem*> result;
    QModelIndexList indexes = m_treeView->selectionModel()->selectedIndexes();
    for (auto index : indexes) {
        if (SessionItem* item = m_fitParameterModel->itemForIndex(index)) {
            if (item->hasModelType<FitParameterItem>()) {
                auto* fitParItem = dynamic_cast<FitParameterItem*>(item);
                ASSERT(fitParItem);
                result.push_back(fitParItem);
            }
        }
    }
    return result;
}
 
//! Returns list of FitParameterItem's which doesn't have any links attached.
 
QVector<FitParameterItem*> FitParameterWidget::emptyFitParameters()
{
    QVector<FitParameterItem*> result;
    for (auto* fitParItem : jobItem()->fitParameterContainerItem()->fitParameterItems())
        if (fitParItem->linkItems().empty())
            result.push_back(fitParItem);
 
    return result;
}
 
//! Returns links of FitParameterLink's item selected in FitParameterItem tree
 
QStringList FitParameterWidget::selectedFitParameterLinks()
{
    QStringList result;
    QModelIndexList indexes = m_treeView->selectionModel()->selectedIndexes();
    for (QModelIndex index : indexes) {
        if (SessionItem* item = m_fitParameterModel->itemForIndex(index)) {
            if (item->parentItem()->hasModelType<FitParameterLinkItem>()) {
                auto* fitParItem = dynamic_cast<FitParameterLinkItem*>(item->parentItem());
                ASSERT(fitParItem);
                result.push_back(fitParItem->link());
            }
        }
    }
    return result;
}
 
//! Makes first column in FitParameterItem's tree related to ParameterItem link occupy whole space.
 
void FitParameterWidget::spanParameters()
{
    m_treeView->expandAll();
    for (int i = 0; i < m_fitParameterModel->rowCount(QModelIndex()); i++) {
        QModelIndex parameter = m_fitParameterModel->index(i, 0, QModelIndex());
        if (!parameter.isValid())
            break;
        int childRowCount = m_fitParameterModel->rowCount(parameter);
        if (childRowCount > 0) {
            for (int j = 0; j < childRowCount; j++)
                m_treeView->setFirstColumnSpanned(j, parameter, true);
        }
    }
}
 
//! Places overlay label on top of tree view, if there is no fit parameters
void FitParameterWidget::updateInfoLabel()
{
    if (!jobItem())
        return;
 
    m_infoLabel->setShown(jobItem()->fitParameterContainerItem()->isEmpty());
}
 
void FitParameterWidget::connectFitParametersSelection(bool active)
{
    if (active) {
        connect(m_treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
                &FitParameterWidget::onFitParametersSelectionChanged, Qt::UniqueConnection);
    } else {
        disconnect(m_treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
                   &FitParameterWidget::onFitParametersSelectionChanged);
    }
}
 
JobItem* FitParameterWidget::jobItem()
{
    return dynamic_cast<JobItem*>(currentItem());
}