File indexing completed on 2024-05-12 04:44:29

 // 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 "chromahuediagram.h"
 // Second, the private implementation.
 #include "chromahuediagram_p.h" // IWYU pragma: associated
 
 #include "abstractdiagram.h"
 #include "asyncimageprovider.h"
 #include "chromahueimageparameters.h"
 #include "cielchd50values.h"
 #include "colorwheelimage.h"
 #include "constpropagatingrawpointer.h"
 #include "constpropagatinguniquepointer.h"
 #include "helper.h"
 #include "helperconstants.h"
 #include "helperconversion.h"
 #include "lchdouble.h"
 #include "polarpointf.h"
 #include "rgbcolorspace.h"
 #include <lcms2.h>
 #include <qbrush.h>
 #include <qcolor.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 The 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. */
 ChromaHueDiagram::ChromaHueDiagram(const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace, QWidget *parent)
     : AbstractDiagram(parent)
     , d_pointer(new ChromaHueDiagramPrivate(this, colorSpace))
 {
     // Setup LittleCMS. This is the first thing to do, because other
     // operations rely on a working LittleCMS.
     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);
 
     // Connections
     connect(&d_pointer->m_chromaHueImage, //
             &AsyncImageProvider<ChromaHueImageParameters>::interlacingPassCompleted, //
             this,
             &ChromaHueDiagram::callUpdate);
 
     // Initialize the color
     setCurrentColor(CielchD50Values::srgbVersatileInitialColor);
 }
 
 /** @brief Default destructor */
 ChromaHueDiagram::~ChromaHueDiagram() 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. */
 ChromaHueDiagramPrivate::ChromaHueDiagramPrivate(ChromaHueDiagram *backLink, const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace)
     : m_currentColor{0, 0, 0} // dummy value
     , m_wheelImage(colorSpace)
     , q_pointer(backLink)
 {
 }
 
 /** @brief React on a mouse press event.
  *
  * Reimplemented from base class.
  *
  * @internal
  * @post
  * - If the mouse is clicked with the circular diagram (inside or
  *   outside of the visible gamut), than this widget gets the focus
  *   and and @ref ChromaHueDiagramPrivate::m_isMouseEventActive is
  *   set to <tt>true</tt> to track mouse movements from now on.
  *   Reacts on all clicks (left, middle, right). If the mouse was
  *   within the gamut, the diagram’s handle is displaced there. If
  *   the mouse was outside the gamut, the diagram’s handle always stays
  *   within the gamut: The hue value is correctly retained, while the chroma
  *   value is the highest possible chroma within the gamut at this hue.
  * @endinternal
  *
  * @param event The corresponding mouse event */
 void ChromaHueDiagram::mousePressEvent(QMouseEvent *event)
 {
     // TODO Also accept out-of-gamut clicks when they are covered by the
     // current handle.
     const bool isWithinCircle = //
         d_pointer->isWidgetPixelPositionWithinMouseSensibleCircle(event->pos());
     if (isWithinCircle) {
         event->accept();
         // Mouse focus is handled manually because so we can accept
         // focus only on mouse clicks within the displayed gamut, while
         // rejecting focus otherwise. In the constructor, therefore
         // Qt::FocusPolicy::TabFocus is specified, so that manual handling
         // of mouse focus is up to this code here.
         setFocus(Qt::MouseFocusReason);
         // Enable mouse tracking from now on:
         d_pointer->m_isMouseEventActive = true;
         // As clicks are only accepted within the visible gamut, the mouse
         // cursor is made invisible. Its function is taken over by the
         // handle itself within the displayed gamut.
         setCursor(Qt::BlankCursor);
         // Set the color property
         d_pointer->setColorFromWidgetPixelPosition(event->pos());
         // Schedule a paint event, so that the wheel handle will show. It’s
         // not enough to hope setColorFromWidgetCoordinates() would do this,
         // because setColorFromWidgetCoordinates() would not update the
         // widget if the mouse click was done at the same position as the
         // current color handle.
         update();
     } else {
         // Make sure default behavior like drag-window in KDE’s
         // “Breeze” widget style works if this widget does not
         // actually react itself on a mouse event.
         event->ignore();
     }
 }
 
 /** @brief React on a mouse move event.
  *
  * Reimplemented from base class.
  *
  * @internal
  * @post Reacts only on mouse move events if
  * @ref ChromaHueDiagramPrivate::m_isMouseEventActive is <tt>true</tt>:
  * - If the mouse moves within the gamut, the diagram’s handle is displaced
  *   there. The mouse cursor is invisible; only the diagram’ handle is
  *   visible.
  * - If the mouse moves outside the gamut, the diagram’s handle always stays
  *   within the gamut: The hue value is correctly retained, while the chroma
  *   value is the highest possible chroma within the gamut at this hue.
  *   Both, the diagram’s handle <em>and</em> the mouse cursor are
  *   visible.
  * @endinternal
  *
  * @param event The corresponding mouse event */
 void ChromaHueDiagram::mouseMoveEvent(QMouseEvent *event)
 {
     if (d_pointer->m_isMouseEventActive) {
         event->accept();
         const cmsCIELab cielabD50 = //
             d_pointer->fromWidgetPixelPositionToLab(event->pos());
         const bool isWithinCircle = //
             d_pointer->isWidgetPixelPositionWithinMouseSensibleCircle( //
                 event->pos());
         if (isWithinCircle && d_pointer->m_rgbColorSpace->isCielabD50InGamut(cielabD50)) {
             setCursor(Qt::BlankCursor);
         } else {
             unsetCursor();
         }
         d_pointer->setColorFromWidgetPixelPosition(event->pos());
     } else {
         // Make sure default behavior like drag-window in KDE’s
         // Breeze widget style works.
         event->ignore();
     }
 }
 
 /** @brief React on a mouse release event.
  *
  * Reimplemented from base class. Reacts on all clicks (left, middle, right).
  *
  * @param event The corresponding mouse event
  *
  * @internal
  *
  * @post If @ref ChromaHueDiagramPrivate::m_isMouseEventActive is
  * <tt>true</tt> then:
  * - If the mouse is within the gamut, the diagram’s handle is displaced
  *   there.
  * - If the mouse moves outside the gamut, the diagram’s handle always stays
  *   within the gamut: The hue value is correctly retained, while the chroma
  *   value is the highest possible chroma within the gamut at this hue.
  * - The mouse cursor is made visible (if he wasn’t yet visible anyway).
  * - @ref ChromaHueDiagramPrivate::m_isMouseEventActive is set
  *   to <tt>false</tt>.
  *
  * @todo What if the widget displays a gamut that has no L*=0.1 because its
  * blackpoint is lighter.? Sacrificing chroma alone does not help? How to
  * react (for mouse input, keyboard input, but also API functions like
  * setColor()? */
 void ChromaHueDiagram::mouseReleaseEvent(QMouseEvent *event)
 {
     if (d_pointer->m_isMouseEventActive) {
         event->accept();
         unsetCursor();
         d_pointer->m_isMouseEventActive = false;
         d_pointer->setColorFromWidgetPixelPosition(event->pos());
         // Schedule a paint event, so that the wheel handle will be hidden.
         // It’s not enough to hope setColorFromWidgetCoordinates() would do
         // this, because setColorFromWidgetCoordinates() would not update the
         // widget if the mouse click was done at the same position as the
         // current color handle.
         update();
     } else {
         // Make sure default behavior 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, at the point at 0°/360° wrapping applies.
  *
  * @param event The corresponding mouse event */
 void ChromaHueDiagram::wheelEvent(QWheelEvent *event)
 {
     // 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 bool isWithinCircle = //
         d_pointer->isWidgetPixelPositionWithinMouseSensibleCircle( //
             event->position().toPoint());
     if (
         // Do nothing while a the mouse is clicked and the mouse movement is
         // tracked anyway because this would be confusing for the user.
         (!d_pointer->m_isMouseEventActive)
         // Only react on good old vertical wheels,
         // and not on horizontal wheels.
         && (event->angleDelta().y() != 0)
         // Only react on wheel events when then happen in the appropriate
         // area.
         // 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.
         && isWithinCircle
         // then:
     ) {
         event->accept();
         // Calculate the new hue.
         // This may result in a hue smaller then 0° or bigger then 360°.
         // This should not make any problems.
         LchDouble newColor = d_pointer->m_currentColor;
         newColor.h += standardWheelStepCount(event) * singleStepHue;
         setCurrentColor( //
             d_pointer->m_rgbColorSpace->reduceCielchD50ChromaToFitIntoGamut(newColor));
     } else {
         event->ignore();
     }
 }
 
 /** @brief React on key press events.
  *
  * Reimplemented from base class.
  *
  * The keys do not react in form of up, down, left and right like in
  * Cartesian coordinate systems. The keys change radius and angel like
  * in polar coordinate systems, because our color model is also based
  * on a polar coordinate system.
  *
  * For chroma changes: Moves the handle as much as possible into the
  * desired direction as long as this is still in the gamut.
  * - Qt::Key_Up increments chroma a small step
  * - Qt::Key_Down decrements chroma a small step
  * - Qt::Key_PageUp increments chroma a big step
  * - Qt::Key_PageDown decrements chroma a big step
  *
  * For hue changes: If necessary, the chroma value is reduced to get an
  * in-gamut color with the new hue.
  * - Qt::Key_Left increments hue a small step
  * - Qt::Key_Right decrements hue a small step
  * - Qt::Key_Home increments hue a big step
  * - Qt::Key_End decrements hue a big step
  *
  * @param event the event
  *
  * @internal
  *
  * @todo Is this behavior really a good user experience? Or is it confusing
  * that left, right, up and down don’t do what was expected? What could be
  * more intuitive keys for changing radius and angle? At least the arrow keys
  * are likely that the user tries them out by trial-and-error. */
 void ChromaHueDiagram::keyPressEvent(QKeyEvent *event)
 {
     LchDouble newColor = currentColor();
     switch (event->key()) {
     case Qt::Key_Up:
         newColor.c += singleStepChroma;
         break;
     case Qt::Key_Down:
         newColor.c -= singleStepChroma;
         break;
     case Qt::Key_Left:
         newColor.h += singleStepHue;
         break;
     case Qt::Key_Right:
         newColor.h -= singleStepHue;
         break;
     case Qt::Key_PageUp:
         newColor.c += pageStepChroma;
         break;
     case Qt::Key_PageDown:
         newColor.c -= pageStepChroma;
         break;
     case Qt::Key_Home:
         newColor.h += pageStepHue;
         break;
     case Qt::Key_End:
         newColor.h -= 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);
         return;
     }
     // Here we reach only if the key has been recognized. If not, in the
     // default branch of the switch statement, we would have passed the
     // keyPressEvent yet to the parent and returned.
     if (newColor.c < 0) {
         // Do not allow negative chroma values.
         // (Doing so would be counter-intuitive.)
         newColor.c = 0;
     }
     // Move the value into gamut (if necessary):
     newColor = d_pointer->m_rgbColorSpace->reduceCielchD50ChromaToFitIntoGamut(newColor);
     // Apply the new value:
     setCurrentColor(newColor);
 }
 
 /** @brief Recommended size for the widget.
  *
  * Reimplemented from base class.
  *
  * @returns Recommended size for the widget.
  *
  * @sa @ref minimumSizeHint() */
 QSize ChromaHueDiagram::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 ChromaHueDiagram::minimumSizeHint() const
 {
     const int mySize =
         // Considering the gradient length two times, as the diagram
         // shows the center of the coordinate system in the middle,
         // and each side of the center should be well visible.
         2 * d_pointer->diagramBorder() + 2 * gradientMinimumLength();
     // Expand to the global minimum size for GUI elements
     return QSize(mySize, mySize);
 }
 
 // No documentation here (documentation of properties
 // and its getters are in the header)
 LchDouble ChromaHueDiagram::currentColor() const
 {
     return d_pointer->m_currentColor;
 }
 
 /** @brief Setter for the @ref currentColor property.
  *
  * @param newCurrentColor the new color */
 void ChromaHueDiagram::setCurrentColor(const LchDouble &newCurrentColor)
 {
     if (newCurrentColor.hasSameCoordinates(d_pointer->m_currentColor)) {
         return;
     }
 
     const LchDouble oldColor = d_pointer->m_currentColor;
 
     d_pointer->m_currentColor = newCurrentColor;
 
     // Update, if necessary, the diagram.
     if (d_pointer->m_currentColor.l != oldColor.l) {
         const qreal temp = qBound(static_cast<qreal>(0), //
                                   d_pointer->m_currentColor.l, //
                                   static_cast<qreal>(100));
         d_pointer->m_chromaHueImageParameters.lightness = temp;
         // TODO xxx Enable this line one the performance problem is solved.
         // This is meant to free memory in the cache if the widget is
         // not currently visible.
         // d_pointer->m_chromaHueImage.setImageParameters(d_pointer->m_chromaHueImageParameters);
     }
 
     // Schedule a paint event:
     update();
 
     // Emit notify signal
     Q_EMIT currentColorChanged(newCurrentColor);
 }
 
 /** @brief The point that is the center of the diagram coordinate system.
  *
  * @returns The point that is the center of the diagram coordinate system,
  * measured in <em>device-independent pixels</em> relative to the widget
  * coordinate system.
  *
  * @sa @ref diagramOffset provides a one-dimensional
  * representation of this very same fact. */
 QPointF ChromaHueDiagramPrivate::diagramCenter() const
 {
     const qreal tempOffset{diagramOffset()};
     return QPointF(tempOffset, tempOffset);
 }
 
 /** @brief The point that is the center of the diagram coordinate system.
  *
  * @returns The offset between the center of the widget coordinate system
  * and the center of the diagram coordinate system. The value is measured in
  * <em>device-independent pixels</em> relative to the widget’s coordinate
  * system. The value is identical for both, x axis and y axis.
  *
  * @sa @ref diagramCenter provides a two-dimensional
  * representation of this very same fact. */
 qreal ChromaHueDiagramPrivate::diagramOffset() const
 {
     return q_pointer->maximumWidgetSquareSize() / 2.0;
 }
 
 /** @brief React on a resize event.
  *
  * Reimplemented from base class.
  *
  * @param event The corresponding resize event */
 void ChromaHueDiagram::resizeEvent(QResizeEvent *event)
 {
     Q_UNUSED(event)
 
     // Update the widget content
     d_pointer->m_wheelImage.setImageSize(maximumPhysicalSquareSize());
     d_pointer->m_chromaHueImageParameters.imageSizePhysical =
         // Guaranteed to be ≥ 0:
         maximumPhysicalSquareSize();
     // TODO xxx Enable this line once the performance problem is solved.
     // This is meant to free memory in the cache if the widget is
     // not currently visible.
     // d_pointer->m_chromaHueImage.setImageParameters(d_pointer->m_chromaHueImageParameters);
 
     // As Qt documentation says:
     //     “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.”
 }
 
 /** @brief  Widget coordinate point corresponding to the
  * @ref ChromaHueDiagram::currentColor property
  *
  * @returns Widget coordinate point corresponding to the
  * @ref ChromaHueDiagram::currentColor property. This is the position
  * of @ref ChromaHueDiagram::currentColor in the gamut diagram, but measured
  * and expressed as widget coordinate point.
  *
  * @sa @ref ChromaHueMeasurement "Measurement details" */
 QPointF ChromaHueDiagramPrivate::widgetCoordinatesFromCurrentColor() const
 {
     const qreal scaleFactor = //
         (q_pointer->maximumWidgetSquareSize() - 2.0 * diagramBorder()) //
         / (2.0 * m_rgbColorSpace->profileMaximumCielchD50Chroma());
     QPointF currentColor = //
         PolarPointF(m_currentColor.c, m_currentColor.h).toCartesian();
     return QPointF(
         // x:
         currentColor.x() * scaleFactor + diagramOffset(),
         // y:
         diagramOffset() - currentColor.y() * scaleFactor);
 }
 
 /** @brief Converts widget pixel positions to Lab coordinates
  *
  * @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 The Lab coordinates of the currently displayed gamut diagram
  * for the (center of the) given pixel position.
  * @sa @ref ChromaHueMeasurement "Measurement details" */
 cmsCIELab ChromaHueDiagramPrivate::fromWidgetPixelPositionToLab(const QPoint position) const
 {
     const qreal scaleFactor = //
         (2.0 * m_rgbColorSpace->profileMaximumCielchD50Chroma()) //
         / (q_pointer->maximumWidgetSquareSize() - 2.0 * diagramBorder());
     // The pixel at position 0 0 has its top left border at position 0 0
     // and its bottom right border at position 1 1 and its center at
     // position 0.5 0.5. Its the center of the pixel that is our reference
     // for conversion, therefore we have to ship by 0.5 widget pixels.
     constexpr qreal pixelValueShift = 0.5;
     cmsCIELab lab;
     lab.L = m_currentColor.l;
     lab.a = //
         (position.x() + pixelValueShift - diagramOffset()) * scaleFactor;
     lab.b = //
         (position.y() + pixelValueShift - diagramOffset()) * scaleFactor * (-1);
     return lab;
 }
 
 /** @brief Sets the @ref ChromaHueDiagram::currentColor property corresponding
  * to a given widget pixel position.
  *
  * @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.
  *
  * @post If the <em>center</em> of the widget pixel is within the represented
  * gamut, then the @ref ChromaHueDiagram::currentColor property is
  * set correspondingly. If the center of the widget pixel is outside
  * the gamut, then the chroma value is reduced (while the hue is
  * maintained) until arriving at the outer shell of the gamut; the
  * @ref ChromaHueDiagram::currentColor property is than set to this adapted
  * color.
  *
  * @note This function works independently of the actually displayed color
  * gamut diagram. So if parts of the gamut (the high chroma parts) are cut
  * off in the visible diagram, this does not influence this function.
  *
  * @sa @ref ChromaHueMeasurement "Measurement details"
  *
  * @internal
  *
  * @todo What when the mouse goes outside the gray circle, but more gamut
  * is available outside (because @ref RgbColorSpace::profileMaximumCielchD50Chroma()
  * was chosen too small)? For consistency, the handle of the diagram should
  * stay within the gray circle, and this should be interpreted also actually
  * as the value at the position of the handle. */
 void ChromaHueDiagramPrivate::setColorFromWidgetPixelPosition(const QPoint position)
 {
     const cmsCIELab lab = fromWidgetPixelPositionToLab(position);
     const auto myColor = //
         m_rgbColorSpace->reduceCielchD50ChromaToFitIntoGamut(toLchDouble(lab));
     q_pointer->setCurrentColor(myColor);
 }
 
 /** @brief Tests if a widget pixel position is within the mouse sensible circle.
  *
  * The mouse sensible circle contains the inner gray circle (on which the
  * gamut diagram is painted).
  * @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 <tt>true</tt> if the (center of the) pixel at the given position
  * is within the circle, <tt>false</tt> otherwise. */
 bool ChromaHueDiagramPrivate::isWidgetPixelPositionWithinMouseSensibleCircle(const QPoint position) const
 {
     const qreal radius = PolarPointF(
                              // Position relative to
                              // polar coordinate system center:
                              position
                              - diagramCenter()
                              // Apply the offset between
                              // - a pixel position on one hand and
                              // - a coordinate point in the middle of this very
                              //   same pixel on the other:
                              + QPointF(0.5, 0.5))
                              .radius();
 
     const qreal diagramCircleRadius = //
         q_pointer->maximumWidgetSquareSize() / 2.0 - diagramBorder();
 
     return (radius <= diagramCircleRadius);
 }
 
 /** @brief Paint the widget.
  *
  * Reimplemented from base class.
  *
  * @param event the paint event
  *
  * @internal
  *
  * @post
  * - Paints the widget. Takes the existing
  *   @ref ChromaHueDiagramPrivate::m_chromaHueImage and
  *   @ref ChromaHueDiagramPrivate::m_wheelImage and paints them on the widget.
  *   If their cache is up-to-date, this operation is fast, otherwise
  *   considerably slower.
  * - Paints the handles.
  * - If the widget has focus, it also paints the focus indicator. As the
  *   widget is round, we cannot use <tt>QStyle::PE_FrameFocusRect</tt> for
  *   painting this, neither does <tt>QStyle</tt> provide build-in support
  *   for round widgets. Therefore, we draw the focus indicator ourself,
  *   which means its form is not controlled by <tt>QStyle</tt>.
  *
  * @todo Show the indicator on the color wheel not only while a mouse button
  * is pressed, but also while a keyboard button is pressed.
  *
  * @todo What when @ref ChromaHueDiagramPrivate::m_currentColor has a valid
  * in-gamut color, but this color is out of the <em>displayed</em> diagram?
  * How to handle that? */
 void ChromaHueDiagram::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 buffer(maximumPhysicalSquareSize(), // width
                   maximumPhysicalSquareSize(), // height
                   QImage::Format_ARGB32_Premultiplied // format
     );
     buffer.fill(Qt::transparent);
     buffer.setDevicePixelRatio(devicePixelRatioF());
 
     // Other initialization
     QPainter bufferPainter(&buffer);
     QPen pen;
     const QBrush transparentBrush{Qt::transparent};
     // Set color of the handle: Black or white, depending on the lightness of
     // the currently selected color.
     const QColor handleColor //
         {handleColorFromBackgroundLightness(d_pointer->m_currentColor.l)};
     const QPointF widgetCoordinatesFromCurrentColor //
         {d_pointer->widgetCoordinatesFromCurrentColor()};
 
     // Paint the gamut itself as available in the cache.
     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_chromaHueImageParameters.borderPhysical =
         // TODO It might be useful to reduce this border to (near to) zero, and
         // than paint with an offset (if this is possible with drawEllipse?).
         // Then the memory consumption would be reduced somewhat.
         d_pointer->diagramBorder() * devicePixelRatioF();
     d_pointer->m_chromaHueImageParameters.imageSizePhysical =
         // Guaranteed to be ≥ 0:
         maximumPhysicalSquareSize();
     const qreal temp = qBound(static_cast<qreal>(0), //
                               d_pointer->m_currentColor.l, //
                               static_cast<qreal>(100));
     d_pointer->m_chromaHueImageParameters.lightness = temp;
     d_pointer->m_chromaHueImageParameters.devicePixelRatioF = //
         devicePixelRatioF();
     d_pointer->m_chromaHueImageParameters.rgbColorSpace = //
         d_pointer->m_rgbColorSpace;
     d_pointer->m_chromaHueImage.setImageParameters( //
         d_pointer->m_chromaHueImageParameters);
     d_pointer->m_chromaHueImage.refreshAsync();
     const qreal circleRadius = //
         (maximumWidgetSquareSize() - 2 * d_pointer->diagramBorder()) / 2.0;
     bufferPainter.setRenderHint(QPainter::Antialiasing, true);
     bufferPainter.setPen(QPen(Qt::NoPen));
     bufferPainter.setBrush(d_pointer->m_chromaHueImage.getCache());
     bufferPainter.drawEllipse(
         // center:
         QPointF(maximumWidgetSquareSize() / 2.0, //
                 maximumWidgetSquareSize() / 2.0),
         // width:
         circleRadius,
         // height:
         circleRadius);
 
     // Paint a color wheel around
     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), // position of the image
         d_pointer->m_wheelImage.getImage() // the image itself
     );
 
     // Paint a handle on the color wheel (only if a mouse event is
     // currently active).
     if (d_pointer->m_isMouseEventActive) {
         // The radius of the outer border of the color wheel
         const qreal radius = //
             maximumWidgetSquareSize() / 2.0 - spaceForFocusIndicator();
         // Get widget coordinate point for the handle
         QPointF myHandleInner = PolarPointF(radius - gradientThickness(), //
                                             d_pointer->m_currentColor.h)
                                     .toCartesian();
         myHandleInner.ry() *= -1; // Transform to Widget coordinate points
         myHandleInner += d_pointer->diagramCenter();
         QPointF myHandleOuter = //
             PolarPointF(radius, d_pointer->m_currentColor.h).toCartesian();
         myHandleOuter.ry() *= -1; // Transform to Widget coordinate points
         myHandleOuter += d_pointer->diagramCenter();
         // Draw the line
         pen = QPen();
         pen.setWidth(handleOutlineThickness());
         // TODO Instead of Qt::FlatCap, we could really paint a handle
         // that does match perfectly the round inner and outer border
         // of the wheel. But: Is it really worth the complexity?
         pen.setCapStyle(Qt::FlatCap);
         pen.setColor(handleColor);
         bufferPainter.setPen(pen);
         bufferPainter.setRenderHint(QPainter::Antialiasing, true);
         bufferPainter.drawLine(myHandleInner, myHandleOuter);
     }
 
     // Paint the handle within the gamut
     bufferPainter.setRenderHint(QPainter::Antialiasing, true);
     pen = QPen();
     pen.setWidth(handleOutlineThickness());
     pen.setColor(handleColor);
     pen.setCapStyle(Qt::RoundCap);
     bufferPainter.setPen(pen);
     bufferPainter.setBrush(transparentBrush);
     bufferPainter.drawEllipse(widgetCoordinatesFromCurrentColor, // center
                               handleRadius(), // x radius
                               handleRadius() // y radius
     );
     const auto diagramOffset = d_pointer->diagramOffset();
     const QPointF diagramCartesianCoordinatesFromCurrentColor(
         // x:
         widgetCoordinatesFromCurrentColor.x() - diagramOffset,
         // y:
         (widgetCoordinatesFromCurrentColor.y() - diagramOffset) * (-1));
     PolarPointF diagramPolarCoordinatesFromCurrentColor( //
         diagramCartesianCoordinatesFromCurrentColor);
     // lineRadius will be a point at the middle of the line thickness
     // of the circular handle.
     qreal lineRadius = //
         diagramPolarCoordinatesFromCurrentColor.radius() - handleRadius();
     if (lineRadius > 0) {
         QPointF lineEndWidgetCoordinates = //
             PolarPointF(
                 // radius:
                 lineRadius,
                 // angle:
                 diagramPolarCoordinatesFromCurrentColor.angleDegree() //
                 )
                 .toCartesian();
         lineEndWidgetCoordinates.ry() *= (-1);
         lineEndWidgetCoordinates += d_pointer->diagramCenter();
         bufferPainter.drawLine(
             // point 1 (center of the diagram):
             d_pointer->diagramCenter(),
             // point 2:
             lineEndWidgetCoordinates);
     }
 
     // Paint a focus indicator.
     //
     // We could paint a focus indicator (round or rectangular) around the
     // handle. Depending on the currently selected hue for the diagram, it
     // looks ugly because the colors of focus indicator and diagram do not
     // harmonize, or it is mostly invisible if the colors are similar. So
     // this approach does not work well.
     //
     // It seems better to paint a focus indicator for the whole widget.
     // We could use the style primitives to paint a rectangular focus
     // indicator around the whole widget:
     //
     // style()->drawPrimitive(
     //     QStyle::PE_FrameFocusRect,
     //     &option,
     //     &painter,
     //     this
     // );
     //
     // However, this does not work well because this widget does not have a
     // rectangular form.
     //
     // Then we have to design the line that we want to display. It is better
     // to do that ourselves instead of relying on generic QStyle::PE_Frame or
     // similar solutions as their result seems to be quite unpredictable
     // across various styles. So we use handleOutlineThickness as line width
     // and paint it at the left-most possible position. As m_wheelBorder
     // accommodates also to handleRadius(), the distance of the focus line to
     // the real widget also does, which looks nice.
     if (hasFocus()) {
         bufferPainter.setRenderHint(QPainter::Antialiasing, true);
         pen = QPen();
         pen.setWidth(handleOutlineThickness());
         pen.setColor(focusIndicatorColor());
         bufferPainter.setPen(pen);
         bufferPainter.setBrush(transparentBrush);
         bufferPainter.drawEllipse(
             // center:
             d_pointer->diagramCenter(),
             // x radius:
             diagramOffset - handleOutlineThickness() / 2.0,
             // y radius:
             diagramOffset - handleOutlineThickness() / 2.0);
     }
 
     // Paint the buffer to the actual widget
     QPainter widgetPainter(this);
     widgetPainter.setRenderHint(QPainter::Antialiasing, false);
     widgetPainter.drawImage(QPoint(0, 0), buffer);
 }
 
 /** @brief The border around the round diagram.
  *
  * Measured in <em>device-independent pixels</em>.
  *
  * @returns The border. This is the space where the surrounding color wheel
  * and the focus indicator are painted. */
 int ChromaHueDiagramPrivate::diagramBorder() const
 {
     return
         // The space outside the wheel:
         q_pointer->spaceForFocusIndicator()
         // Add space for the wheel itself:
         + q_pointer->gradientThickness()
         // Add extra space between wheel and diagram:
         + 2 * q_pointer->handleOutlineThickness();
 }
 
 } // namespace PerceptualColor