DisplaySettingsTab Class Reference

#include <kis_dlg_preferences.h>

Inheritance diagram for DisplaySettingsTab:

Public Member Functions
	DisplaySettingsTab (QWidget *parent=0, const char *name=0)
void	setDefault ()
Public Member Functions inherited from WdgDisplaySettings
	WdgDisplaySettings (QWidget *parent, const char *name)

Protected Slots
void	slotPreferredSurfaceFormatChanged (int index)
void	slotUseOpenGLToggled (bool isChecked)

Detailed Description

Display settings tab for preferences dialog

Definition at line 312 of file kis_dlg_preferences.h.

Constructor & Destructor Documentation

DisplaySettingsTab()

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

We hide the HDR page in Wayland mode, because the mode is managed by a different page. We still keep the disabled tab visible on other systems just to promote the existence of this feature.

Definition at line 2070 of file kis_dlg_preferences.cc.

    : WdgDisplaySettings(parent, name)
{
    KisConfig cfg(true);
 
    const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL");
    const QString rendererSoftwareText = i18nc("canvas renderer", "Software Renderer (very slow)");
#ifdef Q_OS_WIN
    const QString rendererOpenGLESText =
        qEnvironmentVariable("QT_ANGLE_PLATFORM") != "opengl"
        ? i18nc("canvas renderer", "Direct3D 11 via ANGLE")
        : i18nc("canvas renderer", "OpenGL via ANGLE");
#else
    const QString rendererOpenGLESText = i18nc("canvas renderer", "OpenGL ES");
#endif
 
    const KisOpenGL::OpenGLRenderer renderer = KisOpenGL::getCurrentOpenGLRenderer();
    lblCurrentRenderer->setText(renderer == KisOpenGL::RendererOpenGLES ? rendererOpenGLESText :
                                renderer == KisOpenGL::RendererDesktopGL ? rendererOpenGLText :
                                renderer == KisOpenGL::RendererSoftware ? rendererSoftwareText :
                                i18nc("canvas renderer", "Unknown"));
 
    cmbPreferredRenderer->clear();
 
    const KisOpenGL::OpenGLRenderers supportedRenderers = KisOpenGL::getSupportedOpenGLRenderers();
    const bool onlyOneRendererSupported =
        supportedRenderers == KisOpenGL::RendererDesktopGL ||
        supportedRenderers == KisOpenGL::RendererOpenGLES ||
        supportedRenderers == KisOpenGL::RendererSoftware;
 
 
    if (!onlyOneRendererSupported) {
        QString qtPreferredRendererText;
        if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererOpenGLES) {
            qtPreferredRendererText = rendererOpenGLESText;
        } else if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererSoftware) {
            qtPreferredRendererText = rendererSoftwareText;
        } else {
            qtPreferredRendererText = rendererOpenGLText;
        }
        cmbPreferredRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto);
        cmbPreferredRenderer->setCurrentIndex(0);
    } else {
        cmbPreferredRenderer->setEnabled(false);
    }
 
    if (supportedRenderers & KisOpenGL::RendererDesktopGL) {
        cmbPreferredRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL);
        if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) {
            cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
        }
    }
 
    if (supportedRenderers & KisOpenGL::RendererOpenGLES) {
        cmbPreferredRenderer->addItem(rendererOpenGLESText, KisOpenGL::RendererOpenGLES);
        if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererOpenGLES) {
            cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
        }
    }
 
    if (supportedRenderers & KisOpenGL::RendererSoftware) {
        cmbPreferredRenderer->addItem(rendererSoftwareText, KisOpenGL::RendererSoftware);
        if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererSoftware) {
            cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
        }
    }
 
    if (!(supportedRenderers &
          (KisOpenGL::RendererDesktopGL |
           KisOpenGL::RendererOpenGLES |
           KisOpenGL::RendererSoftware))) {
 
        grpOpenGL->setEnabled(false);
        grpOpenGL->setChecked(false);
        chkUseTextureBuffer->setEnabled(false);
        cmbAssistantsDrawMode->setEnabled(false);
        cmbFilterMode->setEnabled(false);
    } else {
        grpOpenGL->setEnabled(true);
        grpOpenGL->setChecked(cfg.useOpenGL());
        chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
        chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
        cmbAssistantsDrawMode->setEnabled(cfg.useOpenGL());
        cmbAssistantsDrawMode->setCurrentIndex(assistantDrawModeToIndex(cfg.assistantsDrawMode()));
        cmbFilterMode->setEnabled(cfg.useOpenGL());
        cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode());
        // Don't show the high quality filtering mode if it's not available
        if (!KisOpenGL::supportsLoD()) {
            cmbFilterMode->removeItem(3);
        }
    }
 
    {
        std::optional<KisOpenGL::XcbGLProviderProtocol> currentXcbGlProvider = KisOpenGL::xcbGlProviderProtocol();
 
        lblPreferredXcbGlApi->setVisible(currentXcbGlProvider.has_value());
        cmbPreferredXcbGlApi->setVisible(currentXcbGlProvider.has_value());
 
        if (currentXcbGlProvider.has_value()) {
            const QString glxCurrent = i18nc("@item:inlistbox", "GLX (current)");
            const QString glxNotCurrent = i18nc("@item:inlistbox", "GLX");
            const QString eglCurrent = i18nc("@item:inlistbox", "EGL (current)");
            const QString eglNotCurrent = i18nc("@item:inlistbox", "EGL");
 
            cmbPreferredXcbGlApi->addItem(*currentXcbGlProvider == KisOpenGL::XCB_GLX ? glxCurrent : glxNotCurrent, KisOpenGL::XCB_GLX);
            cmbPreferredXcbGlApi->addItem(*currentXcbGlProvider == KisOpenGL::XCB_EGL ? eglCurrent : eglNotCurrent, KisOpenGL::XCB_EGL);
 
            cmbPreferredXcbGlApi->setToolTip(i18nc("@info:tooltip",
                "<p>If you are using Krita on X11 or XWayland and experience slowness, "
                "try switching between EGL and GLX</p>"));
 
            KisOpenGL::XcbGLProviderProtocol preferredValue =
                cfg.preferXcbEglProvider() ? KisOpenGL::XCB_EGL : KisOpenGL::XCB_GLX;
 
            int index = cmbPreferredXcbGlApi->findData(preferredValue);
 
            KIS_SAFE_ASSERT_RECOVER(index >= 0) {
                index = 0;
            }
            cmbPreferredXcbGlApi->setCurrentIndex(index);
        }
    }
 
    lblCurrentDisplayFormat->setText("");
    lblCurrentRootSurfaceFormat->setText("");
    grpHDRWarning->setVisible(false);
    cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpaceWrapper::sRGBColorSpace, 8));
#ifdef HAVE_HDR
    cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpaceWrapper::bt2020PQColorSpace, 10));
    cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpaceWrapper::scRGBColorSpace, 16));
#endif
    cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
    slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 
    QOpenGLContext *context = QOpenGLContext::currentContext();
 
    if (!context) {
        context = QOpenGLContext::globalShareContext();
    }
 
    if (context) {
        QScreen *screen = KisPart::instance()->currentMainwindow()->screen();
        KisScreenInformationAdapter adapter(context);
        if (screen && adapter.isValid()) {
            KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
            if (info.isValid()) {
                QStringList toolTip;
 
                toolTip << i18n("Display Id: %1", info.screen->name());
                toolTip << i18n("Display Name: %1 %2", info.screen->manufacturer(), info.screen->model());
                toolTip << i18n("Min Luminance: %1", info.minLuminance);
                toolTip << i18n("Max Luminance: %1", info.maxLuminance);
                toolTip << i18n("Max Full Frame Luminance: %1", info.maxFullFrameLuminance);
                toolTip << i18n("Red Primary: %1, %2", info.redPrimary[0], info.redPrimary[1]);
                toolTip << i18n("Green Primary: %1, %2", info.greenPrimary[0], info.greenPrimary[1]);
                toolTip << i18n("Blue Primary: %1, %2", info.bluePrimary[0], info.bluePrimary[1]);
                toolTip << i18n("White Point: %1, %2", info.whitePoint[0], info.whitePoint[1]);
 
                lblCurrentDisplayFormat->setToolTip(toolTip.join('\n'));
                lblCurrentDisplayFormat->setText(colorSpaceString(info.colorSpace, info.bitsPerColor));
            } else {
                lblCurrentDisplayFormat->setToolTip("");
                lblCurrentDisplayFormat->setText(i18n("Unknown"));
            }
        } else {
            lblCurrentDisplayFormat->setToolTip("");
            lblCurrentDisplayFormat->setText(i18n("Unknown"));
            qWarning() << "Failed to fetch display info:" << adapter.errorString();
        }
 
        const QSurfaceFormat currentFormat = KisOpenGLModeProber::instance()->surfaceformatInUse();
        const auto colorSpace = KisSurfaceColorSpaceWrapper::fromQtColorSpace(currentFormat.colorSpace());
        lblCurrentRootSurfaceFormat->setText(colorSpaceString(colorSpace, currentFormat.redBufferSize()));
        cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(cfg.rootSurfaceFormat()));
        connect(cmbPreferedRootSurfaceFormat, SIGNAL(currentIndexChanged(int)), SLOT(slotPreferredSurfaceFormatChanged(int)));
        slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
    }
 
#ifndef HAVE_HDR
    tabHDR->setEnabled(false);
 
    if (KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
        const int hdrTabIndex = tabWidget->indexOf(tabHDR);
        KIS_SAFE_ASSERT_RECOVER_NOOP(hdrTabIndex >= 0);
        if (hdrTabIndex >= 0) {
            tabWidget->setTabVisible(hdrTabIndex, false);
        }
    }
#endif
 
    const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings();
    if (openglWarnings.isEmpty()) {
        grpOpenGLWarnings->setVisible(false);
    } else {
        QString text = QString("<p><b>%1</b>").arg(i18n("Warning(s):"));
        text.append("<ul>");
        Q_FOREACH (const QString &warning, openglWarnings) {
            text.append("<li>");
            text.append(warning.toHtmlEscaped());
            text.append("</li>");
        }
        text.append("</ul></p>");
        grpOpenGLWarnings->setText(text);
        grpOpenGLWarnings->setPixmap(
            grpOpenGLWarnings->style()->standardIcon(QStyle::SP_MessageBoxWarning).pixmap(QSize(32, 32)));
        grpOpenGLWarnings->setVisible(true);
    }
 
    KisImageConfig imageCfg(false);
 
    KoColor c;
    c.fromQColor(imageCfg.selectionOverlayMaskColor());
    c.setOpacity(1.0);
    btnSelectionOverlayColor->setColor(c);
    sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
    sldSelectionOverlayOpacity->setSingleStep(0.05);
    sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor().alphaF());
 
    sldSelectionOutlineOpacity->setRange(0.0, 1.0, 2);
    sldSelectionOutlineOpacity->setSingleStep(0.05);
    sldSelectionOutlineOpacity->setValue(imageCfg.selectionOutlineOpacity());
 
    intCheckSize->setValue(cfg.checkSize());
    chkMoving->setChecked(cfg.scrollCheckers());
    KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
    ck1.fromQColor(cfg.checkersColor1());
    colorChecks1->setColor(ck1);
    KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
    ck2.fromQColor(cfg.checkersColor2());
    colorChecks2->setColor(ck2);
    KoColor cb(KoColorSpaceRegistry::instance()->rgb8());
    cb.fromQColor(cfg.canvasBorderColor());
    canvasBorder->setColor(cb);
    hideScrollbars->setChecked(cfg.hideScrollbars());
    chkCurveAntialiasing->setChecked(cfg.antialiasCurves());
    chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline());
    chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor());
    chkHidePopups->setChecked(cfg.hidePopups());
 
    connect(grpOpenGL, SIGNAL(toggled(bool)), SLOT(slotUseOpenGLToggled(bool)));
 
    KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
    gridColor.fromQColor(cfg.getPixelGridColor());
    pixelGridColorButton->setColor(gridColor);
    pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold() * 100);
    KisSpinBoxI18nHelper::setText(pixelGridDrawingThresholdBox, i18nc("{n} is the number value, % is the percent sign", "{n}%"));
}

References KisConfig::antialiasCurves(), KisConfig::antialiasSelectionOutline(), KisConfig::assistantsDrawMode(), KisScreenInformationAdapter::ScreenInfo::bitsPerColor, KisScreenInformationAdapter::ScreenInfo::bluePrimary, KisSurfaceColorSpaceWrapper::bt2020PQColorSpace, KisConfig::BT709_G22, KisConfig::canvasBorderColor(), KisConfig::checkersColor1(), KisConfig::checkersColor2(), KisConfig::checkSize(), KisScreenInformationAdapter::ScreenInfo::colorSpace, KisPart::currentMainwindow(), KisScreenInformationAdapter::errorString(), KoColor::fromQColor(), KisSurfaceColorSpaceWrapper::fromQtColorSpace(), KisOpenGL::getCurrentOpenGLRenderer(), KisOpenGL::getOpenGLWarnings(), KisConfig::getPixelGridColor(), KisConfig::getPixelGridDrawingThreshold(), KisOpenGL::getQtPreferredOpenGLRenderer(), KisOpenGL::getSupportedOpenGLRenderers(), KisOpenGL::getUserPreferredOpenGLRendererConfig(), KisScreenInformationAdapter::ScreenInfo::greenPrimary, KisConfig::hidePopups(), KisConfig::hideScrollbars(), KisScreenInformationAdapter::infoForScreen(), KoColorSpaceRegistry::instance(), KisPart::instance(), KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), KisScreenInformationAdapter::ScreenInfo::isValid(), KisScreenInformationAdapter::isValid(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_NOOP, KisScreenInformationAdapter::ScreenInfo::maxFullFrameLuminance, KisScreenInformationAdapter::ScreenInfo::maxLuminance, KisScreenInformationAdapter::ScreenInfo::minLuminance, KisConfig::openGLFilteringMode(), KisConfig::preferXcbEglProvider(), KisScreenInformationAdapter::ScreenInfo::redPrimary, KisOpenGL::RendererAuto, KisOpenGL::RendererDesktopGL, KisOpenGL::RendererOpenGLES, KisOpenGL::RendererSoftware, KisConfig::rootSurfaceFormat(), KisScreenInformationAdapter::ScreenInfo::screen, KisSurfaceColorSpaceWrapper::scRGBColorSpace, KisConfig::scrollCheckers(), KisImageConfig::selectionOutlineOpacity(), KisImageConfig::selectionOverlayMaskColor(), KoColor::setOpacity(), KisSpinBoxI18nHelper::setText(), KisConfig::showSingleChannelAsColor(), slotPreferredSurfaceFormatChanged(), slotUseOpenGLToggled(), KisSurfaceColorSpaceWrapper::sRGBColorSpace, KisOpenGL::supportsLoD(), KisOpenGLModeProber::surfaceformatInUse(), KisConfig::useOpenGL(), KisConfig::useOpenGLTextureBuffer(), KisScreenInformationAdapter::ScreenInfo::whitePoint, KisOpenGL::XCB_EGL, KisOpenGL::XCB_GLX, and KisOpenGL::xcbGlProviderProtocol().

Member Function Documentation

setDefault()

void DisplaySettingsTab::setDefault

(

)

Definition at line 2323 of file kis_dlg_preferences.cc.

{
    KisConfig cfg(true);
    cmbPreferredRenderer->setCurrentIndex(0);
    if (!(KisOpenGL::getSupportedOpenGLRenderers() &
            (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererOpenGLES))) {
        grpOpenGL->setEnabled(false);
        grpOpenGL->setChecked(false);
        chkUseTextureBuffer->setEnabled(false);
        cmbAssistantsDrawMode->setEnabled(false);
        cmbFilterMode->setEnabled(false);
    }
    else {
        grpOpenGL->setEnabled(true);
        grpOpenGL->setChecked(cfg.useOpenGL(true));
        chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
        chkUseTextureBuffer->setEnabled(true);
        cmbAssistantsDrawMode->setEnabled(true);
        cmbAssistantsDrawMode->setCurrentIndex(assistantDrawModeToIndex(cfg.assistantsDrawMode(true)));
        cmbFilterMode->setEnabled(true);
        cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
    }
 
    chkMoving->setChecked(cfg.scrollCheckers(true));
 
    KisImageConfig imageCfg(false);
 
    KoColor c;
    c.fromQColor(imageCfg.selectionOverlayMaskColor(true));
    c.setOpacity(1.0);
    btnSelectionOverlayColor->setColor(c);
    sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor(true).alphaF());
 
    sldSelectionOutlineOpacity->setValue(imageCfg.selectionOutlineOpacity(true));
 
    intCheckSize->setValue(cfg.checkSize(true));
    KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
    ck1.fromQColor(cfg.checkersColor1(true));
    colorChecks1->setColor(ck1);
    KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
    ck2.fromQColor(cfg.checkersColor2(true));
    colorChecks2->setColor(ck2);
    KoColor cvb(KoColorSpaceRegistry::instance()->rgb8());
    cvb.fromQColor(cfg.canvasBorderColor(true));
    canvasBorder->setColor(cvb);
    hideScrollbars->setChecked(cfg.hideScrollbars(true));
    chkCurveAntialiasing->setChecked(cfg.antialiasCurves(true));
    chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline(true));
    chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor(true));
    chkHidePopups->setChecked(cfg.hidePopups(true));
 
    KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
    gridColor.fromQColor(cfg.getPixelGridColor(true));
    pixelGridColorButton->setColor(gridColor);
    pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold(true) * 100);
    KisSpinBoxI18nHelper::setText(pixelGridDrawingThresholdBox, i18nc("{n} is the number value, % is the percent sign", "{n}%"));
 
    cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
    slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
}

References KisConfig::antialiasCurves(), KisConfig::antialiasSelectionOutline(), KisConfig::assistantsDrawMode(), KisConfig::BT709_G22, KisConfig::canvasBorderColor(), KisConfig::checkersColor1(), KisConfig::checkersColor2(), KisConfig::checkSize(), KoColor::fromQColor(), KisConfig::getPixelGridColor(), KisConfig::getPixelGridDrawingThreshold(), KisOpenGL::getSupportedOpenGLRenderers(), KisConfig::hidePopups(), KisConfig::hideScrollbars(), KoColorSpaceRegistry::instance(), KisConfig::openGLFilteringMode(), KisOpenGL::RendererDesktopGL, KisOpenGL::RendererOpenGLES, KisConfig::scrollCheckers(), KisImageConfig::selectionOutlineOpacity(), KisImageConfig::selectionOverlayMaskColor(), KoColor::setOpacity(), KisSpinBoxI18nHelper::setText(), KisConfig::showSingleChannelAsColor(), slotPreferredSurfaceFormatChanged(), KisConfig::useOpenGL(), and KisConfig::useOpenGLTextureBuffer().

slotPreferredSurfaceFormatChanged

void DisplaySettingsTab::slotPreferredSurfaceFormatChanged ( int index )

protectedslot

Definition at line 2391 of file kis_dlg_preferences.cc.

{
    Q_UNUSED(index);
 
    QOpenGLContext *context = QOpenGLContext::currentContext();
    if (context) {
        QScreen *screen = KisPart::instance()->currentMainwindow()->screen();
        KisScreenInformationAdapter adapter(context);
        if (adapter.isValid()) {
            KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
            if (info.isValid()) {
                if (cmbPreferedRootSurfaceFormat->currentIndex() != formatToIndex(KisConfig::BT709_G22) &&
                    info.colorSpace == KisSurfaceColorSpaceWrapper::sRGBColorSpace) {
                    grpHDRWarning->setVisible(true);
                    grpHDRWarning->setPixmap(
                        grpHDRWarning->style()->standardIcon(QStyle::SP_MessageBoxWarning).pixmap(QSize(32, 32)));
                    grpHDRWarning->setText(i18n("<b>Warning:</b> current display doesn't support HDR rendering"));
                } else {
                    grpHDRWarning->setVisible(false);
                }
            }
        }
    }
}

References KisConfig::BT709_G22, KisScreenInformationAdapter::ScreenInfo::colorSpace, KisPart::currentMainwindow(), KisScreenInformationAdapter::infoForScreen(), KisPart::instance(), KisScreenInformationAdapter::ScreenInfo::isValid(), KisScreenInformationAdapter::isValid(), and KisSurfaceColorSpaceWrapper::sRGBColorSpace.

slotUseOpenGLToggled

void DisplaySettingsTab::slotUseOpenGLToggled ( bool isChecked )

protectedslot

Definition at line 2384 of file kis_dlg_preferences.cc.

{
    chkUseTextureBuffer->setEnabled(isChecked);
    cmbFilterMode->setEnabled(isChecked);
    cmbAssistantsDrawMode->setEnabled(isChecked);
}

---

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