MaskEditorPropertyPanel.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Mask/MaskEditorPropertyPanel.cpp
//! @brief     Implements class MaskEditorPropertyPanel
//!
//! @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/Mask/MaskEditorPropertyPanel.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Device/MaskItems.h"
#include "GUI/Model/Model/SessionModel.h"
#include "GUI/View/Common/DoubleSpinBox.h"
#include "GUI/View/PlotUtil/IntensityDataPropertyWidget.h"
#include "GUI/View/Tool/GroupBoxCollapser.h"
#include "GUI/View/Tool/LayoutUtils.h"
 
#include <QCheckBox>
#include <QFormLayout>
#include <QGroupBox>
#include <QLineEdit>
#include <QListView>
 
MaskEditorPropertyPanel::MaskEditorPropertyPanel(QWidget* parent)
    : QWidget(parent)
    , m_listView(new QListView)
    , m_plotPropertyEditor(new IntensityDataPropertyWidget)
    , m_maskModel(nullptr)
    , m_intensityDataItem(nullptr)
    , m_currentMaskItem(nullptr)
    , m_inhibitSelectionChange(false)
{
    setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Expanding);
    setObjectName(QLatin1String("MaskEditorToolPanel"));
    setAttribute(Qt::WA_StyledBackground, true);
    setProperty("stylable", true); // for stylesheet addressing
 
    m_listView->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(m_listView, &QListView::customContextMenuRequested, this,
            &MaskEditorPropertyPanel::onCustomContextMenuRequested);
 
    auto* mainLayout = new QVBoxLayout;
    mainLayout->setContentsMargins(0, 0, 0, 0);
    mainLayout->setSpacing(8);
 
    // -- plot properties
    auto* plotPropertiesGroup = new QGroupBox("Plot properties", this);
    auto* plotPropertiesLayout = new QVBoxLayout(plotPropertiesGroup);
    plotPropertiesLayout->setContentsMargins(0, 0, 0, 0);
    m_plotPropertyEditor->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
    plotPropertiesLayout->addWidget(m_plotPropertyEditor);
    GroupBoxCollapser::installIntoGroupBox(plotPropertiesGroup);
 
    // -- mask stack
    auto* maskStackGroup = new QGroupBox("Mask stack", this);
    auto* maskStackLayout = new QVBoxLayout(maskStackGroup);
    maskStackLayout->setContentsMargins(0, 0, 0, 0);
    m_listView->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
    maskStackLayout->addWidget(m_listView);
    GroupBoxCollapser::installIntoGroupBox(maskStackGroup);
 
    // -- mask properties
    auto* maskPropertiesGroup = new QGroupBox("Mask properties", this);
    maskPropertiesGroup->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
    m_maskPropertiesLayout = new QFormLayout(maskPropertiesGroup);
    m_maskPropertiesLayout->setContentsMargins(8, 8, 8, 8);
    GroupBoxCollapser::installIntoGroupBox(maskPropertiesGroup);
 
    mainLayout->addWidget(plotPropertiesGroup);
    mainLayout->addWidget(maskStackGroup);
    mainLayout->addWidget(maskPropertiesGroup);
    mainLayout->addSpacerItem(
        new QSpacerItem(0, 10, QSizePolicy::Fixed, QSizePolicy::MinimumExpanding));
 
    setLayout(mainLayout);
}
 
QSize MaskEditorPropertyPanel::sizeHint() const
{
    return QSize(128, 128);
}
 
QSize MaskEditorPropertyPanel::minimumSizeHint() const
{
    return QSize(128, 128);
}
 
void MaskEditorPropertyPanel::setMaskContext(SessionModel* model,
                                             const QModelIndex& maskContainerIndex,
                                             IntensityDataItem* intensityItem)
{
    m_maskModel = model;
    m_rootIndex = maskContainerIndex;
    m_intensityDataItem = intensityItem;
 
    m_listView->setModel(m_maskModel);
    m_listView->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
    m_listView->setRootIndex(m_rootIndex);
 
    connect(m_listView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
            &MaskEditorPropertyPanel::onSelectionChanged, Qt::UniqueConnection);
 
    m_plotPropertyEditor->setItem(m_intensityDataItem);
}
 
void MaskEditorPropertyPanel::resetContext()
{
    m_maskModel = nullptr;
    m_rootIndex = {};
    m_intensityDataItem = nullptr;
    m_listView->setModel(nullptr);
    setCurrentMaskItem(nullptr);
    m_plotPropertyEditor->setItem(nullptr);
}
 
QItemSelectionModel* MaskEditorPropertyPanel::selectionModel()
{
    ASSERT(m_listView);
    return m_listView->selectionModel();
}
 
//! Show/Hide panel. When panel is hidden, all property editors are disabled.
void MaskEditorPropertyPanel::setPanelHidden(bool hidden)
{
    setHidden(hidden);
 
    if (!m_rootIndex.isValid())
        return;
 
    if (hidden) {
        setCurrentMaskItem(nullptr);
        m_plotPropertyEditor->setItem(nullptr);
    } else {
        QModelIndexList indexes = selectionModel()->selectedIndexes();
        if (!indexes.empty())
            setCurrentMaskItem(maskItemForIndex(indexes.front()));
 
        m_plotPropertyEditor->setItem(m_intensityDataItem);
    }
}
 
void MaskEditorPropertyPanel::onSelectionChanged(const QItemSelection& selected,
                                                 const QItemSelection&)
{
    if (m_inhibitSelectionChange)
        return;
 
    if (!selected.empty())
        setCurrentMaskItem(maskItemForIndex(selected.indexes().front()));
    else
        setCurrentMaskItem(nullptr);
}
 
void MaskEditorPropertyPanel::onCustomContextMenuRequested(const QPoint& point)
{
    emit itemContextMenuRequest(m_listView->mapToGlobal(point));
}
 
void MaskEditorPropertyPanel::setCurrentMaskItem(MaskItem* maskItem)
{
    if (m_currentMaskItem)
        m_currentMaskItem->mapper()->unsubscribe(this);
 
    GUI::Util::Layout::clearLayout(m_maskPropertiesLayout);
 
    m_currentMaskItem = maskItem;
 
    createMaskEditorUI();
}
 
void MaskEditorPropertyPanel::createMaskEditorUI()
{
    if (!m_currentMaskItem)
        return;
 
    auto* maskItem = m_currentMaskItem; // shorthand
    // -- mask value (only if not RoI)
    if (!dynamic_cast<RegionOfInterestItem*>(maskItem)) {
        const auto maskValueGetter = [=] { return maskItem->maskValue(); };
        const auto maskValueSetter = [=](bool b) { maskItem->setMaskValue(b); };
        addMaskCheckBox("Mask value", maskValueGetter, maskValueSetter);
    }
    // -- mask visibility
    const auto visibilityValueGetter = [=] { return maskItem->isVisibleValue(); };
    const auto visibilityValueSetter = [=](bool b) {
        m_inhibitSelectionChange = true;
        maskItem->setIsVisibleValue(b);
        m_inhibitSelectionChange = false;
    };
    addMaskCheckBox("Show", visibilityValueGetter, visibilityValueSetter);
 
    // -- name (only if not RoI)
    if (!dynamic_cast<RegionOfInterestItem*>(maskItem)) {
        auto* edit = new QLineEdit(maskItem->maskName(), m_maskPropertiesLayout->parentWidget());
        connect(edit, &QLineEdit::textEdited, [=](const QString& t) { maskItem->setMaskName(t); });
        m_maskPropertiesLayout->addRow("Name:", edit);
    }
 
    if (auto* c = dynamic_cast<RectangleItem*>(maskItem)) {
        addMaskSpinBox(c->xLow());
        addMaskSpinBox(c->yLow());
        addMaskSpinBox(c->xUp());
        addMaskSpinBox(c->yUp());
    } else if (auto* c = dynamic_cast<EllipseItem*>(maskItem)) {
        addMaskSpinBox(c->xCenter());
        addMaskSpinBox(c->yCenter());
        addMaskSpinBox(c->xRadius());
        addMaskSpinBox(c->yRadius());
        addMaskSpinBox(c->angle());
    } else if (auto* c = dynamic_cast<VerticalLineItem*>(maskItem))
        addMaskSpinBox(c->posX());
    else if (auto* c = dynamic_cast<HorizontalLineItem*>(maskItem))
        addMaskSpinBox(c->posY());
}
 
void MaskEditorPropertyPanel::addMaskSpinBox(DoubleDescriptor d)
{
    auto* spinBox = new DoubleSpinBox(m_maskPropertiesLayout->parentWidget(), d);
    spinBox->setBaseValue(d.get());
    QObject::connect(spinBox, &DoubleSpinBox::baseValueChanged,
                     [=](double newValue) { d.set(newValue); });
 
    m_currentMaskItem->mapper()->setOnPropertyChange(
        [=](const QString&) { spinBox->updateValue(); }, this);
 
    m_maskPropertiesLayout->addRow(d.label + ":", spinBox);
}
 
void MaskEditorPropertyPanel::addMaskCheckBox(const QString& title, function<bool()> getter,
                                              function<void(bool)> setter)
{
    auto* checkBox = new QCheckBox(title, m_maskPropertiesLayout->parentWidget());
    checkBox->setChecked(getter());
    connect(checkBox, &QCheckBox::stateChanged, [=]() { setter(checkBox->isChecked()); });
 
    // listen on property change
    m_currentMaskItem->mapper()->setOnPropertyChange(
        [=](const QString&) {
            QSignalBlocker b(checkBox);
            checkBox->setChecked(getter());
        },
        this);
 
    m_maskPropertiesLayout->addRow(checkBox);
}
 
MaskItem* MaskEditorPropertyPanel::maskItemForIndex(const QModelIndex& index)
{
    return dynamic_cast<MaskItem*>(m_maskModel->itemForIndex(index));
}