kis_equalizer_slider.cpp

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2015 Dmitry Kazakov <dimula73@gmail.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "kis_equalizer_slider.h"
 
#include <QStyle>
#include <QPainter>
#include <QMouseEvent>
#include <QApplication>
#include <QStyleOptionSlider>
 
#include "kis_global.h"
#include "kis_debug.h"
 
#include "KisAnimTimelineColors.h"
 
 
struct KisEqualizerSlider::Private
{
    Private(KisEqualizerSlider *_q) : q(_q), isRightmost(false), toggleState(true) {}
 
    KisEqualizerSlider *q;
    bool isRightmost;
    bool toggleState;
 
 
    QRect boundingRect() const;
    QRect sliderRect() const;
 
    int mousePosToValue(const QPoint &pt, bool round) const;
};
 
KisEqualizerSlider::KisEqualizerSlider(QWidget *parent)
    : QAbstractSlider(parent),
      m_d(new Private(this))
{
    setOrientation(Qt::Vertical);
    setFocusPolicy(Qt::WheelFocus);
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}
 
KisEqualizerSlider::~KisEqualizerSlider()
{
}
 
void KisEqualizerSlider::setRightmost(bool value)
{
    m_d->isRightmost = value;
}
 
void KisEqualizerSlider::setToggleState(bool value)
{
    m_d->toggleState = value;
    update();
 
}
 
QRect KisEqualizerSlider::Private::boundingRect() const
{
    QRect bounds = q->rect().adjusted(0, 0, -static_cast<int>(isRightmost), -1);
    return bounds;
}
 
QRect KisEqualizerSlider::Private::sliderRect() const
{
    const int offset = 3;
    QRect filling = boundingRect().adjusted(offset + 1, offset + 1,
                                            -offset, -offset);
 
    return filling;
}
 
int KisEqualizerSlider::Private::mousePosToValue(const QPoint &pt,  bool round) const
{
    const QRect areaRect = sliderRect();
 
    int rawValue = -pt.y() + (areaRect.top() + areaRect.height());
    int maxRawValue = areaRect.height();
 
    int value = QStyle::sliderValueFromPosition(q->minimum(), q->maximum(), rawValue, maxRawValue);
 
    if (round) {
        const int singleStep = q->singleStep();
        value = ((value + singleStep / 2) / singleStep) * singleStep;
    }
 
    return value;
}
 
void KisEqualizerSlider::mousePressEvent(QMouseEvent *ev)
{
    if (maximum() == minimum() || (ev->buttons() ^ ev->button())) {
        ev->ignore();
        return;
    }
 
    const bool precise = ev->modifiers() & Qt::ControlModifier ||
        ev->button() == Qt::RightButton;
 
    int value = m_d->mousePosToValue(ev->pos(), !precise);
    setSliderPosition(value);
    triggerAction(SliderMove);
    setRepeatAction(SliderNoAction);
}
 
void KisEqualizerSlider::mouseMoveEvent(QMouseEvent *ev)
{
    if (ev->modifiers() & Qt::ShiftModifier &&
        !rect().contains(ev->pos())) {
 
        ev->ignore();
        return;
    }
 
    const bool precise = ev->modifiers() & Qt::ControlModifier ||
        ev->buttons() & Qt::RightButton;
 
    int value = m_d->mousePosToValue(ev->pos(), !precise);
    setSliderPosition(value);
    triggerAction(SliderMove);
    setRepeatAction(SliderNoAction);
}
 
void KisEqualizerSlider::mouseReleaseEvent(QMouseEvent *ev)
{
    Q_UNUSED(ev);
}
 
QSize KisEqualizerSlider::sizeHint() const
{
    return QSize(25, 150);
}
 
QSize KisEqualizerSlider::minimumSizeHint() const
{
    return QSize(10, 40);
}
 
void KisEqualizerSlider::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
 
    const QRect bounds = m_d->boundingRect();
    const QColor backgroundColor = palette().color(QPalette::Base);
 
 
    QPainter p(this);
 
    { // draw border
 
        QStyleOptionViewItem option; // empty!
        const int gridHint = style()->styleHint(QStyle::SH_Table_GridLineColor, &option, this);
        const QColor gridColor = static_cast<QRgb>(gridHint);
        const QPen gridPen(gridColor);
 
        p.setPen(gridPen);
        p.setBrush(backgroundColor);
        p.drawRect(bounds);
    }
 
    { // draw slider
        QRect sliderRect = m_d->sliderRect();
        const int sliderPos =  QStyle::sliderPositionFromValue(minimum(), maximum(), value(), sliderRect.height());
        sliderRect.adjust(0, sliderRect.height() - sliderPos, 0, 0);
 
        p.setPen(Qt::transparent);
 
        QColor color = m_d->toggleState ?
                    KisAnimTimelineColors::instance()->onionSkinsSliderEnabledColor() :
                    KisAnimTimelineColors::instance()->onionSkinsSliderDisabledColor();
        p.setBrush(color);
 
        p.drawRect(sliderRect);
    }
 
    QString textValue = QString::number(value());
 
    /*  Text isn't really needed for onion skinning and makes it look a bit cluttered. Uncomment this out of that changes.
    { // draw text
        QPalette::ColorRole textRole = QPalette::Text;
 
        //Draw text shadow, This will increase readability when the background of same color
        QRect shadowRect(bounds);
        shadowRect.translate(1,1);
        QColor textColor = palette().color(textRole);
        QColor shadowColor = (textColor.value() <= 128)
            ? QColor(255,255,255,160) : QColor(0,0,0,160);
 
        p.setPen(shadowColor);
        p.drawText(shadowRect, Qt::AlignCenter, textValue);
 
        p.setPen(textColor);
        p.drawText(bounds, Qt::AlignCenter, textValue);
    }
    */
 
    // draw focus rect
    if (hasFocus()) {
        QStyleOptionFocusRect fropt;
        fropt.initFrom(this);
        fropt.backgroundColor = backgroundColor;
 
        int dfw1 = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, &fropt, this) + 1,
            dfw2 = dfw1 * 2;
        fropt.rect = kisGrowRect(bounds, -dfw1 - dfw2);
 
        style()->drawPrimitive(QStyle::PE_FrameFocusRect, &fropt, &p, this);
    }
}