File indexing completed on 2024-10-13 04:16:21

 // SPDX-FileCopyrightText: Lukas Sommer <sommerluk@gmail.com>
 // SPDX-License-Identifier: BSD-2-Clause OR MIT
 
 // Own headers
 // First the interface, which forces the header to be self-contained.
 #include "colorwheel.h"
 // Second, the private implementation.
 #include "colorwheel_p.h" // IWYU pragma: associated
 
 #include "abstractdiagram.h"
 #include "cielchd50values.h"
 #include "colorwheelimage.h"
 #include "constpropagatingrawpointer.h"
 #include "constpropagatinguniquepointer.h"
 #include "helper.h"
 #include "helperconstants.h"
 #include "helpermath.h"
 #include "helperposixmath.h"
 #include "polarpointf.h"
 #include <qevent.h>
 #include <qimage.h>
 #include <qnamespace.h>
 #include <qpainter.h>
 #include <qpen.h>
 #include <qpoint.h>
 #include <qsharedpointer.h>
 #include <qwidget.h>
 
 namespace PerceptualColor
 {
 /** @brief Constructor
  *
  * @param colorSpace The color space within which this widget should operate.
  * Can be created with @ref RgbColorSpaceFactory.
  *
  * @param parent The widget’s parent widget. This parameter will be passed
  * to the base class’s constructor. */
 ColorWheel::ColorWheel(const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace, QWidget *parent)
     : AbstractDiagram(parent)
     , d_pointer(new ColorWheelPrivate(this, colorSpace))
 {
     // Setup the color space must be the first thing to do because
     // other operations rely on a working color space.
     d_pointer->m_rgbColorSpace = colorSpace;
 
     // Set focus policy
     // In Qt, usually focus (QWidget::hasFocus()) by mouse click is
     // either not accepted at all or accepted always for the hole rectangular
     // widget, depending on QWidget::focusPolicy(). This is not
     // convenient and intuitive for big, circular-shaped widgets like this one.
     // It would be nicer if the focus would only be accepted by mouse clicks
     // <em>within the circle itself</em>. Qt does not provide a build-in way to
     // do this. But a workaround to implement this behavior is possible: Set
     // QWidget::focusPolicy() to <em>not</em> accept focus by mouse
     // click. Then, reimplement mousePressEvent() and call
     // setFocus(Qt::MouseFocusReason) if the mouse click is within the
     // circle. Therefore, this class simply defaults to
     // Qt::FocusPolicy::TabFocus for QWidget::focusPolicy().
     setFocusPolicy(Qt::FocusPolicy::TabFocus);
 }
 
 /** @brief Default destructor */
 ColorWheel::~ColorWheel() noexcept
 {
 }
 
 /** @brief Constructor
  *
  * @param backLink Pointer to the object from which <em>this</em> object
  * is the private implementation.
  *
  * @param colorSpace The color space within which this widget should operate. */
 ColorWheelPrivate::ColorWheelPrivate(ColorWheel *backLink, const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace)
     : m_wheelImage(colorSpace)
     , q_pointer(backLink)
 {
     // Initialization
     m_hue = CielchD50Values::neutralHue;
 }
 
 /** @brief Convert widget pixel positions to wheel coordinate points.
  *
  * @param position The position of a pixel of the widget coordinate
  * system. The given value  does not necessarily need to be within the
  * actual displayed diagram or even the gamut itself. It might even be
  * negative.
  *
  * @returns A coordinate point relative to a polar coordinate system
  * who’s center is exactly in the middle of the displayed wheel. Measured
  * in <em>device-independent pixels</em>.
  *
  * @sa @ref fromWheelToWidgetCoordinates */
 PolarPointF ColorWheelPrivate::fromWidgetPixelPositionToWheelCoordinates(const QPoint position) const
 {
     const qreal radius = q_pointer->maximumWidgetSquareSize() / 2.0;
     const QPointF temp{position.x() - radius + 0.5, radius - position.y() + 0.5};
     return PolarPointF(temp);
 }
 
 /** @brief Convert wheel coordinate points to widget coordinate points.
  *
  * @param wheelCoordinates A coordinate point relative to a polar coordinate
  * system who’s center is exactly in the middle of the displayed wheel.
  * Measured in <em>device-independent pixels</em>.
  *
  * @returns The same coordinate point relative to the coordinate system of
  * this widget. Measured in <em>device-independent pixels</em>.
  *
  * @sa @ref fromWidgetPixelPositionToWheelCoordinates */
 QPointF ColorWheelPrivate::fromWheelToWidgetCoordinates(const PolarPointF wheelCoordinates) const
 {
     const qreal radius = q_pointer->maximumWidgetSquareSize() / 2.0;
     QPointF result = wheelCoordinates.toCartesian();
     result.setX(result.x() + radius);
     result.setY(radius - result.y());
     return result;
 }
 
 /** @brief React on a mouse press event.
  *
  * Reimplemented from base class.
  *
  * Does not differentiate between left, middle and right mouse click.
  *
  * If the mouse is clicked within the wheel ribbon, than the handle is placed
  * here and further mouse movements are tracked.
  *
  * @param event The corresponding mouse event
  *
  * @internal
  *
  * @sa @ref ColorWheelPrivate::m_isMouseEventActive */
 void ColorWheel::mousePressEvent(QMouseEvent *event)
 {
     const qreal radius = maximumWidgetSquareSize() / 2.0 - spaceForFocusIndicator();
     PolarPointF myPolarPoint = d_pointer->fromWidgetPixelPositionToWheelCoordinates(event->pos());
 
     // Ignore clicks outside the wheel
     if (myPolarPoint.radius() > radius) {
         // Make sure default coordinates like drag-window
         // in KDE’s Breeze widget style works:
         event->ignore();
         return;
     }
 
     // If inside the wheel (either in the wheel ribbon itself or in the hole
     // in the middle), take focus:
     setFocus(Qt::MouseFocusReason);
 
     if (myPolarPoint.radius() > radius - gradientThickness()) {
         d_pointer->m_isMouseEventActive = true;
         setHue(myPolarPoint.angleDegree());
     } else {
         // Make sure default coordinates like drag-window
         // in KDE’s Breeze widget style works:
         event->ignore();
     }
 
     return;
 }
 
 /** @brief React on a mouse move event.
  *
  * Reimplemented from base class.
  *
  * Reacts only on mouse move events if previously there had been a mouse press
  * event that had been accepted. If previously there had not been a mouse
  * press event, the mouse move event is ignored.
  *
  * @param event The corresponding mouse event
  *
  * @internal
  *
  * @sa @ref ColorWheelPrivate::m_isMouseEventActive */
 void ColorWheel::mouseMoveEvent(QMouseEvent *event)
 {
     if (d_pointer->m_isMouseEventActive) {
         setHue(d_pointer->fromWidgetPixelPositionToWheelCoordinates(event->pos()).angleDegree());
     } else {
         // Make sure default coordinates like drag-window in KDE’s Breeze
         // widget style works
         event->ignore();
     }
 }
 
 /** @brief React on a mouse release event.
  *
  * Reimplemented from base class. Does not differentiate between left,
  * middle and right mouse click.
  *
  * @param event The corresponding mouse event
  *
  * @internal
  *
  * @sa @ref ColorWheelPrivate::m_isMouseEventActive
  *
  * @sa @ref ColorWheelPrivate::m_isMouseEventActive */
 void ColorWheel::mouseReleaseEvent(QMouseEvent *event)
 {
     if (d_pointer->m_isMouseEventActive) {
         d_pointer->m_isMouseEventActive = false;
         setHue(d_pointer->fromWidgetPixelPositionToWheelCoordinates(event->pos()).angleDegree());
     } else {
         // Make sure default coordinates like drag-window in KDE’s Breeze
         // widget style works
         event->ignore();
     }
 }
 
 /** @brief React on a mouse wheel event.
  *
  * Reimplemented from base class.
  *
  * Scrolling up raises the hue value, scrolling down lowers the hue value.
  * Of course, the point at 0°/360° it not blocking.
  *
  * @param event The corresponding mouse event */
 void ColorWheel::wheelEvent(QWheelEvent *event)
 {
     const qreal radius = maximumWidgetSquareSize() / 2.0 - spaceForFocusIndicator();
     // Though QWheelEvent::position() returns a floating point
     // value, this value seems to corresponds to a pixel position
     // and not a coordinate point. Therefore, we convert to QPoint.
     const PolarPointF myPolarPoint = //
         d_pointer->fromWidgetPixelPositionToWheelCoordinates(event->position().toPoint());
     if (
         // Do nothing while mouse movement is tracked anyway. This would
         // be confusing:
         (!d_pointer->m_isMouseEventActive)
         // Only react on wheel events when its in the wheel ribbon or in
         // the inner hole:
         && (myPolarPoint.radius() <= radius)
         // Only react on good old vertical wheels, and not on horizontal wheels:
         && (event->angleDelta().y() != 0)
         // then:
     ) {
         d_pointer->setHueNormalized(d_pointer->m_hue + standardWheelStepCount(event) * singleStepHue);
     } else {
         event->ignore();
     }
 }
 
 /** @brief React on key press events.
  *
  * Reimplemented from base class.
  *
  * Reacts on key press events. When the <em>plus</em> key or the <em>minus</em>
  * key are pressed, it raises or lowers the hue. When <tt>Qt::Key_Insert</tt>
  * or <tt>Qt::Key_Delete</tt> are pressed, it raises or lowers the hue faster.
  *
  * @param event the corresponding event
  *
  * @internal
  *
  * @todo The keys are chosen to not conflict with @ref ChromaHueDiagram. But:
  * They are a little strange. Does this really make sense? */
 void ColorWheel::keyPressEvent(QKeyEvent *event)
 {
     switch (event->key()) {
     case Qt::Key_Plus:
         d_pointer->setHueNormalized(d_pointer->m_hue + singleStepHue);
         break;
     case Qt::Key_Minus:
         d_pointer->setHueNormalized(d_pointer->m_hue - singleStepHue);
         break;
     case Qt::Key_Insert:
         d_pointer->setHueNormalized(d_pointer->m_hue + pageStepHue);
         break;
     case Qt::Key_Delete:
         d_pointer->setHueNormalized(d_pointer->m_hue - pageStepHue);
         break;
     default:
         /* Quote from Qt documentation:
          *
          * If you reimplement this handler, it is very important
          * that you call the base class implementation if you do not
          * act upon the key.
          *
          * The default implementation closes popup widgets if the user
          * presses the key sequence for QKeySequence::Cancel (typically
          * the Escape key). Otherwise the event is ignored, so that the
          * widget’s parent can interpret it. */
         QWidget::keyPressEvent(event);
         break;
     }
 }
 
 /** @brief Paint the widget.
  *
  * Reimplemented from base class.
  *
  * @param event the paint event
  *
  * @internal
  *
  * The wheel is painted using @ref ColorWheelPrivate::m_wheelImage.
  * The focus indicator (if any) and the handle are painted on-the-fly.
  *
  * @todo Make the wheel to be drawn horizontally and vertically aligned?? Or
  * better top-left aligned for LTR layouts and top-right aligned for RTL
  * layouts?
  *
  * @todo Better design (smaller wheel ribbon?) for small widget sizes */
 void ColorWheel::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event)
     // We do not paint directly on the widget, but on a QImage buffer first:
     // Render anti-aliased looks better. But as Qt documentation says:
     //
     //      “Renderhints are used to specify flags to QPainter that may or
     //       may not be respected by any given engine.”
     //
     // Painting here directly on the widget might lead to different
     // anti-aliasing results depending on the underlying window system. This
     // is especially problematic as anti-aliasing might shift or not a pixel
     // to the left or to the right. So we paint on a QImage first. As QImage
     // (at difference to QPixmap and a QWidget) is independent of native
     // platform rendering, it guarantees identical anti-aliasing results on
     // all platforms. Here the quote from QPainter class documentation:
     //
     //      “To get the optimal rendering result using QPainter, you should
     //       use the platform independent QImage as paint device; i.e. using
     //       QImage will ensure that the result has an identical pixel
     //       representation on any platform.”
     QImage paintBuffer(maximumPhysicalSquareSize(), // width
                        maximumPhysicalSquareSize(), // height
                        QImage::Format_ARGB32_Premultiplied // format
     );
     paintBuffer.fill(Qt::transparent);
     paintBuffer.setDevicePixelRatio(devicePixelRatioF());
     QPainter bufferPainter(&paintBuffer);
 
     // Paint the color wheel
     bufferPainter.setRenderHint(QPainter::Antialiasing, false);
     // As devicePixelRatioF() might have changed, we make sure everything
     // that might depend on devicePixelRatioF() is updated before painting.
     d_pointer->m_wheelImage.setBorder(spaceForFocusIndicator() * devicePixelRatioF());
     d_pointer->m_wheelImage.setDevicePixelRatioF(devicePixelRatioF());
     d_pointer->m_wheelImage.setImageSize(maximumPhysicalSquareSize());
     d_pointer->m_wheelImage.setWheelThickness(gradientThickness() * devicePixelRatioF());
     bufferPainter.drawImage(QPoint(0, 0), // image position (top-left)
                             d_pointer->m_wheelImage.getImage() // the image itself
     );
 
     // Paint the handle
     const qreal wheelOuterRadius = maximumWidgetSquareSize() / 2.0 - spaceForFocusIndicator();
     // Get widget coordinates for the handle
     QPointF myHandleInner = d_pointer->fromWheelToWidgetCoordinates(
         // Inner point at the wheel:
         PolarPointF(wheelOuterRadius - gradientThickness(), // x
                     d_pointer->m_hue // y
                     ));
     QPointF myHandleOuter = d_pointer->fromWheelToWidgetCoordinates(
         // Outer point at the wheel:
         PolarPointF(wheelOuterRadius, d_pointer->m_hue));
     // Draw the line
     QPen pen;
     pen.setWidth(handleOutlineThickness());
     pen.setCapStyle(Qt::FlatCap);
     pen.setColor(Qt::black);
     bufferPainter.setPen(pen);
     bufferPainter.setRenderHint(QPainter::Antialiasing, true);
     bufferPainter.drawLine(myHandleInner, myHandleOuter);
 
     // Paint a focus indicator if the widget has the focus
     if (hasFocus()) {
         bufferPainter.setRenderHint(QPainter::Antialiasing, true);
         pen = QPen();
         pen.setWidth(handleOutlineThickness());
         pen.setColor(focusIndicatorColor());
         bufferPainter.setPen(pen);
         const qreal center = maximumWidgetSquareSize() / 2.0;
         bufferPainter.drawEllipse(
             // center:
             QPointF(center, center),
             // x radius:
             center - handleOutlineThickness() / 2.0,
             // y radius:
             center - handleOutlineThickness() / 2.0);
     }
 
     // Paint the buffer to the actual widget
     QPainter widgetPainter(this);
     widgetPainter.setRenderHint(QPainter::Antialiasing, false);
     widgetPainter.drawImage(QPoint(0, 0), paintBuffer);
 }
 
 /** @brief React on a resize event.
  *
  * Reimplemented from base class.
  *
  * @param event The corresponding resize event */
 void ColorWheel::resizeEvent(QResizeEvent *event)
 {
     Q_UNUSED(event)
 
     // Update the widget content
     d_pointer->m_wheelImage.setImageSize(maximumPhysicalSquareSize());
     /* As by Qt documentation:
      *     “The widget will be erased and receive a paint event immediately
      *      after processing the resize event. No drawing need be (or should
      *      be) done inside this handler.” */
 }
 
 // No documentation here (documentation of properties
 // and its getters are in the header)
 qreal ColorWheel::hue() const
 {
     return d_pointer->m_hue;
 }
 
 /** @brief Setter for the @ref hue property.
  *  @param newHue the new hue */
 void ColorWheel::setHue(const qreal newHue)
 {
     if (d_pointer->m_hue != newHue) {
         d_pointer->m_hue = newHue;
         Q_EMIT hueChanged(d_pointer->m_hue);
         update();
     }
 }
 
 /** @brief Setter for the @ref ColorWheel::hue property.
  *  @param newHue the new hue
  *  @post Normalizes newHue, and than sets @ref ColorWheel::hue to the
  * normalized value. */
 void ColorWheelPrivate::setHueNormalized(const qreal newHue)
 {
     const qreal temp = normalizedAngle360(newHue);
     q_pointer->setHue(temp);
 }
 
 /** @brief Recommended size for the widget.
  *
  * Reimplemented from base class.
  *
  * @returns Recommended size for the widget.
  *
  * @sa @ref minimumSizeHint() */
 QSize ColorWheel::sizeHint() const
 {
     return minimumSizeHint() * scaleFromMinumumSizeHintToSizeHint;
 }
 
 /** @brief Recommended minimum size for the widget.
  *
  * Reimplemented from base class.
  *
  * @returns Recommended minimum size for the widget.
  *
  * @sa @ref sizeHint() */
 QSize ColorWheel::minimumSizeHint() const
 {
     // We interpret the gradientMinimumLength() as the length between two
     // poles of human perception. Around the wheel, there are four of them
     // (0° red, 90° yellow, 180° green, 270° blue). So the circumference of
     // the inner circle of the wheel is 4 × gradientMinimumLength(). By
     // dividing it by π, we get the required inner diameter:
     const qreal innerDiameter = 4 * gradientMinimumLength() / pi;
     const int size = qRound(innerDiameter + 2 * gradientThickness() + 2 * spaceForFocusIndicator());
     // Expand to the global minimum size for GUI elements
     return QSize(size, size);
 }
 
 /** @brief The empty space around the diagrams reserved for the focus
  * indicator.
  *
  * This is a simple redirect to @ref AbstractDiagram::spaceForFocusIndicator().
  * It is meant to allow access from friend classes of @ref ColorWheel.
  *
  * Measured in <em>device-independent pixels</em>.
  *
  * @returns The empty space around diagrams (distance between widget outline
  * and color wheel outline) reserved for the focus indicator. */
 int ColorWheelPrivate::border() const
 {
     return q_pointer->spaceForFocusIndicator();
 }
 
 /** @brief The inner diameter of the color wheel.
  *
  * It is meant to allow access from friend classes of @ref ColorWheel.
  *
  * @returns The inner diameter of the color wheel, measured in
  * <em>device-independent pixels</em>. This is the diameter of the empty
  * circle within the color wheel. */
 qreal ColorWheelPrivate::innerDiameter() const
 {
     return
         // Size for the widget:
         q_pointer->maximumWidgetSquareSize()
         // Reduce space for the wheel ribbon:
         - 2 * q_pointer->gradientThickness()
         // Reduce space for  the focus indicator (border around wheel ribbon):
         - 2 * q_pointer->spaceForFocusIndicator();
 }
 
 } // namespace PerceptualColor