detail_label_slider.hpp

#pragma once
 
#pragma warning(push)
#pragma warning(disable : 4800)
#pragma warning(disable : 4251)
#pragma warning(disable : 4244)
#include <QFrame>
#include <QSlider>
#include <QToolButton>
#include <QLabel>
#include <QGridLayout>
#pragma warning(pop)
 
#include "../../global.hpp"
#include "../../utilities/system_info.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
    namespace Private
    {
 
      class LabelSlider : public QFrame
      {
 
        Q_OBJECT
 
      public:
        explicit LabelSlider(Qt::Orientation orientation = Qt::Vertical, bool enableButtons = false,
                             QWidget *parent = 0)
            : QFrame(parent)
            , buttonSize_(15, 15)
            , boldLabel_(false)
        {
          auto layout = new QGridLayout(this);  // NOLINT(cppcoreguidelines-owning-memory)
 
          slider_ = new QSlider;  // NOLINT
          slider_->setOrientation(orientation);
 
          QObject::connect(
              slider_, &QSlider::sliderReleased, this,
              [=]() {
                SetValue(slider_->value());
                ValueChanged(slider_->value());  // send signal
              },
              Qt::QueuedConnection);
 
          maxLabel_ =
              new QLabel(QString::number(std::numeric_limits<int>::max()));  // NOLINT(cppcoreguidelines-owning-memory)
          minLabel_ =
              new QLabel(QString::number(std::numeric_limits<int>::min()));  // NOLINT(cppcoreguidelines-owning-memory)
 
          auto upButton_ = new QToolButton;  // NOLINT
          upButton_->setArrowType(Qt::UpArrow);
          upButton_->setMaximumSize(buttonSize_);
 
          auto downButton_ = new QToolButton;  // NOLINT
          downButton_->setArrowType(Qt::DownArrow);
          downButton_->setMaximumSize(buttonSize_);
 
          QObject::connect(
              upButton_, &QToolButton::clicked, this,
              [=]() {
                auto value = slider_->value();
                value += slider_->singleStep();
                if (value > Maximum())
                  value = Maximum();
                SetValue(value);
              },
              Qt::QueuedConnection);
 
          QObject::connect(
              downButton_, &QToolButton::clicked, this,
              [=]() {
                auto value = slider_->value();
                value -= slider_->singleStep();
                if (value < Minimum())
                  value = Minimum();
                SetValue(value);
              },
              Qt::QueuedConnection);
 
          layout->addWidget(maxLabel_, 0, 0, Qt::AlignRight);
          layout->addWidget(slider_, 1, 1, Qt::AlignCenter);
          layout->addWidget(minLabel_, 2, 0, Qt::AlignRight);
 
          if (enableButtons)
          {
            layout->addWidget(upButton_, 0, 1, Qt::AlignCenter);
            layout->addWidget(downButton_, 2, 1, Qt::AlignCenter);
          }
        }
 
        void SetMinimum(int value)
        {
          slider_->setMinimum(value);
          SetLabel(minLabel_, QString::number(value));
        }
 
        void SetMaximum(int value)
        {
          slider_->setMaximum(value);
          SetLabel(maxLabel_, QString::number(value));
        }
 
        void SetValue(int value)
        {
          // Get a valid value (depending on singleStep)
          value = ValidValue(value);
 
          // Set the value
          if (slider_->value() != value)
            slider_->setValue(value);
 
          ValueChanged(value);  // send signal
        }
 
        void SetSingleStep(int value)
        {
          slider_->setSingleStep(value);
        }
 
        int Minimum()
        {
          return slider_->minimum();
        }
 
        int Maximum()
        {
          return slider_->maximum();
        }
 
        int Value()
        {
          return slider_->value();
        }
 
        int SingleStep()
        {
          return slider_->singleStep();
        }
 
        void SetBoldLabel(bool value)
        {
          boldLabel_ = value;
          SetLabel(maxLabel_, maxLabel_->text());
          SetLabel(minLabel_, minLabel_->text());
        }
 
      Q_SIGNALS:
 
        void ValueChanged(int value);
 
      private:
        void SetLabel(QLabel *label, const QString &text)
        {
          if (boldLabel_)
            label->setText("<b>" + text + "</b>");
          else
            label->setText(text);
        }
 
        int ValidValue(int value)
        {
          if (value == Maximum())
          {
            while (value % SingleStep() != 0)
              --value;
            return value;
          }
          else if (value == Minimum())
          {
            while (value % SingleStep() != 0)
              ++value;
            return value;
          }
 
          auto modulo = value % SingleStep();
          if (modulo != 0)
          {
            // move to upper value
            if (modulo >= (SingleStep() / 2))
            {
              while (value % SingleStep() != 0)
                ++value;
            }
            // move to lower value
            else
            {
              while (value % SingleStep() != 0)
                --value;
            }
          }
 
          return value;
        }
 
      private:
        QSlider *slider_;
        QLabel *maxLabel_;
        QLabel *minLabel_;
        QSize buttonSize_;
        bool boldLabel_;
 
      }; /* class ValueScrollBar */
 
    } /* namespace Private */
  } /* namespace UI */
 
  CVB_END_INLINE_NS
 
} /* namespace Cvb */