diff --git a/scan/sanedialog.cpp b/scan/sanedialog.cpp
index f79eb82f..e5bf6e7d 100644
--- a/scan/sanedialog.cpp
+++ b/scan/sanedialog.cpp
@@ -1,118 +1,118 @@
 /* ============================================================
  *
  * Date        : 2008-04-17
  * Description : Sane plugin interface for KDE
  *
  * Copyright (C) 2008 by Kare Sars <kare dot sars at iki dot fi>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * ============================================================ */
 
 #include "sanedialog.h"
 
 #include <KLocalizedString>
 #include "kpLogCategories.h"
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KWindowConfig>
 #include <KConfigGroup>
 
 #include <QPushButton>
 
 SaneDialog::SaneDialog(QWidget *parent)
     : KPageDialog(parent)
 {
     setFaceType(static_cast<KPageDialog::FaceType> (Plain));
     setWindowTitle(i18nc("@title:window", "Acquire Image"));
 
     buttonBox()->setStandardButtons(QDialogButtonBox::Close);
     buttonBox()->button(QDialogButtonBox::Close)->setDefault(true);
 
 
     m_ksanew = new KSaneIface::KSaneWidget(this);
     addPage(m_ksanew, QString());
 
     connect(m_ksanew, SIGNAL(imageReady(QByteArray&,int,int,int,int)),
             this, SLOT(imageReady(QByteArray&,int,int,int,int)));
 
     m_openDev = QString();
 }
 
 bool SaneDialog::setup()
 {
     if(!m_ksanew) {
         // new failed
         return false;
     }
     if (!m_openDev.isEmpty()) {
         return true;
     }
     // need to select a scanner
-    m_openDev = m_ksanew->selectDevice(0);
+    m_openDev = m_ksanew->selectDevice(nullptr);
     if (m_openDev.isEmpty()) {
        // either no scanner was found or then cancel was pressed.
         return false;
     }
     if (m_ksanew->openDevice(m_openDev) == false) {
         // could not open the scanner
-        KMessageBox::sorry(0, i18n("Opening the selected scanner failed."));
+        KMessageBox::sorry(nullptr, i18n("Opening the selected scanner failed."));
         m_openDev = QString();
         return false;
     }
 
     // restore scan dialog size and all options for the selected device if available
     KSharedConfigPtr configPtr = KSharedConfig::openConfig("scannersettings");
     KWindowConfig::restoreWindowSize(windowHandle(), KConfigGroup(configPtr, "ScanDialog"));
     QString groupName = m_openDev;
     if (configPtr->hasGroup(groupName)) {
         KConfigGroup group(configPtr, groupName);
         QStringList keys = group.keyList();
         for (int i = 0; i < keys.count(); i++)
             m_ksanew->setOptVal(keys[i], group.readEntry(keys[i]));
     }
 
    return true;
 }
 
 SaneDialog::~SaneDialog()
 {
     if (m_ksanew && !m_openDev.isEmpty()) {
         // save scan dialog size and all options for the selected device if available
         KSharedConfigPtr configPtr = KSharedConfig::openConfig("scannersettings");
         KConfigGroup group(configPtr, "ScanDialog");
         KWindowConfig::saveWindowSize(windowHandle(), group, KConfigGroup::Persistent);
         group = configPtr->group(m_openDev);
         QMap<QString, QString> opts;
         m_ksanew->getOptVals(opts);
         QMap<QString, QString>::const_iterator i = opts.constBegin();
         for (; i != opts.constEnd(); ++i)
             group.writeEntry(i.key(), i.value(), KConfigGroup::Persistent);
     }
 }
 
 void SaneDialog::imageReady(QByteArray &data, int w, int h, int bpl, int f)
 {
     /* copy the image data into img */
     QImage img = m_ksanew->toQImage(data, w, h, bpl, static_cast<KSaneIface::KSaneWidget::ImageFormat> (f));
     emit finalImage(img, nextId());
 }
 
 int SaneDialog::nextId()
 {
     return ++m_currentId;
 }
diff --git a/widgets/imagelib/effects/kpNumInput.cpp b/widgets/imagelib/effects/kpNumInput.cpp
index 455d46be..433a68c9 100644
--- a/widgets/imagelib/effects/kpNumInput.cpp
+++ b/widgets/imagelib/effects/kpNumInput.cpp
@@ -1,710 +1,710 @@
 /* This file is part of the KDE libraries
  * Initial implementation:
  *     Copyright (c) 1997 Patrick Dowler <dowler@morgul.fsh.uvic.ca>
  * Rewritten and maintained by:
  *     Copyright (c) 2000 Dirk Mueller <mueller@kde.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "kpNumInput.h"
 
 #include <cmath>
 
 #include <QApplication>
 #include <QDebug>
 #include <QLabel>
 #include <QLineEdit>
 #include <QResizeEvent>
 #include <QSlider>
 #include <QStyle>
 
 #include <KConfigDialogManager>
 #include <KLocalizedString>
 
 static inline int calcDiffByTen(int x, int y)
 {
     // calculate ( x - y ) / 10 without overflowing ints:
     return (x / 10) - (y / 10)  + (x % 10 - y % 10) / 10;
 }
 
 // ----------------------------------------------------------------------------
 
 class kpNumInputPrivate
 {
 public:
     kpNumInputPrivate(kpNumInput *q) :
         q(q),
         column1Width(0),
         column2Width(0),
-        label(0),
-        slider(0),
-        labelAlignment(0)
+        label(nullptr),
+        slider(nullptr),
+        labelAlignment(nullptr)
     {
     }
 
     static kpNumInputPrivate *get(const kpNumInput *i)
     {
         return i->d;
     }
 
     kpNumInput *q;
     int column1Width, column2Width;
 
     QLabel  *label;
     QSlider *slider;
     QSize    sliderSize, labelSize;
 
     Qt::Alignment labelAlignment;
 };
 
 #define K_USING_kpNumInput_P(_d) kpNumInputPrivate *_d = kpNumInputPrivate::get(this)
 
 kpNumInput::kpNumInput(QWidget *parent)
     : QWidget(parent), d(new kpNumInputPrivate(this))
 {
     setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed));
     setFocusPolicy(Qt::StrongFocus);
     KConfigDialogManager::changedMap()->insert("kpIntNumInput", SIGNAL(valueChanged(int)));
     KConfigDialogManager::changedMap()->insert("QSpinBox", SIGNAL(valueChanged(int)));
     KConfigDialogManager::changedMap()->insert("kpDoubleSpinBox", SIGNAL(valueChanged(double)));
 }
 
 kpNumInput::~kpNumInput()
 {
     delete d;
 }
 
 QSlider *kpNumInput::slider() const
 {
     return d->slider;
 }
 
 bool kpNumInput::showSlider() const
 {
     return d->slider;
 }
 
 void kpNumInput::setLabel(const QString &label, Qt::Alignment a)
 {
     if (label.isEmpty()) {
         delete d->label;
-        d->label = 0;
-        d->labelAlignment = 0;
+        d->label = nullptr;
+        d->labelAlignment = nullptr;
     } else {
         if (!d->label) {
             d->label = new QLabel(this);
         }
         d->label->setText(label);
         d->label->setObjectName("kpNumInput::QLabel");
         d->label->setAlignment(a);
         // if no vertical alignment set, use Top alignment
         if (!(a & (Qt::AlignTop | Qt::AlignBottom | Qt::AlignVCenter))) {
             a |= Qt::AlignTop;
         }
         d->labelAlignment = a;
     }
 
     layout();
 }
 
 QString kpNumInput::label() const
 {
     return d->label ? d->label->text() : QString();
 }
 
 void kpNumInput::layout()
 {
     // label sizeHint
     d->labelSize = (d->label ? d->label->sizeHint() : QSize(0, 0));
 
     if (d->label && (d->labelAlignment & Qt::AlignVCenter)) {
         d->column1Width = d->labelSize.width() + 4;
     } else {
         d->column1Width = 0;
     }
 
     // slider sizeHint
     d->sliderSize = (d->slider ? d->slider->sizeHint() : QSize(0, 0));
 
     doLayout();
 
 }
 
 QSize kpNumInput::sizeHint() const
 {
     return minimumSizeHint();
 }
 
 void kpNumInput::setSteps(int minor, int major)
 {
     if (d->slider) {
         d->slider->setSingleStep(minor);
         d->slider->setPageStep(major);
     }
 }
 
 // ----------------------------------------------------------------------------
 
 class kpIntNumInput::kpIntNumInputPrivate
 {
 public:
     kpIntNumInput *q;
     QSpinBox     *intSpinBox;
     QSize        intSpinBoxSize;
 
     kpIntNumInputPrivate(kpIntNumInput *q)
         : q(q) {}
 };
 
 kpIntNumInput::kpIntNumInput(QWidget *parent)
     : kpNumInput(parent)
     , d(new kpIntNumInputPrivate(this))
 {
     initWidget(0);
 }
 
 kpIntNumInput::kpIntNumInput(int val, QWidget *parent)
     : kpNumInput(parent)
     , d(new kpIntNumInputPrivate(this))
 {
     initWidget(val);
 }
 
 QSpinBox *kpIntNumInput::spinBox() const
 {
     return d->intSpinBox;
 }
 
 void kpIntNumInput::initWidget(int val)
 {
     d->intSpinBox = new QSpinBox(this);
     d->intSpinBox->setRange(INT_MIN, INT_MAX);
     d->intSpinBox->setSingleStep(1);
     d->intSpinBox->setValue(val);
     d->intSpinBox->setObjectName("kpIntNumInput::QSpinBox");
 
     connect(d->intSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), this, &kpIntNumInput::spinValueChanged);
 
     setFocusProxy(d->intSpinBox);
     layout();
 }
 
 void kpIntNumInput::spinValueChanged(int val)
 {
     K_USING_kpNumInput_P(priv);
 
     if (priv->slider) {
         priv->slider->setValue(val);
     }
 
     emit valueChanged(val);
 }
 
 void kpIntNumInput::setRange(int lower, int upper, int singleStep)
 {
     if (upper < lower || singleStep <= 0) {
         qDebug() << "WARNING: kpIntNumInput::setRange() called with bad arguments. Ignoring call...";
         return;
     }
 
     d->intSpinBox->setMinimum(lower);
     d->intSpinBox->setMaximum(upper);
     d->intSpinBox->setSingleStep(singleStep);
 
     singleStep = d->intSpinBox->singleStep(); // maybe QRangeControl didn't like our lineStep?
 
     layout();
 
     // update slider information
     K_USING_kpNumInput_P(priv);
     if (!priv->slider) {
         priv->slider = new QSlider(Qt::Horizontal, this);
         connect(priv->slider, &QSlider::valueChanged,
                 d->intSpinBox, &QSpinBox::setValue);
         priv->slider->setTickPosition(QSlider::TicksBelow);
         layout();
     }
 
     const int value = d->intSpinBox->value();
     priv->slider->setRange(d->intSpinBox->minimum(), d->intSpinBox->maximum());
     priv->slider->setPageStep(d->intSpinBox->singleStep());
     priv->slider->setValue(value);
     // calculate (upper-lower)/10 without overflowing int's:
     const int major = calcDiffByTen(d->intSpinBox->maximum(), d->intSpinBox->minimum());
 
     priv->slider->setSingleStep(d->intSpinBox->singleStep());
     priv->slider->setPageStep(qMax(1, major));
     priv->slider->setTickInterval(major);
 }
 
 void kpIntNumInput::setMinimum(int min)
 {
     setRange(min, d->intSpinBox->maximum(), d->intSpinBox->singleStep());
 }
 
 int kpIntNumInput::minimum() const
 {
     return d->intSpinBox->minimum();
 }
 
 void kpIntNumInput::setMaximum(int max)
 {
     setRange(d->intSpinBox->minimum(), max, d->intSpinBox->singleStep());
 }
 
 int kpIntNumInput::maximum() const
 {
     return d->intSpinBox->maximum();
 }
 
 int kpIntNumInput::singleStep() const
 {
     return d->intSpinBox->singleStep();
 }
 
 void kpIntNumInput::setSingleStep(int singleStep)
 {
     d->intSpinBox->setSingleStep(singleStep);
 }
 
 void kpIntNumInput::setSuffix(const QString &suffix)
 {
     d->intSpinBox->setSuffix(suffix);
 
     layout();
 }
 
 QString kpIntNumInput::suffix() const
 {
     return d->intSpinBox->suffix();
 }
 
 void kpIntNumInput::setEditFocus(bool mark)
 {
     if (mark)
     {
         d->intSpinBox->setFocus();
     }
 }
 
 QSize kpIntNumInput::minimumSizeHint() const
 {
     K_USING_kpNumInput_P(priv);
     ensurePolished();
 
     int w;
     int h;
 
     h = qMax(d->intSpinBoxSize.height(), priv->sliderSize.height());
 
     // if in extra row, then count it here
     if (priv->label && (priv->labelAlignment & (Qt::AlignBottom | Qt::AlignTop))) {
         h += 4 + priv->labelSize.height();
     } else {
         // label is in the same row as the other widgets
         h = qMax(h, priv->labelSize.height() + 2);
     }
 
     const int spacingHint = style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
     w = priv->slider ? priv->slider->sizeHint().width() + spacingHint : 0;
     w += priv->column1Width + priv->column2Width;
 
     if (priv->labelAlignment & (Qt::AlignTop | Qt::AlignBottom)) {
         w = qMax(w, priv->labelSize.width() + 4);
     }
 
     return QSize(w, h);
 }
 
 void kpIntNumInput::doLayout()
 {
     K_USING_kpNumInput_P(priv);
 
     d->intSpinBoxSize = d->intSpinBox->sizeHint();
     priv->column2Width = d->intSpinBoxSize.width();
 
     if (priv->label) {
         priv->label->setBuddy(d->intSpinBox);
     }
 }
 
 void kpIntNumInput::resizeEvent(QResizeEvent *e)
 {
     K_USING_kpNumInput_P(priv);
 
     int w = priv->column1Width;
     int h = 0;
     const int spacingHint = style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
 
     if (priv->label && (priv->labelAlignment & Qt::AlignTop)) {
         priv->label->setGeometry(0, 0, e->size().width(), priv->labelSize.height());
         h += priv->labelSize.height() + spacingHint;
     }
 
     if (priv->label && (priv->labelAlignment & Qt::AlignVCenter)) {
         priv->label->setGeometry(0, 0, w, d->intSpinBoxSize.height());
     }
 
     if (qApp->layoutDirection() == Qt::RightToLeft) {
         d->intSpinBox->setGeometry(w, h, priv->slider ? priv->column2Width : qMax(priv->column2Width, e->size().width() - w), d->intSpinBoxSize.height());
         w += priv->column2Width + spacingHint;
 
         if (priv->slider) {
             priv->slider->setGeometry(w, h, e->size().width() - w, d->intSpinBoxSize.height() + spacingHint);
         }
     } else if (priv->slider) {
         priv->slider->setGeometry(w, h, e->size().width() - (w + priv->column2Width + spacingHint), d->intSpinBoxSize.height() + spacingHint);
         d->intSpinBox->setGeometry(w + priv->slider->size().width() + spacingHint, h, priv->column2Width, d->intSpinBoxSize.height());
     } else {
         d->intSpinBox->setGeometry(w, h, qMax(priv->column2Width, e->size().width() - w), d->intSpinBoxSize.height());
     }
 
     h += d->intSpinBoxSize.height() + 2;
 
     if (priv->label && (priv->labelAlignment & Qt::AlignBottom)) {
         priv->label->setGeometry(0, h, priv->labelSize.width(), priv->labelSize.height());
     }
 }
 
 kpIntNumInput::~kpIntNumInput()
 {
     delete d;
 }
 
 void kpIntNumInput::setValue(int val)
 {
     d->intSpinBox->setValue(val);
     // slider value is changed by spinValueChanged
 }
 
 int kpIntNumInput::value() const
 {
     return d->intSpinBox->value();
 }
 
 void kpIntNumInput::setSpecialValueText(const QString &text)
 {
     d->intSpinBox->setSpecialValueText(text);
     layout();
 }
 
 QString kpIntNumInput::specialValueText() const
 {
     return d->intSpinBox->specialValueText();
 }
 
 void kpIntNumInput::setLabel(const QString &label, Qt::Alignment a)
 {
     K_USING_kpNumInput_P(priv);
 
     kpNumInput::setLabel(label, a);
 
     if (priv->label) {
         priv->label->setBuddy(d->intSpinBox);
     }
 }
 
 // ----------------------------------------------------------------------------
 
 class kpDoubleNumInput::kpDoubleNumInputPrivate
 {
 public:
     kpDoubleNumInputPrivate()
-        : spin(0) {}
+        : spin(nullptr) {}
     QDoubleSpinBox *spin;
     QSize editSize;
     QString specialValue;
 };
 
 kpDoubleNumInput::kpDoubleNumInput(QWidget *parent)
     : kpNumInput(parent)
     , d(new kpDoubleNumInputPrivate())
 
 {
     initWidget(0.0, 0.0, 9999.0, 0.01, 2);
 }
 
 kpDoubleNumInput::kpDoubleNumInput(double lower, double upper, double value, QWidget *parent,
                                  double singleStep, int precision)
     : kpNumInput(parent)
     , d(new kpDoubleNumInputPrivate())
 {
     initWidget(value, lower, upper, singleStep, precision);
 }
 
 kpDoubleNumInput::~kpDoubleNumInput()
 {
     delete d;
 }
 
 QString kpDoubleNumInput::specialValueText() const
 {
     return d->specialValue;
 }
 
 void kpDoubleNumInput::initWidget(double value, double lower, double upper,
                                  double singleStep, int precision)
 {
     d->spin = new QDoubleSpinBox(this);
     d->spin->setRange(lower, upper);
     d->spin->setSingleStep(singleStep);
     d->spin->setValue(value);
     d->spin->setDecimals(precision);
 
     d->spin->setObjectName("kpDoubleNumInput::QDoubleSpinBox");
     setFocusProxy(d->spin);
     connect(d->spin, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
             this, &kpDoubleNumInput::valueChanged);
 
     layout();
 }
 
 double kpDoubleNumInput::mapSliderToSpin(int val) const
 {
     K_USING_kpNumInput_P(priv);
 
     // map [slidemin,slidemax] to [spinmin,spinmax]
     const double spinmin = d->spin->minimum();
     const double spinmax = d->spin->maximum();
     const double slidemin = priv->slider->minimum(); // cast int to double to avoid
     const double slidemax = priv->slider->maximum(); // overflow in rel denominator
     const double rel = (double(val) - slidemin) / (slidemax - slidemin);
     return spinmin + rel * (spinmax - spinmin);
 }
 
 void kpDoubleNumInput::sliderMoved(int val)
 {
     d->spin->setValue(mapSliderToSpin(val));
 }
 
 void kpDoubleNumInput::spinBoxChanged(double val)
 {
     K_USING_kpNumInput_P(priv);
 
     const double spinmin = d->spin->minimum();
     const double spinmax = d->spin->maximum();
     const double slidemin = priv->slider->minimum(); // cast int to double to avoid
     const double slidemax = priv->slider->maximum(); // overflow in rel denominator
 
     const double rel = (val - spinmin) / (spinmax - spinmin);
 
     if (priv->slider) {
         priv->slider->blockSignals(true);
         priv->slider->setValue(qRound(slidemin + rel * (slidemax - slidemin)));
         priv->slider->blockSignals(false);
     }
 }
 
 QSize kpDoubleNumInput::minimumSizeHint() const
 {
     K_USING_kpNumInput_P(priv);
 
     ensurePolished();
 
     int w;
     int h;
 
     h = qMax(d->editSize.height(), priv->sliderSize.height());
 
     // if in extra row, then count it here
     if (priv->label && (priv->labelAlignment & (Qt::AlignBottom | Qt::AlignTop))) {
         h += 4 + priv->labelSize.height();
     } else {
         // label is in the same row as the other widgets
         h = qMax(h, priv->labelSize.height() + 2);
     }
 
     const int spacingHint = style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
     w = priv->slider ? priv->slider->sizeHint().width() + spacingHint : 0;
     w += priv->column1Width + priv->column2Width;
 
     if (priv->labelAlignment & (Qt::AlignTop | Qt::AlignBottom)) {
         w = qMax(w, priv->labelSize.width() + 4);
     }
 
     return QSize(w, h);
 }
 
 void kpDoubleNumInput::resizeEvent(QResizeEvent *e)
 {
     K_USING_kpNumInput_P(priv);
 
     int w = priv->column1Width;
     int h = 0;
     const int spacingHint = style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
 
     if (priv->label && (priv->labelAlignment & Qt::AlignTop)) {
         priv->label->setGeometry(0, 0, e->size().width(), priv->labelSize.height());
         h += priv->labelSize.height() + 4;
     }
 
     if (priv->label && (priv->labelAlignment & Qt::AlignVCenter)) {
         priv->label->setGeometry(0, 0, w, d->editSize.height());
     }
 
     if (qApp->layoutDirection() == Qt::RightToLeft) {
         d->spin->setGeometry(w, h, priv->slider ? priv->column2Width
                              : e->size().width() - w, d->editSize.height());
         w += priv->column2Width + spacingHint;
 
         if (priv->slider) {
             priv->slider->setGeometry(w, h, e->size().width() - w, d->editSize.height() + spacingHint);
         }
     } else if (priv->slider) {
         priv->slider->setGeometry(w, h, e->size().width() -
                                   (priv->column1Width + priv->column2Width + spacingHint),
                                   d->editSize.height() + spacingHint);
         d->spin->setGeometry(w + priv->slider->width() + spacingHint, h,
                              priv->column2Width, d->editSize.height());
     } else {
         d->spin->setGeometry(w, h, e->size().width() - w, d->editSize.height());
     }
 
     h += d->editSize.height() + 2;
 
     if (priv->label && (priv->labelAlignment & Qt::AlignBottom)) {
         priv->label->setGeometry(0, h, priv->labelSize.width(), priv->labelSize.height());
     }
 }
 
 void kpDoubleNumInput::doLayout()
 {
     K_USING_kpNumInput_P(priv);
 
     d->editSize = d->spin->sizeHint();
     priv->column2Width = d->editSize.width();
 }
 
 void kpDoubleNumInput::setValue(double val)
 {
     d->spin->setValue(val);
 }
 
 void kpDoubleNumInput::setRange(double lower, double upper, double singleStep)
 {
     K_USING_kpNumInput_P(priv);
 
     QDoubleSpinBox *spin = d->spin;
 
     d->spin->setRange(lower, upper);
     d->spin->setSingleStep(singleStep);
 
     const double range = spin->maximum() - spin->minimum();
     const double steps = range * pow(10.0, spin->decimals());
     if (!priv->slider) {
         priv->slider = new QSlider(Qt::Horizontal, this);
         priv->slider->setTickPosition(QSlider::TicksBelow);
         // feedback line: when one moves, the other moves, too:
         connect(priv->slider, &QSlider::valueChanged,
                 this, &kpDoubleNumInput::sliderMoved);
         layout();
     }
     if (steps > 1000 ) {
         priv->slider->setRange(0, 1000);
         priv->slider->setSingleStep(1);
         priv->slider->setPageStep(50);
     } else {
         const int singleSteps = qRound(steps);
         priv->slider->setRange(0, singleSteps);
         priv->slider->setSingleStep(1);
         const int pageSteps = qBound(1, singleSteps / 20, 10);
         priv->slider->setPageStep(pageSteps);
     }
     spinBoxChanged(spin->value());
     connect(spin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &kpDoubleNumInput::spinBoxChanged);
 
     layout();
 }
 
 void kpDoubleNumInput::setMinimum(double min)
 {
     setRange(min, maximum(), d->spin->singleStep());
 }
 
 double kpDoubleNumInput::minimum() const
 {
     return d->spin->minimum();
 }
 
 void kpDoubleNumInput::setMaximum(double max)
 {
     setRange(minimum(), max, d->spin->singleStep());
 }
 
 double kpDoubleNumInput::maximum() const
 {
     return d->spin->maximum();
 }
 
 double kpDoubleNumInput::singleStep() const
 {
     return d->spin->singleStep();
 }
 
 void kpDoubleNumInput::setSingleStep(double singleStep)
 {
     d->spin->setSingleStep(singleStep);
 }
 
 double kpDoubleNumInput::value() const
 {
     return d->spin->value();
 }
 
 QString kpDoubleNumInput::suffix() const
 {
     return d->spin->suffix();
 }
 
 void kpDoubleNumInput::setSuffix(const QString &suffix)
 {
     d->spin->setSuffix(suffix);
 
     layout();
 }
 
 void kpDoubleNumInput::setDecimals(int decimals)
 {
     d->spin->setDecimals(decimals);
 
     layout();
 }
 
 int kpDoubleNumInput::decimals() const
 {
     return d->spin->decimals();
 }
 
 void kpDoubleNumInput::setSpecialValueText(const QString &text)
 {
     d->spin->setSpecialValueText(text);
 
     layout();
 }
 
 void kpDoubleNumInput::setLabel(const QString &label, Qt::Alignment a)
 {
     K_USING_kpNumInput_P(priv);
 
     kpNumInput::setLabel(label, a);
 
     if (priv->label) {
         priv->label->setBuddy(d->spin);
     }
 }
 
 #include "moc_kpNumInput.cpp"