File indexing completed on 2024-04-28 15:32:14

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 1997 Martin Jones <mjones@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kselector.h"
 
 #include <QPaintEvent>
 #include <QPainter>
 #include <QPixmap>
 #include <QStyle>
 #include <QStyleOption>
 
 //-----------------------------------------------------------------------------
 /*
  * 1D value selector with contents drawn by derived class.
  * See KColorDialog for example.
  */
 
 #define ARROWSIZE 5
 
 class KSelectorPrivate
 {
 public:
     bool m_indent = true;
     QStyle::PrimitiveElement arrowPE = QStyle::PE_IndicatorArrowLeft;
 };
 
 class KGradientSelectorPrivate
 {
 public:
     KGradientSelectorPrivate(KGradientSelector *qq)
         : q(qq)
     {
     }
 
     KGradientSelector *q;
     QLinearGradient gradient;
     QString text1;
     QString text2;
 };
 
 KSelector::KSelector(QWidget *parent)
     : QAbstractSlider(parent)
     , d(new KSelectorPrivate)
 {
     setOrientation(Qt::Horizontal);
 }
 
 KSelector::KSelector(Qt::Orientation o, QWidget *parent)
     : QAbstractSlider(parent)
     , d(new KSelectorPrivate)
 {
     setOrientation(o);
     if (o == Qt::Horizontal) {
         setArrowDirection(Qt::UpArrow);
     }
 }
 
 KSelector::~KSelector() = default;
 
 void KSelector::setIndent(bool i)
 {
     d->m_indent = i;
 }
 
 bool KSelector::indent() const
 {
     return d->m_indent;
 }
 
 QRect KSelector::contentsRect() const
 {
     int w = indent() ? style()->pixelMetric(QStyle::PM_DefaultFrameWidth) : 0;
     // TODO: is the height:width ratio of an indicator arrow always 2:1? hm.
     int iw = (w < ARROWSIZE) ? ARROWSIZE : w;
 
     if (orientation() == Qt::Vertical) {
         if (arrowDirection() == Qt::RightArrow) {
             return QRect(w + ARROWSIZE, //
                          iw,
                          width() - w * 2 - ARROWSIZE,
                          height() - iw * 2);
         } else {
             return QRect(w, //
                          iw,
                          width() - w * 2 - ARROWSIZE,
                          height() - iw * 2);
         }
     } else { // Qt::Horizontal
         if (arrowDirection() == Qt::UpArrow) {
             return QRect(iw, //
                          w,
                          width() - 2 * iw,
                          height() - w * 2 - ARROWSIZE);
         } else {
             return QRect(iw, //
                          w + ARROWSIZE,
                          width() - 2 * iw,
                          height() - w * 2 - ARROWSIZE);
         }
     }
 }
 
 void KSelector::paintEvent(QPaintEvent *)
 {
     QPainter painter;
     int w = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
     int iw = (w < ARROWSIZE) ? ARROWSIZE : w;
 
     painter.begin(this);
 
     if (indent()) {
         QStyleOptionFrame opt;
         opt.initFrom(this);
         opt.state = QStyle::State_Sunken;
         if (orientation() == Qt::Vertical) {
             opt.rect.adjust(0, iw - w, -5, w - iw);
         } else {
             opt.rect.adjust(iw - w, 0, w - iw, -5);
         }
         QBrush oldBrush = painter.brush();
         painter.setBrush(Qt::NoBrush);
         style()->drawPrimitive(QStyle::PE_Frame, &opt, &painter, this);
         painter.setBrush(oldBrush);
     }
 
     drawContents(&painter);
 
     QPoint pos = calcArrowPos(value());
     drawArrow(&painter, pos);
 
     painter.end();
 }
 
 void KSelector::mousePressEvent(QMouseEvent *e)
 {
     setSliderDown(true);
     moveArrow(e->pos());
 }
 
 void KSelector::mouseMoveEvent(QMouseEvent *e)
 {
     moveArrow(e->pos());
 }
 
 void KSelector::mouseReleaseEvent(QMouseEvent *e)
 {
     moveArrow(e->pos());
     setSliderDown(false);
 }
 
 void KSelector::wheelEvent(QWheelEvent *e)
 {
     int val = value() + e->angleDelta().y() / 120;
     setSliderDown(true);
     setValue(val);
     setSliderDown(false);
 }
 
 void KSelector::moveArrow(const QPoint &pos)
 {
     int val;
     int w = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
     int iw = (w < ARROWSIZE) ? ARROWSIZE : w;
 
     if (orientation() == Qt::Vertical) {
         val = (maximum() - minimum()) * (height() - pos.y() - iw) / (height() - iw * 2) + minimum();
     } else {
         val = (maximum() - minimum()) * (pos.x() - iw) / (width() - iw * 2) + minimum();
     }
 
     setValue(val);
     update();
 }
 
 QPoint KSelector::calcArrowPos(int val)
 {
     QPoint p;
     int w = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
     int iw = (w < ARROWSIZE) ? ARROWSIZE : w;
 
     if (orientation() == Qt::Vertical) {
         p.setY(height() - iw - 1 - (height() - 2 * iw - 1) * val / (maximum() - minimum()));
 
         if (d->arrowPE == QStyle::PE_IndicatorArrowRight) {
             p.setX(0);
         } else {
             p.setX(width() - 5);
         }
     } else {
         p.setX(iw + (width() - 2 * iw - 1) * val / (maximum() - minimum()));
 
         if (d->arrowPE == QStyle::PE_IndicatorArrowDown) {
             p.setY(0);
         } else {
             p.setY(height() - 5);
         }
     }
 
     return p;
 }
 
 void KSelector::setArrowDirection(Qt::ArrowType direction)
 {
     switch (direction) {
     case Qt::UpArrow:
         if (orientation() == Qt::Horizontal) {
             d->arrowPE = QStyle::PE_IndicatorArrowUp;
         } else {
             d->arrowPE = QStyle::PE_IndicatorArrowLeft;
         }
         break;
     case Qt::DownArrow:
         if (orientation() == Qt::Horizontal) {
             d->arrowPE = QStyle::PE_IndicatorArrowDown;
         } else {
             d->arrowPE = QStyle::PE_IndicatorArrowRight;
         }
         break;
     case Qt::LeftArrow:
         if (orientation() == Qt::Vertical) {
             d->arrowPE = QStyle::PE_IndicatorArrowLeft;
         } else {
             d->arrowPE = QStyle::PE_IndicatorArrowDown;
         }
         break;
     case Qt::RightArrow:
         if (orientation() == Qt::Vertical) {
             d->arrowPE = QStyle::PE_IndicatorArrowRight;
         } else {
             d->arrowPE = QStyle::PE_IndicatorArrowUp;
         }
         break;
 
     case Qt::NoArrow:
         break;
     }
 }
 
 Qt::ArrowType KSelector::arrowDirection() const
 {
     switch (d->arrowPE) {
     case QStyle::PE_IndicatorArrowUp:
         return Qt::UpArrow;
     case QStyle::PE_IndicatorArrowDown:
         return Qt::DownArrow;
     case QStyle::PE_IndicatorArrowRight:
         return Qt::RightArrow;
     case QStyle::PE_IndicatorArrowLeft:
     default:
         return Qt::LeftArrow;
     }
 }
 
 void KSelector::drawContents(QPainter *)
 {
 }
 
 void KSelector::drawArrow(QPainter *painter, const QPoint &pos)
 {
     painter->setPen(QPen());
     painter->setBrush(QBrush(palette().color(QPalette::ButtonText)));
 
     QStyleOption o;
 
     if (orientation() == Qt::Vertical) {
         o.rect = QRect(pos.x(), pos.y() - ARROWSIZE / 2, ARROWSIZE, ARROWSIZE);
     } else {
         o.rect = QRect(pos.x() - ARROWSIZE / 2, pos.y(), ARROWSIZE, ARROWSIZE);
     }
     style()->drawPrimitive(d->arrowPE, &o, painter, this);
 }
 
 //----------------------------------------------------------------------------
 
 KGradientSelector::KGradientSelector(QWidget *parent)
     : KSelector(parent)
     , d(new KGradientSelectorPrivate(this))
 {
 }
 
 KGradientSelector::KGradientSelector(Qt::Orientation o, QWidget *parent)
     : KSelector(o, parent)
     , d(new KGradientSelectorPrivate(this))
 {
 }
 
 KGradientSelector::~KGradientSelector() = default;
 
 void KGradientSelector::drawContents(QPainter *painter)
 {
     d->gradient.setStart(contentsRect().topLeft());
     if (orientation() == Qt::Vertical) {
         d->gradient.setFinalStop(contentsRect().bottomLeft());
     } else {
         d->gradient.setFinalStop(contentsRect().topRight());
     }
     QBrush gradientBrush(d->gradient);
 
     if (!gradientBrush.isOpaque()) {
         QPixmap chessboardPattern(16, 16);
         QPainter patternPainter(&chessboardPattern);
         patternPainter.fillRect(0, 0, 8, 8, Qt::black);
         patternPainter.fillRect(8, 8, 8, 8, Qt::black);
         patternPainter.fillRect(0, 8, 8, 8, Qt::white);
         patternPainter.fillRect(8, 0, 8, 8, Qt::white);
         patternPainter.end();
         painter->fillRect(contentsRect(), QBrush(chessboardPattern));
     }
     painter->fillRect(contentsRect(), gradientBrush);
 
     if (orientation() == Qt::Vertical) {
         int yPos = contentsRect().top() + painter->fontMetrics().ascent() + 2;
         int xPos = contentsRect().left() + (contentsRect().width() - painter->fontMetrics().horizontalAdvance(d->text2)) / 2;
         QPen pen(qGray(firstColor().rgb()) > 180 ? Qt::black : Qt::white);
         painter->setPen(pen);
         painter->drawText(xPos, yPos, d->text2);
 
         yPos = contentsRect().bottom() - painter->fontMetrics().descent() - 2;
         xPos = contentsRect().left() + (contentsRect().width() - painter->fontMetrics().horizontalAdvance(d->text1)) / 2;
         pen.setColor(qGray(secondColor().rgb()) > 180 ? Qt::black : Qt::white);
         painter->setPen(pen);
         painter->drawText(xPos, yPos, d->text1);
     } else {
         int yPos = contentsRect().bottom() - painter->fontMetrics().descent() - 2;
 
         QPen pen(qGray(firstColor().rgb()) > 180 ? Qt::black : Qt::white);
         painter->setPen(pen);
         painter->drawText(contentsRect().left() + 2, yPos, d->text1);
 
         pen.setColor(qGray(secondColor().rgb()) > 180 ? Qt::black : Qt::white);
         painter->setPen(pen);
         painter->drawText(contentsRect().right() - painter->fontMetrics().horizontalAdvance(d->text2) - 2, yPos, d->text2);
     }
 }
 
 QSize KGradientSelector::minimumSize() const
 {
     return sizeHint();
 }
 
 void KGradientSelector::setStops(const QGradientStops &stops)
 {
     d->gradient.setStops(stops);
     update();
 }
 
 QGradientStops KGradientSelector::stops() const
 {
     return d->gradient.stops();
 }
 
 void KGradientSelector::setColors(const QColor &col1, const QColor &col2)
 {
     d->gradient.setColorAt(0.0, col1);
     d->gradient.setColorAt(1.0, col2);
     update();
 }
 
 void KGradientSelector::setText(const QString &t1, const QString &t2)
 {
     d->text1 = t1;
     d->text2 = t2;
     update();
 }
 
 void KGradientSelector::setFirstColor(const QColor &col)
 {
     d->gradient.setColorAt(0.0, col);
     update();
 }
 
 void KGradientSelector::setSecondColor(const QColor &col)
 {
     d->gradient.setColorAt(1.0, col);
     update();
 }
 
 void KGradientSelector::setFirstText(const QString &t)
 {
     d->text1 = t;
     update();
 }
 
 void KGradientSelector::setSecondText(const QString &t)
 {
     d->text2 = t;
     update();
 }
 
 QColor KGradientSelector::firstColor() const
 {
     return d->gradient.stops().first().second;
 }
 
 QColor KGradientSelector::secondColor() const
 {
     return d->gradient.stops().last().second;
 }
 
 QString KGradientSelector::firstText() const
 {
     return d->text1;
 }
 
 QString KGradientSelector::secondText() const
 {
     return d->text2;
 }
 
 #include "moc_kselector.cpp"