swatchbook.cpp

// 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 "swatchbook.h"
// Second, the private implementation.
#include "swatchbook_p.h" // IWYU pragma: associated
 
#include "abstractdiagram.h"
#include "constpropagatingrawpointer.h"
#include "constpropagatinguniquepointer.h"
#include "helper.h"
#include "helpermath.h"
#include "initializetranslation.h"
#include "lchdouble.h"
#include "rgbcolorspace.h"
#include <algorithm>
#include <optional>
#include <qapplication.h>
#include <qcoreapplication.h>
#include <qcoreevent.h>
#include <qevent.h>
#include <qfontmetrics.h>
#include <qline.h>
#include <qlist.h>
#include <qmargins.h>
#include <qnamespace.h>
#include <qpainter.h>
#include <qpainterpath.h>
#include <qpen.h>
#include <qpoint.h>
#include <qrect.h>
#include <qsharedpointer.h>
#include <qsizepolicy.h>
#include <qstringliteral.h>
#include <qstyle.h>
#include <qstyleoption.h>
#include <qtransform.h>
#include <qwidget.h>
 
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
#include <qcontainerfwd.h>
#else
#include <qstringlist.h>
#include <qvector.h>
#endif
 
namespace PerceptualColor
{
 
/** @brief Retranslate the UI with all user-visible strings.
 *
 * This function updates all user-visible strings by using
 * <tt>Qt::tr()</tt> to get up-to-date translations.
 *
 * This function is meant to be called at the end of the constructor and
 * additionally after each <tt>QEvent::LanguageChange</tt> event.
 *
 * @note This is the same concept as
 * <a href="https://doc.qt.io/qt-5/designer-using-a-ui-file.html">
 * Qt Designer, which also provides a function of the same name in
 * uic-generated code</a>. */
void SwatchBookPrivate::retranslateUi()
{
    // Which symbol is appropriate as selection mark? This might depend on
    // culture and language. For more information, see also
    // https://en.wikipedia.org/w/index.php?title=Check_mark&oldid=1030853305#International_differences
    // Therefore, we provide translation support for the selection mark.
 
    // NOTE Some candidates for “translations” of this character might be
    // emoji characters that might render colorful on some systems and
    // some fonts. It would be great to disable color fonts and only
    // accept black fonts. However, this seems to be impossible with Qt.
    // There is a command-line option named “nocolorfonts”, documented at
    // https://doc.qt.io/qt-6/qguiapplication.html#QGuiApplication
    // However, this is only available for DirectWrite font rendering
    // on Windows. There does not seem to be a cross-platform solution
    // currently.
    /*: @item Indicate the selected color in the swatch book. This symbol
    should be translated to whatever symbol is most appropriate for “selected”
    in the translation language. Example symbols: ✓ U+2713 CHECK MARK.
    ✗ U+2717 BALLOT X. ✘ U+2718 HEAVY BALLOT X. ○ U+25CB WHITE CIRCLE.
    ◯ U+25EF LARGE CIRCLE. Do not use emoji characters as they may render
    colorful on some systems, so they will ignore the automatically chosen
    color which is used get best contrast with the background. (Also
    U+FE0E VARIATION SELECTOR-15 does not prevent colorful rendering.) */
    const QString translation = tr("✓");
 
    // Test if all characters of the translated string are actually
    // available in the given font.
    auto ucs4 = translation.toUcs4();
    bool okay = true;
    QFontMetricsF myFontMetrics(q_pointer->font());
    for (int i = 0; okay && (i < ucs4.count()); ++i) {
        okay = myFontMetrics.inFontUcs4(ucs4.at(i));
    }
 
    // Return
    if (okay) {
        m_selectionMark = translation;
    } else {
        m_selectionMark = QString();
    }
 
    // Schedule a paint event to make the changes visible.
    q_pointer->update();
}
 
/** @brief Constructor
 *
 * @param colorSpace The color space of the swatches.
 * @param swatches The colors in the given color space. The first dimension
 *        (@ref Array2D::iCount()) is interpreted as horizontal axis from
 *        left to right on LTR layouts, and the other way around on RTL
 *        layouts. The second dimension of the array (@ref Array2D::jCount())
 *        is interpreted as vertical axis, from top to bottom.
 * @param wideSpacing Set of axis where the spacing should be wider than
 *        normal. This is useful to give some visual structure: When your
 *        swatches are organized logically in columns, set
 *        <tt>Qt::Orientation::Horizontal</tt> here. To use normal spacing
 *        everywhere, simply set this parameter to <tt>{}</tt>.
 * @param parent The parent of the widget, if any */
SwatchBook::SwatchBook(const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace,
                       const Array2D<QColor> &swatches,
                       Qt::Orientations wideSpacing,
                       QWidget *parent)
    : AbstractDiagram(parent)
    , d_pointer(new SwatchBookPrivate(this, swatches, wideSpacing))
{
    d_pointer->m_rgbColorSpace = colorSpace;
 
    setFocusPolicy(Qt::FocusPolicy::StrongFocus);
 
    setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
    // Trigger paint events whenever the mouse enters or leaves the widget.
    // (Important on some QStyle who might paint widgets different then.)
    setAttribute(Qt::WA_Hover);
 
    // Initialize the selection (and implicitly the currentColor property):
    d_pointer->selectSwatch(8, 0); // Same default as in QColorDialog
 
    initializeTranslation(QCoreApplication::instance(),
                          // An empty std::optional means: If in initialization
                          // had been done yet, repeat this initialization.
                          // If not, do a new initialization now with default
                          // values.
                          std::optional<QStringList>());
    d_pointer->retranslateUi();
}
 
/** @brief Destructor */
SwatchBook::~SwatchBook() noexcept
{
}
 
/** @brief Constructor
 *
 * @param backLink Pointer to the object from which <em>this</em> object
 * is the private implementation.
 * @param swatches The swatches.
 * @param wideSpacing Set of axis using @ref widePatchSpacing instead
 *        of @ref normalPatchSpacing. */
SwatchBookPrivate::SwatchBookPrivate(SwatchBook *backLink, const Array2D<QColor> &swatches, Qt::Orientations wideSpacing)
    : m_swatches(swatches)
    , m_wideSpacing(wideSpacing)
    , q_pointer(backLink)
{
}
 
/** @brief Recommended size for the widget.
 *
 * Reimplemented from base class.
 *
 * @returns Recommended size for the widget.
 *
 * @sa @ref minimumSizeHint() */
QSize SwatchBook::sizeHint() const
{
    return minimumSizeHint();
}
 
/** @brief Recommended minimum size for the widget.
 *
 * Reimplemented from base class.
 *
 * @returns Recommended minimum size for the widget.
 *
 * @sa @ref sizeHint() */
QSize SwatchBook::minimumSizeHint() const
{
    ensurePolished();
    QStyleOptionFrame myOption;
    d_pointer->initStyleOption(&myOption);
    const auto contentSize = d_pointer->colorPatchesSizeWithMargin();
    const auto styleSize = style()->sizeFromContents(QStyle::CT_LineEdit, //
                                                     &myOption,
                                                     contentSize,
                                                     this);
 
    // On some style like (for example the MacOS style), sizeFromContents()
    // for line edits returns a value that is less height than the content
    // size. Therefore, here comes some safety code:
    const auto lineWidth = myOption.lineWidth;
    QMargins margins{lineWidth, lineWidth, lineWidth, lineWidth};
    const QSize minimumSize = contentSize.grownBy(margins);
 
    return minimumSize.expandedTo(styleSize);
}
 
// No documentation here (documentation of properties
// and its getters are in the header)
QColor SwatchBook::currentColor() const
{
    return d_pointer->m_currentColor;
}
 
/** @brief Setter for the @ref currentColor property.
 *
 * @param newCurrentColor the new color */
void SwatchBook::setCurrentColor(const QColor &newCurrentColor)
{
    // Convert to RGB:
    QColor temp = newCurrentColor;
    if (!temp.isValid()) {
        temp = Qt::black; // Conformance with QColorDialog
    }
    if (temp.spec() != QColor::Spec::Rgb) {
        // Make sure that the QColor::spec() is QColor::Spec::Rgb.
        // QColorDialog apparently calls QColor.rgb() within its
        // setCurrentColor function; this will however round to 8 bit
        // per channel. We prefer a more exact conversion to RGB:
        temp = QColor::fromRgbF( //
            temp.redF(),
            temp.greenF(),
            temp.blueF(),
            temp.alphaF());
    }
 
    if (temp == d_pointer->m_currentColor) {
        return;
    }
 
    d_pointer->m_currentColor = temp;
 
    bool colorFound = false;
    const qsizetype myColumnCount = d_pointer->m_swatches.iCount();
    const qsizetype myRowCount = d_pointer->m_swatches.jCount();
    int columnIndex = 0;
    int rowIndex = 0;
    for (columnIndex = 0; //
         columnIndex < myColumnCount; //
         ++columnIndex) {
        for (rowIndex = 0; rowIndex < myRowCount; ++rowIndex) {
            if (d_pointer->m_swatches.value(columnIndex, rowIndex) == temp) {
                colorFound = true;
                break;
            }
        }
        if (colorFound) {
            break;
        }
    }
    if (colorFound) {
        d_pointer->m_selectedColumn = columnIndex;
        d_pointer->m_selectedRow = rowIndex;
    } else {
        d_pointer->m_selectedColumn = -1;
        d_pointer->m_selectedRow = -1;
    }
 
    Q_EMIT currentColorChanged(temp);
 
    update();
}
 
/** @brief Selects a swatch from the book.
 *
 * @pre Both parameters are valid indexes within @ref m_swatches.
 * (Otherwise there will likely be a crash.)
 *
 * @param newCurrentColomn Index of the column.
 *
 * @param newCurrentRow Index of the row.
 *
 * @post If the given swatch is empty, nothing happens. Otherwise, it is
 * selected and the selection mark is visible and @ref SwatchBook::currentColor
 * has the value of this color. */
void SwatchBookPrivate::selectSwatch(QListSizeType newCurrentColomn, QListSizeType newCurrentRow)
{
    const auto newColor = m_swatches.value(newCurrentColomn, newCurrentRow);
    if (!newColor.isValid()) {
        return;
    }
    m_selectedColumn = newCurrentColomn;
    m_selectedRow = newCurrentRow;
    if (newColor != m_currentColor) {
        m_currentColor = newColor;
        Q_EMIT q_pointer->currentColorChanged(newColor);
    }
    q_pointer->update();
}
 
/** @brief Horizontal spacing between color patches.
 *
 * @returns Horizontal spacing between color patches, measured in
 * device-independent pixel. The value depends on the
 * current <tt>QStyle</tt>.
 *
 * @sa @ref verticalPatchSpacing */
int SwatchBookPrivate::horizontalPatchSpacing() const
{
    if (m_wideSpacing.testFlag(Qt::Orientation::Horizontal)) {
        return widePatchSpacing();
    }
    return normalPatchSpacing();
}
 
/** @brief Value for a wide spacing between swatches.
 *
 * @returns Wide spacing between color patches, measured in
 * device-independent pixel. The value depends on the
 * current <tt>QStyle</tt>.
 *
 * @sa @ref normalPatchSpacing */
int SwatchBookPrivate::widePatchSpacing() const
{
    // NOTE The value is derived from the current QStyle’s values for some
    // horizontal spacings. This seems reasonable because some styles might
    // have tighter metrics for vertical spacing, which might not look good
    // here. The derived value is actually useful for both, horizontal and
    // vertical metrics.
 
    int temp = q_pointer->style()->pixelMetric( //
        QStyle::PM_LayoutHorizontalSpacing,
        nullptr,
        q_pointer.toPointerToConstObject());
    if (temp <= 0) {
        // Some styles like Qt’s build-in “Plastique” style or the external
        // “QtCurve” style return 0 here. If so, we fall back to the left
        // margin. (We do not use qMax() because this workaround should
        // really only apply when the returned value is 0, because under
        // normal circumstances, it might be intentional that the left
        // margin is bigger than the horizontal spacing.)
        temp = q_pointer->style()->pixelMetric( //
            QStyle::PM_LayoutLeftMargin,
            nullptr,
            q_pointer.toPointerToConstObject());
    }
    // Another fallback (if also PM_LayoutLeftMargin fails):
    if (temp <= 0) {
        temp = q_pointer->style()->pixelMetric( //
            QStyle::PM_DefaultFrameWidth,
            nullptr,
            q_pointer.toPointerToConstObject());
    }
    // A last-resort fallback:
    return qMax(temp, 2);
}
 
/** @brief Vertical spacing between color patches.
 *
 * @returns Vertical spacing between color patches, measured in
 * device-independent pixel. The value is typically smaller than
 * @ref horizontalPatchSpacing(), to symbolize that the binding
 * between patches is vertically stronger than horizontally. */
int SwatchBookPrivate::verticalPatchSpacing() const
{
    if (m_wideSpacing.testFlag(Qt::Orientation::Vertical)) {
        return widePatchSpacing();
    }
    return normalPatchSpacing();
}
 
/** @brief Normal spacing between color swatches.
 *
 * @returns Normal spacing between color patches, measured in
 * device-independent pixel. The value is typically smaller than
 * @ref widePatchSpacing(), to symbolize that the binding
 * between patches is stronger. */
int SwatchBookPrivate::normalPatchSpacing() const
{
    return qMax(widePatchSpacing() / 3, // ⅓ looks nice
                1 // minimal useful value for a line visible as all scales
    );
}
 
/** @brief Initializes a <tt>QStyleOptionFrame</tt> object for this widget
 * in its current state.
 *
 * This function is provided analogous to many Qt widgets that also
 * provide a function of that name with this purpose.
 *
 * @param option The object that will be initialized
 *
 * @note The value in QStyleOptionFrame::rect is not initialized. */
void SwatchBookPrivate::initStyleOption(QStyleOptionFrame *option) const
{
    if (option == nullptr) {
        return;
    }
    option->initFrom(q_pointer.toPointerToConstObject());
    option->lineWidth = q_pointer->style()->pixelMetric( //
        QStyle::PM_DefaultFrameWidth,
        option,
        q_pointer.toPointerToConstObject());
    option->midLineWidth = 0;
    option->state |= QStyle::State_Sunken;
    // The following option is not set because this widget
    // currently has no read-only mode:
    // option->state |= QStyle::State_ReadOnly;
    option->features = QStyleOptionFrame::None;
}
 
/** @brief Offset between top-left of the widget and top-left of the content.
 *
 * @param styleOptionFrame The options that will be passed to <tt>QStyle</tt>
 * to calculate correctly the offset.
 *
 * @returns The pixel position of the top-left pixel of the content area
 * which can be used for the color patches. */
QPoint SwatchBookPrivate::offset(const QStyleOptionFrame &styleOptionFrame) const
{
    const QPoint innerMarginOffset = QPoint( //
        q_pointer->style()->pixelMetric(QStyle::PM_LayoutLeftMargin),
        q_pointer->style()->pixelMetric(QStyle::PM_LayoutTopMargin));
 
    QStyleOptionFrame temp = styleOptionFrame; // safety copy
    const QRectF frameContentRectangle = q_pointer->style()->subElementRect( //
        QStyle::SE_LineEditContents,
        &temp, // Risk of changes, therefore using the safety copy
        q_pointer.toPointerToConstObject());
    const QSizeF swatchbookContentSize = colorPatchesSizeWithMargin();
 
    // Some styles, such as the Fusion style, regularly return a slightly
    // larger rectangle through QStyle::subElementRect() than the one
    // requested in SwatchBook::minimumSizeHint(), which we need to draw
    // the color patches. In the case of the Kvantum style,
    // QStyle::subElementRect().height() is even greater than
    // SwatchBook::height(). It extends beyond the widget's own dimensions,
    // both at the top and bottom. QStyle::subElementRect().y() is
    // negative. Please see https://github.com/tsujan/Kvantum/issues/676
    // for more information. To ensure a visually pleasing rendering, we
    // implement centering within QStyle::subElementRect().
    QPointF frameOffset = frameContentRectangle.center();
    frameOffset.rx() -= swatchbookContentSize.width() / 2.;
    frameOffset.ry() -= swatchbookContentSize.height() / 2.;
 
    return (frameOffset + innerMarginOffset).toPoint();
}
 
/** @brief React on a mouse press event.
 *
 * Reimplemented from base class.
 *
 * @param event The corresponding mouse event */
void SwatchBook::mousePressEvent(QMouseEvent *event)
{
    // NOTE We will not actively ignore the event, even if we didn’t actually
    // react on it. Therefore, Breeze and other styles cannot move
    // the window when clicking in the middle between two patches.
    // This is intentional, because allowing it would be confusing:
    // - The space between the patches is quite limited anyway, so
    //   it’s not worth the pain and could be surprising because somebody
    //   can click there by mistake.
    // - We use the same background as QLineEdit, which at its turn also
    //   does not allow moving the window with a left-click within the
    //   field. We should be consistent with this behaviour.
 
    const QSize myColorPatchSize = d_pointer->patchSizeOuter();
    const int myPatchWidth = myColorPatchSize.width();
    const int myPatchHeight = myColorPatchSize.height();
    QStyleOptionFrame myFrameStyleOption;
    d_pointer->initStyleOption(&myFrameStyleOption);
    const QPoint temp = event->pos() - d_pointer->offset(myFrameStyleOption);
 
    if ((temp.x() < 0) || (temp.y() < 0)) {
        return; // Click position too much leftwards or upwards.
    }
 
    const auto columnWidth = myPatchWidth + d_pointer->horizontalPatchSpacing();
    const int xWithinPatch = temp.x() % columnWidth;
    if (xWithinPatch >= myPatchWidth) {
        return; // Click position horizontally between two patch columns
    }
 
    const auto rowHeight = myPatchHeight + d_pointer->verticalPatchSpacing();
    const int yWithinPatch = temp.y() % rowHeight;
    if (yWithinPatch >= myPatchHeight) {
        return; // Click position vertically between two patch rows
    }
 
    const int rowIndex = temp.y() / rowHeight;
    if (!isInRange<qsizetype>(0, rowIndex, d_pointer->m_swatches.jCount() - 1)) {
        // The index is out of range. This might happen when the user
        // clicks very near to the border, where is no other patch
        // anymore, but which is still part of the widget.
        return;
    }
 
    const int visualColumnIndex = temp.x() / columnWidth;
    QListSizeType columnIndex;
    if (layoutDirection() == Qt::LayoutDirection::LeftToRight) {
        columnIndex = visualColumnIndex;
    } else {
        columnIndex = //
            d_pointer->m_swatches.iCount() - 1 - visualColumnIndex;
    }
    if (!isInRange<qsizetype>(0, columnIndex, d_pointer->m_swatches.iCount() - 1)) {
        // The index is out of range. This might happen when the user
        // clicks very near to the border, where is no other patch
        // anymore, but which is still part of the widget.
        return;
    }
 
    // If we reached here, the click must have been within a patch
    // and we have valid indexes.
    d_pointer->selectSwatch(columnIndex, rowIndex);
}
 
/** @brief The size of the color patches.
 *
 * This is the bounding box around the outer limit.
 *
 * @returns The size of the color patches, measured in device-independent
 * pixel.
 *
 * @sa @ref patchSizeInner */
QSize SwatchBookPrivate::patchSizeOuter() const
{
    q_pointer->ensurePolished();
    const QSize mySize = patchSizeInner();
    QStyleOptionToolButton myOptions;
    myOptions.initFrom(q_pointer.toPointerToConstObject());
    myOptions.rect.setSize(mySize);
    return q_pointer->style()->sizeFromContents( //
        QStyle::CT_ToolButton,
        &myOptions,
        mySize,
        q_pointer.toPointerToConstObject());
}
 
/** @brief Size of the inner space of a color patch.
 *
 * This is typically smaller than @ref patchSizeOuter.
 *
 * @returns Size of the inner space of a color patch, measured in
 * device-independent pixel. */
QSize SwatchBookPrivate::patchSizeInner() const
{
    const int metric = q_pointer->style()->pixelMetric( //
        QStyle::PM_ButtonIconSize,
        nullptr,
        q_pointer.toPointerToConstObject());
    const int size = std::max({metric, //
                               horizontalPatchSpacing(), //
                               verticalPatchSpacing()});
    return QSize(size, size);
}
 
/** @brief Paint the widget.
 *
 * Reimplemented from base class.
 *
 * @param event the paint event */
void SwatchBook::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event)
 
    // Initialization
    QPainter widgetPainter(this);
    widgetPainter.setRenderHint(QPainter::Antialiasing);
    QStyleOptionFrame frameStyleOption;
    d_pointer->initStyleOption(&frameStyleOption);
    const int horizontalSpacing = d_pointer->horizontalPatchSpacing();
    const int verticalSpacing = d_pointer->verticalPatchSpacing();
    const QSize patchSizeOuter = d_pointer->patchSizeOuter();
    const int patchWidthOuter = patchSizeOuter.width();
    const int patchHeightOuter = patchSizeOuter.height();
 
    // Draw the background
    {
        // We draw the frame slightly shrunk on windowsvista style. Otherwise,
        // when the windowsvista style is used on 125% scale factor and with
        // a multi-monitor setup, the frame would sometimes not render on some
        // of the borders on some of the screens.
        const bool vistaStyle = QString::compare( //
                                    QApplication::style()->objectName(),
                                    QStringLiteral("windowsvista"),
                                    Qt::CaseInsensitive)
            == 0;
        const int shrink = vistaStyle ? 1 : 0;
        const QMargins margins(shrink, shrink, shrink, shrink);
        auto shrunkFrameStyleOption = frameStyleOption;
        shrunkFrameStyleOption.rect = frameStyleOption.rect - margins;
        // NOTE On ukui style, drawing this primitive results in strange
        // rendering on mouse hover. Actual behaviour: The whole panel
        // background is drawn blue. Expected behaviour: Only the frame is
        // drawn blue (as ukui actually does when rendering a QLineEdit).
        // Playing around with PE_FrameLineEdit instead of or additional to
        // PE_PanelLineEdit did not give better results either.
        // As ukui has many, many graphical glitches and bugs (up to
        // crashed unfixed for years), we assume that this is a problem of
        // ukui, and not of our code. Furthermore, while the behavior is
        // unexpected, the rendering doesn’t look completely terrible; we
        // can live with that.
        style()->drawPrimitive(QStyle::PE_PanelLineEdit, //
                               &shrunkFrameStyleOption,
                               &widgetPainter,
                               this);
    }
 
    // Draw the color patches
    const QPoint offset = d_pointer->offset(frameStyleOption);
    const QListSizeType columnCount = d_pointer->m_swatches.iCount();
    QListSizeType visualColumn;
    for (int columnIndex = 0; columnIndex < columnCount; ++columnIndex) {
        for (int row = 0; //
             row < d_pointer->m_swatches.jCount(); //
             ++row //
        ) {
            const auto swatchColor = //
                d_pointer->m_swatches.value(columnIndex, row);
            if (swatchColor.isValid()) {
                widgetPainter.setBrush(swatchColor);
                widgetPainter.setPen(Qt::NoPen);
                if (layoutDirection() == Qt::LayoutDirection::LeftToRight) {
                    visualColumn = columnIndex;
                } else {
                    visualColumn = columnCount - 1 - columnIndex;
                }
                widgetPainter.drawRect( //
                    offset.x() //
                        + (static_cast<int>(visualColumn) //
                           * (patchWidthOuter + horizontalSpacing)),
                    offset.y() //
                        + row * (patchHeightOuter + verticalSpacing),
                    patchWidthOuter,
                    patchHeightOuter);
            }
        }
    }
 
    // If there is no selection mark to draw, nothing more to do: Return!
    if (d_pointer->m_selectedColumn < 0 || d_pointer->m_selectedRow < 0) {
        return;
    }
 
    // Draw the selection mark (if any)
    const QListSizeType visualSelectedColumnIndex = //
        (layoutDirection() == Qt::LayoutDirection::LeftToRight) //
        ? d_pointer->m_selectedColumn //
        : d_pointer->m_swatches.iCount() - 1 - d_pointer->m_selectedColumn;
    const LchDouble colorCielchD50 = //
        d_pointer->m_rgbColorSpace->toCielchD50Double( //
            d_pointer //
                ->m_swatches //
                .value(d_pointer->m_selectedColumn, d_pointer->m_selectedRow) //
                .rgba64() //
        );
    const QColor selectionMarkColor = //
        handleColorFromBackgroundLightness(colorCielchD50.l);
    const QPointF selectedPatchOffset = QPointF( //
        offset.x() //
            + (static_cast<int>(visualSelectedColumnIndex) //
               * (patchWidthOuter + horizontalSpacing)), //
        offset.y() //
            + (static_cast<int>(d_pointer->m_selectedRow) //
               * (patchHeightOuter + verticalSpacing)));
    const QSize patchSizeInner = d_pointer->patchSizeInner();
    const int patchWidthInner = patchSizeInner.width();
    const int patchHeightInner = patchSizeInner.height();
    if (d_pointer->m_selectionMark.isEmpty()) {
        // If no selection mark is available for the current translation in
        // the current font, we will draw a hard-coded fallback mark.
        const QSize sizeDifference = patchSizeOuter - patchSizeInner;
        // Offset of the selection mark to the border of the patch:
        QPointF selectionMarkOffset = QPointF( //
            sizeDifference.width() / 2.0,
            sizeDifference.height() / 2.0);
        if (patchWidthInner > patchHeightInner) {
            selectionMarkOffset.rx() += //
                ((patchWidthInner - patchHeightInner) / 2.0);
        }
        if (patchHeightInner > patchWidthInner) {
            selectionMarkOffset.ry() += //
                ((patchHeightInner - patchWidthInner) / 2.0);
        }
        const int effectiveSquareSize = qMin( //
            patchHeightInner,
            patchWidthInner);
        qreal penWidth = effectiveSquareSize * 0.08;
        QPen pen;
        pen.setColor(selectionMarkColor);
        pen.setCapStyle(Qt::PenCapStyle::RoundCap);
        pen.setWidthF(penWidth);
        widgetPainter.setPen(pen);
        QPointF point1 = QPointF(penWidth, //
                                 0.7 * effectiveSquareSize);
        point1 += selectedPatchOffset + selectionMarkOffset;
        QPointF point2(0.35 * effectiveSquareSize, //
                       1 * effectiveSquareSize - penWidth);
        point2 += selectedPatchOffset + selectionMarkOffset;
        QPointF point3(1 * effectiveSquareSize - penWidth, //
                       penWidth);
        point3 += selectedPatchOffset + selectionMarkOffset;
        widgetPainter.drawLine(QLineF(point1, point2));
        widgetPainter.drawLine(QLineF(point2, point3));
    } else {
        QPainterPath textPath;
        // Render the selection mark string in the path
        textPath.addText(0, 0, font(), d_pointer->m_selectionMark);
        // Align the path top-left to the path’s virtual coordinate system
        textPath.translate(textPath.boundingRect().x() * (-1), //
                           textPath.boundingRect().y() * (-1));
        // QPainterPath::boundingRect() might be slow. Cache the result:
        const QSizeF boundingRectangleSize = textPath.boundingRect().size();
 
        if (!boundingRectangleSize.isEmpty()) { // Prevent division by 0
            QTransform textTransform;
 
            // Offset for the current patch
            textTransform.translate(
                // x:
                selectedPatchOffset.x() //
                    + (patchWidthOuter - patchWidthInner) / 2,
                // y:
                selectedPatchOffset.y() //
                    + (patchHeightOuter - patchHeightInner) / 2);
 
            // Scale to maximum and center within the margins
            const qreal scaleFactor = qMin(
                // Horizontal scale factor:
                patchWidthInner / boundingRectangleSize.width(),
                // Vertical scale factor:
                patchHeightInner / boundingRectangleSize.height());
            QSizeF scaledSelectionMarkSize = //
                boundingRectangleSize * scaleFactor;
            const QSizeF temp = //
                (patchSizeInner - scaledSelectionMarkSize) / 2;
            textTransform.translate(temp.width(), temp.height());
            textTransform.scale(scaleFactor, scaleFactor);
 
            // Draw
            widgetPainter.setTransform(textTransform);
            widgetPainter.setPen(Qt::NoPen);
            widgetPainter.setBrush(selectionMarkColor);
            widgetPainter.drawPath(textPath);
        }
    }
}
 
/** @brief React on key press events.
 *
 * Reimplemented from base class.
 *
 * When the arrow keys are pressed, it moves the selection mark
 * into the desired direction.
 * When <tt>Qt::Key_PageUp</tt>, <tt>Qt::Key_PageDown</tt>,
 * <tt>Qt::Key_Home</tt> or <tt>Qt::Key_End</tt> are pressed, it moves the
 * handle a big step into the desired direction.
 *
 * Other key events are forwarded to the base class.
 *
 * @param event the event */
void SwatchBook::keyPressEvent(QKeyEvent *event)
{
    QListSizeType columnShift = 0;
    QListSizeType rowShift = 0;
    const int writingDirection = //
        (layoutDirection() == Qt::LeftToRight) //
        ? 1 //
        : -1;
    switch (event->key()) {
    case Qt::Key_Up:
        rowShift = -1;
        break;
    case Qt::Key_Down:
        rowShift = 1;
        break;
    case Qt::Key_Left:
        columnShift = -1 * writingDirection;
        break;
    case Qt::Key_Right:
        columnShift = 1 * writingDirection;
        break;
    case Qt::Key_PageUp:
        rowShift = (-1) * d_pointer->m_swatches.jCount();
        break;
    case Qt::Key_PageDown:
        rowShift = d_pointer->m_swatches.jCount();
        break;
    case Qt::Key_Home:
        columnShift = (-1) * d_pointer->m_swatches.iCount();
        break;
    case Qt::Key_End:
        columnShift = d_pointer->m_swatches.iCount();
        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 currently no color of the swatch book is selected, select the
    // first color as default.
    if ((d_pointer->m_selectedColumn < 0) && (d_pointer->m_selectedRow < 0)) {
        d_pointer->selectSwatch(0, 0);
        return;
    }
 
    const int accelerationFactor = 2;
    if (event->modifiers().testFlag(Qt::ControlModifier)) {
        columnShift *= accelerationFactor;
        rowShift *= accelerationFactor;
    }
 
    d_pointer->selectSwatch( //
        qBound<QListSizeType>(0, //
                              d_pointer->m_selectedColumn + columnShift,
                              d_pointer->m_swatches.iCount() - 1),
        qBound<QListSizeType>(0, //
                              d_pointer->m_selectedRow + rowShift, //
                              d_pointer->m_swatches.jCount() - 1));
}
 
/** @brief Handle state changes.
 *
 * Implements reaction on <tt>QEvent::LanguageChange</tt>.
 *
 * Reimplemented from base class.
 *
 * @param event The event. */
void SwatchBook::changeEvent(QEvent *event)
{
    if (event->type() == QEvent::LanguageChange) {
        // From QCoreApplication documentation:
        //     “Installing or removing a QTranslator, or changing an installed
        //      QTranslator generates a LanguageChange event for the
        //      QCoreApplication instance. A QApplication instance will
        //      propagate the event to all toplevel widgets […].
        // Retranslate this widget itself:
        d_pointer->retranslateUi();
    }
 
    QWidget::changeEvent(event);
}
 
/** @brief Size necessary to render the color patches, including a margin.
 *
 * @returns Size necessary to render the color patches, including a margin.
 * Measured in device-independent pixels. */
QSize SwatchBookPrivate::colorPatchesSizeWithMargin() const
{
    q_pointer->ensurePolished();
    const QSize patchSize = patchSizeOuter();
    const int columnCount = static_cast<int>(m_swatches.iCount());
    const int rowCount = static_cast<int>(m_swatches.jCount());
    const int width = //
        q_pointer->style()->pixelMetric(QStyle::PM_LayoutLeftMargin) //
        + columnCount * patchSize.width() //
        + (columnCount - 1) * horizontalPatchSpacing() //
        + q_pointer->style()->pixelMetric(QStyle::PM_LayoutRightMargin);
    const int height = //
        q_pointer->style()->pixelMetric(QStyle::PM_LayoutTopMargin) //
        + rowCount * patchSize.height() //
        + (rowCount - 1) * verticalPatchSpacing() //
        + q_pointer->style()->pixelMetric(QStyle::PM_LayoutBottomMargin);
    return QSize(width, height);
}
 
} // namespace PerceptualColor