Make RealLimitsItem::P_(XMIN|XMAX) private

GUI/Models/DistributionItems.cpp

@@ -59,15 +59,18 @@ void DistributionItem::init_limits_group(const RealLimits& limits, double factor
     } else if (limits.isNonnegative()) {
         setGroupProperty(P_LIMITS, "RealLimitsNonnegative");
     } else if (limits.isLowerLimited()) {
-        SessionItem* lim = setGroupProperty(P_LIMITS, "RealLimitsLowerLimited");
-        lim->setItemValue(RealLimitsItem::P_XMIN, limits.lowerLimit() * factor);
+        LowerLimitedItem* lim = dynamic_cast<LowerLimitedItem*>
+            (setGroupProperty(P_LIMITS, "RealLimitsLowerLimited"));
+        lim->setLowerLimit(limits.lowerLimit() * factor);
     } else if (limits.isUpperLimited()) {
-        SessionItem* lim = setGroupProperty(P_LIMITS, "RealLimitsUpperLimited");
-        lim->setItemValue(RealLimitsItem::P_XMAX, limits.upperLimit() * factor);
+        UpperLimitedItem* lim = dynamic_cast<UpperLimitedItem*>
+            (setGroupProperty(P_LIMITS, "RealLimitsUpperLimited"));
+        lim->setUpperLimit(limits.upperLimit() * factor);
     } else if (limits.isLimited()) {
-        SessionItem* lim = setGroupProperty(P_LIMITS, "RealLimitsLimited");
-        lim->setItemValue(RealLimitsItem::P_XMIN, limits.lowerLimit() * factor);
-        lim->setItemValue(RealLimitsItem::P_XMAX, limits.upperLimit() * factor);
+        LimitedItem* lim = dynamic_cast<LimitedItem*>
+            (setGroupProperty(P_LIMITS, "RealLimitsLimited"));
+        lim->setLowerLimit(limits.lowerLimit() * factor);
+        lim->setUpperLimit(limits.upperLimit() * factor);
     }
 }
 

GUI/Models/RealLimitsItems.cpp

@@ -22,7 +22,39 @@ const QString tooltip_max_value = "Maximum allowed value, value excluded.";
 const QString RealLimitsItem::P_XMIN = "Min";
 const QString RealLimitsItem::P_XMAX = "Max";
 
-RealLimitsItem::RealLimitsItem(const QString& name) : SessionItem(name) {}
+RealLimitsItem::RealLimitsItem(const QString& name,
+                               const std::optional<double>& lower,
+                               const std::optional<double>& upper)
+    : SessionItem(name)
+{
+    if (lower)
+        addProperty(P_XMIN, lower.value())
+            ->setToolTip(tooltip_min_value).setLimits(RealLimits::limitless());
+    
+    if (upper)
+        addProperty(P_XMAX, upper.value())
+            ->setToolTip(tooltip_max_value).setLimits(RealLimits::limitless());
+}
+
+double RealLimitsItem::lowerLimit() const
+{
+    return getItemValue(P_XMIN).toDouble();
+}
+
+void RealLimitsItem::setLowerLimit(double lower)
+{
+    setItemValue(P_XMIN, lower);
+}
+
+double RealLimitsItem::upperLimit() const
+{
+    return getItemValue(P_XMAX).toDouble();
+}
+
+void RealLimitsItem::setUpperLimit(double upper)
+{
+    setItemValue(P_XMAX, upper);
+}
 
 // --------------------------------------------------------------------------------------------- //
 
@@ -53,38 +85,32 @@ RealLimits NonnegativeItem::createRealLimits(double /*scale_factor*/) const
 
 // --------------------------------------------------------------------------------------------- //
 
-LowerLimitedItem::LowerLimitedItem() : RealLimitsItem("RealLimitsLowerLimited")
-{
-    addProperty(P_XMIN, 0.0)->setToolTip(tooltip_min_value).setLimits(RealLimits::limitless());
-}
+LowerLimitedItem::LowerLimitedItem() : RealLimitsItem("RealLimitsLowerLimited", 0.0)
+{}
 
 RealLimits LowerLimitedItem::createRealLimits(double scale_factor) const
 {
-    return RealLimits::lowerLimited(scale_factor * getItemValue(P_XMIN).toDouble());
+    return RealLimits::lowerLimited(scale_factor * lowerLimit());
 }
 
 // --------------------------------------------------------------------------------------------- //
 
-UpperLimitedItem::UpperLimitedItem() : RealLimitsItem("RealLimitsUpperLimited")
-{
-    addProperty(P_XMAX, 1.0)->setToolTip(tooltip_max_value).setLimits(RealLimits::limitless());
-}
+UpperLimitedItem::UpperLimitedItem()
+    : RealLimitsItem("RealLimitsUpperLimited", std::nullopt, 1.0)
+{}
 
 RealLimits UpperLimitedItem::createRealLimits(double scale_factor) const
 {
-    return RealLimits::upperLimited(scale_factor * getItemValue(P_XMAX).toDouble());
+    return RealLimits::upperLimited(scale_factor * upperLimit());
 }
 
 // --------------------------------------------------------------------------------------------- //
 
-LimitedItem::LimitedItem() : RealLimitsItem("RealLimitsLimited")
-{
-    addProperty(P_XMIN, 0.0)->setToolTip(tooltip_min_value).setLimits(RealLimits::limitless());
-    addProperty(P_XMAX, 1.0)->setToolTip(tooltip_max_value).setLimits(RealLimits::limitless());
-}
+LimitedItem::LimitedItem() : RealLimitsItem("RealLimitsLimited", 0.0, 1.0)
+{}
 
 RealLimits LimitedItem::createRealLimits(double scale_factor) const
 {
-    return RealLimits::limited(scale_factor * getItemValue(P_XMIN).toDouble(),
-                               scale_factor * getItemValue(P_XMAX).toDouble());
+    return RealLimits::limited(scale_factor * lowerLimit(),
+                               scale_factor * upperLimit());
 }

GUI/Models/RealLimitsItems.h

@@ -18,10 +18,20 @@
 #include "GUI/Models/SessionItem.h"
 
 class BA_CORE_API_ RealLimitsItem : public SessionItem {
-public:
+private:
     static const QString P_XMIN;
     static const QString P_XMAX;
-    RealLimitsItem(const QString& name);
+
+protected:
+    RealLimitsItem(const QString& name,
+                   const std::optional<double>& lower = std::nullopt,
+                   const std::optional<double>& upper = std::nullopt);
+    double lowerLimit() const;
+    void setLowerLimit(double lower);
+    double upperLimit() const;
+    void setUpperLimit(double upper);
+
+public:
     virtual ~RealLimitsItem() {}
     virtual RealLimits createRealLimits(double scale_factor = 1.0) const = 0;
 };
@@ -48,18 +58,22 @@ class BA_CORE_API_ LowerLimitedItem : public RealLimitsItem {
 public:
     LowerLimitedItem();
     RealLimits createRealLimits(double scale_factor = 1.0) const;
+    using RealLimitsItem::setLowerLimit;
 };
 
 class BA_CORE_API_ UpperLimitedItem : public RealLimitsItem {
 public:
     UpperLimitedItem();
     RealLimits createRealLimits(double scale_factor = 1.0) const;
+    using RealLimitsItem::setUpperLimit;    
 };
 
 class BA_CORE_API_ LimitedItem : public RealLimitsItem {
 public:
     LimitedItem();
     RealLimits createRealLimits(double scale_factor = 1.0) const;
+    using RealLimitsItem::setLowerLimit;
+    using RealLimitsItem::setUpperLimit;    
 };
 
 #endif // BORNAGAIN_GUI_MODELS_REALLIMITSITEMS_H