LayerEditorUtils.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/SampleDesigner/LayerEditorUtils.cpp
//! @brief     Implements class LayerEditorUtils
//!
//! @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/SampleDesigner/LayerEditorUtils.h"
#include "GUI/Model/Descriptor/VectorDescriptor.h"
#include "GUI/Model/Sample/FormFactorItems.h"
#include "GUI/Model/Sample/LayerRoughnessItems.h"
#include "GUI/Model/Sample/MesoCrystalItem.h"
#include "GUI/Model/Sample/ParticleCompositionItem.h"
#include "GUI/Model/Sample/ParticleCoreShellItem.h"
#include "GUI/Model/Sample/ParticleItem.h"
#include "GUI/Model/Sample/ProfileItems.h"
#include "GUI/View/Common/DoubleSpinBox.h"
#include "GUI/View/SampleDesigner/FormLayouter.h"
#include "GUI/View/SampleDesigner/MesoCrystalForm.h"
#include "GUI/View/SampleDesigner/ParticleCompositionForm.h"
#include "GUI/View/SampleDesigner/ParticleCoreShellForm.h"
#include "GUI/View/SampleDesigner/ParticleForm.h"
 
#include <QLabel>
#include <QMenu>
#include <QPushButton>
 
namespace {
 
void updateLabelUnit(QLabel* label, const QString& unit)
{
    QString text = label->text();
    const bool hasColon = text.indexOf(":") > 0;
    text = text.left(text.indexOf("["));
    text = text.trimmed();
    if (text.endsWith(":"))
        text.chop(1);
 
    if (!unit.isEmpty())
        text += " [" + unit + "]";
    if (hasColon)
        text += ":";
    label->setText(text);
}
 
} // namespace
 
void LayerEditorUtils::updateLabelUnit(QLabel* label, DoubleSpinBox* editor)
{
    ::updateLabelUnit(label, editor->displayUnitAsString());
}
 
void LayerEditorUtils::updateLabelUnit(QLabel* label)
{
    if (auto* editor = dynamic_cast<DoubleSpinBox*>(label->buddy()))
        ::updateLabelUnit(label, editor->displayUnitAsString());
}
 
void LayerEditorUtils::addMultiPropertyToGrid(QGridLayout* m_gridLayout, int firstCol,
                                              const DoubleDescriptors& valueDescriptors,
                                              SampleEditorController* ec, bool vertically,
                                              bool addSpacer)
{
    const auto setNewValue = [=](double newValue, DoubleDescriptor d) {
        ec->setDouble(newValue, d);
    };
 
    addMultiPropertyToGrid(m_gridLayout, firstCol, valueDescriptors, setNewValue, vertically,
                           addSpacer);
}
 
void LayerEditorUtils::addMultiPropertyToGrid(QGridLayout* m_gridLayout, int firstCol,
                                              const DoubleDescriptors& valueDescriptors,
                                              function<void(double, DoubleDescriptor)> setNewValue,
                                              bool vertically, bool addSpacer)
{
    int col = firstCol;
    for (const auto& valueDescriptor : valueDescriptors) {
        auto* editor = new DoubleSpinBox(m_gridLayout->parentWidget(), valueDescriptor);
        QObject::connect(editor, &DoubleSpinBox::baseValueChanged,
                         [=](double newValue) { setNewValue(newValue, valueDescriptor); });
 
        QString labeltext = valueDescriptor.label;
        if (!vertically && !labeltext.endsWith(":"))
            labeltext += ":";
        auto* label = new QLabel(labeltext, m_gridLayout->parentWidget());
        label->setBuddy(editor); // necessary for unit-updating
        LayerEditorUtils::updateLabelUnit(label, editor);
 
        if (vertically) {
            m_gridLayout->addWidget(label, 0, col);
            m_gridLayout->addWidget(editor, 1, col);
            col++;
        } else {
            m_gridLayout->addWidget(label, 1, col++);
            m_gridLayout->addWidget(editor, 1, col++);
        }
    }
    if (addSpacer)
        m_gridLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding), 0, col);
}
 
void LayerEditorUtils::addMultiPropertyToGrid(QGridLayout* m_gridLayout, int firstCol,
                                              const DoubleDescriptors& valueDescriptors,
                                              SampleEditorController* ec, bool addSpacer)
{
    addMultiPropertyToGrid(m_gridLayout, firstCol, valueDescriptors, ec,
                           valueDescriptors.size() > 1, addSpacer);
}
 
void LayerEditorUtils::addVectorToGrid(QGridLayout* m_gridLayout, int firstCol,
                                       const VectorDescriptor& v, SampleEditorController* ec,
                                       bool vertically, bool addSpacer)
{
    addMultiPropertyToGrid(m_gridLayout, firstCol, {v.x, v.y, v.z}, ec, vertically, addSpacer);
}
 
 
void LayerEditorUtils::addVectorToGrid(QGridLayout* m_gridLayout, int firstCol,
                                       const VectorDescriptor& v,
                                       function<void(double, DoubleDescriptor)> setNewValue,
                                       bool vertically, bool addSpacer)
{
    addMultiPropertyToGrid(m_gridLayout, firstCol, {v.x, v.y, v.z}, setNewValue, vertically,
                           addSpacer);
}
 
QLabel* LayerEditorUtils::createBoldLabel(const QString& text)
{
    auto* l = new QLabel(text);
    QFont f = l->font();
    f.setBold(true);
    l->setFont(f);
    return l;
}
 
DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(RotationItem* item)
{
    if (!item)
        return {};
 
    return item->rotationValues();
}
 
DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(Profile2DItem* item)
{
    return item->valueDescriptors();
}
 
DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(Profile1DItem* item)
{
    return item->valueDescriptors();
}
 
DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(FormFactorItem* item)
{
    return item->geometryValues();
}
 
DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(LayerBasicRoughnessItem* r)
{
    if (r)
        return {r->sigma(), r->hurst(), r->lateralCorrelationLength()};
 
    return {};
}
 
QWidget* LayerEditorUtils::createWidgetForItemWithParticles(QWidget* parentWidget,
                                                            ItemWithParticles* itemWithParticles,
                                                            bool allowAbundance,
                                                            SampleEditorController* ec,
                                                            bool allowRemove /*= true*/)
{
    if (auto* composition = dynamic_cast<ParticleCompositionItem*>(itemWithParticles))
        return new ParticleCompositionForm(parentWidget, composition, ec, allowRemove);
 
    if (auto* coreShell = dynamic_cast<ParticleCoreShellItem*>(itemWithParticles))
        return new ParticleCoreShellForm(parentWidget, coreShell, ec, allowRemove);
 
    if (auto* meso = dynamic_cast<MesoCrystalItem*>(itemWithParticles))
        return new MesoCrystalForm(parentWidget, meso, ec, allowRemove);
 
    if (auto* particle = dynamic_cast<ParticleItem*>(itemWithParticles))
        return new ParticleForm(parentWidget, particle, allowAbundance, ec, allowRemove);
 
    ASSERT(false);
    return nullptr;
}
 
QPushButton* LayerEditorUtils::createAddParticleButton(
    QWidget* parentWidget, std::function<void(FormFactorItemCatalog::Type t)> slotAddFormFactor,
    std::function<void(ItemWithParticlesCatalog::Type t)> slotAddParticle)
{
    auto* btn = new QPushButton("Add particle", parentWidget);
 
    auto* menu = new QMenu(btn);
    QMenu* menuForEntries = menu;
 
    const auto group = [&](const QString& title) { menuForEntries = menu->addMenu(title); };
 
    group("Hard particles");
    for (const auto type : FormFactorItemCatalog::hardParticleTypes()) {
        const auto ui = FormFactorItemCatalog::uiInfo(type);
        QAction* a = menuForEntries->addAction(QIcon(ui.iconPath), ui.menuEntry);
        a->setToolTip(ui.description);
        QObject::connect(a, &QAction::triggered, [=]() { slotAddFormFactor(type); });
    }
 
    group("Ripples");
    for (const auto type : FormFactorItemCatalog::rippleTypes()) {
        const auto ui = FormFactorItemCatalog::uiInfo(type);
        QAction* a = menuForEntries->addAction(QIcon(ui.iconPath), ui.menuEntry);
        a->setToolTip(ui.description);
        QObject::connect(a, &QAction::triggered, [=]() { slotAddFormFactor(type); });
    }
 
    group("Particle assemblies");
    for (const auto type :
         {ItemWithParticlesCatalog::Type::Composition, ItemWithParticlesCatalog::Type::CoreShell,
          ItemWithParticlesCatalog::Type::MesoCrystal}) {
        const auto ui = ItemWithParticlesCatalog::uiInfo(type);
        QAction* a = menuForEntries->addAction(QIcon(ui.iconPath), ui.menuEntry);
        a->setToolTip(ui.description);
        QObject::connect(a, &QAction::triggered, [=]() { slotAddParticle(type); });
    }
 
    btn->setMenu(menu);
 
    return btn;
}
 
QList<QColor> LayerEditorUtils::predefinedLayerColors()
{
    static QList<QColor> colors = {QColor(230, 255, 213), QColor(194, 252, 240),
                                   QColor(239, 228, 176), QColor(200, 191, 231),
                                   QColor(253, 205, 193), QColor(224, 193, 253)};
 
    return colors;
}