colordialog.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 "colordialog.h"
// Second, the private implementation.
#include "colordialog_p.h" // IWYU pragma: associated
 
#include "absolutecolor.h"
#include "chromahuediagram.h"
#include "cielchd50values.h"
#include "colorpatch.h"
#include "constpropagatingrawpointer.h"
#include "constpropagatinguniquepointer.h"
#include "gradientslider.h"
#include "helper.h"
#include "helperconstants.h"
#include "helperconversion.h"
#include "helperqttypes.h"
#include "initializetranslation.h"
#include "multispinbox.h"
#include "multispinboxsection.h"
#include "oklchvalues.h"
#include "rgbcolor.h"
#include "rgbcolorspace.h"
#include "rgbcolorspacefactory.h"
#include "screencolorpicker.h"
#include "setting.h"
#include "swatchbook.h"
#include "wheelcolorpicker.h"
#include <algorithm>
#include <lcms2.h>
#include <optional>
#include <qaction.h>
#include <qapplication.h>
#include <qboxlayout.h>
#include <qbytearray.h>
#include <qchar.h>
#include <qcombobox.h>
#include <qcoreapplication.h>
#include <qcoreevent.h>
#include <qdatetime.h>
#include <qdebug.h>
#include <qdialogbuttonbox.h>
#include <qfontmetrics.h>
#include <qformlayout.h>
#include <qgridlayout.h>
#include <qgroupbox.h>
#include <qguiapplication.h>
#include <qicon.h>
#include <qkeysequence.h>
#include <qlabel.h>
#include <qlineedit.h>
#include <qlist.h>
#include <qlocale.h>
#include <qobject.h>
#include <qpair.h>
#include <qpointer.h>
#include <qpushbutton.h>
#include <qregularexpression.h>
#include <qscopedpointer.h>
#include <qscreen.h>
#include <qsharedpointer.h>
#include <qshortcut.h>
#include <qsize.h>
#include <qsizepolicy.h>
#include <qspinbox.h>
#include <qstackedlayout.h>
#include <qstringbuilder.h>
#include <qstringliteral.h>
#include <qtabwidget.h>
#include <qtoolbutton.h>
#include <qvalidator.h>
#include <qversionnumber.h>
#include <qwidget.h>
#include <utility>
class QShowEvent;
 
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
#include <qcontainerfwd.h>
#include <qobjectdefs.h>
#else
#include <qstringlist.h>
#endif
 
#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
#include <qstylehints.h>
#endif
 
namespace PerceptualColor
{
 
/** @brief A text with the name of the color model.
 *
 * @param model The signature of the color model.
 *
 * @returns A text with the name of the color model, or an empty
 * QString if the model is unknown. If a translation is available,
 * the translation is returned instead of the original English text. */
QString ColorDialogPrivate::translateColorModel(cmsColorSpaceSignature model)
{
    switch (model) {
    case cmsSigXYZData:
        /*: @item A color model: X, Y, Z. */
        return tr("XYZ");
    case cmsSigLabData:
        /*: @item A color model: Lightness, a, b. */
        return tr("Lab");
    case cmsSigRgbData:
        /*: @item A color model: red, green, blue. */
        return tr("RGB");
    case cmsSigLuvData:
        // return tr("Luv"); // Currently not supported.
        return QString();
    case cmsSigYCbCrData:
        // return tr("YCbCr"); // Currently not supported.
        return QString();
    case cmsSigYxyData:
        // return tr("Yxy"); // Currently not supported.
        return QString();
    case cmsSigGrayData:
        // return tr("Grayscale"); // Currently not supported.
        return QString();
    case cmsSigHsvData:
        // return tr("HSV"); // Currently not supported.
        return QString();
    case cmsSigHlsData:
        // return tr("HSL"); // Currently not supported.
        return QString();
    case cmsSigCmykData:
        // return tr("CMYK"); // Currently not supported.
        return QString();
    case cmsSigCmyData:
        // return tr("CMY"); // Currently not supported.
        return QString();
    case cmsSigNamedData: // Does not exist in ICC 4.4.
    case cmsSig2colorData:
    case cmsSig3colorData:
    case cmsSig4colorData:
    case cmsSig5colorData:
    case cmsSig6colorData:
    case cmsSig7colorData:
    case cmsSig8colorData:
    case cmsSig9colorData:
    case cmsSig10colorData:
    case cmsSig11colorData:
    case cmsSig12colorData:
    case cmsSig13colorData:
    case cmsSig14colorData:
    case cmsSig15colorData:
        // return tr("Named color"); // Currently not supported.
        return QString();
    case cmsSig1colorData:
    case cmsSigLuvKData:
    case cmsSigMCH1Data:
    case cmsSigMCH2Data:
    case cmsSigMCH3Data:
    case cmsSigMCH4Data:
    case cmsSigMCH5Data:
    case cmsSigMCH6Data:
    case cmsSigMCH7Data:
    case cmsSigMCH8Data:
    case cmsSigMCH9Data:
    case cmsSigMCHAData:
    case cmsSigMCHBData:
    case cmsSigMCHCData:
    case cmsSigMCHDData:
    case cmsSigMCHEData:
    case cmsSigMCHFData:
    // Unhandeled: These values do not exist in ICC 4.4 standard as
    // published at https://www.color.org/specification/ICC.1-2022-05.pdf
    // page 35, table 19 — Data colour space signatures.
    default:
        break;
    }
    return QString();
}
 
/** @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>.
 *
 * @internal
 *
 * @todo Add to the color-space tooltip information about available rendering
 * intents (we have yet RgbColorSpacePrivate::intentList but do not use it
 * anywhere) and the RGB profile illuminant? (This would have to be implemented
 * in @ref RgbColorSpace first.)
 *
 * @todo As the tooltip for color-space information is quite big, would
 * it be better to do what systemsettings does in globaldesign/fonts? They
 * have a small button with an “i” symbol (for information), which does
 * nothing when it’s clicked, but when hovering with the mouse, it shows
 * the tooltip?
 *
 * @todo How to make tooltip information available for touch-screen users?
 *
 * @todo Provide the information
 * of @ref RgbColorSpace::profileRenderingIntentDirections() in the tooltip of the
 * color space. Example: Rendering intents: Perceptual (input, output, proof)
 * [br] Relative (input, proof) [br] Saturation (output) [br]
 * Absolute colorimetric (proof). Missing rendering intents are not displayed.
 * Limiting ourself to these four standard rendering intents, leaving LittleCMS
 * extensions out of scope. Providing i18n instead of using the rendering
 * intent descriptions of LittleCMS.
 */
void ColorDialogPrivate::retranslateUi()
{
    /*: @item/plain Percentage value in a spinbox. Range: 0%–100%. */
    const QPair<QString, QString> percentageInSpinbox = //
        getPrefixSuffix(tr("%1%"));
 
    /*: @item/plain Arc-degree value in a spinbox. Range: 0°–360°. */
    const QPair<QString, QString> arcDegreeInSpinbox = //
        getPrefixSuffix(tr("%1°"));
 
    QStringList profileInfo;
    const QString name = //
        m_rgbColorSpace->profileName().toHtmlEscaped();
    if (!name.isEmpty()) {
        /*: @item:intext An information from the color profile to be added
        to the info text about current color space. */
        profileInfo.append(tableRow.arg(tr("Name:"), name));
    }
    /*: @item:intext The maximum chroma. */
    const QString maximumCielchD50Chroma = //
        tr("%L1 (estimated)")
            .arg(m_rgbColorSpace->profileMaximumCielchD50Chroma(), //
                 0, //
                 'f', //
                 decimals);
    /*: @item:intext An information from the color profile to be added
    to the info text about current color space. */
    profileInfo.append( //
        tableRow.arg(tr("Maximum CIELCh-D50 chroma:"), maximumCielchD50Chroma));
    /*: @item:intext The maximum chroma. */
    const QString maximumOklchChroma = //
        tr("%L1 (estimated)")
            .arg(m_rgbColorSpace->profileMaximumOklchChroma(), //
                 0, //
                 'f', //
                 okdecimals);
    /*: @item:intext An information from the color profile to be added
    to the info text about current color space. */
    profileInfo.append( //
        tableRow.arg(tr("Maximum Oklch chroma:"), maximumOklchChroma));
    QString profileClass;
    switch (m_rgbColorSpace->profileClass()) {
    case cmsSigDisplayClass:
        /*: @item:intext The class of an ICC profile. */
        profileClass = tr("Display profile");
        break;
    case cmsSigAbstractClass: // Image effect profile (Abstract profile)
                              // This ICC profile class is called "abstract
                              // profile" in the official standard. However,
                              // the name is misleading. The actual function of
                              // these ICC profiles is to apply image effects.
    case cmsSigColorSpaceClass: // Color space conversion profile
    case cmsSigInputClass: // Input profile
    case cmsSigLinkClass: // Device link profile
    case cmsSigNamedColorClass: // Named color profile
    case cmsSigOutputClass: // Output profile
        // These profile classes are currently not supported.
        break;
    }
    if (!profileClass.isEmpty()) {
        /*: @item:intext An information from the color profile to be added
        to the info text about current color space. */
        profileInfo.append( //
            tableRow.arg(tr("Profile class:"), profileClass));
    }
    const QString colorModel = //
        translateColorModel(m_rgbColorSpace->profileColorModel());
    if (!colorModel.isEmpty()) {
        /*: @item:intext An information from the color profile to be added
        to the info text about current color space.
        The color model of the color space which is described by this
        profile. */
        profileInfo.append(tableRow.arg(tr("Color model:"), colorModel));
    }
    const QString manufacturer = //
        m_rgbColorSpace->profileManufacturer().toHtmlEscaped();
    if (!manufacturer.isEmpty()) {
        /*: @item:intext An information from the color profile to be added
        to the info text about current color space.
        This is usually the manufacturer of the device to which
        the colour profile applies. */
        profileInfo.append(tableRow.arg(tr("Manufacturer:"), manufacturer));
    }
    const QString model = //
        m_rgbColorSpace->profileModel().toHtmlEscaped();
    if (!model.isEmpty()) {
        /*: @item:intext An information from the color profile to be added to
        the info text about current color space.
        This is usually the model identifier of the device to which
        the colour profile applies. */
        profileInfo.append(tableRow.arg(tr("Device model:"), (model)));
    }
    const QDateTime creationDateTime = //
        m_rgbColorSpace->profileCreationDateTime();
    if (!creationDateTime.isNull()) {
        const auto creationDateTimeString = QLocale().toString(
            // Date and time:
            creationDateTime,
            // Format:
            QLocale::LongFormat);
        /*: @item:intext An information from the color profile to be added to
        the info text about current color space.
        This is the date and time of the creation of the profile. */
        profileInfo.append( //
            tableRow.arg(tr("Created:"), (creationDateTimeString)));
    }
    const QVersionNumber iccVersion = m_rgbColorSpace->profileIccVersion();
    /*: @item:intext An information from the color profile to be added to
    the info text about current color space.
    This is the version number of the ICC file format that is used. */
    profileInfo.append( //
        tableRow.arg(tr("ICC format:"), (iccVersion.toString())));
    const bool hasMatrixShaper = //
        m_rgbColorSpace->profileHasMatrixShaper();
    const bool hasClut = //
        m_rgbColorSpace->profileHasClut();
    if (hasMatrixShaper || hasClut) {
        const QString matrixShaperString = tableRow.arg(
            /*: @item:intext An information from the color profile to be added
            to the info text about current color space.
            Wether the profile has a matrix shaper or a color lookup table
            (CLUT) or both. */
            tr("Implementation:"));
        if (hasMatrixShaper && hasClut) {
            /*: @item:intext An information from the color profile to be added
            to the info text about current color space.
            Wether the profile has a matrix shaper or a color lookup table
            (CLUT) or both. */
            profileInfo.append( //
                matrixShaperString.arg(tr("Matrices and color lookup tables")));
        } else if (hasMatrixShaper) {
            /*: @item:intext An information from the color profile to be added
            to the info text about current color space.
            Wether the profile has a matrix shaper or a color lookup table
            (CLUT) or both. */
            profileInfo.append(matrixShaperString.arg(tr("Matrices")));
        } else if (hasClut) {
            /*: @item:intext An information from the color profile to be added
            to the info text about current color space.
            Wether the profile has a matrix shaper or a color lookup table
            (CLUT) or both. */
            profileInfo.append( //
                matrixShaperString.arg(tr("Color lookup tables")));
        }
    }
    const QString pcsColorModelText = //
        translateColorModel(m_rgbColorSpace->profilePcsColorModel());
    if (!pcsColorModelText.isEmpty()) {
        /*: @item:intext An information from the color profile to be added
        to the info text about current color space.
        The color model of the PCS (profile connection space) which is used
        internally by this profile. */
        profileInfo.append( //
            tableRow.arg(tr("PCS color model:"), pcsColorModelText));
    }
    const QString copyright = m_rgbColorSpace->profileCopyright();
    if (!copyright.isEmpty()) {
        /*: @item:intext An information from the color profile to be added
        to the info text about current color space.
        The copyright of this profile. */
        profileInfo.append(tableRow.arg(tr("Copyright:"), copyright));
    }
    const qint64 fileSize = //
        m_rgbColorSpace->profileFileSize();
    if (fileSize >= 0) {
        /*: @item:intext An information from the color profile to be added to
        the info text about current color space.
        This is the size of the ICC file that was read in. */
        profileInfo.append(tableRow.arg(tr("File size:"), //
                                        QLocale().formattedDataSize(fileSize)));
    }
    const QString fileName = //
        m_rgbColorSpace->profileAbsoluteFilePath();
    if (!fileName.isEmpty()) {
        /*: @item:intext An information from the color profile to be added to
        the info text about current color space. */
        profileInfo.append(tableRow.arg(tr("File name:"), fileName));
    }
    if (profileInfo.isEmpty()) {
        m_rgbGroupBox->setToolTip(QString());
    } else {
        const QString tableString = QStringLiteral(
            "<b>%1</b><br/>"
            "<table border=\"0\" cellpadding=\"2\" cellspacing=\"0\">"
            "%2"
            "</table>");
        m_rgbGroupBox->setToolTip(richTextMarker
                                  + tableString.arg(
                                      /*: @info:intext Title of info text about
                                      current color space (will be followed by
                                      other information as available
                                      in the color profile. */
                                      tr("Color space information"), //
                                      profileInfo.join(QString())));
    }
 
    /*: @label:spinbox Label for CIE’s CIELCH color model, based on Lightness,
     * Chroma and Hue, and using the D50 illuminant as white point.*/
    m_cielchD50SpinBoxLabel->setText(tr("&CIELCH D50:"));
 
    /*: @label:spinbox Label for Oklch color model, based on Lightness, Chroma,
    Hue, and using the D65 illuminant as white point. */
    m_oklchSpinBoxLabel->setText(tr("O&klch:"));
 
    /*: @label:spinbox Label for RGB color model, based on Red, Green, Blue. */
    m_rgbSpinBoxLabel->setText(tr("&RGB:"));
 
    /*: @label:textbox Label for hexadecimal RGB representation like #12ab45 */
    m_rgbLineEditLabel->setText(tr("He&x:"));
 
    const int swatchBookIndex = m_tabWidget->indexOf(m_swatchBookWrapperWidget);
    if (swatchBookIndex >= 0) {
        /*: @title:tab
        The tab contains swatch books showing colors. */
        const auto mnemonic = tr("&Swatch book");
        m_tabWidget->setTabToolTip( //
            swatchBookIndex, //
            richTextMarker + fromMnemonicToRichText(mnemonic));
        m_swatchBookTabShortcut->setKey(QKeySequence::mnemonic(mnemonic));
    }
 
    const int hueFirstIndex = m_tabWidget->indexOf(m_hueFirstWrapperWidget);
    if (hueFirstIndex >= 0) {
        /*: @title:tab
        The tab contains a visual UI to choose first the hue, and in a
        second step chroma and lightness. */
        const auto mnemonic = tr("&Hue-based");
        m_tabWidget->setTabToolTip( //
            hueFirstIndex, //
            richTextMarker + fromMnemonicToRichText(mnemonic));
        m_hueFirstTabShortcut->setKey(QKeySequence::mnemonic(mnemonic));
    }
    const int lightnessFirstIndex = //
        m_tabWidget->indexOf(m_lightnessFirstWrapperWidget);
    if (lightnessFirstIndex >= 0) {
        /*: @title:tab
        The tab contains a visual UI to choose first the lightness, and in a
        second step chroma and hue.
        “Lightness” is different from “brightness”/“value”
        and should therefore get a different translation. */
        const auto mnemonic = tr("&Lightness-based");
        m_tabWidget->setTabToolTip( //
            lightnessFirstIndex, //
            richTextMarker + fromMnemonicToRichText(mnemonic));
        m_lightnessFirstTabShortcut->setKey(QKeySequence::mnemonic(mnemonic));
    }
    const int numericIndex = //
        m_tabWidget->indexOf(m_numericalWidget);
    if (numericIndex >= 0) {
        /*: @title:tab
        The tab contains a UI to describe the color with numbers: Spin boxes
        and line edits containing values like “#2A7845” or “RGB 85 45 12”. */
        const auto mnemonic = tr("&Numeric");
        m_tabWidget->setTabToolTip( //
            numericIndex, //
            richTextMarker + fromMnemonicToRichText(mnemonic));
        m_numericalTabShortcut->setKey(QKeySequence::mnemonic(mnemonic));
    }
 
    /*: @label:spinbox HSL (hue, saturation, lightness) */
    m_hslSpinBoxLabel->setText(tr("HS&L:"));
 
    /*: @label:spinbox HSV (hue, saturation, value) and HSB (hue, saturation,
    brightness) are two different names for the very same color model. */
    m_hsvSpinBoxLabel->setText(tr("HS&V/HSB:"));
 
    /*: @label:spinbox HWB (hue, whiteness, blackness) */
    m_hwbSpinBoxLabel->setText(tr("H&WB:"));
 
    /*: @action:button */
    m_buttonOK->setText(tr("&OK"));
 
    /*: @action:button */
    m_buttonCancel->setText(tr("&Cancel"));
    /*: @info:tooltip Help text for RGB spinbox. */
    m_rgbSpinBox->setToolTip( //
        richTextMarker
        + tr("<p>Red: 0⁠–⁠255</p>"
             "<p>Green: 0⁠–⁠255</p>"
             "<p>Blue: 0⁠–⁠255</p>"));
 
    /*: @info:tooltip Help text for hexadecimal code. */
    m_rgbLineEdit->setToolTip( //
        richTextMarker
        + tr("<p>Hexadecimal color code, as used in HTML: #RRGGBB</p>"
             "<p>RR: two-digit code for red: 00⁠–⁠FF</p>"
             "<p>GG: two-digit code for green: 00⁠–⁠FF</p>"
             "<p>BB: two-digit code for blue: 00⁠–⁠FF</p>"));
 
    /*: @info:tooltip Help text for HSL (hue, saturation, lightness).
    Saturation: 0 means something on the grey axis; 255 means something
    between the grey axis and the most colorful color. This is different
    from “chroma” and should therefore get a different translation.
    Lightness: 0 means always black; 255 means always white. This is
    different from “brightness” and should therefore get a different
    translation. */
    m_hslSpinBox->setToolTip(richTextMarker
                             + tr("<p>Hue: 0°⁠–⁠360°</p>"
                                  "<p>HSL-Saturation: 0%⁠–⁠100%</p>"
                                  "<p>Lightness: 0%⁠–⁠100%</p>"));
 
    /*: @info:tooltip Help text for HWB (hue, whiteness, blackness).
    The idea behind is that the hue defines the pure (maximum colorful) color.
    Than, white color can be added, creating a “tint”. Or black color
    can be added, creating a “shade”. Or both can be added, creating a “tone“.
    See https://en.wikipedia.org/wiki/Tint,_shade_and_tone for more
    information. 0% white + 0% black = pure color. 100% white
    + 0% black = white. 0% white + 100% black = black. 50% white + 50% black
    = gray. 50% white + 0% black = tint. 25% white + 25% black = tone.
    0% white + 50% black = shade. */
    m_hwbSpinBox->setToolTip(richTextMarker
                             + tr("<p>Hue: 0°⁠–⁠360°</p>"
                                  "<p>Whiteness: 0%⁠–⁠100%</p>"
                                  "<p>Blackness: 0%⁠–⁠100%</p>"));
 
    /*: @info:tooltip Help text for HSV/HSB. HSV (hue, saturation, value)
    and HSB (hue, saturation, brightness) are two different names for the
    very same color model. Saturation: 0 means something between black and
    white; 255 means something between black and the most colorful color.
    This is different from “chroma” and should therefore get a different
    translation. Brightness/value: 0 means always black; 255 means something
    between white and the most colorful color. This is different from
    “lightness” and should therefore get a different translation. */
    m_hsvSpinBox->setToolTip(richTextMarker
                             + tr("<p>Hue: 0°⁠–⁠360°</p>"
                                  "<p>HSV/HSB-Saturation: 0%⁠–⁠100%</p>"
                                  "<p>Brightness/Value: 0%⁠–⁠100%</p>"));
 
    m_alphaSpinBox->setPrefix(percentageInSpinbox.first);
    m_alphaSpinBox->setSuffix(percentageInSpinbox.second);
 
    /*: @label:slider Accessible name for lightness slider. This is different
    from “brightness”/“value” and should therefore get a different
    translation. */
    m_lchLightnessSelector->setAccessibleName(tr("Lightness"));
 
    /*: @info:tooltip Help text for CIELCH. “lightness” is different from
    “brightness”/“value” and should therefore get a different translation. */
    m_cielchD50SpinBox->setToolTip(richTextMarker
                                   + tr("<p>Lightness: 0%⁠–⁠100%</p>"
                                        "<p>Chroma: 0⁠–⁠%L1</p>"
                                        "<p>Hue: 0°⁠–⁠360°</p>")
                                         .arg(CielchD50Values::maximumChroma));
 
    constexpr double maxOklchChroma = OklchValues::maximumChroma;
    /*: @info:tooltip Help text for Oklch. “lightness” is different from
    “brightness”/“value” and should therefore get a different translation. */
    m_oklchSpinBox->setToolTip(richTextMarker
                               + tr("<p>Lightness: %L1⁠–⁠%L2</p>"
                                    "<p>Chroma: %L3⁠–⁠%L4</p>"
                                    "<p>Hue: 0°⁠–⁠360°</p>"
                                    "<p>Whitepoint: D65</p>")
                                     .arg(0., 0, 'f', okdecimals)
                                     .arg(1., 0, 'f', okdecimals)
                                     .arg(0., 0, 'f', okdecimals)
                                     .arg(maxOklchChroma, 0, 'f', okdecimals));
 
    /*: @label:slider An opacity of 0 means completely
    transparent. The higher the opacity value increases, the
    more opaque the colour becomes,  until it finally becomes
    completely opaque at the highest possible opacity value. */
    const QString opacityLabel = tr("Op&acity:");
    m_alphaGradientSlider->setAccessibleName(opacityLabel);
    m_alphaLabel->setText(opacityLabel);
 
    // HSL spin box
    QList<MultiSpinBoxSection> hslSections = //
        m_hslSpinBox->sectionConfigurations();
    if (hslSections.count() != 3) {
        qWarning() //
            << "Expected 3 sections in HSV MultiSpinBox, but got" //
            << hslSections.count() //
            << "instead. This is a bug in libperceptualcolor.";
    } else {
        hslSections[0].setPrefix(arcDegreeInSpinbox.first);
        hslSections[0].setSuffix( //
            arcDegreeInSpinbox.second + m_multispinboxSectionSeparator);
        hslSections[1].setPrefix( //
            m_multispinboxSectionSeparator + percentageInSpinbox.first);
        hslSections[1].setSuffix( //
            percentageInSpinbox.second + m_multispinboxSectionSeparator);
        hslSections[2].setPrefix( //
            m_multispinboxSectionSeparator + percentageInSpinbox.first);
        hslSections[2].setSuffix(percentageInSpinbox.second);
        m_hslSpinBox->setSectionConfigurations(hslSections);
    }
 
    // HWB spin box
    QList<MultiSpinBoxSection> hwbSections = //
        m_hwbSpinBox->sectionConfigurations();
    if (hwbSections.count() != 3) {
        qWarning() //
            << "Expected 3 sections in HSV MultiSpinBox, but got" //
            << hwbSections.count() //
            << "instead. This is a bug in libperceptualcolor.";
    } else {
        hwbSections[0].setPrefix(arcDegreeInSpinbox.first);
        hwbSections[0].setSuffix( //
            arcDegreeInSpinbox.second + m_multispinboxSectionSeparator);
        hwbSections[1].setPrefix( //
            m_multispinboxSectionSeparator + percentageInSpinbox.first);
        hwbSections[1].setSuffix( //
            percentageInSpinbox.second + m_multispinboxSectionSeparator);
        hwbSections[2].setPrefix( //
            m_multispinboxSectionSeparator + percentageInSpinbox.first);
        hwbSections[2].setSuffix( //
            percentageInSpinbox.second);
        m_hwbSpinBox->setSectionConfigurations(hwbSections);
    }
 
    // HSV spin box
    QList<MultiSpinBoxSection> hsvSections = //
        m_hsvSpinBox->sectionConfigurations();
    if (hsvSections.count() != 3) {
        qWarning() //
            << "Expected 3 sections in HSV MultiSpinBox, but got" //
            << hsvSections.count() //
            << "instead. This is a bug in libperceptualcolor.";
    } else {
        hsvSections[0].setPrefix(arcDegreeInSpinbox.first);
        hsvSections[0].setSuffix( //
            arcDegreeInSpinbox.second + m_multispinboxSectionSeparator);
        hsvSections[1].setPrefix( //
            m_multispinboxSectionSeparator + percentageInSpinbox.first);
        hsvSections[1].setSuffix( //
            percentageInSpinbox.second + m_multispinboxSectionSeparator);
        hsvSections[2].setPrefix( //
            m_multispinboxSectionSeparator + percentageInSpinbox.first);
        hsvSections[2].setSuffix(percentageInSpinbox.second);
        m_hsvSpinBox->setSectionConfigurations(hsvSections);
    }
 
    // CIELCH-D50 spin box
    QList<MultiSpinBoxSection> cielchD50Sections = //
        m_cielchD50SpinBox->sectionConfigurations();
    if (cielchD50Sections.count() != 3) {
        qWarning() //
            << "Expected 3 sections in CIELCH-D50 MultiSpinBox, but got" //
            << cielchD50Sections.count() //
            << "instead. This is a bug in libperceptualcolor.";
    } else {
        cielchD50Sections[0].setPrefix(percentageInSpinbox.first);
        cielchD50Sections[0].setSuffix( //
            percentageInSpinbox.second + m_multispinboxSectionSeparator);
        cielchD50Sections[1].setPrefix(m_multispinboxSectionSeparator);
        cielchD50Sections[1].setSuffix(m_multispinboxSectionSeparator);
        cielchD50Sections[2].setPrefix(m_multispinboxSectionSeparator + arcDegreeInSpinbox.first);
        cielchD50Sections[2].setSuffix(arcDegreeInSpinbox.second);
        m_cielchD50SpinBox->setSectionConfigurations(cielchD50Sections);
    }
 
    // Oklch spin box
    QList<MultiSpinBoxSection> oklchSections = //
        m_oklchSpinBox->sectionConfigurations();
    if (oklchSections.count() != 3) {
        qWarning() //
            << "Expected 3 sections in Oklch MultiSpinBox, but got" //
            << oklchSections.count() //
            << "instead. This is a bug in libperceptualcolor.";
    } else {
        oklchSections[0].setPrefix(QString());
        oklchSections[0].setSuffix(m_multispinboxSectionSeparator);
        oklchSections[1].setPrefix(m_multispinboxSectionSeparator);
        oklchSections[1].setSuffix(m_multispinboxSectionSeparator);
        oklchSections[2].setPrefix( //
            m_multispinboxSectionSeparator + arcDegreeInSpinbox.first);
        oklchSections[2].setSuffix(arcDegreeInSpinbox.second);
        m_oklchSpinBox->setSectionConfigurations(oklchSections);
    }
 
    if (m_screenColorPickerButton) {
        /*: @action:button (eye dropper/pipette).
        A click on the button transforms the mouse cursor to a cross and lets
        the user choose a color from the screen by doing a left-click.
        Same text as in QColorDialog */
        const auto mnemonic = tr("&Pick screen color");
        m_screenColorPickerButton->setToolTip( //
            richTextMarker + fromMnemonicToRichText(mnemonic));
        m_screenColorPickerButton->setShortcut( //
            QKeySequence::mnemonic(mnemonic));
    }
 
    /*: @info:tooltip Tooltip for the gamut-correction action.
    The icon for this action is only visible in the UI while the
    color value within the corresponding spinbox is an out-of-gamut
    value. A click on the icon will change the spinbox’s values to
    the nearest in-gamut color (and make the icon disappear). */
    const auto gamutMnemonic = //
        tr("Click to snap to nearest in-&gamut color");
    const QString gamutTooltip = //
        richTextMarker + fromMnemonicToRichText(gamutMnemonic);
    const auto gamutShortcut = QKeySequence::mnemonic(gamutMnemonic);
    m_cielchD50SpinBoxGamutAction->setToolTip(gamutTooltip);
    m_cielchD50SpinBoxGamutAction->setShortcut(gamutShortcut);
    m_oklchSpinBoxGamutAction->setToolTip(gamutTooltip);
    m_oklchSpinBoxGamutAction->setShortcut(gamutShortcut);
 
    /*: @item:inlistbox
    The swatch grid showing the basic colors like yellow,
    orange, red… Same text as in QColorDialog */
    m_swatchBookSelector->setItemText(0, tr("Basic colors")); // TODO xxx Short cut? /plain or /richtext or how is the correct context marker?
 
    /*: @item:inlistbox
    The swatch grid showing the history of
    previously selected colors. */
    m_swatchBookSelector->setItemText(1, tr("History")); // TODO xxx Short cut? /plain or /richtext or how is the correct context marker?
 
    /*: @item:inlistbox
    The swatch grid showing the history of
    previously selected colors. */
    m_swatchBookSelector->setItemText(2, tr("Custom Colors")); // TODO xxx Short cut? /plain or /richtext or how is the correct context marker?
 
    // NOTE No need to call
    //
    // q_pointer->adjustSize();
    //
    // because our layout adopts automatically to the
    // new size of the strings. Indeed, calling
    //
    // q_pointer->adjustSize();
    //
    // would change the height (!) of the widget: While it might seem
    // reasonable that the width changes when the strings change, the
    // height should not. We didn’t find the reason and didn’t manage
    // to reproduce this behaviour within the unit tests. But anyway
    // the call is not necessary, as mentioned earlier.
}
 
/** @brief Reloads all icons, adapting to the current color schema and
 * widget style. */
void ColorDialogPrivate::reloadIcons()
{
    m_currentIconThemeType = guessColorSchemeTypeFromWidget(q_pointer);
 
    static const QStringList swatchBookIcons //
        {QStringLiteral("paint-swatch"),
         // For “symbolic” (monochromatic) vs “full-color” icons, see
         // https://pointieststick.com/2023/08/12/how-all-this-icon-stuff-is-going-to-work-in-plasma-6/
         QStringLiteral("palette"),
         QStringLiteral("palette-symbolic")};
    const int swatchBookIndex = //
        m_tabWidget->indexOf(m_swatchBookWrapperWidget);
    if (swatchBookIndex >= 0) {
        m_tabWidget->setTabIcon(swatchBookIndex, //
                                qIconFromTheme(swatchBookIcons, //
                                               QStringLiteral("color-swatch"),
                                               m_currentIconThemeType));
    }
 
    static const QStringList hueFirstIcons //
        {
            QStringLiteral("color-mode-hue-shift-positive"),
        };
    const int hueFirstIndex = //
        m_tabWidget->indexOf(m_hueFirstWrapperWidget);
    if (hueFirstIndex >= 0) {
        m_tabWidget->setTabIcon(hueFirstIndex, //
                                qIconFromTheme(hueFirstIcons, //
                                               QStringLiteral("steering-wheel"),
                                               m_currentIconThemeType));
    }
 
    static const QStringList lightnessFirstIcons //
        {
            QStringLiteral("brightness-high"),
        };
    const int lightnessFirstIndex = //
        m_tabWidget->indexOf(m_lightnessFirstWrapperWidget);
    if (lightnessFirstIndex >= 0) {
        m_tabWidget->setTabIcon(lightnessFirstIndex, //
                                qIconFromTheme(lightnessFirstIcons, //
                                               QStringLiteral("brightness-2"),
                                               m_currentIconThemeType));
    }
 
    static const QStringList numericIcons //
        {
            QStringLiteral("black_sum"),
        };
    const int numericIndex = //
        m_tabWidget->indexOf(m_numericalWidget);
    if (numericIndex >= 0) {
        m_tabWidget->setTabIcon(numericIndex, //
                                qIconFromTheme(numericIcons, //
                                               QStringLiteral("123"),
                                               m_currentIconThemeType));
    }
 
    // Gamut button for some spin boxes
    static const QStringList gamutIconNames //
        {
            QStringLiteral("data-warning"),
            QStringLiteral("dialog-warning-symbolic"),
        };
    const QIcon gamutIcon = qIconFromTheme(gamutIconNames, //
                                           QStringLiteral("eye-exclamation"),
                                           m_currentIconThemeType);
    m_cielchD50SpinBoxGamutAction->setIcon(gamutIcon);
    m_oklchSpinBoxGamutAction->setIcon(gamutIcon);
 
    static const QStringList candidates //
        {
            QStringLiteral("color-picker"), //
            QStringLiteral("gtk-color-picker"), //
            QStringLiteral("tool_color_picker"), //
        };
    if (!m_screenColorPickerButton.isNull()) {
        m_screenColorPickerButton->setIcon( //
            qIconFromTheme(candidates, //
                           QStringLiteral("color-picker"),
                           m_currentIconThemeType));
    }
}
 
/** @brief Basic initialization.
 *
 * @param colorSpace The color space within which this widget should operate.
 * Can be created with @ref RgbColorSpaceFactory.
 *
 * Code that is shared between the various overloaded constructors.
 *
 * @todo The RTL layout is broken for @ref SwatchBook. Thought a stretch
 * is added in the layout, the @ref SwatchBook stays left-aligned
 * instead of right-aligned if there is too much space. Why doesn’t this
 * right-align? For @ref m_wheelColorPicker and @ref m_chromaHueDiagram
 * the same code works fine! */
void ColorDialogPrivate::initialize(const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace)
{
    // Do not show the “?” button in the window title. This button is displayed
    // by default on widgets that inherit from QDialog. But we do not want the
    // button because we do not provide What’s-This-help anyway, so having
    // the button would be confusing.
    q_pointer->setWindowFlag(Qt::WindowContextHelpButtonHint, false);
 
    // initialize color space and its dependencies
    m_rgbColorSpace = colorSpace;
    m_wcsBasicColors = wcsBasicColors(colorSpace);
    m_wcsBasicDefaultColor = m_wcsBasicColors.value(4, 2);
 
    // create the graphical selectors
    m_swatchBookBasicColors = new SwatchBook(m_rgbColorSpace, //
                                             m_wcsBasicColors, //
                                             Qt::Orientation::Horizontal);
    auto swatchBookBasicColorsLayout = new QGridLayout();
    auto swatchBookBasicColorsLayoutWidget = new QWidget();
    swatchBookBasicColorsLayoutWidget->setLayout(swatchBookBasicColorsLayout);
    swatchBookBasicColorsLayoutWidget->setContentsMargins(0, 0, 0, 0);
    swatchBookBasicColorsLayout->setContentsMargins(0, 0, 0, 0);
    swatchBookBasicColorsLayout->addWidget(m_swatchBookBasicColors);
    swatchBookBasicColorsLayout->setRowStretch(1, 1);
    swatchBookBasicColorsLayout->setColumnStretch(1, 1);
    m_swatchBookHistory = new SwatchBook(m_rgbColorSpace, //
                                         Swatches(), //
                                         Qt::Orientation::Vertical);
    auto swatchBookHistoryLayout = new QGridLayout();
    auto swatchBookHistoryLayoutWidget = new QWidget();
    swatchBookHistoryLayoutWidget->setLayout(swatchBookHistoryLayout);
    swatchBookHistoryLayoutWidget->setContentsMargins(0, 0, 0, 0);
    swatchBookHistoryLayout->setContentsMargins(0, 0, 0, 0);
    swatchBookHistoryLayout->addWidget(m_swatchBookHistory);
    swatchBookHistoryLayout->setRowStretch(1, 1);
    swatchBookHistoryLayout->setColumnStretch(1, 1);
    loadHistoryFromSettingsToSwatchBook();
    m_swatchBookCustomColors = new SwatchBook( //
        m_rgbColorSpace, //
        Swatches(), //
        Qt::Orientation::Horizontal | Qt::Orientation::Vertical);
    m_swatchBookCustomColors->setEditable(true);
    auto swatchBookCustomColorsLayout = new QGridLayout();
    auto swatchBookCustomColorsLayoutWidget = new QWidget();
    swatchBookCustomColorsLayoutWidget->setLayout(swatchBookCustomColorsLayout);
    swatchBookCustomColorsLayoutWidget->setContentsMargins(0, 0, 0, 0);
    swatchBookCustomColorsLayout->setContentsMargins(0, 0, 0, 0);
    swatchBookCustomColorsLayout->addWidget(m_swatchBookCustomColors);
    swatchBookCustomColorsLayout->setRowStretch(1, 1);
    swatchBookCustomColorsLayout->setColumnStretch(1, 1);
    loadCustomColorsFromSettingsToSwatchBook();
    connect(m_swatchBookCustomColors, // sender
            &SwatchBook::swatchGridChanged, // signal
            this, // receiver
            [this](const Swatches &newSwatches) {
                m_settings.customColors.setValue(newSwatches.toQList());
            });
    m_swatchBookStack = new QStackedLayout();
    m_swatchBookStack->addWidget(swatchBookBasicColorsLayoutWidget);
    m_swatchBookStack->addWidget(swatchBookHistoryLayoutWidget);
    m_swatchBookStack->addWidget(swatchBookCustomColorsLayoutWidget);
    QHBoxLayout *swatchBookInnerLayout = new QHBoxLayout();
    swatchBookInnerLayout->addLayout(m_swatchBookStack);
    swatchBookInnerLayout->addStretch();
    QVBoxLayout *swatchBookOuterLayout = new QVBoxLayout();
    m_swatchBookSelector = new QComboBox();
    m_swatchBookSelector->addItem(QString());
    m_swatchBookSelector->addItem(QString());
    m_swatchBookSelector->addItem(QString());
    connect(m_swatchBookSelector, //
            &QComboBox::currentIndexChanged,
            this,
            [this](int i) {
                switch (i) {
                case 0:
                    m_swatchBookStack->setCurrentIndex(0);
                    m_settings.swatchBookPage.setValue( //
                        PerceptualSettings::SwatchBookPage::BasicColors);
                    break;
                case 1:
                    m_swatchBookStack->setCurrentIndex(1);
                    m_settings.swatchBookPage.setValue( //
                        PerceptualSettings::SwatchBookPage::History);
                    break;
                case 2:
                    m_swatchBookStack->setCurrentIndex(2);
                    m_settings.swatchBookPage.setValue( //
                        PerceptualSettings::SwatchBookPage::CustomColors);
                    break;
                };
            });
    swatchBookOuterLayout->addWidget(m_swatchBookSelector);
    swatchBookOuterLayout->addLayout(swatchBookInnerLayout);
    swatchBookOuterLayout->addStretch();
    m_swatchBookWrapperWidget = new QWidget();
    m_swatchBookWrapperWidget->setLayout(swatchBookOuterLayout);
    connect(&m_settings.history, //
            &Setting<PerceptualSettings::ColorList>::valueChanged,
            this,
            &ColorDialogPrivate::loadHistoryFromSettingsToSwatchBook);
    connect(&m_settings.customColors, //
            &Setting<PerceptualSettings::ColorList>::valueChanged,
            this,
            &ColorDialogPrivate::loadCustomColorsFromSettingsToSwatchBook);
    m_wheelColorPicker = new WheelColorPicker(m_rgbColorSpace);
    m_hueFirstWrapperWidget = new QWidget;
    QHBoxLayout *tempHueFirstLayout = new QHBoxLayout;
    tempHueFirstLayout->addWidget(m_wheelColorPicker);
    m_hueFirstWrapperWidget->setLayout(tempHueFirstLayout);
 
    m_lchLightnessSelector = new GradientSlider(m_rgbColorSpace);
    GenericColor blackCielchD50;
    blackCielchD50.first = 0;
    blackCielchD50.second = 0;
    blackCielchD50.third = 0;
    blackCielchD50.fourth = 1;
    GenericColor whiteCielchD50;
    whiteCielchD50.first = 100;
    whiteCielchD50.second = 0;
    whiteCielchD50.third = 0;
    whiteCielchD50.fourth = 1;
    m_lchLightnessSelector->setColors(blackCielchD50, whiteCielchD50);
    m_chromaHueDiagram = new ChromaHueDiagram(m_rgbColorSpace);
    QHBoxLayout *tempLightnesFirstLayout = new QHBoxLayout();
    tempLightnesFirstLayout->addWidget(m_lchLightnessSelector);
    tempLightnesFirstLayout->addWidget(m_chromaHueDiagram);
    m_lightnessFirstWrapperWidget = new QWidget();
    m_lightnessFirstWrapperWidget->setLayout(tempLightnesFirstLayout);
 
    initializeScreenColorPicker();
 
    m_tabWidget = new QTabWidget;
    // It would be good to have bigger icons. Via QStyle::pixelMetrics()
    // we could get values for this. QStyle::PM_LargeIconSize seems to large,
    // be we could use std::max() with QStyle::PM_ToolBarIconSize,
    // QStyle::PM_SmallIconSize, QStyle::PM_TabBarIconSize,
    // QStyle::PM_ButtonIconSize. But the problem is a regression in Qt6
    // (compared to Qt5) that breaks rendering of bigger icons via
    // QTabWidget::iconSize(): https://bugreports.qt.io/browse/QTBUG-114849
    // Furthermore, it appears that the MacOS style does not adjust the height
    // of the tab bar to match the icon height. This causes larger icons to
    // simply overflow, which looks like a rendering issue. Therefore,
    // currently we stick with the default icons size for tab bars.
    m_tabWidget->addTab(m_swatchBookWrapperWidget, QString());
    m_swatchBookTabShortcut = new QShortcut(q_pointer);
    connect(m_swatchBookTabShortcut, //
            &QShortcut::activated,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_swatchBookWrapperWidget));
            });
    connect(m_swatchBookTabShortcut, //
            &QShortcut::activatedAmbiguously,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_swatchBookWrapperWidget));
            });
 
    m_tabWidget->addTab(m_hueFirstWrapperWidget, QString());
    m_hueFirstTabShortcut = new QShortcut(q_pointer);
    connect(m_hueFirstTabShortcut, //
            &QShortcut::activated,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_hueFirstWrapperWidget));
            });
    connect(m_hueFirstTabShortcut, //
            &QShortcut::activatedAmbiguously,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_hueFirstWrapperWidget));
            });
 
    m_tabWidget->addTab(m_lightnessFirstWrapperWidget, QString());
    m_lightnessFirstTabShortcut = new QShortcut(q_pointer);
    connect(m_lightnessFirstTabShortcut, //
            &QShortcut::activated,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_lightnessFirstWrapperWidget));
            });
    connect(m_lightnessFirstTabShortcut, //
            &QShortcut::activatedAmbiguously,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_lightnessFirstWrapperWidget));
            });
 
    m_tabTable.insert(&m_swatchBookWrapperWidget, //
                      QStringLiteral("swatch"));
    m_tabTable.insert(&m_hueFirstWrapperWidget, //
                      QStringLiteral("hue-based"));
    m_tabTable.insert(&m_lightnessFirstWrapperWidget, //
                      QStringLiteral("lightness-based"));
    m_tabTable.insert(&m_numericalWidget, //
                      QStringLiteral("numerical"));
    connect(m_tabWidget, //
            &QTabWidget::currentChanged, //
            this, //
            &ColorDialogPrivate::saveCurrentTab);
 
    // Create the ColorPatch
    m_colorPatch = new ColorPatch();
    m_colorPatch->setMinimumSize(m_colorPatch->minimumSizeHint() * 1.5);
 
    QHBoxLayout *headerLayout = new QHBoxLayout();
    headerLayout->addWidget(m_colorPatch, 1);
    m_screenColorPickerButton->setSizePolicy(QSizePolicy::Minimum, // horizontal
                                             QSizePolicy::Minimum); // vertical
    headerLayout->addWidget(m_screenColorPickerButton,
                            // Do not grow the cell in the direction
                            // of the QBoxLayout:
                            0,
                            // No alignment: Fill the entire cell.
                            Qt::Alignment());
 
    // Create widget for the numerical values
    m_numericalWidget = initializeNumericPage();
    m_numericalTabShortcut = new QShortcut(q_pointer);
    connect(m_numericalTabShortcut, //
            &QShortcut::activated,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_numericalWidget));
            });
    connect(m_numericalTabShortcut, //
            &QShortcut::activatedAmbiguously,
            this,
            [this]() {
                m_tabWidget->setCurrentIndex( //
                    m_tabWidget->indexOf(m_numericalWidget));
            });
 
    // Create layout for graphical and numerical widgets
    m_selectorLayout = new QHBoxLayout();
    m_selectorLayout->addWidget(m_tabWidget);
    m_selectorLayout->addWidget(m_numericalWidget);
 
    // Create widgets for alpha value
    QHBoxLayout *m_alphaLayout = new QHBoxLayout();
    m_alphaGradientSlider = new GradientSlider(m_rgbColorSpace, //
                                               Qt::Orientation::Horizontal);
    m_alphaGradientSlider->setSingleStep(singleStepAlpha);
    m_alphaGradientSlider->setPageStep(pageStepAlpha);
    m_alphaSpinBox = new QDoubleSpinBox();
    m_alphaSpinBox->setAlignment(Qt::AlignmentFlag::AlignRight);
    m_alphaSpinBox->setMinimum(0);
    m_alphaSpinBox->setMaximum(100);
    // The suffix is set in retranslateUi.
    m_alphaSpinBox->setDecimals(decimals);
    m_alphaSpinBox->setSingleStep(singleStepAlpha * 100);
    // m_alphaSpinBox is of type QDoubleSpinBox which does not allow to
    // configure the pageStep.
    m_alphaLabel = new QLabel();
    m_alphaLabel->setBuddy(m_alphaSpinBox);
    m_alphaLayout->addWidget(m_alphaLabel);
    m_alphaLayout->addWidget(m_alphaGradientSlider);
    m_alphaLayout->addWidget(m_alphaSpinBox);
 
    // Create the default buttons
    // We use standard buttons, because these standard buttons are
    // created by Qt and have automatically the correct icons and so on
    // (as designated in the current platform and widget style).
    // Though we use standard buttons, (later) we set the text manually to
    // get full control over the translation. Otherwise, loading a
    // different translation files than the user’s QLocale::system()
    // default locale would not update the standard button texts.
    m_buttonBox = new QDialogButtonBox();
    // NOTE We start with the OK button, and not with the Cancel button.
    // This is because apparently, the first button becomes the default
    // one (though Qt documentation says differently). If Cancel would
    // be the first, it would become the default button, which is not
    // what we want. (Even QPushButton::setDefault() will not change this
    // afterwards.)
    m_buttonOK = m_buttonBox->addButton(QDialogButtonBox::Ok);
    m_buttonCancel = m_buttonBox->addButton(QDialogButtonBox::Cancel);
    // The Qt documentation at
    // https://doc.qt.io/qt-5/qcoreapplication.html#installTranslator
    // says that Qt::LanguageChange events are only send to top-level
    // widgets. However, our experience is that also the QDialogButtonBox
    // receives Qt::LanguageChange events and reacts on it by updating
    // the user-visible string of all standard buttons. We do not want
    // to use custom buttons because of the advantages of standard
    // buttons that are described above. On the other hand, we do not
    // want Qt to change our string because we use our own translation
    // here.
    m_buttonBox->installEventFilter(&m_languageChangeEventFilter);
    m_buttonOK->installEventFilter(&m_languageChangeEventFilter);
    m_buttonCancel->installEventFilter(&m_languageChangeEventFilter);
    connect(m_buttonBox, // sender
            &QDialogButtonBox::accepted, // signal
            q_pointer, // receiver
            &PerceptualColor::ColorDialog::accept); // slot
    connect(m_buttonBox, // sender
            &QDialogButtonBox::rejected, // signal
            q_pointer, // receiver
            &PerceptualColor::ColorDialog::reject); // slot
 
    // Create the main layout
    QVBoxLayout *tempMainLayout = new QVBoxLayout();
    tempMainLayout->addLayout(headerLayout);
    tempMainLayout->addLayout(m_selectorLayout);
    tempMainLayout->addLayout(m_alphaLayout);
    tempMainLayout->addWidget(m_buttonBox);
    q_pointer->setLayout(tempMainLayout);
 
    // initialize signal-slot-connections
    connect(m_colorPatch, // sender
            &ColorPatch::colorChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readColorPatchValue // slot
    );
    connect(m_swatchBookBasicColors, // sender
            &SwatchBook::currentColorChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readSwatchBookBasicColorsValue // slot
    );
    connect(m_swatchBookHistory, // sender
            &SwatchBook::currentColorChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readSwatchBookHistoryValue // slot
    );
    connect(m_swatchBookCustomColors, // sender
            &SwatchBook::currentColorChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readSwatchBookCustomColorsValue // slot
    );
    connect(m_rgbSpinBox, // sender
            &MultiSpinBox::sectionValuesChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readRgbNumericValues // slot
    );
    connect(m_rgbLineEdit, // sender
            &QLineEdit::textChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readRgbHexValues // slot
    );
    connect(m_rgbLineEdit, // sender
            &QLineEdit::editingFinished, // signal
            this, // receiver
            &ColorDialogPrivate::updateRgbHexButBlockSignals // slot
    );
    connect(m_hslSpinBox, // sender
            &MultiSpinBox::sectionValuesChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readHslNumericValues // slot
    );
    connect(m_hwbSpinBox, // sender
            &MultiSpinBox::sectionValuesChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readHwbNumericValues // slot
    );
    connect(m_hsvSpinBox, // sender
            &MultiSpinBox::sectionValuesChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readHsvNumericValues // slot
    );
    connect(m_cielchD50SpinBox, // sender
            &MultiSpinBox::sectionValuesChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readLchNumericValues // slot
    );
    connect(m_cielchD50SpinBox, // sender
            &MultiSpinBox::editingFinished, // signal
            this, // receiver
            &ColorDialogPrivate::updateLchButBlockSignals // slot
    );
    connect(m_oklchSpinBox, // sender
            &MultiSpinBox::sectionValuesChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readOklchNumericValues // slot
    );
    connect(m_oklchSpinBox, // sender
            &MultiSpinBox::editingFinished, // signal
            this, // receiver
            &ColorDialogPrivate::updateOklchButBlockSignals // slot
    );
    connect(m_lchLightnessSelector, // sender
            &GradientSlider::valueChanged, // signal
            this, // receiver
            &ColorDialogPrivate::readLightnessValue // slot
    );
    connect(m_wheelColorPicker, // sender
            &WheelColorPicker::currentColorCielchD50Changed, // signal
            this, // receiver
            &ColorDialogPrivate::readWheelColorPickerValues // slot
    );
    connect(m_chromaHueDiagram, // sender
            &ChromaHueDiagram::currentColorCielchD50Changed, // signal
            this, // receiver
            &ColorDialogPrivate::readChromaHueDiagramValue // slot
    );
    connect(m_alphaGradientSlider, // sender
            &GradientSlider::valueChanged, // signal
            this, // receiver
            &ColorDialogPrivate::updateColorPatch // slot
    );
    connect(m_alphaGradientSlider, // sender
            &GradientSlider::valueChanged, // signal
            this, // receiver
            [this](const qreal newFraction) { // lambda
                const QSignalBlocker blocker(m_alphaSpinBox);
                m_alphaSpinBox->setValue(newFraction * 100);
            });
    connect(m_alphaSpinBox, // sender
            QOverload<double>::of(&QDoubleSpinBox::valueChanged), // signal
            this, // receiver
            [this](const double newValue) { // lambda
                // m_alphaGradientSlider has range [0, 1], while the signal
                // has range [0, 100]. This has to be adapted:
                m_alphaGradientSlider->setValue(newValue / 100);
            });
 
    // Initialize the options
    q_pointer->setOptions(QColorDialog::ColorDialogOption::DontUseNativeDialog);
 
    // We are setting the translated default window title here instead
    // of setting it within retranslateUi(). This is because also QColorDialog
    // does not update the window title on LanguageChange events (probably
    // to avoid confusion, because it’s difficult to tell exactly if the
    // library user did or did not explicitly change the window title.
    /*: @title:window Default window title. Same text as in QColorDialog */
    q_pointer->setWindowTitle(tr("Select color"));
 
    // Enable size grip
    // As this dialog can indeed be resized, the size grip should
    // be enabled. So, users can see the little triangle at the
    // right bottom of the dialog (or the left bottom on a
    // right-to-left layout). So, the user will be aware
    // that he can indeed resize this dialog, which is
    // important as the users are used to the default
    // platform dialog, which often do not allow resizing. Therefore,
    // by default, QDialog::isSizeGripEnabled() should be true.
    // NOTE: Some widget styles like Oxygen or Breeze leave the size grip
    // widget invisible; nevertheless it reacts on mouse events. Other
    // widget styles indeed show the size grip widget, like Fusion or
    // QtCurve.
    q_pointer->setSizeGripEnabled(true);
 
    // The q_pointer’s object is still not fully initialized at this point,
    // but it’s base class constructor has fully run; this should be enough
    // to use functionality based on QWidget, so we can use it as parent.
    m_cielchD50SpinBoxGamutAction = new QAction(q_pointer);
    connect(m_cielchD50SpinBoxGamutAction, // sender
            &QAction::triggered, // signal
            this, // receiver
            &ColorDialogPrivate::updateLchButBlockSignals // slot
    );
    m_oklchSpinBoxGamutAction = new QAction(q_pointer);
    connect(m_oklchSpinBoxGamutAction, // sender
            &QAction::triggered, // signal
            this, // receiver
            &ColorDialogPrivate::updateOklchButBlockSignals // slot
    );
    // However, here we hide the action because initially the
    // current color should be in-gamut, so no need for the gamut action
    // to be visible.
    m_cielchD50SpinBoxGamutAction->setVisible(false);
    m_cielchD50SpinBox->addActionButton( //
        m_cielchD50SpinBoxGamutAction, //
        QLineEdit::ActionPosition::TrailingPosition);
    m_oklchSpinBoxGamutAction->setVisible(false);
    m_oklchSpinBox->addActionButton( //
        m_oklchSpinBoxGamutAction, //
        QLineEdit::ActionPosition::TrailingPosition);
 
    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>());
    retranslateUi();
 
    reloadIcons();
#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
    connect(qGuiApp->styleHints(), // sender
            &QStyleHints::colorSchemeChanged, // signal
            this, // receiver
            &ColorDialogPrivate::reloadIcons);
#endif
}
 
/** @brief Constructor
 *
 *  @param parent pointer to the parent widget, if any
 *  @post The @ref currentColor property is set to a default value. */
ColorDialog::ColorDialog(QWidget *parent)
    : QDialog(parent)
    , d_pointer(new ColorDialogPrivate(this))
{
    d_pointer->initialize(RgbColorSpaceFactory::createSrgb());
    setCurrentColor(d_pointer->defaultColor());
}
 
/** @brief Constructor
 *
 *  @param initial the initially chosen color of the dialog
 *  @param parent pointer to the parent widget, if any
 *  @post The object is constructed and @ref setCurrentColor() is called
 *  with <em>initial</em>. See @ref setCurrentColor() for the modifications
 *  that will be applied before setting the current color. Especially, as
 *  this dialog is constructed by default without alpha support, the
 *  alpha channel of <em>initial</em> is ignored and a fully opaque color is
 *  used. */
ColorDialog::ColorDialog(const QColor &initial, QWidget *parent)
    : QDialog(parent)
    , d_pointer(new ColorDialogPrivate(this))
{
    d_pointer->initialize(RgbColorSpaceFactory::createSrgb());
    // Calling setCurrentColor() guaranties to update all widgets
    // because it always sets a valid color, even when the color
    // parameter was invalid. As m_currentOpaqueColor is invalid
    // be default, and therefor different, setCurrentColor()
    // guaranties to update all widgets.
    setCurrentColor(initial);
}
 
/** @brief Constructor
 *
 *  @param colorSpace The color space within which this widget should operate.
 *  Can be created with @ref RgbColorSpaceFactory.
 *  @param parent pointer to the parent widget, if any
 *  @post The @ref currentColor property is set to a default value. */
ColorDialog::ColorDialog(const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace, QWidget *parent)
    : QDialog(parent)
    , d_pointer(new ColorDialogPrivate(this))
{
    d_pointer->initialize(colorSpace);
    setCurrentColor(d_pointer->defaultColor());
}
 
/** @brief Returns the default value for @ref ColorDialog::currentColor.
 *
 * @returns  the default value for @ref ColorDialog::currentColor. Comes from
 * the history (if any), or otherwise from @ref m_wcsBasicDefaultColor. */
QColor ColorDialogPrivate::defaultColor() const
{
    const auto history = m_settings.history.value();
    return history.value(0, m_wcsBasicDefaultColor);
}
 
/** @brief Constructor
 *
 *  @param colorSpace The color space within which this widget should operate.
 *  Can be created with @ref RgbColorSpaceFactory.
 *  @param initial the initially chosen color of the dialog
 *  @param parent pointer to the parent widget, if any
 *  @post The object is constructed and @ref setCurrentColor() is called
 *  with <em>initial</em>. See @ref setCurrentColor() for the modifications
 *  that will be applied before setting the current color. Especially, as
 *  this dialog is constructed by default without alpha support, the
 *  alpha channel of <em>initial</em> is ignored and a fully opaque color is
 *  used. */
ColorDialog::ColorDialog(const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace, const QColor &initial, QWidget *parent)
    : QDialog(parent)
    , d_pointer(new ColorDialogPrivate(this))
{
    d_pointer->initialize(colorSpace);
    // Calling setCurrentColor() guaranties to update all widgets
    // because it always sets a valid color, even when the color
    // parameter was invalid. As m_currentOpaqueColor is invalid
    // be default, and therefor different, setCurrentColor()
    // guaranties to update all widgets.
    setCurrentColor(initial);
}
 
/** @brief Destructor */
ColorDialog::~ColorDialog() noexcept
{
    // All the layouts and widgets used here are automatically child widgets
    // of this dialog widget. Therefor they are deleted automatically.
    // Also m_rgbColorSpace is of type RgbColorSpace(), which
    // inherits from QObject, and is a child of this dialog widget, does
    // not need to be deleted manually.
}
 
/** @brief Constructor
 *
 * @param backLink Pointer to the object from which <em>this</em> object
 * is the private implementation. */
ColorDialogPrivate::ColorDialogPrivate(ColorDialog *backLink)
    : q_pointer(backLink)
{
}
 
// No documentation here (documentation of properties
// and its getters are in the header)
QColor ColorDialog::currentColor() const
{
    QColor temp = d_pointer->m_currentOpaqueColorRgb.rgbQColor;
    temp.setAlphaF( //
        static_cast<QColorFloatType>( //
            d_pointer->m_alphaGradientSlider->value()));
    return temp;
}
 
/** @brief Setter for @ref currentColor property.
 *
 * @param color the new color
 * @post The property @ref currentColor is adapted as follows:
 * - If <em>color</em> is not valid, <tt>Qt::black</tt> is used instead.
 * - If <em>color</em>’s <tt>QColor::Spec</tt> is <em>not</em>
 *   <tt>QColor::Spec::Rgb</tt> then it will be converted silently
 *   to <tt>QColor::Spec::Rgb</tt>
 * - The RGB part of @ref currentColor will be the RGB part of <tt>color</tt>.
 * - The alpha channel of @ref currentColor will be the alpha channel
 *   of <tt>color</tt> if at the moment of the function call
 *   the <tt>QColorDialog::ColorDialogOption::ShowAlphaChannel</tt> option is
 *   set. It will be fully opaque otherwise. */
void ColorDialog::setCurrentColor(const QColor &color)
{
    QColor temp;
    if (color.isValid()) {
        // Make sure that the QColor::spec() is QColor::Spec::Rgb.
        temp = color.toRgb();
    } else {
        // For invalid colors same behavior as QColorDialog
        temp = QColor(Qt::black);
    }
    if (testOption(ColorDialog::ColorDialogOption::ShowAlphaChannel)) {
        d_pointer->m_alphaGradientSlider->setValue( //
            static_cast<double>(temp.alphaF()));
    } else {
        d_pointer->m_alphaGradientSlider->setValue(1);
    }
    // No need to update m_alphaSpinBox as this is done
    // automatically by signals emitted by m_alphaGradientSlider.
    const RgbColor myRgbColor = RgbColor::fromRgbQColor(temp);
    d_pointer->setCurrentOpaqueColor(myRgbColor, nullptr);
}
 
/** @brief Opens the dialog and connects its @ref colorSelected() signal to
 * the slot specified by receiver and member.
 *
 * The signal will be disconnected from the slot when the dialog is closed.
 *
 * Example:
 * @snippet testcolordialog.cpp ColorDialog Open
 *
 * @param receiver the object that will receive the @ref colorSelected() signal
 * @param member the slot that will receive the @ref colorSelected() signal */
void ColorDialog::open(QObject *receiver, const char *member)
{
    connect(this, // sender
            SIGNAL(colorSelected(QColor)), // signal
            receiver, // receiver
            member); // slot
    d_pointer->m_receiverToBeDisconnected = receiver;
    d_pointer->m_memberToBeDisconnected = member;
    QDialog::open();
}
 
/** @brief Updates the color patch widget
 *
 * @post The color patch widget will show the color
 * of @ref m_currentOpaqueColorRgb and the alpha
 * value of @ref m_alphaGradientSlider. */
void ColorDialogPrivate::updateColorPatch()
{
    QColor tempRgbQColor = m_currentOpaqueColorRgb.rgbQColor;
    tempRgbQColor.setAlphaF( //
        static_cast<QColorFloatType>(m_alphaGradientSlider->value()));
    m_colorPatch->setColor(tempRgbQColor);
}
 
/** @brief Overloaded function. */
void ColorDialogPrivate::setCurrentOpaqueColor(const QHash<PerceptualColor::ColorModel, PerceptualColor::GenericColor> &abs, QWidget *const ignoreWidget)
{
    const auto cielchD50 = abs.value(ColorModel::CielchD50);
    const auto rgb1 = m_rgbColorSpace->fromCielchD50ToRgb1(cielchD50);
    const auto rgb255 = GenericColor(rgb1.first * 255, //
                                     rgb1.second * 255,
                                     rgb1.third * 255);
    const auto rgbColor = RgbColor::fromRgb255(rgb255);
    setCurrentOpaqueColor(abs, rgbColor, ignoreWidget);
}
 
/** @brief Overloaded function. */
void ColorDialogPrivate::setCurrentOpaqueColor(const PerceptualColor::RgbColor &rgb, QWidget *const ignoreWidget)
{
    const auto temp = rgb.rgb255;
    const QColor myQColor = QColor::fromRgbF( //
        static_cast<QColorFloatType>(temp.first / 255.), //
        static_cast<QColorFloatType>(temp.second / 255.), //
        static_cast<QColorFloatType>(temp.third / 255.));
    const auto cielchD50 = GenericColor( //
        m_rgbColorSpace->toCielchD50(myQColor.rgba64()));
    setCurrentOpaqueColor( //
        AbsoluteColor::allConversions(ColorModel::CielchD50, cielchD50),
        rgb,
        ignoreWidget);
}
 
/** @brief Updates @ref m_currentOpaqueColorAbs, @ref m_currentOpaqueColorRgb
 * and affected widgets.
 *
 * @param abs The new color in absolute color models
 * @param rgb The new color in RGB and RGB-derived models (profile-dependant)
 *
 * @param ignoreWidget A widget that should <em>not</em> be updated. Or
 * <tt>nullptr</tt> to update <em>all</em> widgets.
 *
 * @post If this function is called recursively, nothing happens. Else
 * the color is moved into the gamut, then @ref m_currentOpaqueColorAbs and
 * @ref m_currentOpaqueColorRgb are updated, and the corresponding widgets
 * are updated (except the widget specified to be ignored – if any).
 *
 * @note Recursive functions calls are ignored. This is useful, because you
 * can connect signals from various widgets to this slot without having to
 * worry about infinite recursions. */
void ColorDialogPrivate::setCurrentOpaqueColor(const QHash<PerceptualColor::ColorModel, PerceptualColor::GenericColor> &abs,
                                               const PerceptualColor::RgbColor &rgb,
                                               QWidget *const ignoreWidget)
{
    const bool isIdentical = //
        (abs == m_currentOpaqueColorAbs) && (rgb == m_currentOpaqueColorRgb);
    if (m_isColorChangeInProgress || isIdentical) {
        // Nothing to do!
        return;
    }
 
    // If we have really some work to do, block recursive calls
    // of this function
    m_isColorChangeInProgress = true;
 
    // Save currentColor() for later comparison
    // Using currentColor() makes sure correct alpha treatment!
    QColor oldQColor = q_pointer->currentColor();
 
    // Update m_currentOpaqueColor
    m_currentOpaqueColorAbs = abs;
    m_currentOpaqueColorRgb = rgb;
 
    // Update basic colors swatch book
    if (m_swatchBookBasicColors != ignoreWidget) {
        m_swatchBookBasicColors->setCurrentColor( //
            m_currentOpaqueColorRgb.rgbQColor);
    }
 
    // Update history swatch book
    if (m_swatchBookHistory != ignoreWidget) {
        m_swatchBookHistory->setCurrentColor(m_currentOpaqueColorRgb.rgbQColor);
    }
 
    // Update custom colors swatch book
    if (m_swatchBookCustomColors != ignoreWidget) {
        m_swatchBookCustomColors->setCurrentColor(m_currentOpaqueColorRgb.rgbQColor);
    }
 
    // Update RGB widget
    if (m_rgbSpinBox != ignoreWidget) {
        m_rgbSpinBox->setSectionValues( //
            m_currentOpaqueColorRgb.rgb255.toQList3());
    }
 
    // Update HSL widget
    if (m_hslSpinBox != ignoreWidget) {
        m_hslSpinBox->setSectionValues( //
            m_currentOpaqueColorRgb.hsl.toQList3());
    }
 
    // Update HWB widget
    if (m_hwbSpinBox != ignoreWidget) {
        m_hwbSpinBox->setSectionValues( //
            m_currentOpaqueColorRgb.hwb.toQList3());
    }
 
    // Update HSV widget
    if (m_hsvSpinBox != ignoreWidget) {
        m_hsvSpinBox->setSectionValues( //
            m_currentOpaqueColorRgb.hsv.toQList3());
    }
 
    // Update CIELCH-D50 widget
    const GenericColor cielchD50 = m_currentOpaqueColorAbs.value(ColorModel::CielchD50);
    if (m_cielchD50SpinBox != ignoreWidget) {
        m_cielchD50SpinBox->setSectionValues(cielchD50.toQList3());
    }
 
    // Update Oklch widget
    const auto oklch = m_currentOpaqueColorAbs.value(ColorModel::OklchD65);
    if (m_oklchSpinBox != ignoreWidget) {
        m_oklchSpinBox->setSectionValues(oklch.toQList3());
    }
 
    // Update RGB hex widget
    if (m_rgbLineEdit != ignoreWidget) {
        updateRgbHexButBlockSignals();
    }
 
    // Update lightness selector
    if (m_lchLightnessSelector != ignoreWidget) {
        m_lchLightnessSelector->setValue( //
            cielchD50.first / static_cast<qreal>(100));
    }
 
    // Update chroma-hue diagram
    if (m_chromaHueDiagram != ignoreWidget) {
        m_chromaHueDiagram->setCurrentColorCielchD50(cielchD50);
    }
 
    // Update wheel color picker
    if (m_wheelColorPicker != ignoreWidget) {
        m_wheelColorPicker->setCurrentColorCielchD50(cielchD50);
    }
 
    // Update alpha gradient slider
    if (m_alphaGradientSlider != ignoreWidget) {
        GenericColor tempColor;
        tempColor.first = cielchD50.first;
        tempColor.second = cielchD50.second;
        tempColor.third = cielchD50.third;
        tempColor.fourth = 0;
        m_alphaGradientSlider->setFirstColorCieLchD50A(tempColor);
        tempColor.fourth = 1;
        m_alphaGradientSlider->setSecondColorCieLchD50A(tempColor);
    }
 
    // Update widgets that take alpha information
    if (m_colorPatch != ignoreWidget) {
        updateColorPatch();
    }
 
    // Emit signal currentColorChanged() only if necessary
    if (q_pointer->currentColor() != oldQColor) {
        Q_EMIT q_pointer->currentColorChanged(q_pointer->currentColor());
    }
 
    // End of this function. Unblock recursive
    // function calls before returning.
    m_isColorChangeInProgress = false;
}
 
/** @brief Reads the value from the lightness selector in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readLightnessValue()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    auto cielchD50 = m_currentOpaqueColorAbs.value(ColorModel::CielchD50);
    cielchD50.first = m_lchLightnessSelector->value() * 100;
    cielchD50 = GenericColor( //
        m_rgbColorSpace->reduceCielchD50ChromaToFitIntoGamut(cielchD50));
    setCurrentOpaqueColor( //
        AbsoluteColor::allConversions(ColorModel::CielchD50, cielchD50), //
        m_lchLightnessSelector);
}
 
/** @brief Reads the HSL numbers in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readHslNumericValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const auto temp = RgbColor::fromHsl( //
        GenericColor(m_hslSpinBox->sectionValues()));
    setCurrentOpaqueColor(temp, m_hslSpinBox);
}
 
/** @brief Reads the HWB numbers in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readHwbNumericValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const auto temp = RgbColor::fromHwb( //
        GenericColor(m_hwbSpinBox->sectionValues()));
    setCurrentOpaqueColor(temp, m_hwbSpinBox);
}
 
/** @brief Reads the HSV numbers in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readHsvNumericValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const auto temp = RgbColor::fromHsv( //
        GenericColor(m_hsvSpinBox->sectionValues()));
    setCurrentOpaqueColor(temp, m_hsvSpinBox);
}
 
/** @brief Reads the decimal RGB numbers in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readRgbNumericValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const auto temp = RgbColor::fromRgb255( //
        GenericColor(m_rgbSpinBox->sectionValues()));
    setCurrentOpaqueColor(temp, m_rgbSpinBox);
}
 
/** @brief Reads the color of the color patch, and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readColorPatchValue()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const QColor temp = m_colorPatch->color();
    if (!temp.isValid()) {
        // No color is currently selected!
        return;
    }
    const auto myRgbColor = RgbColor::fromRgbQColor(temp);
    setCurrentOpaqueColor(myRgbColor, m_colorPatch);
}
 
/** @brief Reads the color of the basic colors widget, and (if any)
 * updates the dialog accordingly. */
void ColorDialogPrivate::readSwatchBookBasicColorsValue()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const QColor temp = m_swatchBookBasicColors->currentColor();
    if (!temp.isValid()) {
        // No color is currently selected!
        return;
    }
    const auto myRgbColor = RgbColor::fromRgbQColor(temp);
    setCurrentOpaqueColor(myRgbColor, m_swatchBookBasicColors);
}
 
/** @brief Reads the color of the history widget, and (if any)
 * updates the dialog accordingly. */
void ColorDialogPrivate::readSwatchBookHistoryValue()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const QColor temp = m_swatchBookHistory->currentColor();
    if (!temp.isValid()) {
        // No color is currently selected!
        return;
    }
    const auto myRgbColor = RgbColor::fromRgbQColor(temp);
    setCurrentOpaqueColor(myRgbColor, m_swatchBookHistory);
}
 
/**
 * @brief Reads the color of the custom colors widget, and (if any)
 * updates the dialog accordingly.
 */
void ColorDialogPrivate::readSwatchBookCustomColorsValue()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const QColor temp = m_swatchBookCustomColors->currentColor();
    if (!temp.isValid()) {
        // No color is currently selected!
        return;
    }
    const auto myRgbColor = RgbColor::fromRgbQColor(temp);
    setCurrentOpaqueColor(myRgbColor, m_swatchBookCustomColors);
}
 
/** @brief Reads the color of the @ref WheelColorPicker in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readWheelColorPickerValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const auto cielchD50 = GenericColor(m_wheelColorPicker->currentColorCielchD50());
    setCurrentOpaqueColor( //
        AbsoluteColor::allConversions(ColorModel::CielchD50, cielchD50),
        m_wheelColorPicker);
}
 
/** @brief Reads the color of the @ref ChromaHueDiagram in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readChromaHueDiagramValue()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const auto cielchD50 = GenericColor(m_chromaHueDiagram->currentColorCielchD50());
    setCurrentOpaqueColor( //
        AbsoluteColor::allConversions(ColorModel::CielchD50, cielchD50),
        m_chromaHueDiagram);
}
 
/** @brief Reads the hexadecimal RGB numbers in the dialog and
 * updates the dialog accordingly. */
void ColorDialogPrivate::readRgbHexValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    QString temp = m_rgbLineEdit->text();
    if (!temp.startsWith(QStringLiteral(u"#"))) {
        temp = QStringLiteral(u"#") + temp;
    }
    QColor rgb;
    rgb.setNamedColor(temp);
    if (rgb.isValid()) {
        const auto myRgbColor = RgbColor::fromRgbQColor(rgb);
        setCurrentOpaqueColor(myRgbColor, m_rgbLineEdit);
    } else {
        m_isDirtyRgbLineEdit = true;
    }
}
 
/** @brief Updates the RGB Hex widget to @ref m_currentOpaqueColorRgb.
 *
 * @post The @ref m_rgbLineEdit gets the value of @ref m_currentOpaqueColorRgb.
 * During this operation, all signals of @ref m_rgbLineEdit are blocked. */
void ColorDialogPrivate::updateRgbHexButBlockSignals()
{
    QSignalBlocker mySignalBlocker(m_rgbLineEdit);
 
    // m_currentOpaqueColor is supposed to be always in-gamut. However,
    // because of rounding issues, a conversion to an unbounded RGB
    // color could result in an invalid color. Therefore, we must
    // use a conversion to a _bounded_ RGB color.
    const auto &rgbFloat = m_currentOpaqueColorRgb.rgb255;
 
    // We cannot rely on the convenient QColor.name() because this function
    // seems to use floor() instead of round(), which does not make sense in
    // our dialog, and it would be inconsistent with the other widgets
    // of the dialog. Therefore, we have to round explicitly (to integers):
    // This format string provides a non-localized format!
    // Format of the numbers:
    // 1) The number itself
    // 2) The minimal field width (2 digits)
    // 3) The base of the number representation (16, hexadecimal)
    // 4) The fill character (leading zero)
    const QString hexString = //
        QStringLiteral(u"#%1%2%3")
            .arg(qBound(0, qRound(rgbFloat.first), 255), //
                 2, //
                 16, //
                 QChar::fromLatin1('0'))
            .arg(qBound(0, qRound(rgbFloat.second), 255), //
                 2, //
                 16, //
                 QChar::fromLatin1('0'))
            .arg(qBound(0, qRound(rgbFloat.third), 255), //
                 2, //
                 16, //
                 QChar::fromLatin1('0'))
            .toUpper(); // Convert to upper case
    m_rgbLineEdit->setText(hexString);
}
 
/** @brief Updates the LCH spin box to @ref m_currentOpaqueColorAbs.
 *
 * @post The @ref m_cielchD50SpinBox gets the value of
 * @ref m_currentOpaqueColorAbs. During this operation, all signals of
 * @ref m_cielchD50SpinBox are blocked. */
void ColorDialogPrivate::updateLchButBlockSignals()
{
    QSignalBlocker mySignalBlocker(m_cielchD50SpinBox);
    const auto cielchD50 = m_currentOpaqueColorAbs.value(ColorModel::CielchD50);
    m_cielchD50SpinBox->setSectionValues(cielchD50.toQList3());
    m_cielchD50SpinBoxGamutAction->setVisible(false);
}
 
/** @brief Updates the Oklch spin box to @ref m_currentOpaqueColorAbs.
 *
 * @post The @ref m_oklchSpinBox gets the value
 * of @ref m_currentOpaqueColorAbs. During this operation,
 * all signals of @ref m_oklchSpinBox are blocked. */
void ColorDialogPrivate::updateOklchButBlockSignals()
{
    QSignalBlocker mySignalBlocker(m_oklchSpinBox);
    const auto oklch = m_currentOpaqueColorAbs.value(ColorModel::OklchD65);
    m_oklchSpinBox->setSectionValues(oklch.toQList3());
    m_oklchSpinBoxGamutAction->setVisible(false);
}
 
/** @brief If no @ref m_isColorChangeInProgress, reads the LCH numbers
 * in the dialog and updates the dialog accordingly. */
void ColorDialogPrivate::readLchNumericValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    const GenericColor lchValues = GenericColor(m_cielchD50SpinBox->sectionValues());
    if (m_rgbColorSpace->isCielchD50InGamut(lchValues)) {
        m_cielchD50SpinBoxGamutAction->setVisible(false);
    } else {
        m_cielchD50SpinBoxGamutAction->setVisible(true);
    }
    const auto myColor = GenericColor( //
        m_rgbColorSpace->reduceCielchD50ChromaToFitIntoGamut(lchValues));
    setCurrentOpaqueColor( //
        AbsoluteColor::allConversions(ColorModel::CielchD50, myColor),
        // widget that will ignored during updating:
        m_cielchD50SpinBox);
}
 
/** @brief If no @ref m_isColorChangeInProgress, reads the Oklch numbers
 * in the dialog and updates the dialog accordingly. */
void ColorDialogPrivate::readOklchNumericValues()
{
    if (m_isColorChangeInProgress) {
        // Nothing to do!
        return;
    }
    // Get final color (in necessary moving the original color into gamut).
    // TODO xxx This code moves into gamut based on the Cielch-D50 instead of
    // the Oklch gamut. This leads to wrong results, because Oklch hue is not
    // guaranteed to be respected. Use actually Oklch to move into gamut!
    GenericColor originalOklch;
    originalOklch.first = m_oklchSpinBox->sectionValues().value(0);
    originalOklch.second = m_oklchSpinBox->sectionValues().value(1);
    originalOklch.third = m_oklchSpinBox->sectionValues().value(2);
    if (m_rgbColorSpace->isOklchInGamut(originalOklch)) {
        m_oklchSpinBoxGamutAction->setVisible(false);
    } else {
        m_oklchSpinBoxGamutAction->setVisible(true);
    }
    const auto inGamutOklch = GenericColor( //
        m_rgbColorSpace->reduceOklchChromaToFitIntoGamut(originalOklch));
    const auto inGamutColor = //
        AbsoluteColor::allConversions(ColorModel::OklchD65, inGamutOklch);
    setCurrentOpaqueColor(inGamutColor,
                          // widget that will ignored during updating:
                          m_oklchSpinBox);
}
 
/** @brief Try to initialize the screen color picker feature.
 *
 * @post If supported, @ref m_screenColorPickerButton
 * is created. Otherwise, it stays <tt>nullptr</tt>. */
void ColorDialogPrivate::initializeScreenColorPicker()
{
    auto screenPicker = new ScreenColorPicker(q_pointer);
    if (!screenPicker->isAvailable()) {
        return;
    }
    m_screenColorPickerButton = new QToolButton;
    screenPicker->setParent(m_screenColorPickerButton); // For better support
    connect(m_screenColorPickerButton,
            &QPushButton::clicked,
            screenPicker,
            // Default capture by reference, but screenPicker by value
            [&, screenPicker]() {
                const auto myColor = q_pointer->currentColor();
                // TODO Restore QColor exactly, but could potentially produce
                // rounding errors: If original MultiColor was derived form
                // LCH, it is not guaranteed that the new MultiColor derived
                // from this QColor will not have rounding errors for LCH.
                screenPicker->startPicking( //
                    fromFloatingToEightBit(myColor.redF()), //
                    fromFloatingToEightBit(myColor.greenF()), //
                    fromFloatingToEightBit(myColor.blueF()));
            });
    connect(screenPicker, //
            &ScreenColorPicker::newColor, //
            q_pointer, //
            [this](const double red, const double green, const double blue, const bool isSRgbGuaranteed) {
                Q_UNUSED(isSRgbGuaranteed) // BUG Currently, there is no color
                // management for the result of the screen color picking.
                // Instead, we should assume probably that the value is sRGB
                // and convert it into the actual working color space of this
                // widget (which might happen to be also sRGB, but could also
                // be different).
                const GenericColor rgb255 //
                    {qBound<double>(0, red * 255, 255), //
                     qBound<double>(0, green * 255, 255),
                     qBound<double>(0, blue * 255, 255)};
                setCurrentOpaqueColor(RgbColor::fromRgb255(rgb255), nullptr);
            });
}
 
/** @brief Initialize the numeric input widgets of this dialog.
 * @returns A pointer to a new widget that has the other, numeric input
 * widgets as child widgets. */
QWidget *ColorDialogPrivate::initializeNumericPage()
{
    // Create RGB MultiSpinBox
    {
        m_rgbSpinBox = new MultiSpinBox();
        QList<MultiSpinBoxSection> rgbSections;
        MultiSpinBoxSection mySection;
        mySection.setDecimals(decimals);
        mySection.setMinimum(0);
        mySection.setMaximum(255);
        // R
        mySection.setPrefix(QString());
        mySection.setSuffix(m_multispinboxSectionSeparator);
        rgbSections.append(mySection);
        // G
        mySection.setPrefix(m_multispinboxSectionSeparator);
        mySection.setSuffix(m_multispinboxSectionSeparator);
        rgbSections.append(mySection);
        // B
        mySection.setPrefix(m_multispinboxSectionSeparator);
        mySection.setSuffix(QString());
        rgbSections.append(mySection);
        // Not setting prefix/suffix here. This will be done in retranslateUi()…
        m_rgbSpinBox->setSectionConfigurations(rgbSections);
    }
 
    // Create widget for the hex style color representation
    {
        m_rgbLineEdit = new QLineEdit();
        m_rgbLineEdit->setMaxLength(7);
        QRegularExpression tempRegularExpression( //
            QStringLiteral(u"#?[0-9A-Fa-f]{0,6}"));
        QRegularExpressionValidator *validator = new QRegularExpressionValidator( //
            tempRegularExpression, //
            q_pointer);
        m_rgbLineEdit->setValidator(validator);
    }
 
    // Create HSL spin box
    {
        m_hslSpinBox = new MultiSpinBox();
        QList<MultiSpinBoxSection> hslSections;
        MultiSpinBoxSection mySection;
        mySection.setDecimals(decimals);
        // H
        mySection.setMinimum(0);
        mySection.setMaximum(360);
        mySection.setWrapping(true);
        hslSections.append(mySection);
        // S
        mySection.setMinimum(0);
        mySection.setMaximum(100);
        mySection.setWrapping(false);
        hslSections.append(mySection);
        // L
        mySection.setMinimum(0);
        mySection.setMaximum(100);
        mySection.setWrapping(false);
        hslSections.append(mySection);
        // Not setting prefix/suffix here. This will be done in retranslateUi()…
        m_hslSpinBox->setSectionConfigurations(hslSections);
    }
 
    // Create HWB spin box
    {
        m_hwbSpinBox = new MultiSpinBox();
        QList<MultiSpinBoxSection> hwbSections;
        MultiSpinBoxSection mySection;
        mySection.setDecimals(decimals);
        // H
        mySection.setMinimum(0);
        mySection.setMaximum(360);
        mySection.setWrapping(true);
        hwbSections.append(mySection);
        // W
        mySection.setMinimum(0);
        mySection.setMaximum(100);
        mySection.setWrapping(false);
        hwbSections.append(mySection);
        // B
        mySection.setMinimum(0);
        mySection.setMaximum(100);
        mySection.setWrapping(false);
        hwbSections.append(mySection);
        // Not setting prefix/suffix here. This will be done in retranslateUi()…
        m_hwbSpinBox->setSectionConfigurations(hwbSections);
    }
 
    // Create HSV spin box
    {
        m_hsvSpinBox = new MultiSpinBox();
        QList<MultiSpinBoxSection> hsvSections;
        MultiSpinBoxSection mySection;
        mySection.setDecimals(decimals);
        // H
        mySection.setMinimum(0);
        mySection.setMaximum(360);
        mySection.setWrapping(true);
        hsvSections.append(mySection);
        // S
        mySection.setMinimum(0);
        mySection.setMaximum(100);
        mySection.setWrapping(false);
        hsvSections.append(mySection);
        // V
        mySection.setMinimum(0);
        mySection.setMaximum(100);
        mySection.setWrapping(false);
        hsvSections.append(mySection);
        // Not setting prefix/suffix here. This will be done in retranslateUi()…
        m_hsvSpinBox->setSectionConfigurations(hsvSections);
    }
 
    // Create RGB layout
    {
        QFormLayout *tempRgbFormLayout = new QFormLayout();
        m_rgbSpinBoxLabel = new QLabel();
        m_rgbSpinBoxLabel->setBuddy(m_rgbSpinBox);
        tempRgbFormLayout->addRow(m_rgbSpinBoxLabel, m_rgbSpinBox);
        m_rgbLineEditLabel = new QLabel();
        m_rgbLineEditLabel->setBuddy(m_rgbLineEdit);
        tempRgbFormLayout->addRow(m_rgbLineEditLabel, m_rgbLineEdit);
        m_hslSpinBoxLabel = new QLabel();
        m_hslSpinBoxLabel->setBuddy(m_hslSpinBox);
        tempRgbFormLayout->addRow(m_hslSpinBoxLabel, m_hslSpinBox);
        m_hwbSpinBoxLabel = new QLabel();
        m_hwbSpinBoxLabel->setBuddy(m_hwbSpinBox);
        tempRgbFormLayout->addRow(m_hwbSpinBoxLabel, m_hwbSpinBox);
        m_hsvSpinBoxLabel = new QLabel();
        m_hsvSpinBoxLabel->setBuddy(m_hsvSpinBox);
        tempRgbFormLayout->addRow(m_hsvSpinBoxLabel, m_hsvSpinBox);
        m_rgbGroupBox = new QGroupBox();
        m_rgbGroupBox->setLayout(tempRgbFormLayout);
        // Using the profile name as QGroupBox title. But on some styles, the
        // title is always shown completely, even if the text is extremly
        // long. As the text is out of our control, and some profiles
        // like Krita’s ITUR_2100_PQ_FULL.ICC have actually extremly
        // long names, we use eliding.
        const QFontMetricsF fontMetrics(m_rgbGroupBox->font());
        const auto elidedProfileName = fontMetrics.elidedText( //
            m_rgbColorSpace->profileName(),
            Qt::TextElideMode::ElideRight,
            // width (in device-independent pixels!):
            tempRgbFormLayout->minimumSize().width());
        m_rgbGroupBox->setTitle(elidedProfileName);
    }
 
    // Create widget for the CIELCH-D50 color representation
    {
        QList<MultiSpinBoxSection> cielchD50Sections;
        m_cielchD50SpinBox = new MultiSpinBox;
        MultiSpinBoxSection mySection;
        mySection.setDecimals(decimals);
        // L
        mySection.setMinimum(0);
        mySection.setMaximum(100);
        mySection.setWrapping(false);
        cielchD50Sections.append(mySection);
        // C
        mySection.setMinimum(0);
        mySection.setMaximum(CielchD50Values::maximumChroma);
        mySection.setWrapping(false);
        cielchD50Sections.append(mySection);
        // H
        mySection.setMinimum(0);
        mySection.setMaximum(360);
        mySection.setWrapping(true);
        cielchD50Sections.append(mySection);
        // Not setting prefix/suffix here. This will be done in retranslateUi()…
        m_cielchD50SpinBox->setSectionConfigurations(cielchD50Sections);
    }
 
    // Create widget for the Oklch color representation
    {
        QList<MultiSpinBoxSection> oklchSections;
        MultiSpinBoxSection mySection;
        m_oklchSpinBox = new MultiSpinBox;
        // L
        mySection.setMinimum(0);
        mySection.setMaximum(1);
        mySection.setSingleStep(singleStepOklabc);
        mySection.setWrapping(false);
        mySection.setDecimals(okdecimals);
        oklchSections.append(mySection);
        // C
        mySection.setMinimum(0);
        mySection.setMaximum(OklchValues::maximumChroma);
        mySection.setSingleStep(singleStepOklabc);
        mySection.setWrapping(false);
        mySection.setDecimals(okdecimals);
        oklchSections.append(mySection);
        // H
        mySection.setMinimum(0);
        mySection.setMaximum(360);
        mySection.setSingleStep(1);
        mySection.setWrapping(true);
        mySection.setDecimals(decimals);
        oklchSections.append(mySection);
        // Not setting the suffix here. This will be done in retranslateUi()…
        m_oklchSpinBox->setSectionConfigurations(oklchSections);
    }
 
    // Create a global widget
    QWidget *tempWidget = new QWidget;
    QVBoxLayout *tempMainLayout = new QVBoxLayout;
    tempWidget->setLayout(tempMainLayout);
    tempWidget->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
    QFormLayout *cielabFormLayout = new QFormLayout;
    m_oklchSpinBoxLabel = new QLabel();
    m_oklchSpinBoxLabel->setBuddy(m_oklchSpinBox);
    cielabFormLayout->addRow(m_oklchSpinBoxLabel, m_oklchSpinBox);
    m_cielchD50SpinBoxLabel = new QLabel();
    m_cielchD50SpinBoxLabel->setBuddy(m_cielchD50SpinBox);
    cielabFormLayout->addRow(m_cielchD50SpinBoxLabel, m_cielchD50SpinBox);
    tempMainLayout->addLayout(cielabFormLayout);
    tempMainLayout->addWidget(m_rgbGroupBox);
    tempMainLayout->addStretch();
 
    // Return
    return tempWidget;
}
 
// No documentation here (documentation of properties
// and its getters are in the header)
QColorDialog::ColorDialogOptions ColorDialog::options() const
{
    return d_pointer->m_options;
}
 
/** @brief Setter for @ref options.
 *
 * Sets a value for just one single option within @ref options.
 * @param option the option to set
 * @param on the new value of the option */
void ColorDialog::setOption(PerceptualColor::ColorDialog::ColorDialogOption option, bool on)
{
    QColorDialog::ColorDialogOptions temp = d_pointer->m_options;
    temp.setFlag(option, on);
    setOptions(temp);
}
 
/** @brief Setter for @ref options
 * @param newOptions the new options
 * @post <em>All</em> options of the widget have the same state
 * (enabled/disabled) as in the given parameter. */
void ColorDialog::setOptions(PerceptualColor::ColorDialog::ColorDialogOptions newOptions)
{
    if (newOptions == d_pointer->m_options) {
        return;
    }
 
    // Save the new options
    d_pointer->m_options = newOptions;
    // Correct QColorDialog::ColorDialogOption::DontUseNativeDialog
    // which must be always on
    d_pointer->m_options.setFlag( //
        QColorDialog::ColorDialogOption::DontUseNativeDialog,
        true);
 
    // Apply the new options (alpha value)
    const bool alphaVisibility = d_pointer->m_options.testFlag( //
        QColorDialog::ColorDialogOption::ShowAlphaChannel);
    d_pointer->m_alphaLabel->setVisible(alphaVisibility);
    d_pointer->m_alphaGradientSlider->setVisible(alphaVisibility);
    d_pointer->m_alphaSpinBox->setVisible(alphaVisibility);
 
    // Apply the new options (buttons)
    d_pointer->m_buttonBox->setVisible(!d_pointer->m_options.testFlag( //
        QColorDialog::ColorDialogOption::NoButtons));
 
    // Notify
    Q_EMIT optionsChanged(d_pointer->m_options);
}
 
/** @brief Getter for @ref options
 *
 * Gets the value of just one single option within @ref options.
 *
 * @param option the requested option
 * @returns the value of the requested option
 */
bool ColorDialog::testOption(PerceptualColor::ColorDialog::ColorDialogOption option) const
{
    return d_pointer->m_options.testFlag(option);
}
 
/** @brief Pops up a modal color dialog, lets the user choose a color, and
 *  returns that color.
 *
 * @param colorSpace The color space within which this widget should operate.
 * @param initial    initial value for currentColor()
 * @param parent     parent widget of the dialog (or 0 for no parent)
 * @param title      window title (or an empty string for the default window
 *                   title)
 * @param options    the options() for customizing the look and feel of the
 *                   dialog
 * @returns          selectedColor(): The color the user has selected; or an
 *                   invalid color if the user has canceled the dialog. */
QColor ColorDialog::getColor(const QSharedPointer<PerceptualColor::RgbColorSpace> &colorSpace,
                             const QColor &initial,
                             QWidget *parent,
                             const QString &title,
                             QColorDialog::ColorDialogOptions options)
{
    ColorDialog temp(colorSpace, parent);
    if (!title.isEmpty()) {
        temp.setWindowTitle(title);
    }
    temp.setOptions(options);
    // setCurrentColor() must be after setOptions()
    // to allow alpha channel support
    temp.setCurrentColor(initial);
    temp.exec();
    return temp.selectedColor();
}
 
/** @brief Pops up a modal color dialog, lets the user choose a color, and
 *  returns that color.
 *
 * @param initial    initial value for currentColor()
 * @param parent     parent widget of the dialog (or 0 for no parent)
 * @param title      window title (or an empty string for the default window
 *                   title)
 * @param options    the options() for customizing the look and feel of the
 *                   dialog
 * @returns          selectedColor(): The color the user has selected; or an
 *                   invalid color if the user has canceled the dialog. */
QColor ColorDialog::getColor(const QColor &initial, QWidget *parent, const QString &title, QColorDialog::ColorDialogOptions options)
{
    return getColor(RgbColorSpaceFactory::createSrgb(), //
                    initial, //
                    parent, //
                    title, //
                    options);
}
 
/** @brief The color that was actually selected by the user.
 *
 * At difference to the @ref currentColor property, this function provides
 * the color that was actually selected by the user by clicking the OK button
 * or pressing the return key or another equivalent action.
 *
 * This function most useful to get the actually selected color <em>after</em>
 * that the dialog has been closed.
 *
 * When a dialog that had been closed or hidden is shown again,
 * this function returns to an invalid QColor().
 *
 * @returns Just after showing the dialog, the value is an invalid QColor. If
 * the user selects a color by clicking the OK button or another equivalent
 * action, the value is the selected color. If the user cancels the dialog
 * (Cancel button, or by pressing the Escape key), the value remains an
 * invalid QColor. */
QColor ColorDialog::selectedColor() const
{
    return d_pointer->m_selectedColor;
}
 
/** @brief Setter for property <em>visible</em>
 *
 * Reimplemented from base class.
 *
 * When a dialog, that wasn't formerly visible, gets visible,
 * it’s @ref selectedColor value is cleared.
 *
 * @param visible holds whether or not the dialog should be visible */
void ColorDialog::setVisible(bool visible)
{
    if (visible && (!isVisible())) {
        // Only delete the selected color if the dialog wasn’t visible before
        // and will be made visible now.
        d_pointer->m_selectedColor = QColor();
        d_pointer->applyLayoutDimensions();
    }
    QDialog::setVisible(visible);
    // HACK If there is a QColorDialog as helper widget for the
    // screen color picker feature, QDialog::setVisible() sometimes
    // changes which is default button; however, this has only been
    // observed running the unit tests on KDE’s CI system running, but
    // not when running the unit tests locally. Force correct default button:
    d_pointer->m_buttonOK->setDefault(true);
}
 
/** @brief Various updates when closing the dialog.
 *
 * Reimplemented from base class.
 * @param result The result with which the dialog has been closed */
void ColorDialog::done(int result)
{
    if (result == QDialog::DialogCode::Accepted) {
        d_pointer->m_selectedColor = currentColor();
        auto history = d_pointer->m_settings.history.value();
        const auto maxHistoryLenght = std::max(d_pointer->historySwatchCount, //
                                               history.count());
        // Remove duplicates of the new value that might exist yet in the list.
        history.removeAll(d_pointer->m_selectedColor);
        // Add the new value at the very beginning.
        history.prepend(d_pointer->m_selectedColor);
        // Adapt list length.
        while (history.count() > maxHistoryLenght) {
            history.removeLast();
        }
        d_pointer->m_settings.history.setValue(history);
        Q_EMIT colorSelected(d_pointer->m_selectedColor);
    } else {
        d_pointer->m_selectedColor = QColor();
    }
    QDialog::done(result);
    if (d_pointer->m_receiverToBeDisconnected) {
        // This “disconnect” uses the old-style syntax, which does not
        // detect errors on compile time. However, we do not see a
        // possibility how to substitute it with the better new-style
        // syntax, given that d_pointer->m_memberToBeDisconnected
        // can contain different classes, which would be difficult
        // it typing the class name directly in the new syntax.
        disconnect(this, // sender
                   SIGNAL(colorSelected(QColor)), // signal
                   d_pointer->m_receiverToBeDisconnected, // receiver
                   d_pointer->m_memberToBeDisconnected.constData() // slot
        );
        d_pointer->m_receiverToBeDisconnected = nullptr;
    }
}
 
// No documentation here (documentation of properties
// and its getters are in the header)
ColorDialog::DialogLayoutDimensions ColorDialog::layoutDimensions() const
{
    return d_pointer->m_layoutDimensions;
}
 
/** @brief Setter for property @ref layoutDimensions
 * @param newLayoutDimensions the new layout dimensions */
void ColorDialog::setLayoutDimensions(const ColorDialog::DialogLayoutDimensions newLayoutDimensions)
{
    if (newLayoutDimensions == d_pointer->m_layoutDimensions) {
        return;
    }
    d_pointer->m_layoutDimensions = newLayoutDimensions;
    d_pointer->applyLayoutDimensions();
    Q_EMIT layoutDimensionsChanged(d_pointer->m_layoutDimensions);
}
 
/** @brief Arranges the layout conforming to @ref ColorDialog::layoutDimensions
 *
 * If @ref ColorDialog::layoutDimensions is DialogLayoutDimensions::automatic
 * than it is first evaluated again if for the current display the collapsed
 * or the expanded layout is used. */
void ColorDialogPrivate::applyLayoutDimensions()
{
    constexpr auto collapsed = ColorDialog::DialogLayoutDimensions::Collapsed;
    constexpr auto expanded = ColorDialog::DialogLayoutDimensions::Expanded;
    // cppcheck-suppress unreadVariable // false positive
    constexpr auto screenSizeDependent = //
        ColorDialog::DialogLayoutDimensions::ScreenSizeDependent;
    int effectivelyAvailableScreenWidth;
    int widthThreeshold;
    switch (m_layoutDimensions) {
    case collapsed:
        m_layoutDimensionsEffective = collapsed;
        break;
    case expanded:
        m_layoutDimensionsEffective = expanded;
        break;
    case screenSizeDependent:
        // Note: The following code works correctly on scaled
        // devices (high-DPI…).
 
        // We should not use more than 70% of the screen for a dialog.
        // That’s roughly the same as the default maximum sizes for
        // a QDialog.
        effectivelyAvailableScreenWidth = qRound( //
            QGuiApplication::primaryScreen()->availableSize().width() * 0.7);
 
        // Now we calculate the space we need for displaying the
        // graphical selectors and the numerical selector at their
        // preferred size in an expanded layout.
        // Start with the size of the graphical selectors.
        widthThreeshold = qMax( //
            m_wheelColorPicker->sizeHint().width(), //
            m_lightnessFirstWrapperWidget->sizeHint().width());
        // Add the size of the numerical selector.
        widthThreeshold += m_numericalWidget->sizeHint().width();
        // Add some space for margins.
        widthThreeshold = qRound(widthThreeshold * 1.2);
 
        // Now decide between collapsed layout and expanded layout
        if (effectivelyAvailableScreenWidth < widthThreeshold) {
            m_layoutDimensionsEffective = collapsed;
        } else {
            m_layoutDimensionsEffective = expanded;
        }
        break;
    default:
        // We should never reach this point, because we treat all possible
        // enum values in the switch statement.
        throw 0;
    }
 
    if (m_layoutDimensionsEffective == collapsed) {
        if (m_selectorLayout->indexOf(m_numericalWidget) >= 0) {
            // Indeed we have expanded layout and have to switch to
            // collapsed layout…
            const bool oldUpdatesEnabled = m_tabWidget->updatesEnabled();
            m_tabWidget->setUpdatesEnabled(false);
            // According to the documentation of QTabWidget::addTab it is
            // recommended to disable visual updates during adding new
            // tabs. This should avoid flickering.
            m_tabWidget->addTab(m_numericalWidget, QString());
            m_tabWidget->setUpdatesEnabled(oldUpdatesEnabled);
            retranslateUi(); // Will put a label for the recently inserted tab.
            reloadIcons(); // Will put an icon for the recently inserted tab.
            // We don’t call m_numericalWidget->show(); because this
            // is controlled by the QTabWidget.
            // Adopt size of dialog to new layout’s size hint:
            q_pointer->adjustSize();
        }
    } else {
        if (m_selectorLayout->indexOf(m_numericalWidget) < 0) {
            // Indeed we have collapsed layout and have to switch to
            // expanded layout…
            m_selectorLayout->addWidget(m_numericalWidget);
            // We call show because the widget is hidden by removing it
            // from its old parent, and needs to be shown explicitly.
            m_numericalWidget->show();
            // Adopt size of dialog to new layout’s size hint:
            q_pointer->adjustSize();
        }
    }
}
 
/** @brief Handle state changes.
 *
 * Implements reaction on <tt>QEvent::LanguageChange</tt>.
 *
 * Reimplemented from base class.
 *
 * @param event The event. */
void ColorDialog::changeEvent(QEvent *event)
{
    const auto type = event->type();
 
    if (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();
        // Retranslate all child widgets that actually need to be retranslated:
        {
            QEvent eventForSwatchBookBasicColors(QEvent::LanguageChange);
            QApplication::sendEvent(d_pointer->m_swatchBookBasicColors, //
                                    &eventForSwatchBookBasicColors);
        }
        {
            QEvent eventForSwatchBookHistory(QEvent::LanguageChange);
            QApplication::sendEvent(d_pointer->m_swatchBookHistory, //
                                    &eventForSwatchBookHistory);
        }
        {
            QEvent eventForSwatchBookCustomColors(QEvent::LanguageChange);
            QApplication::sendEvent(d_pointer->m_swatchBookCustomColors, //
                                    &eventForSwatchBookCustomColors);
        }
        {
            QEvent eventForButtonOk(QEvent::LanguageChange);
            QApplication::sendEvent(d_pointer->m_buttonOK, //
                                    &eventForButtonOk);
        }
        {
            QEvent eventForButtonCancel(QEvent::LanguageChange);
            QApplication::sendEvent(d_pointer->m_buttonOK, //
                                    &eventForButtonCancel);
        }
    }
 
    if ((type == QEvent::PaletteChange) || (type == QEvent::StyleChange)) {
        d_pointer->reloadIcons();
    }
 
    QDialog::changeEvent(event);
}
 
/** @brief Handle show events.
 *
 * Reimplemented from base class.
 *
 * @param event The event.
 *
 * @internal
 *
 * On the first show event, make @ref ColorDialogPrivate::m_tabWidget use
 * the current tab corresponding to @ref ColorDialogPrivate::m_settings. */
void ColorDialog::showEvent(QShowEvent *event)
{
    if (!d_pointer->everShown) {
        constexpr auto expValue = ColorDialog::DialogLayoutDimensions::Expanded;
        const bool exp = d_pointer->m_layoutDimensionsEffective == expValue;
        const auto tabString = exp //
            ? d_pointer->m_settings.tabExpanded.value() //
            : d_pointer->m_settings.tab.value();
        const auto key = d_pointer->m_tabTable.key(tabString, nullptr);
        if (key != nullptr) {
            d_pointer->m_tabWidget->setCurrentWidget(*key);
        }
        // Save the new tab explicitly. If setCurrentWidget() is not
        // different from the default value, it does not trigger the
        // QTabWidget::currentChanged() signal, resulting in the tab
        // not being saved. However, we want to ensure that the tab
        // is saved whenever the user has first seen it.
        d_pointer->saveCurrentTab();
 
        switch (d_pointer->m_settings.swatchBookPage.value()) {
        case PerceptualSettings::SwatchBookPage::BasicColors:
        default:
            d_pointer->m_settings.swatchBookPage.setValue( //
                PerceptualSettings::SwatchBookPage::BasicColors);
            d_pointer->m_swatchBookSelector->setCurrentIndex(0);
            d_pointer->m_swatchBookStack->setCurrentIndex(0);
            break;
        case PerceptualSettings::SwatchBookPage::History:
            d_pointer->m_settings.swatchBookPage.setValue( //
                PerceptualSettings::SwatchBookPage::History);
            d_pointer->m_swatchBookSelector->setCurrentIndex(1);
            d_pointer->m_swatchBookStack->setCurrentIndex(1);
            break;
        case PerceptualSettings::SwatchBookPage::CustomColors:
            d_pointer->m_settings.swatchBookPage.setValue( //
                PerceptualSettings::SwatchBookPage::History);
            d_pointer->m_swatchBookSelector->setCurrentIndex(2);
            d_pointer->m_swatchBookStack->setCurrentIndex(2);
            break;
        }
 
        d_pointer->everShown = true;
    }
    QDialog::showEvent(event);
}
 
/** @brief Saves the current tab of @ref m_tabWidget to @ref m_settings. */
void ColorDialogPrivate::saveCurrentTab()
{
    const auto currentIndex = m_tabWidget->currentIndex();
    QWidget const *const widget = m_tabWidget->widget(currentIndex);
    const auto keyList = m_tabTable.keys();
    auto it = std::find_if( //
        keyList.begin(),
        keyList.end(),
        [widget](const auto &key) {
            return ((*key) == widget);
        } //
    );
    if (it != keyList.end()) {
        const auto tabString = m_tabTable.value(*it);
        constexpr auto expValue = ColorDialog::DialogLayoutDimensions::Expanded;
        if (m_layoutDimensionsEffective == expValue) {
            m_settings.tabExpanded.setValue(tabString);
        } else {
            m_settings.tab.setValue(tabString);
        }
    }
}
 
/** @brief Loads @ref PerceptualSettings::history into
 * @ref m_swatchBookHistory. */
void ColorDialogPrivate::loadHistoryFromSettingsToSwatchBook()
{
    const Swatches historyArray(historyHSwatchCount, //
                                historyVSwatchCount, //
                                m_settings.history.value());
    m_swatchBookHistory->setSwatchGrid(historyArray);
}
 
/** @brief Loads @ref PerceptualSettings::customColors into
 * @ref m_swatchBookCustomColors. */
void ColorDialogPrivate::loadCustomColorsFromSettingsToSwatchBook()
{
    const Swatches customColorsArray(customColorsHSwatchCount, //
                                     customColorsVSwatchCount, //
                                     m_settings.customColors.value());
    m_swatchBookCustomColors->setSwatchGrid(customColorsArray);
}
 
} // namespace PerceptualColor