detail_spinbox64.hpp

#pragma once
 
#pragma warning(push)
#pragma warning(disable : 4800)
#pragma warning(disable : 4251)
#pragma warning(disable : 4244)
#include <QAbstractSpinBox>
#include <QLineEdit>
#pragma warning(pop)
 
#include "../../global.hpp"
#include "../../utilities/system_info.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
    namespace Private
    {
 
      class SpinBox64 : public QAbstractSpinBox
      {
 
        Q_OBJECT
 
      public:
        explicit SpinBox64(QWidget *parent = 0)
            : QAbstractSpinBox(parent)
            , value_(0)
            , min_(std::numeric_limits<qint64>::min())
            , max_(std::numeric_limits<qint64>::max())
            , singleStep_(1)
        {
          setButtonSymbols(QAbstractSpinBox::UpDownArrows);
          setCorrectionMode(QAbstractSpinBox::CorrectToNearestValue);
 
          QObject::connect(this, &SpinBox64::editingFinished, this, &SpinBox64::valueChanged);
        }
 
        void stepBy(int steps) override
        {
          if (steps == -1)
            stepDown();
          else
            stepUp();
        }
 
        QString textFromValue(qint64 value) const
        {
          return QString::number(value);
        }
 
        qint64 valueFromText(const QString &text) const
        {
          return text.toLongLong();
        }
 
        void setValue(qint64 value)
        {
          if (value > max_)
            value_ = max_;
          else if (value < min_)
            value_ = min_;
          else
            value_ = value;
 
          lineEdit()->setText(QString::number(value_));
          ValueChanged(value_);  // send signal
        }
 
        qint64 value() const
        {
          return value_;
        }
 
        void setMaximum(qint64 max)
        {
          max_ = max;
        }
 
        void setMinimum(qint64 min)
        {
          min_ = min;
        }
 
        void setRange(qint64 minimum, qint64 maximum)
        {
          setMinimum(minimum);
          setMaximum(maximum);
        }
 
        qint64 maximum() const
        {
          return max_;
        }
 
        qint64 minimum() const
        {
          return min_;
        }
 
        void setSingleStep(qint64 val)
        {
          if (val < 0)
            return;
 
          singleStep_ = val;
        }
 
        qint64 singleStep()
        {
          return singleStep_;
        }
 
        QValidator::State validate(QString &input, int & /*pos*/) const override
        {
          qlonglong b(Q_UINT64_C(0x8000000000000000));
          qlonglong t(Q_UINT64_C(0x7FFFFFFFFFFFFFFF));
 
          if (input.contains(QLatin1Char(' ')))
            return QValidator::Invalid;
          if (input.isEmpty() || (b < 0 && input == QString(QLatin1Char('-'))))
            return QValidator::Intermediate;
          bool ok      = false;
          auto entered = input.toLongLong(&ok);
          if (!ok || (entered < 0 && b >= 0))
          {
            return QValidator::Invalid;
          }
          else if (entered >= b && entered <= t)
          {
            return QValidator::Acceptable;
          }
          else
          {
            if (entered >= 0)
              return (entered > t) ? QValidator::Invalid : QValidator::Intermediate;
            else
              return (entered < b) ? QValidator::Invalid : QValidator::Intermediate;
          }
        }
 
      public Q_SLOTS:
 
        void stepDown()
        {
          auto value = value_;
          value -= singleStep_;
          if (value < min_)
            value = min_;
 
          setValue(value);
        }
 
        void stepUp()
        {
          auto value = value_;
          value += singleStep_;
          if (value > max_)
            value = max_;
 
          setValue(value);
        }
 
        void valueChanged()
        {
          auto value = lineEdit()->text().toLongLong();
          value_     = value;
          if (value_ > max_)
            value_ = max_;
          else if (value_ < min_)
            value_ = min_;
 
          lineEdit()->setText(QString::number(value_));
          ValueChanged(value_);  // send signal
        }
 
      Q_SIGNALS:
 
        void ValueChanged(qint64 value);
 
      protected:
        QAbstractSpinBox::StepEnabled stepEnabled() const override
        {
          return (StepUpEnabled) | (StepDownEnabled);
        }
 
      private:
        qint64 value_;
        qint64 min_;
        qint64 max_;
        qint64 singleStep_;
 
      }; /* class SpinBox64 */
 
    } /* namespace Private */
  } /* namespace UI */
 
  CVB_END_INLINE_NS
 
} /* namespace Cvb */