Initial commit

Lts/Common/LtsWidgets/lts_spinbox.cpp

@@ -0,0 +1,180 @@
+/**
+ * @RDE_HEADER@
+ * SpinBox, that corrects values to a valid value that fits minimum() + n * singleStep() = value
+ * $Id$
+ * $HeadURL$
+ * $Author$
+ *
+ * Created by Malte Diers, NLSE, 2018-05-07
+ */
+
+#include "lts_spinbox.h"
+
+#include <cmath>
+
+namespace LtsWidgets
+{
+
+LtsSpinBox::LtsSpinBox(QWidget *parent)
+  : QSpinBox(parent)
+{
+}
+
+QValidator::State LtsSpinBox::validate(QString &input, int &pos) const
+{
+  QIntValidator validator;
+  for (auto range : m_validRanges)
+  {
+    validator.setBottom(range.first);
+    validator.setTop(range.second);
+    QValidator::State state = validator.validate(input, pos);
+    if (state == QValidator::Invalid ||
+        state == QValidator::Intermediate)
+      return state;
+  }
+
+  // Now we're sure, it's an int. Therefore toInt() will always be okay:
+  int value = input.toInt();
+  value -= minimum();
+  return (value % singleStep() == 0) ? QValidator::Acceptable : QValidator::Intermediate;
+}
+
+void LtsSpinBox::fixup(QString &str) const
+{
+  QSpinBox::fixup(str);
+
+  if (singleStep() == 1)
+    return;
+
+  bool bOk;
+  int value = str.toInt(&bOk);
+  if (!bOk)
+    return;
+
+  int remainder = (value - minimum()) % singleStep();
+
+  if (2 * remainder > singleStep())
+    value += singleStep();
+
+  value -= remainder;
+
+  if (value > maximum())
+    value -= singleStep();
+
+  str = QString::number(value);
+}
+
+bool LtsSpinBox::setExclusionRanges(const QVector<QPair<int,int> > &exclusionRanges, bool preserveCurrentValues)
+{
+  bool retVal = true;
+  // In eigene Variable
+  auto newExclusions = exclusionRanges;
+  // Hinzufügen?
+  if (preserveCurrentValues)
+    newExclusions += m_exclusions;
+  // ggf. Min und Max tauschen:
+  for (auto &elem : newExclusions)
+  {
+    if (elem.first > elem.second)
+    {
+      int tmp = elem.first;
+      elem.first= elem.second;
+      elem.second = tmp;
+    }
+  }
+  // Sortieren und
+  std::sort(newExclusions.begin(), newExclusions.end(), [](const QPair<int,int> &a, const QPair<int,int> &b) { return a.first < b.first; });
+  for (int i=0; i<newExclusions.size()-1; ++i)
+  {
+    // schauen, dass sie nicht überlappen.
+    if (newExclusions[i].second >= newExclusions[i+1].first)
+    {
+      retVal = false;
+      break;
+    }
+  }
+  // Falls doch - oder falls out of range
+  if (!retVal || newExclusions[0].first <= minimum() || newExclusions[newExclusions.size()-1].second >= maximum())
+  {
+    // Falls nicht "Hinzufügen", Liste leeren. Sonst bleibt alles beim Alten.
+    if (!preserveCurrentValues)
+      m_exclusions.clear();
+    return false;
+  }
+  // Alles in Butter:
+  m_exclusions = exclusionRanges;
+
+  // Put that into validRanges...
+  m_validRanges.clear();
+  if (m_exclusions[0].first - 1 > minimum())
+    m_validRanges.append({minimum(), m_exclusions[0].first - 1});
+  for (int i=0; i<m_exclusions.size()-1; ++i)
+  {
+    // Beware if Ranges join each other: {1..2} {3..7}
+    if (m_exclusions[i].second + 1 < m_exclusions[i+1].first - 1)
+      m_validRanges.append({m_exclusions[i].second + 1, m_exclusions[i+1].first - 1});
+  }
+  if (m_exclusions[m_exclusions.size()-1].second + 1 < maximum())
+    m_validRanges.append({m_exclusions[0].first - 1, maximum()});
+
+  return true;
+}
+
+bool LtsSpinBox::addExclusionRange(int min, int max)
+{
+  return setExclusionRanges({{min, max}}, true);
+}
+
+void LtsSpinBox::clearExclusionRanges()
+{
+  m_exclusions.clear();
+}
+
+
+LtsDoubleSpinBox::LtsDoubleSpinBox(QWidget *parent)
+  : QDoubleSpinBox(parent)
+{
+}
+
+QValidator::State LtsDoubleSpinBox::validate(QString &input, int &pos) const
+{
+  QDoubleValidator validator;
+  validator.setBottom(minimum());
+  validator.setTop(maximum());
+  QValidator::State state = validator.validate(input, pos);
+  if (state == QValidator::Invalid ||
+      state == QValidator::Intermediate)
+    return state;
+
+  // Now we're sure, it's an int. Therefore toInt() will always be okay:
+  double value = input.toDouble();
+  value -= minimum();
+  return qFuzzyCompare(std::fmod(value, singleStep()), 0.0) ? QValidator::Acceptable : QValidator::Intermediate;
+}
+
+void LtsDoubleSpinBox::fixup(QString &str) const
+{
+  QDoubleSpinBox::fixup(str);
+
+  if (qFuzzyCompare(singleStep(), pow(10, decimals())))
+    return;
+
+  bool bOk;
+  double value = str.toDouble(&bOk);
+  if (!bOk)
+    return;
+
+  double remainder = std::fmod(value - minimum(), singleStep());
+
+  if (2 * remainder > singleStep())
+    value += singleStep();
+
+  value -= remainder;
+
+  if (value > maximum())
+    value -= singleStep();
+
+  str = QString::number(value, 'f', decimals());
+}
+
+} // namespace LtsWidgets