qdial.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdial.h"
 
#include <qapplication.h>
#include <qbitmap.h>
#include <qcolor.h>
#include <qevent.h>
#include <qpainter.h>
#include <qpolygon.h>
#include <qregion.h>
#include <qstyle.h>
#include <qstylepainter.h>
#include <qstyleoption.h>
#include <qslider.h>
#include <private/qabstractslider_p.h>
#include <private/qmath_p.h>
#if QT_CONFIG(accessibility)
#include "qaccessible.h"
#endif
#include <qmath.h>
 
QT_BEGIN_NAMESPACE
 
class QDialPrivate : public QAbstractSliderPrivate
{
    Q_DECLARE_PUBLIC(QDial)
public:
    QDialPrivate()
    {
        wrapping = false;
        tracking = true;
        doNotEmit = false;
        target = qreal(3.7);
    }
 
    qreal target;
    uint showNotches : 1;
    uint wrapping : 1;
    uint doNotEmit : 1;
 
    int valueFromPoint(const QPoint &) const;
    double angle(const QPoint &, const QPoint &) const;
    void init();
    virtual int bound(int val) const override;
};
 
void QDialPrivate::init()
{
    Q_Q(QDial);
    showNotches = false;
    q->setFocusPolicy(Qt::WheelFocus);
}
 
int QDialPrivate::bound(int val) const
{
    if (wrapping) {
        if ((val >= minimum) && (val <= maximum))
            return val;
        if (minimum == maximum)
            return minimum;
        val = minimum + ((val - minimum) % (maximum - minimum));
        if (val < minimum)
            val += maximum - minimum;
        return val;
    } else {
        return QAbstractSliderPrivate::bound(val);
    }
}
 
void QDial::initStyleOption(QStyleOptionSlider *option) const
{
    if (!option)
        return;
 
    Q_D(const QDial);
    option->initFrom(this);
    option->minimum = d->minimum;
    option->maximum = d->maximum;
    option->sliderPosition = d->position;
    option->sliderValue = d->value;
    option->singleStep = d->singleStep;
    option->pageStep = d->pageStep;
    option->upsideDown = !d->invertedAppearance;
    option->notchTarget = d->target;
    option->dialWrapping = d->wrapping;
    option->subControls = QStyle::SC_All;
    option->activeSubControls = QStyle::SC_None;
    if (!d->showNotches) {
        option->subControls &= ~QStyle::SC_DialTickmarks;
        option->tickPosition = QSlider::TicksAbove;
    } else {
        option->tickPosition = QSlider::NoTicks;
    }
    option->tickInterval = notchSize();
}
 
int QDialPrivate::valueFromPoint(const QPoint &p) const
{
    Q_Q(const QDial);
    double yy = q->height()/2.0 - p.y();
    double xx = p.x() - q->width()/2.0;
    double a = (xx || yy) ? std::atan2(yy, xx) : 0;
 
    if (a < Q_PI / -2)
        a = a + Q_PI * 2;
 
    int dist = 0;
    int minv = minimum, maxv = maximum;
 
    if (minimum < 0) {
        dist = -minimum;
        minv = 0;
        maxv = maximum + dist;
    }
 
    int r = maxv - minv;
    int v;
    if (wrapping)
        v =  (int)(0.5 + minv + r * (Q_PI * 3 / 2 - a) / (2 * Q_PI));
    else
        v =  (int)(0.5 + minv + r* (Q_PI * 4 / 3 - a) / (Q_PI * 10 / 6));
 
    if (dist > 0)
        v -= dist;
 
    return !invertedAppearance ? bound(v) : maximum - bound(v);
}
 
QDial::QDial(QWidget *parent)
    : QAbstractSlider(*new QDialPrivate, parent)
{
    Q_D(QDial);
    d->init();
}
 
QDial::~QDial()
{
}
 
void QDial::resizeEvent(QResizeEvent *e)
{
    QWidget::resizeEvent(e);
}
 
void QDial::paintEvent(QPaintEvent *)
{
    QStylePainter p(this);
    QStyleOptionSlider option;
    initStyleOption(&option);
    p.drawComplexControl(QStyle::CC_Dial, option);
}
 
void QDial::mousePressEvent(QMouseEvent *e)
{
    Q_D(QDial);
    if (d->maximum == d->minimum ||
        (e->button() != Qt::LeftButton)  ||
        (e->buttons() ^ e->button())) {
        e->ignore();
        return;
    }
    e->accept();
    setSliderPosition(d->valueFromPoint(e->position().toPoint()));
    // ### This isn't quite right,
    // we should be doing a hit test and only setting this if it's
    // the actual dial thingie (similar to what QSlider does), but we have no
    // subControls for QDial.
    setSliderDown(true);
}
 
 
void QDial::mouseReleaseEvent(QMouseEvent * e)
{
    Q_D(QDial);
    if (e->buttons() & (~e->button()) ||
       (e->button() != Qt::LeftButton)) {
        e->ignore();
        return;
    }
    e->accept();
    setValue(d->valueFromPoint(e->position().toPoint()));
    setSliderDown(false);
}
 
 
void QDial::mouseMoveEvent(QMouseEvent * e)
{
    Q_D(QDial);
    if (!(e->buttons() & Qt::LeftButton)) {
        e->ignore();
        return;
    }
    e->accept();
    d->doNotEmit = true;
    setSliderPosition(d->valueFromPoint(e->position().toPoint()));
    d->doNotEmit = false;
}
 
 
void QDial::sliderChange(SliderChange change)
{
    QAbstractSlider::sliderChange(change);
}
 
void QDial::setWrapping(bool enable)
{
    Q_D(QDial);
    if (d->wrapping == enable)
        return;
    d->wrapping = enable;
    update();
}
 
 
bool QDial::wrapping() const
{
    Q_D(const QDial);
    return d->wrapping;
}
 
 
int QDial::notchSize() const
{
    Q_D(const QDial);
    // radius of the arc
    qreal r = qMin(width(), height())/2.0;
    // length of the whole arc
    int l = qRound(r * (d->wrapping ? 6.0 : 5.0) * Q_PI / 6.0);
    // length of the arc from minValue() to minValue()+pageStep()
    if (d->maximum > d->minimum + d->pageStep)
        l = qRound(l * d->pageStep / double(d->maximum - d->minimum));
    // length of a singleStep arc
    l = qMax(l * d->singleStep / (d->pageStep ? d->pageStep : 1), 1);
    // how many times singleStep can be draw in d->target pixels
    l = qMax(qRound(d->target / l), 1);
    // we want notchSize() to be a non-zero multiple of singleStep()
    return d->singleStep * l;
}
 
void QDial::setNotchTarget(double target)
{
    Q_D(QDial);
    d->target = target;
    update();
}
 
qreal QDial::notchTarget() const
{
    Q_D(const QDial);
    return d->target;
}
 
 
void QDial::setNotchesVisible(bool visible)
{
    Q_D(QDial);
    d->showNotches = visible;
    update();
}
 
bool QDial::notchesVisible() const
{
    Q_D(const QDial);
    return d->showNotches;
}
 
QSize QDial::minimumSizeHint() const
{
    return QSize(50, 50);
}
 
QSize QDial::sizeHint() const
{
    return QSize(100, 100);
}
 
bool QDial::event(QEvent *e)
{
    return QAbstractSlider::event(e);
}
 
QT_END_NAMESPACE
 
#include "moc_qdial.cpp"