File indexing completed on 2024-05-12 04:33:23

 /*
  * SPDX-FileCopyrightText: 2007-2011 Kare Sars <kare.sars@iki .fi>
  * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
  *
  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
  */
 
 #include "labeledslider.h"
 // Qt includes
 
 #include <QLabel>
 #include <QSlider>
 
 // KDE includes
 
 #include <KPluralHandlingSpinBox>
 #include <KSaneCore/Option>
 
 namespace KSaneIface
 {
 LabeledSlider::LabeledSlider(QWidget *parent, const QString &ltext,
                              int min, int max, int ste)
     : KSaneOptionWidget(parent, ltext)
 {
     initSlider(min, max, ste);
 }
 
 LabeledSlider::LabeledSlider(QWidget *parent, KSaneCore::Option *option)
     : KSaneOptionWidget(parent, option)
 {
     int maxValue = option->maximumValue().toInt();
     int minValue = option->minimumValue().toInt();
     int stepValue = option->stepValue().toInt();
 
     initSlider(minValue, maxValue, stepValue);
 
     KLocalizedString unitSuffix;
     KSaneCore::Option::OptionUnit unit = option->valueUnit();
     switch (unit) {
 
     case KSaneCore::Option::UnitPixel:
         unitSuffix = ki18ncp("SpinBox parameter unit", " Pixel", " Pixels");
         break;
     case KSaneCore::Option::UnitBit:
         unitSuffix = ki18ncp("SpinBox parameter unit", " Bit", " Bits");
         break;
     case KSaneCore::Option::UnitMilliMeter:
         unitSuffix = ki18ncp("SpinBox parameter unit (Millimeter)", " mm", " mm");
         break;
     case KSaneCore::Option::UnitDPI:
         unitSuffix = ki18ncp("SpinBox parameter unit (Dots Per Inch)", " DPI", " DPI");
         break;
     case KSaneCore::Option::UnitPercent:
         unitSuffix = ki18ncp("SpinBox parameter unit (Percentage)", " %", " %");
         break;
     case KSaneCore::Option::UnitMicroSecond:
         unitSuffix = ki18ncp("SpinBox parameter unit (Microseconds)", " µs", " µs");
         break;
     case KSaneCore::Option::UnitSecond:
         unitSuffix = ki18ncp("SpinBox parameter unit (seconds)", " s", " s");
         break;
     default:
         unitSuffix = KLocalizedString();
         break;
     }
 
     setSuffix(unitSuffix);
     setLabelText(option->title());
     setToolTip(option->description());
     connect(this, &LabeledSlider::valueChanged, option, &KSaneCore::Option::setValue);
     connect(option, &KSaneCore::Option::valueChanged, this, &LabeledSlider::setValue);
     int value = option->value().toInt();
     setValue(value);
 }
 
 LabeledSlider::~LabeledSlider()
 {
 }
 
 void LabeledSlider::initSlider(int minValue, int maxValue, int stepValue)
 {
     m_step = stepValue;
     if (m_step == 0) {
         m_step = 1;
     }
 
     m_slider = new QSlider(this);
     m_slider->setOrientation(Qt::Horizontal);
     m_slider->setMinimum(minValue);
     m_slider->setMaximum(maxValue);
     m_slider->setSingleStep(m_step);
 
     m_spinb = new KPluralHandlingSpinBox(this);
     m_spinb->setMinimum(minValue);
     m_spinb->setMaximum(maxValue);
     m_slider->setSingleStep(m_step);
     m_spinb->setValue(maxValue);
     //m_spinb->setMinimumWidth(m_spinb->sizeHint().width()+35);
     m_spinb->setAlignment(Qt::AlignRight);
     m_spinb->setValue(minValue);
 
     m_spinb->setValue(minValue);
     m_label->setBuddy(m_spinb);
 
     connect(m_spinb, QOverload<int>::of(&QSpinBox::valueChanged), this, &LabeledSlider::syncValues);
     connect(m_slider, &QSlider::valueChanged, this, &LabeledSlider::syncValues);
     connect(m_slider, &QSlider::sliderReleased, this, &LabeledSlider::fixValue);
 
     m_layout->addWidget(m_slider, 0, 2);
     m_layout->addWidget(m_spinb, 0, 1);
     m_layout->setColumnStretch(1, 0);
     m_layout->setColumnStretch(2, 50);
 }
 
 void LabeledSlider::setSuffix(const KLocalizedString &text)
 {
     m_spinb->setSuffix(text);
 }
 
 void LabeledSlider::setValue(const QVariant &val)
 {
     bool ok;
     int value = val.toInt(&ok);
     if (!ok) {
         return;
     }
     if (value != m_slider->value()) {
         m_slider->setValue(value);
     } else if (value != m_spinb->value()) {
         m_spinb->setValue(value);
     }
 }
 
 void LabeledSlider::setRange(int min, int max)
 {
     //std::cout << "min=" << min << ", max=" << max << std::endl;
     m_slider->setRange(min, max);
     m_spinb->setRange(min, max);
 }
 
 void LabeledSlider::setStep(int st)
 {
     m_step = st;
     if (m_step == 0) {
         m_step = 1;
     }
     m_slider->setSingleStep(m_step);
     m_spinb->setSingleStep(m_step);
 }
 
 void LabeledSlider::syncValues(int value)
 {
     if (value != m_spinb->value()) {
         m_spinb->setValue(value);
     } else if (value != m_slider->value()) {
         //ensure that the value m_step is followed also for the m_slider
         if ((value - m_slider->minimum()) % m_step != 0) {
             if (value > m_spinb->value()) {
                 m_slider->setValue(m_slider->value() + (m_step - (value - m_spinb->value())));
             } else {
                 m_slider->setValue(m_slider->value() - (m_step - (m_spinb->value() - value)));
             }
             // this function will be reentered with the signal fom the m_slider
         } else {
             m_slider->setValue(value);
         }
     } else {
         Q_EMIT valueChanged(value);
     }
 }
 
 void LabeledSlider::fixValue()
 {
     //ensure that the value m_step is followed also for the m_slider
     int rest = (m_slider->value() - m_slider->minimum()) % m_step;
 
     if (rest != 0) {
         if (rest > (m_step / 2)) {
             m_slider->setValue(m_slider->value() + (m_step - rest));
         } else {
             m_slider->setValue(m_slider->value() - rest);
         }
         m_spinb->setValue(m_slider->value());
     }
 }
 int LabeledSlider::value() const
 {
     return (m_slider->value());
 }
 
 }  // NameSpace KSaneIface
 
 #include "moc_labeledslider.cpp"