ColorSettingsTab Class Reference

#include <kis_dlg_preferences.h>

Inheritance diagram for ColorSettingsTab:

Public Types
using	CanvasSurfaceBitDepthMode = KisConfig::CanvasSurfaceBitDepthMode
using	CanvasSurfaceMode = KisConfig::CanvasSurfaceMode
enum	PreferredSpaceType { PreferredSpace , MasteringSpace }

Public Member Functions
	ColorSettingsTab (QWidget *parent=0, const char *name=0)
void	setDefault ()

Public Attributes
QPointer< KisSqueezedComboBox >	m_canvasSurfaceBitDepth
QPointer< KisSqueezedComboBox >	m_canvasSurfaceColorSpace
QPointer< QCheckBox >	m_chkEnableCanvasColorSpaceManagement
bool	m_colorManagedByOS {false}
QList< QLabel * >	m_monitorProfileLabels
QList< KisSqueezedComboBox * >	m_monitorProfileWidgets
WdgColorSettings *	m_page
QButtonGroup	m_pasteBehaviourGroup
QPointer< KisCIETongueWidget >	m_preferredSpaceGraphic
QButtonGroup	m_preferredSpaceGraphicMode
QScopedPointer< KisProofingConfigModel >	m_proofModel
QScopedPointer< KisScreenMigrationTracker >	m_screenMigrationTracker

Private Slots
void	installProfile ()
void	refillMonitorProfiles (const KoID &s)
void	toggleAllowMonitorProfileSelection (bool useSystemProfile)
void	toggleUseDefaultColorSpace (bool useDefColorSpace)
void	updatePreferredSpaceGraphic ()
void	updateProofingDisplayInfo ()

Detailed Description

Definition at line 190 of file kis_dlg_preferences.h.

Member Typedef Documentation

CanvasSurfaceBitDepthMode

using ColorSettingsTab::CanvasSurfaceBitDepthMode = KisConfig::CanvasSurfaceBitDepthMode

Definition at line 224 of file kis_dlg_preferences.h.

CanvasSurfaceMode

using ColorSettingsTab::CanvasSurfaceMode = KisConfig::CanvasSurfaceMode

Definition at line 223 of file kis_dlg_preferences.h.

Member Enumeration Documentation

PreferredSpaceType

enum ColorSettingsTab::PreferredSpaceType

Enumerator
PreferredSpace
MasteringSpace

Definition at line 198 of file kis_dlg_preferences.h.

                            {
        PreferredSpace,
        MasteringSpace
    };

Constructor & Destructor Documentation

ColorSettingsTab()

ColorSettingsTab::ColorSettingsTab	(	QWidget *	parent = 0,
		const char *	name = 0 )

Default proofing config

Definition at line 1215 of file kis_dlg_preferences.cc.

    : QWidget(parent)
    , m_proofModel(new KisProofingConfigModel())
{
    setObjectName(name);
 
    // XXX: Make sure only profiles that fit the specified color model
    // are shown in the profile combos
 
    QGridLayout * l = new QGridLayout(this);
    l->setContentsMargins(0, 0, 0, 0);
    m_page = new WdgColorSettings(this);
    l->addWidget(m_page, 0, 0);
 
    KisConfig cfg(true);
 
    m_colorManagedByOS = KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS();
 
    if (!m_colorManagedByOS) {
        m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
        connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
    }
    m_page->chkUseSystemMonitorProfile->setVisible(!m_colorManagedByOS);
 
    m_page->useDefColorSpace->setChecked(cfg.useDefaultColorSpace());
    connect(m_page->useDefColorSpace, SIGNAL(toggled(bool)), this, SLOT(toggleUseDefaultColorSpace(bool)));
    QList<KoID> colorSpaces = KoColorSpaceRegistry::instance()->listKeys();
    for (QList<KoID>::iterator id = colorSpaces.begin(); id != colorSpaces.end(); /* nop */) {
        if (KoColorSpaceRegistry::instance()->colorSpaceColorModelId(id->id()) == AlphaColorModelID) {
            id = colorSpaces.erase(id);
        } else {
            ++id;
        }
    }
    m_page->cmbWorkingColorSpace->setIDList(colorSpaces);
    m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
    m_page->cmbWorkingColorSpace->setEnabled(cfg.useDefaultColorSpace());
 
    if (!m_colorManagedByOS) {
        m_page->bnAddColorProfile->setIcon(koIcon("document-import-16"));
        connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
    }
    m_page->bnAddColorProfile->setVisible(!m_colorManagedByOS);
 
    {
        QStringList profiles;
        QMap<QString, const KoColorProfile *>  profileList;
        Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(RGBAColorModelID.id())) {
            profileList[profile->name()] = profile;
            profiles.append(profile->name());
        }
 
        std::sort(profiles.begin(), profiles.end());
        Q_FOREACH (const QString profile, profiles) {
            m_page->cmbColorProfileForEXR->addSqueezedItem(profile);
        }
 
        const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(RGBAColorModelID.id(), Float16BitsColorDepthID.id());
        const QString defaultProfile = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId);
        const QString userProfile = cfg.readEntry("ExrDefaultColorProfile", defaultProfile);
 
        m_page->cmbColorProfileForEXR->setCurrent(profiles.contains(userProfile) ? userProfile : defaultProfile);
    }
 
 
    if (!m_colorManagedByOS) {
        QFormLayout *monitorProfileGrid = new QFormLayout(m_page->monitorprofileholder);
        monitorProfileGrid->setContentsMargins(0, 0, 0, 0);
        for(int i = 0; i < QGuiApplication::screens().count(); ++i) {
            QLabel *lbl = new QLabel(i18nc("The number of the screen (ordinal) and shortened 'name' of the screen (model + resolution)", "Screen %1 (%2):", i + 1, shortNameOfDisplay(i)));
            lbl->setWordWrap(true);
            m_monitorProfileLabels << lbl;
            KisSqueezedComboBox *cmb = new KisSqueezedComboBox();
            cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
            monitorProfileGrid->addRow(lbl, cmb);
            m_monitorProfileWidgets << cmb;
        }
 
        // disable if not Linux as KisColorManager is not yet implemented outside Linux
#ifndef Q_OS_LINUX
        m_page->chkUseSystemMonitorProfile->setChecked(false);
        m_page->chkUseSystemMonitorProfile->setDisabled(true);
        m_page->chkUseSystemMonitorProfile->setHidden(true);
#endif
 
        refillMonitorProfiles(KoID("RGBA"));
 
        for(int i = 0; i < QApplication::screens().count(); ++i) {
            if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
            }
        }
    } else {
        QVBoxLayout *vboxLayout = new QVBoxLayout(m_page->monitorprofileholder);
        vboxLayout->setContentsMargins(0, 0, 0, 0);
        vboxLayout->addItem(new QSpacerItem(20,20));
 
        QGroupBox *groupBox = new QGroupBox(i18n("Display's color space is managed by the operating system"));
        vboxLayout->addWidget(groupBox);
 
        QFormLayout *monitorProfileGrid = new QFormLayout(groupBox);
        monitorProfileGrid->setContentsMargins(0, 0, 0, 0);
 
        m_chkEnableCanvasColorSpaceManagement =
            new QCheckBox(i18n("Enable canvas color management"), this);
 
        m_chkEnableCanvasColorSpaceManagement->setToolTip(
            i18n("<p>Enabling canvas color management automatically creates "
                 "a separate native surface for the canvas. It might cause "
                 "performance issues on some systems.</p>"
                 ""
                 "<p>If color management is disabled, Krita will render "
                 "the canvas into the surface of the main window, which "
                 "is considered sRGB. It will cause two limitations:"
                 ""
                 "<ol>"
                 "    <li>the color gamut will be limited to sRGB</li>"
                 "    <li>color proofing mode will be limited to \"use global display settings\", "
                 "        i.e. paper white proofing will become impossible</li>"
                 "</ol>"
                "</p>"));
 
        monitorProfileGrid->addRow(m_chkEnableCanvasColorSpaceManagement);
 
        // surface color space
        m_canvasSurfaceColorSpace = new KisSqueezedComboBox();
            m_canvasSurfaceColorSpace->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
        QLabel *canvasSurfaceColorSpaceLbl = new QLabel(i18n("Canvas surface color space:"), this);
        monitorProfileGrid->addRow(canvasSurfaceColorSpaceLbl, m_canvasSurfaceColorSpace);
 
        m_canvasSurfaceColorSpace->addSqueezedItem(i18n("Preferred by operating system"), QVariant::fromValue(CanvasSurfaceMode::Preferred));
        m_canvasSurfaceColorSpace->addSqueezedItem(i18n("Rec 709 Gamma 2.2"), QVariant::fromValue(CanvasSurfaceMode::Rec709g22));
        m_canvasSurfaceColorSpace->addSqueezedItem(i18n("Rec 709 Linear"), QVariant::fromValue(CanvasSurfaceMode::Rec709g10));
        m_canvasSurfaceColorSpace->addSqueezedItem(i18n("Rec 2020 PQ"), QVariant::fromValue(CanvasSurfaceMode::Rec2020pq));
        m_canvasSurfaceColorSpace->addSqueezedItem(i18n("Unmanaged (testing only)"), QVariant::fromValue(CanvasSurfaceMode::Unmanaged));
 
        m_canvasSurfaceColorSpace->setToolTip(
            i18n("<p>Color space of the pixels that are transferred to the "
                 "window compositor. Use \"preferred\" space unless you know "
                 "what you are doing</p>"));
 
        // surface bit depth
        m_canvasSurfaceBitDepth = new KisSqueezedComboBox();
            m_canvasSurfaceBitDepth->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
        QLabel *canvasSurfaceBitDepthLbl = new QLabel(i18n("Canvas surface bit depth (needs restart):"), this);
        monitorProfileGrid->addRow(canvasSurfaceBitDepthLbl, m_canvasSurfaceBitDepth);
 
        m_canvasSurfaceBitDepth->addSqueezedItem(i18n("Auto"), QVariant::fromValue(CanvasSurfaceBitDepthMode::DepthAuto));
        m_canvasSurfaceBitDepth->addSqueezedItem(i18n("8-bit"), QVariant::fromValue(CanvasSurfaceBitDepthMode::Depth8Bit));
        m_canvasSurfaceBitDepth->addSqueezedItem(i18n("10-bit"), QVariant::fromValue(CanvasSurfaceBitDepthMode::Depth10Bit));
 
        m_canvasSurfaceBitDepth->setToolTip(
            i18n("<p>The bit depth of the color that is passed to the window "
                 "compositor. You should switch into 10-bit mode if you want to use "
                 "HDR capabilities of your display</p>"));
 
        const QString currentBitBepthString = QSurfaceFormat::defaultFormat().redBufferSize() == 10 ? i18n("10-bit") : i18n("8-bit");
        QLabel *currentCanvasSurfaceBitDepthLbl = new QLabel(i18n("Current canvas surface bit depth:"), this);
        QLabel *currentCanvasSurfaceBitDepth = new QLabel(currentBitBepthString, this);
        monitorProfileGrid->addRow(currentCanvasSurfaceBitDepthLbl, currentCanvasSurfaceBitDepth);
 
        vboxLayout->addItem(new QSpacerItem(20,20));
 
        KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
        QTextBrowser *preferredLbl = new QTextBrowser(this);
        preferredLbl->setText(i18n("Color space preferred by the operating system:\n%1", KisPlatformPluginInterfaceFactory::instance()->osPreferredColorSpaceReport(mainWindow)));
        preferredLbl->setReadOnly(true);
 
        QHBoxLayout *colorDescriptionChoice = new QHBoxLayout();
        vboxLayout->addLayout(colorDescriptionChoice);
 
        QLabel *descriptionChoiceLabel =  new QLabel(i18n("Diagram:"));
        colorDescriptionChoice->addWidget(descriptionChoiceLabel);
 
        QRadioButton *containerSpace = new QRadioButton(i18nc("@info:radiobutton", "Preferred Space"), this);
        colorDescriptionChoice->addWidget(containerSpace);
        containerSpace->setToolTip(i18nc("@info:tooltip", "This is the space preferred by the operating system."));
        m_preferredSpaceGraphicMode.addButton(containerSpace, PreferredSpace);
 
        QRadioButton *masteringSpace = new QRadioButton(i18nc("@info:radiobutton", "Current Display"), this);
        colorDescriptionChoice->addWidget(masteringSpace);
        m_preferredSpaceGraphicMode.addButton(masteringSpace, MasteringSpace);
        masteringSpace->setToolTip(i18nc("@info:tooltip", "This is the space representing the currently active display."));
 
        QHBoxLayout *colorDescriptionLayout = new QHBoxLayout();
        vboxLayout->addLayout(colorDescriptionLayout);
        m_preferredSpaceGraphic = new KisCIETongueWidget(this);
        colorDescriptionLayout->addWidget(m_preferredSpaceGraphic);
        colorDescriptionLayout->addWidget(preferredLbl);
 
        containerSpace->setChecked(true);
        colorDescriptionChoice->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
 
        m_preferredSpaceGraphic->setFixedSize(QSize(200, 200));
        updatePreferredSpaceGraphic();
        connect(&m_preferredSpaceGraphicMode, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(updatePreferredSpaceGraphic()));
        m_screenMigrationTracker.reset(new KisScreenMigrationTracker(this));
        connect(m_screenMigrationTracker.data(), &KisScreenMigrationTracker::sigScreenChanged,
                this, &ColorSettingsTab::updatePreferredSpaceGraphic);
 
        m_chkEnableCanvasColorSpaceManagement->setChecked(cfg.enableCanvasSurfaceColorSpaceManagement());
 
        {
            auto mode = cfg.canvasSurfaceColorSpaceManagementMode();
            int index = m_canvasSurfaceColorSpace->findData(QVariant::fromValue(mode));
            KIS_SAFE_ASSERT_RECOVER(index >= 0) {
                index = 0;
            }
            m_canvasSurfaceColorSpace->setCurrentIndex(index);
        }
 
        {
            auto mode = cfg.canvasSurfaceBitDepthMode();
            int index = m_canvasSurfaceBitDepth->findData(QVariant::fromValue(mode));
            KIS_SAFE_ASSERT_RECOVER(index >= 0) {
                index = 0;
            }
            m_canvasSurfaceBitDepth->setCurrentIndex(index);
        }
 
        connect(m_chkEnableCanvasColorSpaceManagement, &QCheckBox::toggled, m_canvasSurfaceColorSpace, &QWidget::setEnabled);
        m_canvasSurfaceColorSpace->setEnabled(m_chkEnableCanvasColorSpaceManagement->isChecked());
 
        connect(m_chkEnableCanvasColorSpaceManagement, &QCheckBox::toggled, canvasSurfaceColorSpaceLbl, &QWidget::setEnabled);
        canvasSurfaceColorSpaceLbl->setEnabled(m_chkEnableCanvasColorSpaceManagement->isChecked());
 
        connect(m_chkEnableCanvasColorSpaceManagement, &QCheckBox::toggled, m_canvasSurfaceBitDepth, &QWidget::setEnabled);
        m_canvasSurfaceBitDepth->setEnabled(m_chkEnableCanvasColorSpaceManagement->isChecked());
 
        connect(m_chkEnableCanvasColorSpaceManagement, &QCheckBox::toggled, canvasSurfaceBitDepthLbl, &QWidget::setEnabled);
        canvasSurfaceBitDepthLbl->setEnabled(m_chkEnableCanvasColorSpaceManagement->isChecked());
    }
 
    m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
    m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
    m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors());
    m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
    KisImageConfig cfgImage(true);
 
    KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
 
    m_page->wdgProofingOptions->setProofingConfig(proofingConfig);
 
    m_proofModel->data.set(*proofingConfig.data());
 
    connect(m_page->chkBlackpoint, SIGNAL(toggled(bool)), this, SLOT(updateProofingDisplayInfo()));
    connect(m_page->cmbMonitorIntent, SIGNAL(currentIndexChanged(int)), this, SLOT(updateProofingDisplayInfo()));
    updateProofingDisplayInfo();
 
    m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, KisClipboard::PASTE_ASSUME_WEB);
    m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, KisClipboard::PASTE_ASSUME_MONITOR);
    m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, KisClipboard::PASTE_ASK);
 
    QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
    Q_ASSERT(button);
 
    if (button) {
        button->setChecked(true);
    }
 
    if (!m_colorManagedByOS) {
        toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
    }
}

References KisConfig::allowLCMSOptimization(), AlphaColorModelID, button(), KisConfig::canvasSurfaceBitDepthMode(), KisConfig::canvasSurfaceColorSpaceManagementMode(), KoColorSpaceRegistry::colorSpaceColorModelId(), KoColorSpaceRegistry::colorSpaceId(), KisPart::currentMainwindow(), KoColorSpaceRegistry::defaultProfileForColorSpace(), KisImageConfig::defaultProofingconfiguration(), KisConfig::enableCanvasSurfaceColorSpaceManagement(), Float16BitsColorDepthID, KisConfig::forcePaletteColors(), KoID::id(), installProfile(), KoColorSpaceRegistry::instance(), KisPart::instance(), KisPlatformPluginInterfaceFactory::instance(), KIS_SAFE_ASSERT_RECOVER, koIcon, KoColorSpaceRegistry::listKeys(), m_canvasSurfaceBitDepth, m_canvasSurfaceColorSpace, m_chkEnableCanvasColorSpaceManagement, m_colorManagedByOS, m_monitorProfileLabels, m_monitorProfileWidgets, m_page, m_pasteBehaviourGroup, m_preferredSpaceGraphic, m_preferredSpaceGraphicMode, m_proofModel, m_screenMigrationTracker, MasteringSpace, KisConfig::monitorProfile(), KisConfig::monitorRenderIntent(), KoColorProfile::name, KisClipboard::PASTE_ASK, KisClipboard::PASTE_ASSUME_MONITOR, KisClipboard::PASTE_ASSUME_WEB, KisConfig::pasteBehaviour(), PreferredSpace, KisConfig::readEntry(), refillMonitorProfiles(), RGBAColorModelID, shortNameOfDisplay(), KisScreenMigrationTracker::sigScreenChanged(), KisPlatformPluginInterfaceFactory::surfaceColorManagedByOS(), toggleAllowMonitorProfileSelection(), toggleUseDefaultColorSpace(), updatePreferredSpaceGraphic(), updateProofingDisplayInfo(), KisConfig::useBlackPointCompensation(), KisConfig::useDefaultColorSpace(), KisConfig::useSystemMonitorProfile(), and KisConfig::workingColorSpace().

Member Function Documentation

installProfile

void ColorSettingsTab::installProfile ( )

privateslot

Definition at line 1483 of file kis_dlg_preferences.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_colorManagedByOS);
 
    KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
    dialog.setCaption(i18n("Install Color Profiles"));
    dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
    dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
    QStringList profileNames = dialog.filenames();
 
    KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
    Q_ASSERT(iccEngine);
 
    QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
    Q_FOREACH (const QString &profileName, profileNames) {
        if (!QFile::copy(profileName, saveLocation + QFileInfo(profileName).fileName())) {
            qWarning() << "Could not install profile!" << saveLocation + QFileInfo(profileName).fileName();
            continue;
        }
        iccEngine->addProfile(saveLocation + QFileInfo(profileName).fileName());
    }
 
    KisConfig cfg(true);
    refillMonitorProfiles(KoID("RGBA"));
 
    for(int i = 0; i < QApplication::screens().count(); ++i) {
        if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
            m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
        }
    }
 
}

References KoColorSpaceEngine::addProfile(), KoGenericRegistry< T >::get(), KoColorSpaceEngineRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_colorManagedByOS, m_monitorProfileWidgets, KisConfig::monitorProfile(), KoFileDialog::OpenFiles, refillMonitorProfiles(), and KoResourcePaths::saveLocation().

refillMonitorProfiles

void ColorSettingsTab::refillMonitorProfiles ( const KoID & s )

privateslot

Definition at line 1608 of file kis_dlg_preferences.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_colorManagedByOS);
 
    for (int i = 0; i < QApplication::screens().count(); ++i) {
        m_monitorProfileWidgets[i]->clear();
    }
 
    QMap<QString, const KoColorProfile *>  profileList;
    Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId.id())) {
        profileList[profile->name()] = profile;
    }
 
    Q_FOREACH (const KoColorProfile *profile, profileList.values()) {
        //qDebug() << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
        if (profile->isSuitableForDisplay()) {
            for (int i = 0; i < QApplication::screens().count(); ++i) {
                m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
            }
        }
    }
 
    for (int i = 0; i < QApplication::screens().count(); ++i) {
        m_monitorProfileLabels[i]->setText(i18nc("The number of the screen (ordinal) and shortened 'name' of the screen (model + resolution)", "Screen %1 (%2):", i + 1, shortNameOfDisplay(i)));
        m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
    }
}

References KoColorSpaceRegistry::defaultProfileForColorSpace(), KoID::id(), KoColorSpaceRegistry::instance(), KoColorProfile::isSuitableForDisplay(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_colorManagedByOS, m_monitorProfileLabels, m_monitorProfileWidgets, KoColorProfile::name, and shortNameOfDisplay().

setDefault()

void ColorSettingsTab::setDefault

(

)

Definition at line 1555 of file kis_dlg_preferences.cc.

{
    m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(RGBAColorModelID.id(), Float16BitsColorDepthID.id());
    const QString defaultProfile = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId);
    m_page->cmbColorProfileForEXR->setCurrent(defaultProfile);
 
    KisConfig cfg(true);
 
    if (!m_colorManagedByOS) {
        refillMonitorProfiles(KoID("RGBA"));
    } else {
        m_chkEnableCanvasColorSpaceManagement->setChecked(cfg.enableCanvasSurfaceColorSpaceManagement(true));
 
        {
            auto mode = cfg.canvasSurfaceColorSpaceManagementMode(true);
            int index = m_canvasSurfaceColorSpace->findData(QVariant::fromValue(mode));
            KIS_SAFE_ASSERT_RECOVER(index >= 0) {
                index = 0;
            }
            m_canvasSurfaceColorSpace->setCurrentIndex(index);
        }
 
        {
            auto mode = cfg.canvasSurfaceBitDepthMode(true);
            int index = m_canvasSurfaceBitDepth->findData(QVariant::fromValue(mode));
            KIS_SAFE_ASSERT_RECOVER(index >= 0) {
                index = 0;
            }
            m_canvasSurfaceBitDepth->setCurrentIndex(index);
        }
    }
 
    KisImageConfig cfgImage(true);
    KisProofingConfigurationSP proofingConfig =  cfgImage.defaultProofingconfiguration(true);
    m_page->wdgProofingOptions->setProofingConfig(proofingConfig);
 
    m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation(true));
    m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization(true));
    m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors(true));
    m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent(true));
    if (!m_colorManagedByOS) {
        m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
    }
    QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
    Q_ASSERT(button);
    if (button) {
        button->setChecked(true);
    }
}

References KisConfig::allowLCMSOptimization(), button(), KisConfig::canvasSurfaceBitDepthMode(), KisConfig::canvasSurfaceColorSpaceManagementMode(), KoColorSpaceRegistry::colorSpaceId(), KoColorSpaceRegistry::defaultProfileForColorSpace(), KisImageConfig::defaultProofingconfiguration(), KisConfig::enableCanvasSurfaceColorSpaceManagement(), Float16BitsColorDepthID, KisConfig::forcePaletteColors(), KoID::id(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER, m_canvasSurfaceBitDepth, m_canvasSurfaceColorSpace, m_chkEnableCanvasColorSpaceManagement, m_colorManagedByOS, m_page, m_pasteBehaviourGroup, KisConfig::monitorRenderIntent(), KisConfig::pasteBehaviour(), refillMonitorProfiles(), RGBAColorModelID, KisConfig::useBlackPointCompensation(), and KisConfig::useSystemMonitorProfile().

toggleAllowMonitorProfileSelection

void ColorSettingsTab::toggleAllowMonitorProfileSelection ( bool useSystemProfile )

privateslot

Definition at line 1517 of file kis_dlg_preferences.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_colorManagedByOS);
 
    KisConfig cfg(true);
 
    if (useSystemProfile) {
        QStringList devices = KisColorManager::instance()->devices();
        if (devices.size() == QApplication::screens().count()) {
            for(int i = 0; i < QApplication::screens().count(); ++i) {
                m_monitorProfileWidgets[i]->clear();
                QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                Q_FOREACH (const QString &device, devices) {
                    m_monitorProfileLabels[i]->setText(i18nc("The number of the screen (ordinal) and shortened 'name' of the screen (model + resolution)", "Screen %1 (%2):", i + 1, shortNameOfDisplay(i)));
                    m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                    if (devices[i] == monitorForScreen) {
                        m_monitorProfileWidgets[i]->setCurrentIndex(i);
                    }
                }
            }
        }
    }
    else {
        refillMonitorProfiles(KoID("RGBA"));
 
        for(int i = 0; i < QApplication::screens().count(); ++i) {
            if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
            }
        }
    }
}

References KisColorManager::devices(), KisColorManager::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_colorManagedByOS, m_monitorProfileLabels, m_monitorProfileWidgets, KisConfig::monitorForScreen(), KisConfig::monitorProfile(), refillMonitorProfiles(), and shortNameOfDisplay().

toggleUseDefaultColorSpace

void ColorSettingsTab::toggleUseDefaultColorSpace ( bool useDefColorSpace )

privateslot

Definition at line 1550 of file kis_dlg_preferences.cc.

{
    m_page->cmbWorkingColorSpace->setEnabled(useDefColorSpace);
}

References m_page.

updatePreferredSpaceGraphic

void ColorSettingsTab::updatePreferredSpaceGraphic ( )

privateslot

Definition at line 1644 of file kis_dlg_preferences.cc.

{
    if (!m_preferredSpaceGraphic) return;
    if (!KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) return;
    KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
    QVector<double> colorants;
    QVector <double> whitePoint;
 
#ifdef Q_OS_LINUX
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    KisRootSurfaceInfoProxy proxy(mainWindow);
    std::optional<KisSurfaceColorimetry::SurfaceDescription> currentDescription = proxy.currentSurfaceDescription();
    if (m_preferredSpaceGraphicMode.checkedId() == PreferredSpace) {
        if (currentDescription) {
            if (std::holds_alternative<KisSurfaceColorimetry::Colorimetry>(currentDescription->colorSpace.primaries)) {
                auto col = std::get<KisSurfaceColorimetry::Colorimetry>(currentDescription->colorSpace.primaries);
                colorants << col.red().toxy().x << col.red().toxy().y << col.red().toxyY().Y
                          << col.green().toxy().x << col.green().toxy().y << col.green().toxyY().Y
                          << col.blue().toxy().x << col.blue().toxy().y << col.blue().toxyY().Y;
                whitePoint << col.white().toxy().x << col.white().toxy().y << col.white().toxyY().Y;
                m_preferredSpaceGraphic->setRGBData(whitePoint, colorants);
            } else {
                bool enable = true;
                auto named = std::get<KisSurfaceColorimetry::NamedPrimaries>(currentDescription->colorSpace.primaries);
                KisSurfaceColorimetry::Colorimetry col = KisColorimetryUtils::Colorimetry::BT709;
                if (named == KisSurfaceColorimetry::NamedPrimaries::primaries_srgb) {
                    col = KisColorimetryUtils::Colorimetry::BT709;
                } else if (named == KisSurfaceColorimetry::NamedPrimaries::primaries_adobe_rgb) {
                    col = KisColorimetryUtils::Colorimetry::AdobeRGB;
                } else if (named == KisSurfaceColorimetry::NamedPrimaries::primaries_bt2020) {
                    col = KisColorimetryUtils::Colorimetry::BT2020;
                } else if (named == KisSurfaceColorimetry::NamedPrimaries::primaries_dci_p3) {
                    col = KisColorimetryUtils::Colorimetry::DCIP3;
                } else if (named == KisSurfaceColorimetry::NamedPrimaries::primaries_display_p3) {
                    col = KisColorimetryUtils::Colorimetry::DisplayP3;
                } else {
                    enable = false;
                }
 
                if (enable) {
                    colorants << col.red().toxy().x << col.red().toxy().y << col.red().toxyY().Y
                              << col.green().toxy().x << col.green().toxy().y << col.green().toxyY().Y
                              << col.blue().toxy().x << col.blue().toxy().y << col.blue().toxyY().Y;
                    whitePoint << col.white().toxy().x << col.white().toxy().y << col.white().toxyY().Y;
                    m_preferredSpaceGraphic->setRGBData(whitePoint, colorants);
                } else {
                    m_preferredSpaceGraphic->setProfileDataAvailable(false);
                }
 
            }
        } else {
             m_preferredSpaceGraphic->setProfileDataAvailable(false);
        }
    } else if(m_preferredSpaceGraphicMode.checkedId() == MasteringSpace) {
        if (currentDescription && currentDescription->masteringInfo) {
            auto col = currentDescription->masteringInfo->primaries;
            colorants << col.red().toxy().x << col.red().toxy().y << col.red().toxyY().Y
                      << col.green().toxy().x << col.green().toxy().y << col.green().toxyY().Y
                      << col.blue().toxy().x << col.blue().toxy().y << col.blue().toxyY().Y;
            whitePoint << col.white().toxy().x << col.white().toxy().y << col.white().toxyY().Y;
 
            m_preferredSpaceGraphic->setRGBData(whitePoint, colorants);
        } else {
            m_preferredSpaceGraphic->setProfileDataAvailable(false);
        }
    }
#endif
#endif
    m_preferredSpaceGraphic->update();
}

References KisColorimetryUtils::Colorimetry::AdobeRGB, KisColorimetryUtils::Colorimetry::blue(), KisColorimetryUtils::Colorimetry::BT2020, KisColorimetryUtils::Colorimetry::BT709, KisPart::currentMainwindow(), KisRootSurfaceInfoProxy::currentSurfaceDescription(), KisColorimetryUtils::Colorimetry::DCIP3, KisColorimetryUtils::Colorimetry::DisplayP3, KisColorimetryUtils::Colorimetry::green(), KisPart::instance(), KisPlatformPluginInterfaceFactory::instance(), m_preferredSpaceGraphic, m_preferredSpaceGraphicMode, MasteringSpace, PreferredSpace, KisSurfaceColorimetry::primaries_adobe_rgb, KisSurfaceColorimetry::primaries_bt2020, KisSurfaceColorimetry::primaries_dci_p3, KisSurfaceColorimetry::primaries_display_p3, KisSurfaceColorimetry::primaries_srgb, KisColorimetryUtils::Colorimetry::red(), KisColorimetryUtils::XYZ::toxy(), KisColorimetryUtils::XYZ::toxyY(), KisColorimetryUtils::Colorimetry::white(), KisColorimetryUtils::xy::x, KisColorimetryUtils::xy::y, and KisColorimetryUtils::xyY::Y.

updateProofingDisplayInfo

void ColorSettingsTab::updateProofingDisplayInfo ( )

privateslot

Definition at line 1636 of file kis_dlg_preferences.cc.

                                                 {
    KisDisplayConfig::Options options;
    options.first = KoColorConversionTransformation::Intent(m_page->cmbMonitorIntent->currentIndex());
    options.second = KoColorConversionTransformation::internalConversionFlags();
    options.second.setFlag(KoColorConversionTransformation::BlackpointCompensation, m_page->chkBlackpoint->isChecked());
    m_page->wdgProofingOptions->setDisplayConfigOptions(options);
}

References KoColorConversionTransformation::BlackpointCompensation, KoColorConversionTransformation::internalConversionFlags(), and m_page.

Member Data Documentation

m_canvasSurfaceBitDepth

QPointer<KisSqueezedComboBox> ColorSettingsTab::m_canvasSurfaceBitDepth

Definition at line 229 of file kis_dlg_preferences.h.

m_canvasSurfaceColorSpace

QPointer<KisSqueezedComboBox> ColorSettingsTab::m_canvasSurfaceColorSpace

Definition at line 228 of file kis_dlg_preferences.h.

m_chkEnableCanvasColorSpaceManagement

QPointer<QCheckBox> ColorSettingsTab::m_chkEnableCanvasColorSpaceManagement

Definition at line 227 of file kis_dlg_preferences.h.

m_colorManagedByOS

bool ColorSettingsTab::m_colorManagedByOS {false}

Definition at line 226 of file kis_dlg_preferences.h.

{false};

m_monitorProfileLabels

QList<QLabel*> ColorSettingsTab::m_monitorProfileLabels

Definition at line 218 of file kis_dlg_preferences.h.

m_monitorProfileWidgets

QList<KisSqueezedComboBox*> ColorSettingsTab::m_monitorProfileWidgets

Definition at line 219 of file kis_dlg_preferences.h.

m_page

WdgColorSettings* ColorSettingsTab::m_page

Definition at line 216 of file kis_dlg_preferences.h.

m_pasteBehaviourGroup

QButtonGroup ColorSettingsTab::m_pasteBehaviourGroup

Definition at line 217 of file kis_dlg_preferences.h.

m_preferredSpaceGraphic

QPointer<KisCIETongueWidget> ColorSettingsTab::m_preferredSpaceGraphic

Definition at line 230 of file kis_dlg_preferences.h.

m_preferredSpaceGraphicMode

QButtonGroup ColorSettingsTab::m_preferredSpaceGraphicMode

Definition at line 231 of file kis_dlg_preferences.h.

m_proofModel

QScopedPointer<KisProofingConfigModel> ColorSettingsTab::m_proofModel

Definition at line 220 of file kis_dlg_preferences.h.

m_screenMigrationTracker

QScopedPointer<KisScreenMigrationTracker> ColorSettingsTab::m_screenMigrationTracker

Definition at line 221 of file kis_dlg_preferences.h.

---

The documentation for this class was generated from the following files:

• libs/ui/dialogs/kis_dlg_preferences.h
• libs/ui/dialogs/kis_dlg_preferences.cc