detail_spinbox_slider.hpp

#pragma once
 
#pragma warning(push)
#pragma warning(disable : 4800)
#pragma warning(disable : 4251)
#pragma warning(disable : 4244)
#include <QFrame>
#include <QPushButton>
#include <QHBoxLayout>
#include <QDialog>
#include <QEvent>
#pragma warning(pop)
 
#include "../../global.hpp"
#include "detail_spinbox64.hpp"
#include "detail_label_slider.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
    namespace Private
    {
 
      class SpinBoxSlider64 : public QFrame
      {
 
        Q_OBJECT
 
      public:
        explicit SpinBoxSlider64(QWidget *parent = 0)
            : QFrame(parent)
            , sliderDialog_(nullptr)
            , sliderCoarse_(nullptr)
            , sliderFine_(nullptr)
        {
          auto layout = new QHBoxLayout(this);  // NOLINT(cppcoreguidelines-owning-memory)
          layout->setContentsMargins(0, 0, 0, 0);
          layout->setSpacing(0);
 
          spinBox_ = new SpinBox64();  // NOLINT
          layout->addWidget(spinBox_);
          QObject::connect(spinBox_, &SpinBox64::ValueChanged, this, &SpinBoxSlider64::SpinBoxChanged,
                           Qt::QueuedConnection);
 
          button_ = new QPushButton("...");  // NOLINT
          button_->setFixedWidth(20);
          layout->setStretch(0, 1);
          layout->addWidget(button_);
          QObject::connect(button_, &QPushButton::pressed, this, &SpinBoxSlider64::ButtonPressed, Qt::QueuedConnection);
 
          installEventFilter(this);
 
          if (!CanCast())
          {
            button_->hide();
          }
        }
 
        void SetMinimum(qint64 minimum)
        {
          spinBox_->setMinimum(minimum);
 
          if (sliderFine_)
            sliderFine_->SetMinimum((int)minimum);
 
          if (CanCast())
            button_->show();
          else
            button_->hide();
        }
 
        void SetMaximum(qint64 maximum)
        {
          spinBox_->setMaximum(maximum);
 
          if (CanCast())
            button_->show();
          else
            button_->hide();
        }
 
        void SetRange(qint64 minimum, qint64 maximum)
        {
          spinBox_->setRange(minimum, maximum);
 
          if (CanCast())
            button_->show();
          else
            button_->hide();
        }
 
        qint64 Minimum() const
        {
          return spinBox_->minimum();
        }
 
        qint64 Maximum() const
        {
          return spinBox_->maximum();
        }
 
        void SetValue(qint64 val)
        {
          spinBox_->setValue(val);
        }
 
        qint64 Value() const
        {
          return spinBox_->value();
        }
 
        void SetSingleStep(qint64 val)
        {
          spinBox_->setSingleStep(val);
        }
 
        qint64 SingleStep() const
        {
          return spinBox_->singleStep();
        }
 
      Q_SIGNALS:
 
        void ValueChanged(qint64 value);
 
      public Q_SLOTS:
 
        void SliderFineChanged(int value)
        {
          // Adjust spinbox
          auto oldState = spinBox_->blockSignals(true);
          spinBox_->setValue(value);
          spinBox_->blockSignals(oldState);
 
          // Adjust the coarse slider
          oldState = sliderCoarse_->blockSignals(true);
          sliderCoarse_->SetValue(value);
          sliderCoarse_->blockSignals(oldState);
 
          ValueChanged(static_cast<qint64>(value));  // send signal
        }
 
        void SliderCoarseChanged(int value)
        {
          // Adjust spinbox
          auto oldState = spinBox_->blockSignals(true);
          spinBox_->setValue(value);
          spinBox_->blockSignals(oldState);
 
          // Adjust the fine slider
          oldState = sliderFine_->blockSignals(true);
          SetFineSliderRanges(value);
          SetFineSlider(value);
          sliderFine_->blockSignals(oldState);
 
          ValueChanged(static_cast<qint64>(value));  // send signal
        }
 
        void SpinBoxChanged(qint64 value)
        {
          // Adjust fine slider
          if (sliderFine_)
          {
            auto oldState = sliderFine_->blockSignals(true);
            SetFineSliderRanges(static_cast<int>(value));  // only called if CanCast() is true
            SetFineSlider(static_cast<int>(value));        // only called if CanCast() is true
            sliderFine_->blockSignals(oldState);
          }
 
          // Adjust coarse slider
          if (sliderCoarse_)
          {
            auto oldState = sliderCoarse_->blockSignals(true);
            sliderCoarse_->SetValue(static_cast<int>(value));  // only called if CanCast() is true
            sliderCoarse_->blockSignals(oldState);
          }
 
          ValueChanged(value);  // send signal
        }
 
        void ButtonPressed()
        {
          if (CanCast())
          {
            auto min   = static_cast<int>(Minimum());
            auto max   = static_cast<int>(Maximum());
            auto value = static_cast<int>(Value());
            ShowSliderDialog(min, max, value);
          }
        }
 
        void HideDialogBox()
        {
          if (sliderDialog_)
            sliderDialog_->hide();
        }
 
        void ShowDialogBox()
        {
          if (sliderDialog_)
            sliderDialog_->show();
        }
 
        bool IsDialogBoxVisible()
        {
          if (sliderDialog_)
            return sliderDialog_->isVisible();
          return false;
        }
 
      protected:
        bool eventFilter(QObject *obj, QEvent *event) override
        {
          if (sliderDialog_)
          {
            button_->updateGeometry();
            auto g = button_->geometry();
 
            auto buttonPos     = button_->rect().bottomRight();
            auto buttonPosGlob = button_->mapToGlobal(buttonPos);
 
            auto x = buttonPosGlob.x();
            auto y = buttonPosGlob.y();
 
            // allow a range of change of 60 (otherwise the dialog can flicker)
            static const int range = 60;
            if (buttonPosGlobal_.x() < x - range || buttonPosGlobal_.x() > x + range || buttonPosGlobal_.y() < y - range
                || buttonPosGlobal_.y() > y + range)
            {
              sliderDialog_->move(buttonPosGlob.x() - sliderDialog_->width(), buttonPosGlob.y());
              buttonPosGlobal_ = buttonPosGlob;
            }
          }
 
          return QObject::eventFilter(obj, event);
        }
 
      private:
        void ShowSliderDialog(int min, int max, int value)
        {
          if (sliderDialog_)
          {
            if (sliderDialog_->isVisible())
              sliderDialog_->hide();
            else
              sliderDialog_->show();
            return;
          }
 
          sliderDialog_ = new QDialog(this);  // NOLINT(cppcoreguidelines-owning-memory)
          sliderDialog_->setWindowFlags(Qt::Dialog | Qt::FramelessWindowHint);
          sliderDialog_->setObjectName("sliderDialog");
          sliderDialog_->setStyleSheet("#sliderDialog{border:1px solid black}");
 
          auto layout = new QHBoxLayout(sliderDialog_);  // NOLINT(cppcoreguidelines-owning-memory)
          layout->setContentsMargins(0, 0, 0, 0);
          layout->setSpacing(0);
 
          sliderFine_ = new LabelSlider(Qt::Vertical, false, sliderDialog_);  // NOLINT(cppcoreguidelines-owning-memory)
          sliderFine_->SetMinimum(FineSliderMin(value));
          sliderFine_->SetMaximum(FineSliderMax(value));
          sliderFine_->SetSingleStep(static_cast<int>(spinBox_->singleStep()));  // only called if CanCast() is true
          sliderFine_->SetValue(value);
 
          QObject::connect(sliderFine_, &LabelSlider::ValueChanged, this, &SpinBoxSlider64::SliderFineChanged,
                           Qt::QueuedConnection);
 
          sliderCoarse_ =
              new LabelSlider(Qt::Vertical, true, sliderDialog_);  // NOLINT(cppcoreguidelines-owning-memory)
          sliderCoarse_->SetMinimum(min);
          sliderCoarse_->SetMaximum(max);
          sliderCoarse_->SetSingleStep(FineSliderSubRange());
          sliderCoarse_->SetBoldLabel(true);
          sliderCoarse_->SetValue(value);
 
          QString scrollMin = "<b>" + QString::number(min) + "</b>";
          QString scrollMax = "<b>" + QString::number(max) + "</b>";
 
          layout->addWidget(sliderFine_);
 
          // Only add the coarse slider, if necessary
          if ((sliderCoarse_->Maximum() - sliderCoarse_->Minimum() > sliderCoarse_->SingleStep()))
            layout->addWidget(sliderCoarse_);
 
          QObject::connect(sliderCoarse_, &LabelSlider::ValueChanged, this, &SpinBoxSlider64::SliderCoarseChanged,
                           Qt::QueuedConnection);
 
          sliderDialog_->adjustSize();
 
          button_->updateGeometry();
          auto buttonPos     = button_->rect().bottomRight();
          auto buttonPosGlob = button_->mapToGlobal(buttonPos);
          sliderDialog_->move(buttonPosGlob.x() - sliderDialog_->width(), buttonPosGlob.y());
          buttonPosGlobal_ = buttonPosGlob;
 
          sliderDialog_->show();
        }
 
        int FineSliderMin(int value)
        {
          auto minimum = spinBox_->minimum();
 
          if (value > spinBox_->maximum())
            value = static_cast<int>(spinBox_->maximum());  // only called if CanCast() is true
 
          auto min = value - FineSliderSubRange();
          if (min <= minimum)
            min = static_cast<int>(minimum);  // only called if CanCast() is true
 
          return min;
        }
 
        int FineSliderMax(int value)
        {
          auto maximum = spinBox_->maximum();
 
          if (value < spinBox_->minimum())
            value = static_cast<int>(spinBox_->minimum());  // only called if CanCast() is true
 
          auto max = value + FineSliderSubRange();
          if (max >= maximum)
            max = static_cast<int>(maximum);  // only called if CanCast() is true
 
          return max;
        }
 
        void SetFineSliderRanges(int value)
        {
          if (value >= sliderFine_->Minimum() && value <= sliderFine_->Maximum())
            return;
 
          sliderFine_->SetMinimum(FineSliderMin(value));
          sliderFine_->SetMaximum(FineSliderMax(value));
        }
 
        void SetFineSlider(int value)
        {
          if (value >= sliderFine_->Minimum() && value <= sliderFine_->Maximum())
          {
            sliderFine_->SetValue(value);
          }
          else
          {
            SetFineSliderRanges(value);
            sliderFine_->SetValue(value);
          }
        }
 
        bool IsInRange(int value)
        {
          if (value >= spinBox_->minimum() && value <= spinBox_->maximum())
            return true;
          return false;
        }
 
        int FineSliderSubRange()
        {
          auto subrange = MAX_FINE_SLIDER_RANGE;
          while (subrange % SingleStep() != 0)
            --subrange;
          return subrange;
        }
 
        bool CanCast()
        {
          return !(Minimum() < std::numeric_limits<int>::min() || Minimum() > std::numeric_limits<int>::max()
                   || Maximum() < std::numeric_limits<int>::min() || Maximum() > std::numeric_limits<int>::max());
        }
 
      private:
        SpinBox64 *spinBox_;
        QPushButton *button_;
        QPoint buttonPosGlobal_;
        QDialog *sliderDialog_;
        LabelSlider *sliderCoarse_;
        LabelSlider *sliderFine_;
 
        static const int MAX_FINE_SLIDER_RANGE = 250;
 
      }; /* class SpinBoxSlider64 */
 
    } /* namespace Private */
  } /* namespace UI */
 
  CVB_END_INLINE_NS
 
} /* namespace Cvb */