Differential D19155 Diff 52082 libs/ui/dialogs/kis_dlg_preferences.cc

Changeset View

Standalone View

View Options

libs/ui/dialogs/kis_dlg_preferences.cc

Context not available.
21 21​
22#include "kis_dlg_preferences.h" 22​#include "kis_dlg_preferences.h"
23 23​
24​#include <config-hdr.h>
24#include <opengl/kis_opengl.h> 25​#include <opengl/kis_opengl.h>
25 26​
26#include <QBitmap> 27​#include <QBitmap>
Context not available.
974//--------------------------------------------------------------------------------------------------- 975​//---------------------------------------------------------------------------------------------------
975 976​
976#include "KoColor.h" 977​#include "KoColor.h"
978​#include "opengl/KisOpenGLModeProber.h"
979​#include "opengl/KisScreenInformationAdapter.h"
980​#include <QOpenGLContext>
981​#include <QScreen>
982​
983​QString colorSpaceString(QSurfaceFormat::ColorSpace cs, int depth)
984​{
985​ const QString csString =
986​#ifdef HAVE_HDR
987​ cs == QSurfaceFormat::bt2020PQColorSpace ? "Rec. 2020 PQ" :
988​ cs == QSurfaceFormat::scRGBColorSpace ? "Rec. 709 Linear" :
989​#endif
990​ cs == QSurfaceFormat::sRGBColorSpace ? "sRGB" :
991​ cs == QSurfaceFormat::DefaultColorSpace ? "sRGB" :
992​ "Unknown Color Space";
993​
994​ return QString("%1 (%2 bit)").arg(csString).arg(depth);
995​}
996​
997​int formatToIndex(KisConfig::RootSurfaceFormat fmt)
998​{
999​ return fmt == KisConfig::BT2020_PQ ? 1 :
1000​ fmt == KisConfig::BT709_G10 ? 2 :
1001​ 0;
1002​}
1003​
1004​KisConfig::RootSurfaceFormat indexToFormat(int value)
1005​{
1006​ return value == 1 ? KisConfig::BT2020_PQ :
1007​ value == 2 ? KisConfig::BT709_G10 :
1008​ KisConfig::BT709_G22;
1009​}
977 1010​
978DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name) 1011​DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
979 : WdgDisplaySettings(parent, name) 1012​ : WdgDisplaySettings(parent, name)
Context not available.
982 1015​
983 const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL"); 1016​ const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL");
984#ifdef Q_OS_WIN 1017​#ifdef Q_OS_WIN
985 const QString rendererAngleText = i18nc("canvas renderer", "Direct3D 11 via ANGLE"); 1018​ const QString rendererOpenGLESText = i18nc("canvas renderer", "Direct3D 11 via ANGLE");
986 cmbRenderer->clear(); 1019​#else
1020​ const QString rendererOpenGLESText = i18nc("canvas renderer", "OpenGL ES");
1021​#endif
1022​ lblCurrentRenderer->setText(KisOpenGL::hasOpenGLES() ? rendererOpenGLESText : rendererOpenGLText);
1023​
1024​ cmbPreferredRenderer->clear();
987 QString qtPreferredRendererText; 1025​ QString qtPreferredRendererText;
988 if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererAngle) { 1026​ if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererOpenGLES) {
989 qtPreferredRendererText = rendererAngleText; 1027​ qtPreferredRendererText = rendererOpenGLESText;
990 } else { 1028​ } else {
991 qtPreferredRendererText = rendererOpenGLText; 1029​ qtPreferredRendererText = rendererOpenGLText;
992 } 1030​ }
993 cmbRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto); 1031​ cmbPreferredRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto);
994 cmbRenderer->setCurrentIndex(0); 1032​ cmbPreferredRenderer->setCurrentIndex(0);
995 if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererDesktopGL) { 1033​ if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererDesktopGL) {
996 cmbRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL); 1034​ cmbPreferredRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL);
997 if (KisOpenGL::getNextUserOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) { 1035​ if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) {
998 cmbRenderer->setCurrentIndex(cmbRenderer->count() - 1); 1036​ cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
999 } 1037​ }
1000 } 1038​ }
1001 if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererAngle) { 1039​
1002 cmbRenderer->addItem(rendererAngleText, KisOpenGL::RendererAngle); 1040​#ifdef Q_OS_WIN
1003 if (KisOpenGL::getNextUserOpenGLRendererConfig() == KisOpenGL::RendererAngle) { 1041​ if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererOpenGLES) {
1004 cmbRenderer->setCurrentIndex(cmbRenderer->count() - 1); 1042​ cmbPreferredRenderer->addItem(rendererOpenGLESText, KisOpenGL::RendererOpenGLES);
1043​ if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererOpenGLES) {
1044​ cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
1005 } 1045​ }
1006 } 1046​ }
1007#else ​
1008 lblRenderer->setEnabled(false); ​
1009 cmbRenderer->setEnabled(false); ​
1010 cmbRenderer->clear(); ​
1011 cmbRenderer->addItem(rendererOpenGLText); ​
1012 cmbRenderer->setCurrentIndex(0); ​
1013#endif 1047​#endif
1014 1048​
1015#ifdef Q_OS_WIN ​
1016 if (!(KisOpenGL::getSupportedOpenGLRenderers() & 1049​ if (!(KisOpenGL::getSupportedOpenGLRenderers() &
1017 (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererAngle))) { 1050​ (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererOpenGLES))) {
1018#else ​
1019 if (!KisOpenGL::hasOpenGL()) { ​
1020#endif ​
1021 grpOpenGL->setEnabled(false); 1051​ grpOpenGL->setEnabled(false);
1022 grpOpenGL->setChecked(false); 1052​ grpOpenGL->setChecked(false);
1023 chkUseTextureBuffer->setEnabled(false); 1053​ chkUseTextureBuffer->setEnabled(false);
Context not available.
1039 } 1069​ }
1040 } 1070​ }
1041 1071​
1072​ lblCurrentDisplayFormat->setText("");
1073​ lblCurrentRootSurfaceFormat->setText("");
1074​ lblHDRWarning->setText("");
1075​ cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(QSurfaceFormat::sRGBColorSpace, 8));
1076​#ifdef HAVE_HDR
1077​ cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(QSurfaceFormat::bt2020PQColorSpace, 10));
1078​ cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(QSurfaceFormat::scRGBColorSpace, 16));
1079​#endif
1080​ cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
1081​ slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
1082​
1083​ QOpenGLContext *context = QOpenGLContext::currentContext();
1084​
1085​ if (!context) {
1086​ context = QOpenGLContext::globalShareContext();
1087​ }
1088​
1089​ if (context) {
1090​ QScreen *screen = QGuiApplication::screenAt(rect().center());
1091​ KisScreenInformationAdapter adapter(context);
1092​ if (screen && adapter.isValid()) {
1093​ KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
1094​ if (info.isValid()) {
1095​ QStringList toolTip;
1096​
1097​ toolTip << i18n("Display Id: %1", info.screen->name());
1098​ toolTip << i18n("Display Name: %1 %2", info.screen->manufacturer(), info.screen->model());
1099​ toolTip << i18n("Min Luminance: %1", info.minLuminance);
1100​ toolTip << i18n("Max Luminance: %1", info.maxLuminance);
1101​ toolTip << i18n("Max Full Frame Luminance: %1", info.maxFullFrameLuminance);
1102​ toolTip << i18n("Red Primary: %1, %2", info.redPrimary[0], info.redPrimary[1]);
1103​ toolTip << i18n("Green Primary: %1, %2", info.greenPrimary[0], info.greenPrimary[1]);
1104​ toolTip << i18n("Blue Primary: %1, %2", info.bluePrimary[0], info.bluePrimary[1]);
1105​ toolTip << i18n("White Point: %1, %2", info.whitePoint[0], info.whitePoint[1]);
1106​
1107​ lblCurrentDisplayFormat->setToolTip(toolTip.join('\n'));
1108​ lblCurrentDisplayFormat->setText(colorSpaceString(info.colorSpace, info.bitsPerColor));
1109​ } else {
1110​ lblCurrentDisplayFormat->setToolTip("");
1111​ lblCurrentDisplayFormat->setText(i18n("Unknown"));
1112​ }
1113​ } else {
1114​ lblCurrentDisplayFormat->setToolTip("");
1115​ lblCurrentDisplayFormat->setText(i18n("Unknown"));
1116​ qWarning() << "Failed to fetch display info:" << adapter.errorString();
1117​ }
1118​
1119​ const QSurfaceFormat currentFormat = KisOpenGLModeProber::instance()->surfaceformatInUse();
1120​ lblCurrentRootSurfaceFormat->setText(colorSpaceString(currentFormat.colorSpace(), currentFormat.redBufferSize()));
1121​ cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(cfg.rootSurfaceFormat()));
1122​
1123​ connect(cmbPreferedRootSurfaceFormat, SIGNAL(currentIndexChanged(int)), SLOT(slotPreferredSurfaceFormatChanged(int)));
1124​ slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
1125​ }
1126​
1127​#ifndef HAVE_HDR
1128​ grpHDRSettings->setVisible(false);
1129​#endif
1130​
1042 const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings(); 1131​ const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings();
1043 if (openglWarnings.isEmpty()) { 1132​ if (openglWarnings.isEmpty()) {
1044 lblOpenGLWarnings->setVisible(false); 1133​ lblOpenGLWarnings->setVisible(false);
Context not available.
1099void DisplaySettingsTab::setDefault() 1188​void DisplaySettingsTab::setDefault()
1100{ 1189​{
1101 KisConfig cfg(true); 1190​ KisConfig cfg(true);
1102 cmbRenderer->setCurrentIndex(0); 1191​ cmbPreferredRenderer->setCurrentIndex(0);
1103#ifdef Q_OS_WIN ​
1104 if (!(KisOpenGL::getSupportedOpenGLRenderers() & 1192​ if (!(KisOpenGL::getSupportedOpenGLRenderers() &
1105 (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererAngle))) { 1193​ (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererOpenGLES))) {
1106#else ​
1107 if (!KisOpenGL::hasOpenGL()) { ​
1108#endif ​
1109 grpOpenGL->setEnabled(false); 1194​ grpOpenGL->setEnabled(false);
1110 grpOpenGL->setChecked(false); 1195​ grpOpenGL->setChecked(false);
1111 chkUseTextureBuffer->setEnabled(false); 1196​ chkUseTextureBuffer->setEnabled(false);
Context not available.
1144 gridColor.fromQColor(cfg.getPixelGridColor(true)); 1229​ gridColor.fromQColor(cfg.getPixelGridColor(true));
1145 pixelGridColorButton->setColor(gridColor); 1230​ pixelGridColorButton->setColor(gridColor);
1146 pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold(true) * 100); 1231​ pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold(true) * 100);
1232​
1233​ cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
1234​ slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
1147} 1235​}
1148 1236​
1149void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked) 1237​void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
Context not available.
1153 cmbFilterMode->setEnabled(isChecked); 1241​ cmbFilterMode->setEnabled(isChecked);
1154} 1242​}
1155 1243​
1244​void DisplaySettingsTab::slotPreferredSurfaceFormatChanged(int index)
1245​{
1246​ Q_UNUSED(index);
1247​
1248​ QOpenGLContext *context = QOpenGLContext::currentContext();
1249​ if (context) {
1250​ QScreen *screen = QGuiApplication::screenAt(rect().center());
1251​ KisScreenInformationAdapter adapter(context);
1252​ if (adapter.isValid()) {
1253​ KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
1254​ if (info.isValid()) {
1255​ if (cmbPreferedRootSurfaceFormat->currentIndex() != formatToIndex(KisConfig::BT709_G22) &&
1256​ info.colorSpace == QSurfaceFormat::sRGBColorSpace) {
1257​ lblHDRWarning->setText(i18n("WARNING: current display doesn't support HDR rendering"));
1258​ } else {
1259​ lblHDRWarning->setText("");
1260​ }
1261​ }
1262​ }
1263​ }
1264​}
1265​
1156//--------------------------------------------------------------------------------------------------- 1266​//---------------------------------------------------------------------------------------------------
1157FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent) 1267​FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
1158{ 1268​{
Context not available.
1453 1563​
1454 dialog->m_performanceSettings->save(); 1564​ dialog->m_performanceSettings->save();
1455 1565​
1456#ifdef Q_OS_WIN ​
1457 { 1566​ {
1458 KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>( 1567​ KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
1459 dialog->m_displaySettings->cmbRenderer->itemData( 1568​ dialog->m_displaySettings->cmbPreferredRenderer->itemData(
1460 dialog->m_displaySettings->cmbRenderer->currentIndex()).toInt()); 1569​ dialog->m_displaySettings->cmbPreferredRenderer->currentIndex()).toInt());
1461 KisOpenGL::setNextUserOpenGLRendererConfig(renderer); 1570​ KisOpenGL::setUserPreferredOpenGLRendererConfig(renderer);
1462 const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation); ​
1463 QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat); ​
1464 kritarc.setValue("OpenGLRenderer", KisOpenGL::convertOpenGLRendererToConfig(renderer)); ​
1465 } 1571​ }
1466#endif 1572​
1467 if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked()) 1573​ if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
1468 cfg.setCanvasState("TRY_OPENGL"); 1574​ cfg.setCanvasState("TRY_OPENGL");
1469 cfg.setUseOpenGL(dialog->m_displaySettings->grpOpenGL->isChecked()); 1575​ cfg.setUseOpenGL(dialog->m_displaySettings->grpOpenGL->isChecked());
1470 cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked()); 1576​ cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
1471 cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex()); 1577​ cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
1472 cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked()); 1578​ cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
1579​ cfg.setRootSurfaceFormat(&kritarc, indexToFormat(dialog->m_displaySettings->cmbPreferedRootSurfaceFormat->currentIndex()));
1473 1580​
1474 cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value()); 1581​ cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value());
1475 cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked()); 1582​ cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked());
Context not available.