CustomEditors.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/PropertyEditor/CustomEditors.cpp
//! @brief     Implements CustomEditors classes
//!
//! @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/PropertyEditor/CustomEditors.h"
#include "Base/Util/Assert.h"
#include "Fit/Param/RealLimits.h"
#include "GUI/Model/Data/SessionData.h"
#include "GUI/Util/ComboProperty.h"
#include "GUI/View/Common/CustomEventFilters.h"
#include "GUI/View/Common/ScientificSpinBox.h"
#include <QBoxLayout>
#include <QComboBox>
#include <cmath>
 
namespace {
 
//! Single step for QDoubleSpinBox.
 
double singleStep(int decimals)
{
    // For item with decimals=3 (i.e. 0.001) single step will be 0.1
    return 1. / std::pow(10., decimals - 1);
}
 
} // namespace
 
//! Sets the data from the model to editor.
 
void CustomEditor::setData(const QVariant& data)
{
    m_data = data;
    initEditor();
}
 
//! Inits editor widgets from m_data.
 
void CustomEditor::initEditor() {}
 
//! Saves the data from the editor and informs external delegates.
 
void CustomEditor::setDataIntern(const QVariant& data)
{
    m_data = data;
    dataChanged(m_data);
}
 
// --- ComboPropertyEditor ---
 
ComboPropertyEditor::ComboPropertyEditor(QWidget* parent)
    : CustomEditor(parent)
    , m_box(new QComboBox)
    , m_wheel_event_filter(new WheelEventEater(this))
{
    setAutoFillBackground(true);
    setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
 
    auto* layout = new QVBoxLayout;
    layout->setMargin(0);
    layout->setSpacing(0);
    layout->addWidget(m_box);
 
    m_box->installEventFilter(m_wheel_event_filter);
 
    setLayout(layout);
    setConnected(true);
}
 
QSize ComboPropertyEditor::sizeHint() const
{
    return m_box->sizeHint();
}
 
QSize ComboPropertyEditor::minimumSizeHint() const
{
    return m_box->minimumSizeHint();
}
 
void ComboPropertyEditor::onIndexChanged(int index)
{
    auto comboProperty = m_data.value<ComboProperty>();
 
    if (comboProperty.currentIndex() != index) {
        comboProperty.setCurrentIndex(index);
        setDataIntern(QVariant::fromValue<ComboProperty>(comboProperty));
    }
}
 
void ComboPropertyEditor::initEditor()
{
    setConnected(false);
 
    m_box->clear();
    m_box->insertItems(0, internLabels());
    m_box->setCurrentIndex(internIndex());
 
    setConnected(true);
}
 
//! Returns list of labels for QComboBox
 
QStringList ComboPropertyEditor::internLabels()
{
    if (!m_data.canConvert<ComboProperty>())
        return {};
    auto comboProperty = m_data.value<ComboProperty>();
    return comboProperty.getValues();
}
 
//! Returns index for QComboBox.
 
int ComboPropertyEditor::internIndex()
{
    if (!m_data.canConvert<ComboProperty>())
        return 0;
    auto comboProperty = m_data.value<ComboProperty>();
    return comboProperty.currentIndex();
}
 
void ComboPropertyEditor::setConnected(bool isConnected)
{
    if (isConnected)
        connect(m_box, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
                &ComboPropertyEditor::onIndexChanged, Qt::UniqueConnection);
    else
        disconnect(m_box, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
                   this, &ComboPropertyEditor::onIndexChanged);
}
 
// --- ScientificSpinBoxEditor ---
 
ScientificSpinBoxEditor::ScientificSpinBoxEditor(QWidget* parent)
    : CustomEditor(parent)
    , m_doubleEditor(new ScientificSpinBox)
{
    setAutoFillBackground(true);
    setFocusPolicy(Qt::StrongFocus);
    m_doubleEditor->setFocusPolicy(Qt::StrongFocus);
    m_doubleEditor->setKeyboardTracking(false);
 
    auto* layout = new QVBoxLayout;
    layout->setMargin(0);
    layout->setSpacing(0);
 
    layout->addWidget(m_doubleEditor);
 
    connect(m_doubleEditor, &ScientificSpinBox::valueChanged, [=] { this->onEditingFinished(); });
 
    setLayout(layout);
 
    setFocusProxy(m_doubleEditor);
}
 
void ScientificSpinBoxEditor::setLimits(const RealLimits& limits)
{
    m_doubleEditor->setMinimum(limits.hasLowerLimit() ? limits.lowerLimit()
                                                      : std::numeric_limits<double>::lowest());
    m_doubleEditor->setMaximum(limits.hasUpperLimit() ? limits.upperLimit()
                                                      : std::numeric_limits<double>::max());
}
 
void ScientificSpinBoxEditor::setDecimals(int decimals)
{
    m_doubleEditor->setDecimals(decimals);
    m_doubleEditor->setSingleStep(singleStep(decimals));
}
 
void ScientificSpinBoxEditor::setSingleStep(double step)
{
    m_doubleEditor->setSingleStep(step);
}
 
void ScientificSpinBoxEditor::onEditingFinished()
{
    double new_value = m_doubleEditor->value();
 
    if (new_value != m_data.toDouble())
        setDataIntern(QVariant::fromValue(new_value));
}
 
void ScientificSpinBoxEditor::initEditor()
{
    ASSERT(m_data.type() == QVariant::Double);
    m_doubleEditor->setValue(m_data.toDouble());
}