create spinboxes directly in DistributionEditor instead of complicated...

create spinboxes directly in DistributionEditor instead of complicated separate forms; make use of descriptors for this

GUI/View/Instrument/DistributionEditor.cpp

@@ -18,8 +18,9 @@
 #include "GUI/Model/Device/BeamDistributionItem.h"
 #include "GUI/Support/XML/Backup.h"
 #include "GUI/Support/XML/Streamer.h"
-#include "GUI/View/Instrument/DistributionForms.h"
+#include "GUI/View/Edit/DoubleSpinBox.h"
 #include "GUI/View/Instrument/DistributionPlot.h"
+#include "GUI/View/PropertyEditor/ScientificSpinBox.h"
 #include "GUI/View/Tool/GroupBoxCollapser.h"
 #include "GUI/View/Tool/WidgetUtils.h"
 #include <QComboBox>
@@ -58,27 +59,91 @@ void DistributionSelector::createDistributionWidgets()
     while (m_formLayout->rowCount() > 1)
         m_formLayout->removeRow(1);
 
-    DistributionForm* form = nullptr;
-    if (m_item->distribution()->is<DistributionCosineItem>())
-        form = new CosineDistributionForm(m_meanConfig, this);
-    else if (m_item->distribution()->is<DistributionGateItem>())
-        form = new GateDistributionForm(this);
-    else if (m_item->distribution()->is<DistributionGaussianItem>())
-        form = new GaussDistributionForm(m_meanConfig, this);
-    else if (m_item->distribution()->is<DistributionLogNormalItem>())
-        form = new LogNormalDistributionForm(this);
-    else if (m_item->distribution()->is<DistributionLorentzItem>())
-        form = new LorentzDistributionForm(m_meanConfig, this);
-    else if (m_item->distribution()->is<DistributionNoneItem>())
-        form = new NoneDistributionForm(m_meanConfig, this);
-    else if (m_item->distribution()->is<DistributionTrapezoidItem>())
-        form = new TrapezoidDistributionForm(this);
-
-    ASSERT(form);
-    form->setupDistribution(m_item);
-    m_formLayout->addRow(form);
-    connect(form, &CosineDistributionForm::distributionChanged, this,
-            &DistributionSelector::distributionChanged);
+    if (auto* cosine = dynamic_cast<DistributionCosineItem*>(m_item->distribution())) {
+        createMeanSpinBox(cosine->mean());
+        createSpinBox(cosine->sigma());
+        createSpinBox(cosine->numberOfSamples());
+        createSpinBox(cosine->sigmaFactor());
+    } else if (auto* gate = dynamic_cast<DistributionGateItem*>(m_item->distribution())) {
+        auto* minSpinbox = createSpinBox(gate->minimum());
+        auto* maxSpinbox = createSpinBox(gate->maximum());
+        connect(minSpinbox, &DoubleSpinBox::baseValueChanged, [=](double d) {
+            if (d > gate->maximum()) {
+                gate->setMaximum(d);
+                maxSpinbox->updateValue();
+            }
+        });
+        connect(maxSpinbox, &DoubleSpinBox::baseValueChanged, [=](double d) {
+            if (d < gate->minimum()) {
+                gate->setMinimum(d);
+                minSpinbox->updateValue();
+            }
+        });
+        createSpinBox(gate->numberOfSamples());
+    } else if (auto* gauss = dynamic_cast<DistributionGaussianItem*>(m_item->distribution())) {
+        createMeanSpinBox(gauss->mean());
+        createSpinBox(gauss->standardDeviation());
+        createSpinBox(gauss->numberOfSamples());
+        createSpinBox(gauss->sigmaFactor());
+    } else if (auto* logNormal = dynamic_cast<DistributionLogNormalItem*>(m_item->distribution())) {
+        createSpinBox(logNormal->median());
+        createSpinBox(logNormal->scaleParameter());
+        createSpinBox(logNormal->numberOfSamples());
+        createSpinBox(logNormal->sigmaFactor());
+    } else if (auto* lorentz = dynamic_cast<DistributionLorentzItem*>(m_item->distribution())) {
+        createMeanSpinBox(lorentz->mean());
+        createSpinBox(lorentz->hwhm());
+        createSpinBox(lorentz->numberOfSamples());
+        createSpinBox(lorentz->sigmaFactor());
+    } else if (auto* none = dynamic_cast<DistributionNoneItem*>(m_item->distribution())) {
+        createMeanSpinBox(none->mean());
+    } else if (auto* trapezoid = dynamic_cast<DistributionTrapezoidItem*>(m_item->distribution())) {
+        createSpinBox(trapezoid->center());
+        createSpinBox(trapezoid->leftWidth());
+        createSpinBox(trapezoid->middleWidth());
+        createSpinBox(trapezoid->rightWidth());
+        createSpinBox(trapezoid->numberOfSamples());
+    }
+}
+
+DoubleSpinBox* DistributionSelector::createSpinBox(const DoubleDescriptor& d)
+{
+    auto* sb = GUI::Util::createSpinBox(m_formLayout, d);
+    connect(sb, &DoubleSpinBox::baseValueChanged, [=](double v) {
+        if (d.get() != v) {
+            d.set(v);
+            emit distributionChanged();
+        }
+    });
+    return sb;
+}
+
+QSpinBox* DistributionSelector::createSpinBox(const UIntDescriptor& d)
+{
+    auto* sb = GUI::Util::createSpinBox(m_formLayout, d);
+    connect(sb, QOverload<int>::of(&QSpinBox::valueChanged), [=](int v) {
+        if (d.get() != v) {
+            d.set(v);
+            emit distributionChanged();
+        }
+    });
+    return sb;
+}
+
+void DistributionSelector::createMeanSpinBox(const DoubleDescriptor& d)
+{
+    if (m_meanConfig) {
+        if (m_meanConfig->scientific) {
+            auto* sb = GUI::Util::createScientificSpinBox(m_formLayout, d);
+            connect(sb, &ScientificSpinBox::valueChanged, [=](double v) {
+                if (d.get() != v) {
+                    d.set(v);
+                    emit distributionChanged();
+                }
+            });
+        } else
+            createSpinBox(d);
+    }
 }
 
 BeamDistributionItem* DistributionSelector::item() const

GUI/View/Instrument/DistributionEditor.h

@@ -24,6 +24,11 @@ class DistributionForm;
 class BeamDistributionItem;
 class QFormLayout;
 class DistributionPlot;
+class DoubleSpinBox;
+class ScientificSpinBox;
+class QSpinBox;
+class DoubleDescriptor;
+class UIntDescriptor;
 
 #include <boost/numeric/interval.hpp>
 
@@ -64,6 +69,9 @@ signals:
 
 private:
     void createDistributionWidgets();
+    DoubleSpinBox* createSpinBox(const DoubleDescriptor& d);
+    QSpinBox* createSpinBox(const UIntDescriptor& d);
+    void createMeanSpinBox(const DoubleDescriptor& d);
 
 private:
     BeamDistributionItem* m_item;