New types of RealLimitsItems have been added.

Fit/Parameters/RealLimits.cpp

@@ -19,25 +19,6 @@
 #include <limits>
 #include <sstream>
 
-namespace {
-
-bool isNonnegative(const RealLimits& lim)
-{
-    return lim.hasLowerLimit() && !lim.hasUpperLimit() && lim.getLowerLimit() == 0.0;
-}
-
-bool isLowerLimited(const RealLimits& lim)
-{
-    return lim.hasLowerLimit() && !lim.hasUpperLimit();
-}
-
-bool isUpperLimited(const RealLimits& lim)
-{
-    return !lim.hasLowerLimit() && lim.hasUpperLimit();
-}
-
-}
-
 //! Creates an object which can have only positive values (>0., zero is not included)
 RealLimits RealLimits::positive()
 {
@@ -56,15 +37,15 @@ std::string RealLimits::toString() const
         result << "positive";
     }
 
-    else if(isNonnegative(*this)) {
+    else if(isNonnegative()) {
         result << "nonnegative";
     }
 
-    else if(isLowerLimited(*this)) {
+    else if(isLowerLimited()) {
         result << "lowerLimited("  << std::fixed <<std::setprecision(2) << getLowerLimit() << ")";
     }
 
-    else if(isUpperLimited(*this)) {
+    else if(isUpperLimited()) {
         result << "upperLimited(" << std::fixed <<std::setprecision(2) << getUpperLimit() << ")";
     }
 
@@ -100,7 +81,22 @@ bool RealLimits::isLimitless() const
 bool RealLimits::isPositive() const
 {
     return hasLowerLimit() && !hasUpperLimit()
-           && getLowerLimit() == std::numeric_limits<double>::min();
+            && getLowerLimit() == std::numeric_limits<double>::min();
+}
+
+bool RealLimits::isNonnegative() const
+{
+    return hasLowerLimit() && !hasUpperLimit() && getLowerLimit() == 0.0;
+}
+
+bool RealLimits::isLowerLimited() const
+{
+    return hasLowerLimit() && !hasUpperLimit();
+}
+
+bool RealLimits::isUpperLimited() const
+{
+    return !hasLowerLimit() && hasUpperLimit();
 }
 
 bool RealLimits::isLimited() const

Fit/Parameters/RealLimits.h

@@ -99,9 +99,10 @@ class BA_CORE_API_ RealLimits
     bool operator!=(const RealLimits &other) const { return !(*this == other); }
 
     bool isLimitless() const;
-
     bool isPositive() const;
-
+    bool isNonnegative() const;
+    bool isLowerLimited() const;
+    bool isUpperLimited() const;
     bool isLimited() const;
 
  protected:

GUI/coregui/Models/DistributionItems.cpp

@@ -50,11 +50,30 @@ void DistributionItem::init_limits_group(const RealLimits& limits)
     if (!isTag(P_LIMITS))
         return;
 
-    if (limits.isPositive()) {
-        setGroupProperty(P_LIMITS, Constants::RealLimitsPositiveType);
-    } else if (limits.isLimitless()) {
+    if (limits.isLimitless()) {
         setGroupProperty(P_LIMITS, Constants::RealLimitsLimitlessType);
-    } else if (limits.isLimited()) {
+
+    }
+
+    else if (limits.isPositive()) {
+        setGroupProperty(P_LIMITS, Constants::RealLimitsPositiveType);
+    }
+
+    else if (limits.isNonnegative()) {
+        setGroupProperty(P_LIMITS, Constants::RealLimitsNonnegativeType);
+    }
+
+    else if (limits.isLowerLimited()) {
+        SessionItem* lim = setGroupProperty(P_LIMITS, Constants::RealLimitsLowerLimitedType);
+        lim->setItemValue(RealLimitsItem::P_XMIN, limits.getLowerLimit());
+    }
+
+    else if (limits.isUpperLimited()) {
+        SessionItem* lim = setGroupProperty(P_LIMITS, Constants::RealLimitsUpperLimitedType);
+        lim->setItemValue(RealLimitsItem::P_XMAX, limits.getUpperLimit());
+    }
+
+    else if (limits.isLimited()) {
         SessionItem* lim = setGroupProperty(P_LIMITS, Constants::RealLimitsLimitedType);
         lim->setItemValue(RealLimitsItem::P_XMIN, limits.getLowerLimit());
         lim->setItemValue(RealLimitsItem::P_XMAX, limits.getUpperLimit());

GUI/coregui/Models/GroupPropertyRegistry.cpp

@@ -135,6 +135,9 @@ GroupPropertyRegistry::SelectableGroupMap_t initializeSelectableGroupMap()
     std::map<QString, QString> limits;
     limits[Constants::RealLimitsLimitlessType] = "Unlimited";
     limits[Constants::RealLimitsPositiveType] = "Positive";
+    limits[Constants::RealLimitsNonnegativeType] = "Nonnegative";
+    limits[Constants::RealLimitsLowerLimitedType] = "LowerLimited";
+    limits[Constants::RealLimitsUpperLimitedType] = "UpperLimited";
     limits[Constants::RealLimitsLimitedType] = "Limited";
     result[Constants::RealLimitsGroup] = limits;
 

GUI/coregui/Models/ItemFactory.cpp

@@ -205,6 +205,9 @@ ItemFactory::ItemMap_t initializeItemMap() {
 
     result[Constants::RealLimitsLimitlessType] = &createInstance<LimitlessItem>;
     result[Constants::RealLimitsPositiveType] = &createInstance<PositiveItem>;
+    result[Constants::RealLimitsNonnegativeType] = &createInstance<NonnegativeItem>;
+    result[Constants::RealLimitsLowerLimitedType] = &createInstance<LowerLimitedItem>;
+    result[Constants::RealLimitsUpperLimitedType] = &createInstance<UpperLimitedItem>;
     result[Constants::RealLimitsLimitedType] = &createInstance<LimitedItem>;
 
     return result;

GUI/coregui/Models/RealLimitsItems.cpp

@@ -15,6 +15,11 @@
 
 #include "RealLimitsItems.h"
 
+namespace {
+const QString tooltip_min_value = "Minimum allowed value, value included.";
+const QString tooltip_max_value = "Maximum allowed value, value excluded.";
+}
+
 const QString RealLimitsItem::P_XMIN = "Min";
 const QString RealLimitsItem::P_XMAX = "Max";
 
@@ -24,6 +29,8 @@ RealLimitsItem::RealLimitsItem(const QString& name)
 
 }
 
+// --------------------------------------------------------------------------------------------- //
+
 LimitlessItem::LimitlessItem()
     : RealLimitsItem(Constants::RealLimitsLimitlessType)
 {
@@ -35,6 +42,8 @@ RealLimits LimitlessItem::createRealLimits() const
     return RealLimits();
 }
 
+// --------------------------------------------------------------------------------------------- //
+
 PositiveItem::PositiveItem()
     : RealLimitsItem(Constants::RealLimitsPositiveType)
 {
@@ -46,12 +55,55 @@ RealLimits PositiveItem::createRealLimits() const
     return RealLimits::positive();
 }
 
+// --------------------------------------------------------------------------------------------- //
+
+NonnegativeItem::NonnegativeItem()
+    : RealLimitsItem(Constants::RealLimitsNonnegativeType)
+{
+
+}
+
+RealLimits NonnegativeItem::createRealLimits() const
+{
+    return RealLimits::nonnegative();
+}
+
+// --------------------------------------------------------------------------------------------- //
+
+LowerLimitedItem::LowerLimitedItem()
+    : RealLimitsItem(Constants::RealLimitsLowerLimitedType)
+{
+    addProperty(P_XMIN, 0.0)->setToolTip(tooltip_min_value)
+        .setLimits(RealLimits::limitless());
+}
+
+RealLimits LowerLimitedItem::createRealLimits() const
+{
+    return RealLimits::lowerLimited(getItemValue(P_XMIN).toDouble());
+}
+
+// --------------------------------------------------------------------------------------------- //
+
+UpperLimitedItem::UpperLimitedItem()
+    : RealLimitsItem(Constants::RealLimitsUpperLimitedType)
+{
+    addProperty(P_XMAX, 1.0)->setToolTip(tooltip_max_value)
+        .setLimits(RealLimits::limitless());
+}
+
+RealLimits UpperLimitedItem::createRealLimits() const
+{
+    return RealLimits::upperLimited(getItemValue(P_XMAX).toDouble());
+}
+
+// --------------------------------------------------------------------------------------------- //
+
 LimitedItem::LimitedItem()
     : RealLimitsItem(Constants::RealLimitsLimitedType)
 {
-    addProperty(P_XMIN, 0.0)->setToolTip("Minimum allowed value")
+    addProperty(P_XMIN, 0.0)->setToolTip(tooltip_min_value)
         .setLimits(RealLimits::limitless());
-    addProperty(P_XMAX, 1.0)->setToolTip("Maximum allowed value")
+    addProperty(P_XMAX, 1.0)->setToolTip(tooltip_max_value)
         .setLimits(RealLimits::limitless());
 }
 

GUI/coregui/Models/RealLimitsItems.h

@@ -44,6 +44,27 @@ public:
     RealLimits createRealLimits() const;
 };
 
+class BA_CORE_API_ NonnegativeItem : public RealLimitsItem
+{
+public:
+    NonnegativeItem();
+    RealLimits createRealLimits() const;
+};
+
+class BA_CORE_API_ LowerLimitedItem : public RealLimitsItem
+{
+public:
+    LowerLimitedItem();
+    RealLimits createRealLimits() const;
+};
+
+class BA_CORE_API_ UpperLimitedItem : public RealLimitsItem
+{
+public:
+    UpperLimitedItem();
+    RealLimits createRealLimits() const;
+};
+
 class BA_CORE_API_ LimitedItem : public RealLimitsItem
 {
 public:

GUI/coregui/Models/item_constants.h

@@ -169,9 +169,11 @@ const ModelType TestMinimizerType = "Test";
 
 const ModelType RealLimitsLimitlessType = "RealLimitsLimitless";
 const ModelType RealLimitsPositiveType = "RealLimitsPositive";
+const ModelType RealLimitsNonnegativeType = "RealLimitsNonnegative";
+const ModelType RealLimitsLowerLimitedType = "RealLimitsLowerLimited";
+const ModelType RealLimitsUpperLimitedType = "RealLimitsUpperLimited";
 const ModelType RealLimitsLimitedType = "RealLimitsLimited";
 
-
 // --- Groups ------------------------------------------------------------------
 
 const ModelType FormFactorGroup = "Form Factor";

Tests/UnitTests/GUI/TestParameterTreeUtils.h

@@ -47,7 +47,6 @@ inline void TestParameterTreeUtils::test_parameterTreeNames()
 
 inline void TestParameterTreeUtils::test_parameterTranslatedNames()
 {
-    QCOMPARE(1,1);
     SampleModel model;
 
     SessionItem *particle = model.insertNewItem(Constants::ParticleType);
@@ -60,7 +59,6 @@ inline void TestParameterTreeUtils::test_parameterTranslatedNames()
 
 inline void TestParameterTreeUtils::test_linkItemFromParameterName()
 {
-    QCOMPARE(1, 1);
     SampleModel model;
 
     SessionItem* particle = model.insertNewItem(Constants::ParticleType);