#include <kis_dlg_preferences.h>

Inheritance diagram for ColorSettingsTab:

Public Types
using	CanvasSurfaceBitDepthMode = KisConfig::CanvasSurfaceBitDepthMode

using	CanvasSurfaceMode = KisConfig::CanvasSurfaceMode

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

QScopedPointer< KisProofingConfigModel >	m_proofModel

Private Slots
void	installProfile ()

void	refillMonitorProfiles (const KoID &s)

void	toggleAllowMonitorProfileSelection (bool useSystemProfile)

void	toggleUseDefaultColorSpace (bool useDefColorSpace)

void	updateProofingDisplayInfo ()

Detailed Description

Definition at line 188 of file kis_dlg_preferences.h.

Member Typedef Documentation

◆ CanvasSurfaceBitDepthMode

using ColorSettingsTab::CanvasSurfaceBitDepthMode = KisConfig::CanvasSurfaceBitDepthMode

Definition at line 214 of file kis_dlg_preferences.h.

◆ CanvasSurfaceMode

using ColorSettingsTab::CanvasSurfaceMode = KisConfig::CanvasSurfaceMode

Definition at line 213 of file kis_dlg_preferences.h.

Constructor & Destructor Documentation

◆ ColorSettingsTab()

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

Default proofing config

Definition at line 1206 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();
        QLabel *preferredLbl = new QLabel(i18n("Color space preferred by the operating system:\n%1", KisPlatformPluginInterfaceFactory::instance()->osPreferredColorSpaceReport(mainWindow)), this);
        vboxLayout->addWidget(preferredLbl);
 
        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_proofModel, KisConfig::monitorProfile(), KisConfig::monitorRenderIntent(), KoColorProfile::name, KisClipboard::PASTE_ASK, KisClipboard::PASTE_ASSUME_MONITOR, KisClipboard::PASTE_ASSUME_WEB, KisConfig::pasteBehaviour(), KisConfig::readEntry(), refillMonitorProfiles(), RGBAColorModelID, shortNameOfDisplay(), KisPlatformPluginInterfaceFactory::surfaceColorManagedByOS(), toggleAllowMonitorProfileSelection(), toggleUseDefaultColorSpace(), updateProofingDisplayInfo(), KisConfig::useBlackPointCompensation(), KisConfig::useDefaultColorSpace(), KisConfig::useSystemMonitorProfile(), and KisConfig::workingColorSpace().

Member Function Documentation

◆ installProfile

void ColorSettingsTab::installProfile ( )

privateslot

Definition at line 1441 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 1566 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 1513 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 1475 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 1508 of file kis_dlg_preferences.cc.

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

References m_page.

◆ updateProofingDisplayInfo

void ColorSettingsTab::updateProofingDisplayInfo ( )

privateslot

Definition at line 1594 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 219 of file kis_dlg_preferences.h.

◆ m_canvasSurfaceColorSpace

QPointer<KisSqueezedComboBox> ColorSettingsTab::m_canvasSurfaceColorSpace

Definition at line 218 of file kis_dlg_preferences.h.

◆ m_chkEnableCanvasColorSpaceManagement

QPointer<QCheckBox> ColorSettingsTab::m_chkEnableCanvasColorSpaceManagement

Definition at line 217 of file kis_dlg_preferences.h.

◆ m_colorManagedByOS

bool ColorSettingsTab::m_colorManagedByOS {false}

Definition at line 216 of file kis_dlg_preferences.h.

216{false};

◆ m_monitorProfileLabels

QList<QLabel*> ColorSettingsTab::m_monitorProfileLabels

Definition at line 209 of file kis_dlg_preferences.h.

◆ m_monitorProfileWidgets

QList<KisSqueezedComboBox*> ColorSettingsTab::m_monitorProfileWidgets

Definition at line 210 of file kis_dlg_preferences.h.

◆ m_page

WdgColorSettings* ColorSettingsTab::m_page

Definition at line 207 of file kis_dlg_preferences.h.

◆ m_pasteBehaviourGroup

QButtonGroup ColorSettingsTab::m_pasteBehaviourGroup

Definition at line 208 of file kis_dlg_preferences.h.

◆ m_proofModel

QScopedPointer<KisProofingConfigModel> ColorSettingsTab::m_proofModel

Definition at line 211 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

Public Types

Public Member Functions

Public Attributes

Private Slots

Detailed Description

Member Typedef Documentation

◆ CanvasSurfaceBitDepthMode

◆ CanvasSurfaceMode

Constructor & Destructor Documentation

◆ ColorSettingsTab()

Member Function Documentation

◆ installProfile

◆ refillMonitorProfiles

◆ setDefault()

◆ toggleAllowMonitorProfileSelection

◆ toggleUseDefaultColorSpace

◆ updateProofingDisplayInfo

Member Data Documentation

◆ m_canvasSurfaceBitDepth

◆ m_canvasSurfaceColorSpace

◆ m_chkEnableCanvasColorSpaceManagement

◆ m_colorManagedByOS

◆ m_monitorProfileLabels

◆ m_monitorProfileWidgets

◆ m_page

◆ m_pasteBehaviourGroup

◆ m_proofModel